diff --git a/novelwriter/__init__.py b/novelwriter/__init__.py
index 3b49359a..b3b39028 100644
--- a/novelwriter/__init__.py
+++ b/novelwriter/__init__.py
@@ -73,7 +73,7 @@ logger = logging.getLogger(__name__)
 #  Main Program
 ##
 
-# Global config singleton
+# Global config and data singletons
 CONFIG = Config()
 SHARED = SharedData()
 
diff --git a/novelwriter/core/tohtml.py b/novelwriter/core/tohtml.py
index 8459ae59..a4d4bb3f 100644
--- a/novelwriter/core/tohtml.py
+++ b/novelwriter/core/tohtml.py
@@ -111,7 +111,7 @@ class ToHtml(Tokenizer):
 
     def getFullResultSize(self) -> int:
         """Return the size of the full HTML result."""
-        return sum([len(x) for x in self._fullHTML])
+        return sum(len(x) for x in self._fullHTML)
 
     def doPreProcessing(self) -> None:
         """Extend the auto-replace to also properly encode some unicode
@@ -122,9 +122,7 @@ class ToHtml(Tokenizer):
         return
 
     def doConvert(self) -> None:
-        """Convert the list of text tokens into a HTML document saved
-        to _result.
-        """
+        """Convert the list of text tokens into an HTML document."""
         if self._genMode == self.M_PREVIEW:
             htmlTags = {  # HTML4 + CSS2 (for Qt)
                 self.FMT_B_B: "<b>",
@@ -160,9 +158,9 @@ class ToHtml(Tokenizer):
 
         self._result = ""
 
-        thisPar = []
-        parStyle = None
-        tmpResult = []
+        para = []
+        pStyle = None
+        lines = []
 
         for tType, tLine, tText, tFormat, tStyle in self._tokens:
 
@@ -231,69 +229,67 @@ class ToHtml(Tokenizer):
 
             # Process Text Type
             if tType == self.T_EMPTY:
-                if parStyle is None:
-                    parStyle = ""
-                if len(thisPar) > 1 and self._cssStyles:
-                    parClass = " class='break'"
+                if pStyle is None:
+                    pStyle = ""
+                if len(para) > 1 and self._cssStyles:
+                    pClass = " class='break'"
                 else:
-                    parClass = ""
-                if len(thisPar) > 0:
-                    tTemp = "<br/>".join(thisPar)
-                    tmpResult.append(f"<p{parClass+parStyle}>{tTemp.rstrip()}</p>\n")
-                thisPar = []
-                parStyle = None
+                    pClass = ""
+                if len(para) > 0:
+                    tTemp = "<br/>".join(para)
+                    lines.append(f"<p{pClass+pStyle}>{tTemp.rstrip()}</p>\n")
+                para = []
+                pStyle = None
 
             elif tType == self.T_TITLE:
                 tHead = tText.replace(nwHeadFmt.BR, "<br/>")
-                tmpResult.append(f"<h1 class='title'{hStyle}>{aNm}{tHead}</h1>\n")
+                lines.append(f"<h1 class='title'{hStyle}>{aNm}{tHead}</h1>\n")
 
             elif tType == self.T_UNNUM:
                 tHead = tText.replace(nwHeadFmt.BR, "<br/>")
-                tmpResult.append(f"<{h2}{hStyle}>{aNm}{tHead}</{h2}>\n")
+                lines.append(f"<{h2}{hStyle}>{aNm}{tHead}</{h2}>\n")
 
             elif tType == self.T_HEAD1:
                 tHead = tText.replace(nwHeadFmt.BR, "<br/>")
-                tmpResult.append(f"<{h1}{h1Cl}{hStyle}>{aNm}{tHead}</{h1}>\n")
+                lines.append(f"<{h1}{h1Cl}{hStyle}>{aNm}{tHead}</{h1}>\n")
 
             elif tType == self.T_HEAD2:
                 tHead = tText.replace(nwHeadFmt.BR, "<br/>")
-                tmpResult.append(f"<{h2}{hStyle}>{aNm}{tHead}</{h2}>\n")
+                lines.append(f"<{h2}{hStyle}>{aNm}{tHead}</{h2}>\n")
 
             elif tType == self.T_HEAD3:
                 tHead = tText.replace(nwHeadFmt.BR, "<br/>")
-                tmpResult.append(f"<{h3}{hStyle}>{aNm}{tHead}</{h3}>\n")
+                lines.append(f"<{h3}{hStyle}>{aNm}{tHead}</{h3}>\n")
 
             elif tType == self.T_HEAD4:
                 tHead = tText.replace(nwHeadFmt.BR, "<br/>")
-                tmpResult.append(f"<{h4}{hStyle}>{aNm}{tHead}</{h4}>\n")
+                lines.append(f"<{h4}{hStyle}>{aNm}{tHead}</{h4}>\n")
 
             elif tType == self.T_SEP:
-                tmpResult.append(f"<p class='sep'{hStyle}>{tText}</p>\n")
+                lines.append(f"<p class='sep'{hStyle}>{tText}</p>\n")
 
             elif tType == self.T_SKIP:
-                tmpResult.append(f"<p class='skip'{hStyle}>&nbsp;</p>\n")
+                lines.append(f"<p class='skip'{hStyle}>&nbsp;</p>\n")
 
             elif tType == self.T_TEXT:
                 tTemp = tText
-                if parStyle is None:
-                    parStyle = hStyle
+                if pStyle is None:
+                    pStyle = hStyle
                 for xPos, xLen, xFmt in reversed(tFormat):
                     tTemp = tTemp[:xPos] + htmlTags[xFmt] + tTemp[xPos+xLen:]
-                thisPar.append(stripEscape(tTemp.rstrip()))
+                para.append(stripEscape(tTemp.rstrip()))
 
             elif tType == self.T_SYNOPSIS and self._doSynopsis:
-                tmpResult.append(self._formatSynopsis(tText))
+                lines.append(self._formatSynopsis(tText))
 
             elif tType == self.T_COMMENT and self._doComments:
-                tmpResult.append(self._formatComments(tText))
+                lines.append(self._formatComments(tText))
 
             elif tType == self.T_KEYWORD and self._doKeywords:
                 tTemp = f"<p{hStyle}>{self._formatKeywords(tText)}</p>\n"
-                tmpResult.append(tTemp)
-
-        self._result = "".join(tmpResult)
-        tmpResult = []
+                lines.append(tTemp)
 
+        self._result = "".join(lines)
         if self._genMode != self.M_PREVIEW:
             self._fullHTML.append(self._result)
 
diff --git a/novelwriter/core/tomd.py b/novelwriter/core/tomd.py
index c9859318..ec1646ad 100644
--- a/novelwriter/core/tomd.py
+++ b/novelwriter/core/tomd.py
@@ -65,10 +65,12 @@ class ToMarkdown(Tokenizer):
     ##
 
     def setStandardMarkdown(self) -> None:
+        """Set the converter to use standard Markdown formatting."""
         self._genMode = self.M_STD
         return
 
     def setGitHubMarkdown(self) -> None:
+        """Set the converter to use GitHub Markdown formatting."""
         self._genMode = self.M_GH
         return
 
@@ -78,12 +80,10 @@ class ToMarkdown(Tokenizer):
 
     def getFullResultSize(self) -> int:
         """Return the size of the full Markdown result."""
-        return sum([len(x) for x in self._fullMD])
+        return sum(len(x) for x in self._fullMD)
 
     def doConvert(self) -> None:
-        """Convert the list of text tokens into a HTML document saved
-        to theResult.
-        """
+        """Convert the list of text tokens into a Markdown document."""
         if self._genMode == self.M_STD:
             # Standard
             mdTags = {
@@ -107,68 +107,65 @@ class ToMarkdown(Tokenizer):
 
         self._result = ""
 
-        thisPar = []
-        tmpResult = []
+        para = []
+        lines = []
 
         for tType, _, tText, tFormat, tStyle in self._tokens:
 
-            # Process Text Type
             if tType == self.T_EMPTY:
-                if len(thisPar) > 0:
-                    tTemp = ("  \n".join(thisPar)).rstrip(" ")
-                    tmpResult.append(f"{tTemp}\n\n")
-                thisPar = []
+                if len(para) > 0:
+                    tTemp = ("  \n".join(para)).rstrip(" ")
+                    lines.append(f"{tTemp}\n\n")
+                para = []
 
             elif tType == self.T_TITLE:
                 tHead = tText.replace(nwHeadFmt.BR, "\n")
-                tmpResult.append(f"# {tHead}\n\n")
+                lines.append(f"# {tHead}\n\n")
 
             elif tType == self.T_UNNUM:
                 tHead = tText.replace(nwHeadFmt.BR, "\n")
-                tmpResult.append(f"## {tHead}\n\n")
+                lines.append(f"## {tHead}\n\n")
 
             elif tType == self.T_HEAD1:
                 tHead = tText.replace(nwHeadFmt.BR, "\n")
-                tmpResult.append(f"# {tHead}\n\n")
+                lines.append(f"# {tHead}\n\n")
 
             elif tType == self.T_HEAD2:
                 tHead = tText.replace(nwHeadFmt.BR, "\n")
-                tmpResult.append(f"## {tHead}\n\n")
+                lines.append(f"## {tHead}\n\n")
 
             elif tType == self.T_HEAD3:
                 tHead = tText.replace(nwHeadFmt.BR, "\n")
-                tmpResult.append(f"### {tHead}\n\n")
+                lines.append(f"### {tHead}\n\n")
 
             elif tType == self.T_HEAD4:
                 tHead = tText.replace(nwHeadFmt.BR, "\n")
-                tmpResult.append(f"#### {tHead}\n\n")
+                lines.append(f"#### {tHead}\n\n")
 
             elif tType == self.T_SEP:
-                tmpResult.append("%s\n\n" % tText)
+                lines.append(f"{tText}\n\n")
 
             elif tType == self.T_SKIP:
-                tmpResult.append("\n\n\n")
+                lines.append("\n\n\n")
 
             elif tType == self.T_TEXT:
                 tTemp = tText
                 for xPos, xLen, xFmt in reversed(tFormat):
                     tTemp = tTemp[:xPos] + mdTags[xFmt] + tTemp[xPos+xLen:]
-                thisPar.append(tTemp.rstrip())
+                para.append(tTemp.rstrip())
 
             elif tType == self.T_SYNOPSIS and self._doSynopsis:
-                locName = self._localLookup("Synopsis")
-                tmpResult.append(f"**{locName}:** {tText}\n\n")
+                label = self._localLookup("Synopsis")
+                lines.append(f"**{label}:** {tText}\n\n")
 
             elif tType == self.T_COMMENT and self._doComments:
-                locName = self._localLookup("Comment")
-                tmpResult.append(f"**{locName}:** {tText}\n\n")
+                label = self._localLookup("Comment")
+                lines.append(f"**{label}:** {tText}\n\n")
 
             elif tType == self.T_KEYWORD and self._doKeywords:
-                tmpResult.append(self._formatKeywords(tText, tStyle))
-
-        self._result = "".join(tmpResult)
-        tmpResult = []
+                lines.append(self._formatKeywords(tText, tStyle))
 
+        self._result = "".join(lines)
         self._fullMD.append(self._result)
 
         return
diff --git a/novelwriter/core/toodt.py b/novelwriter/core/toodt.py
index b69af17b..c4f6b19d 100644
--- a/novelwriter/core/toodt.py
+++ b/novelwriter/core/toodt.py
@@ -27,10 +27,10 @@ along with this program. If not, see <https://www.gnu.org/licenses/>.
 from __future__ import annotations
 
 import logging
-from pathlib import Path
 import xml.etree.ElementTree as ET
 
 from hashlib import sha256
+from pathlib import Path
 from zipfile import ZipFile
 from datetime import datetime
 
@@ -394,9 +394,9 @@ class ToOdt(Tokenizer):
             self.FMT_D_E: "s_",  # Strikethrough close format
         }
 
-        thisPar = []
-        thisFmt = []
-        parStyle = None
+        fmt = []
+        para = []
+        pStyle = None
         for tType, _, tText, tFormat, tStyle in self._tokens:
 
             # Styles
@@ -429,20 +429,20 @@ class ToOdt(Tokenizer):
 
             # Process Text Types
             if tType == self.T_EMPTY:
-                if len(thisPar) > 1 and parStyle is not None:
+                if len(para) > 1 and pStyle is not None:
                     if self._doJustify:
-                        parStyle.setTextAlign("left")
+                        pStyle.setTextAlign("left")
 
-                if len(thisPar) > 0 and parStyle is not None:
-                    tTemp = "\n".join(thisPar)
-                    fTemp = " ".join(thisFmt)
+                if len(para) > 0 and pStyle is not None:
+                    tTemp = "\n".join(para)
+                    fTemp = " ".join(fmt)
                     tTxt = tTemp.rstrip()
                     tFmt = fTemp[:len(tTxt)]
-                    self._addTextPar("Text_20_body", parStyle, tTxt, tFmt=tFmt)
+                    self._addTextPar("Text_20_body", pStyle, tTxt, tFmt=tFmt)
 
-                thisPar = []
-                thisFmt = []
-                parStyle = None
+                fmt = []
+                para = []
+                pStyle = None
 
             elif tType == self.T_TITLE:
                 tHead = tText.replace(nwHeadFmt.BR, "\n")
@@ -475,8 +475,8 @@ class ToOdt(Tokenizer):
                 self._addTextPar("Separator", oStyle, "")
 
             elif tType == self.T_TEXT:
-                if parStyle is None:
-                    parStyle = oStyle
+                if pStyle is None:
+                    pStyle = oStyle
 
                 tFmt = " "*len(tText)
                 for xPos, xLen, xFmt in tFormat:
@@ -484,8 +484,8 @@ class ToOdt(Tokenizer):
 
                 tTxt = tText.rstrip()
                 tFmt = tFmt[:len(tTxt)]
-                thisPar.append(tTxt)
-                thisFmt.append(tFmt)
+                para.append(tTxt)
+                fmt.append(tFmt)
 
             elif tType == self.T_SYNOPSIS and self._doSynopsis:
                 tTemp, fTemp = self._formatSynopsis(tText)
@@ -501,8 +501,8 @@ class ToOdt(Tokenizer):
 
         return
 
-    def closeDocument(self):
-        """Return the serialised XML document"""
+    def closeDocument(self) -> None:
+        """Pack the styles of the XML document."""
         # Build the auto-generated styles
         for styleName, styleObj in self._autoPara.values():
             styleObj.packXML(self._xAuto, styleName)
@@ -510,7 +510,7 @@ class ToOdt(Tokenizer):
             styleObj.packXML(self._xAuto, styleName)
         return
 
-    def saveFlatXML(self, path: str | Path):
+    def saveFlatXML(self, path: str | Path) -> None:
         """Save the data to an .fodt file."""
         with open(path, mode="wb") as fObj:
             xml = ET.ElementTree(self._dFlat)
@@ -519,7 +519,7 @@ class ToOdt(Tokenizer):
         logger.info("Wrote file: %s", path)
         return
 
-    def saveOpenDocText(self, path: str | Path):
+    def saveOpenDocText(self, path: str | Path) -> None:
         """Save the data to an .odt file."""
         mMani = _mkTag("manifest", "manifest")
         mVers = _mkTag("manifest", "version")
@@ -718,9 +718,9 @@ class ToOdt(Tokenizer):
 
         return newName
 
-    def _emToCm(self, emVal: float) -> str:
+    def _emToCm(self, value: float) -> str:
         """Converts an em value to centimetres."""
-        return f"{emVal*2.54/72*self._textSize:.3f}cm"
+        return f"{value*2.54/72*self._textSize:.3f}cm"
 
     ##
     #  Style Elements
@@ -1193,56 +1193,56 @@ class ODTParagraphStyle:
     #  Methods
     ##
 
-    def checkNew(self, refStyle: ODTParagraphStyle) -> bool:
+    def checkNew(self, style: ODTParagraphStyle) -> bool:
         """Check if there are new settings in refStyle that differ from
         those in the current object.
         """
-        for aName, (_, aVal) in refStyle._mAttr.items():
-            if aVal is not None and aVal != self._mAttr[aName][1]:
+        for name, (_, aVal) in style._mAttr.items():
+            if aVal is not None and aVal != self._mAttr[name][1]:
                 return True
-        for aName, (_, aVal) in refStyle._pAttr.items():
-            if aVal is not None and aVal != self._pAttr[aName][1]:
+        for name, (_, aVal) in style._pAttr.items():
+            if aVal is not None and aVal != self._pAttr[name][1]:
                 return True
-        for aName, (_, aVal) in refStyle._tAttr.items():
-            if aVal is not None and aVal != self._tAttr[aName][1]:
+        for name, (_, aVal) in style._tAttr.items():
+            if aVal is not None and aVal != self._tAttr[name][1]:
                 return True
         return False
 
     def getID(self) -> str:
         """Generate a unique ID from the settings."""
-        theString = (
+        string = (
             f"Paragraph:Main:{str(self._mAttr)}:"
             f"Paragraph:Para:{str(self._pAttr)}:"
             f"Paragraph:Text:{str(self._tAttr)}:"
         )
-        return sha256(theString.encode()).hexdigest()
+        return sha256(string.encode()).hexdigest()
 
     def packXML(self, xParent: ET.Element, name: str) -> None:
         """Pack the content into an xml element."""
-        theAttr = {}
-        theAttr[_mkTag("style", "name")] = name
-        theAttr[_mkTag("style", "family")] = "paragraph"
+        attr = {}
+        attr[_mkTag("style", "name")] = name
+        attr[_mkTag("style", "family")] = "paragraph"
         for aName, (aNm, aVal) in self._mAttr.items():
             if aVal is not None:
-                theAttr[_mkTag(aNm, aName)] = aVal
+                attr[_mkTag(aNm, aName)] = aVal
 
-        xEntry = ET.SubElement(xParent, _mkTag("style", "style"), attrib=theAttr)
+        xEntry = ET.SubElement(xParent, _mkTag("style", "style"), attrib=attr)
 
-        theAttr = {}
+        attr = {}
         for aName, (aNm, aVal) in self._pAttr.items():
             if aVal is not None:
-                theAttr[_mkTag(aNm, aName)] = aVal
+                attr[_mkTag(aNm, aName)] = aVal
 
-        if theAttr:
-            ET.SubElement(xEntry, _mkTag("style", "paragraph-properties"), attrib=theAttr)
+        if attr:
+            ET.SubElement(xEntry, _mkTag("style", "paragraph-properties"), attrib=attr)
 
-        theAttr = {}
+        attr = {}
         for aName, (aNm, aVal) in self._tAttr.items():
             if aVal is not None:
-                theAttr[_mkTag(aNm, aName)] = aVal
+                attr[_mkTag(aNm, aName)] = aVal
 
-        if theAttr:
-            ET.SubElement(xEntry, _mkTag("style", "text-properties"), attrib=theAttr)
+        if attr:
+            ET.SubElement(xEntry, _mkTag("style", "text-properties"), attrib=attr)
 
         return
 
@@ -1307,18 +1307,18 @@ class ODTTextStyle:
 
     def packXML(self, xParent: ET.Element, name: str) -> None:
         """Pack the content into an xml element."""
-        theAttr = {}
-        theAttr[_mkTag("style", "name")] = name
-        theAttr[_mkTag("style", "family")] = "text"
-        xEntry = ET.SubElement(xParent, _mkTag("style", "style"), attrib=theAttr)
+        attr = {}
+        attr[_mkTag("style", "name")] = name
+        attr[_mkTag("style", "family")] = "text"
+        xEntry = ET.SubElement(xParent, _mkTag("style", "style"), attrib=attr)
 
-        theAttr = {}
+        attr = {}
         for aName, (aNm, aVal) in self._tAttr.items():
             if aVal is not None:
-                theAttr[_mkTag(aNm, aName)] = aVal
+                attr[_mkTag(aNm, aName)] = aVal
 
-        if theAttr:
-            ET.SubElement(xEntry, _mkTag("style", "text-properties"), attrib=theAttr)
+        if attr:
+            ET.SubElement(xEntry, _mkTag("style", "text-properties"), attrib=attr)
 
         return
 
@@ -1368,17 +1368,17 @@ class XMLParagraph:
 
         return
 
-    def appendText(self, tText: str) -> None:
+    def appendText(self, text: str) -> None:
         """Append text to the XML element. We do this one character at
         the time in order to be able to process line breaks, tabs and
         spaces separately. Multiple spaces are concatenated into a
         single tag, and must therefore be processed separately.
         """
-        tText = stripEscape(tText)
+        text = stripEscape(text)
         nSpaces = 0
-        self._rawTxt += tText
+        self._rawTxt += text
 
-        for c in tText:
+        for c in text:
             if c == " ":
                 nSpaces += 1
                 continue
@@ -1433,17 +1433,17 @@ class XMLParagraph:
 
         return
 
-    def appendSpan(self, tText: str, tFmt: str) -> None:
+    def appendSpan(self, text: str, fmt: str) -> None:
         """Append a text span to the XML element. The span is always
         closed since we do not allow nested spans (like Libre Office).
         Therefore we return to the root element level when we're done
         processing the text of the span.
         """
-        self._xTail = ET.SubElement(self._xRoot, TAG_SPAN, attrib={TAG_STNM: tFmt})
+        self._xTail = ET.SubElement(self._xRoot, TAG_SPAN, attrib={TAG_STNM: fmt})
         self._xTail.text = ""  # Defaults to None
         self._xTail.tail = ""  # Defaults to None
         self._nState = X_SPAN_TEXT
-        self.appendText(tText)
+        self.appendText(text)
         self._nState = X_ROOT_TAIL
         return
 
diff --git a/novelwriter/gui/doceditor.py b/novelwriter/gui/doceditor.py
index 9b81c765..525fd179 100644
--- a/novelwriter/gui/doceditor.py
+++ b/novelwriter/gui/doceditor.py
@@ -56,6 +56,7 @@ from novelwriter.common import minmax, transferCase
 from novelwriter.constants import nwKeyWords, nwUnicode
 from novelwriter.core.index import countWords
 from novelwriter.gui.dochighlight import GuiDocHighlighter
+from novelwriter.gui.editordocument import GuiTextDocument
 from novelwriter.extensions.wheeleventfilter import WheelEventFilter
 
 if TYPE_CHECKING:  # pragma: no cover
@@ -79,6 +80,7 @@ class GuiDocEditor(QPlainTextEdit):
     loadDocumentTagRequest = pyqtSignal(str, Enum)
     novelStructureChanged = pyqtSignal()
     novelItemMetaChanged = pyqtSignal(str)
+    spellCheckStateChanged = pyqtSignal(bool)
 
     def __init__(self, mainGui: GuiMain) -> None:
         super().__init__(parent=mainGui)
@@ -92,18 +94,12 @@ class GuiDocEditor(QPlainTextEdit):
         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._doReplace  = False  # Switch to temporarily disable auto-replace
 
@@ -120,19 +116,20 @@ class GuiDocEditor(QPlainTextEdit):
         self._typPadBefore = ""
         self._typPadAfter = ""
 
-        # Core Elements and Signals
-        qDoc = self.document()
-        qDoc.contentsChange.connect(self._docChange)
+        # 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)
 
-        # Syntax
-        self.highLight = GuiDocHighlighter(qDoc)
-
         # Context Menu
         self.setContextMenuPolicy(Qt.CustomContextMenu)
         self.customContextMenuRequested.connect(self._openContextMenu)
@@ -212,7 +209,7 @@ class GuiDocEditor(QPlainTextEdit):
     @property
     def isEmpty(self) -> bool:
         """Check if the current document is empty."""
-        return self.document().isEmpty()
+        return self._qDocument.isEmpty()
 
     ##
     #  Methods
@@ -229,10 +226,7 @@ class GuiDocEditor(QPlainTextEdit):
         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._doReplace  = False
@@ -266,7 +260,7 @@ class GuiDocEditor(QPlainTextEdit):
         self.docHeader.matchColours()
         self.docFooter.matchColours()
 
-        self.highLight.initHighlighter()
+        self._qDocument.syntaxHighlighter.initHighlighter()
 
         return
 
@@ -275,13 +269,6 @@ class GuiDocEditor(QPlainTextEdit):
         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
@@ -311,23 +298,21 @@ class GuiDocEditor(QPlainTextEdit):
         # Set default text margins
         # Due to cursor visibility, a part of the margin must be
         # allocated to the document itself. See issue #1112.
-        cW = 2*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.AlignJustify)
         if CONFIG.showTabsNSpaces:
-            theOpt.setFlags(theOpt.flags() | QTextOption.ShowTabsAndSpaces)
+            options.setFlags(options.flags() | QTextOption.ShowTabsAndSpaces)
         if CONFIG.showLineEndings:
-            theOpt.setFlags(theOpt.flags() | QTextOption.ShowLineAndParagraphSeparators)
+            options.setFlags(options.flags() | QTextOption.ShowLineAndParagraphSeparators)
 
-        qDoc.setDefaultTextOption(theOpt)
+        self._qDocument.setDefaultTextOption(options)
 
         # Scroll bars
         if CONFIG.hideVScroll:
@@ -377,13 +362,10 @@ class GuiDocEditor(QPlainTextEdit):
 
         qApp.setOverrideCursor(QCursor(Qt.WaitCursor))
         self._docHandle = tHandle
-        self.highLight.setHandle(tHandle)
 
-        tStart = time()
         self._allowAutoReplace(False)
-        self.setPlainText(docText)
+        self._qDocument.setTextContent(docText, tHandle)
         self._allowAutoReplace(True)
-        logger.debug("Document text loaded in %.3f ms", 1000*(time() - tStart))
         qApp.processEvents()
 
         self._lastEdit = time()
@@ -404,14 +386,15 @@ class GuiDocEditor(QPlainTextEdit):
         self.docFooter.updateLineCount()
 
         # 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.document().clearUndoRedoStacks()
         self.setDocumentChanged(False)
+        self._qDocument.clearUndoRedoStacks()
+
         qApp.restoreOverrideCursor()
 
         # Update the status bar
@@ -422,12 +405,12 @@ class GuiDocEditor(QPlainTextEdit):
 
     def updateTagHighLighting(self) -> None:
         """Rerun the syntax highlighter on all meta data lines."""
-        self.highLight.rehighlightByType(GuiDocHighlighter.BLOCK_META)
+        self._qDocument.syntaxHighlighter.rehighlightByType(GuiDocHighlighter.BLOCK_META)
         return
 
     def redrawText(self) -> None:
         """Redraw the text by marking the document content as dirty."""
-        self.document().markContentsDirty(0, self.document().characterCount())
+        self._qDocument.markContentsDirty(0, self._qDocument.characterCount())
         self.updateDocMargins()
         return
 
@@ -458,14 +441,9 @@ class GuiDocEditor(QPlainTextEdit):
             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
@@ -561,7 +539,7 @@ class GuiDocEditor(QPlainTextEdit):
         paragraph and line separators though.
         See: https://doc.qt.io/qt-5/qtextdocument.html#toPlainText
         """
-        text = self.document().toRawText()
+        text = self._qDocument.toRawText()
         text = text.replace(nwUnicode.U_LSEP, "\n")  # Line separators
         text = text.replace(nwUnicode.U_PSEP, "\n")  # Paragraph separators
         return text
@@ -586,7 +564,7 @@ class GuiDocEditor(QPlainTextEdit):
 
     def setCursorPosition(self, position: int) -> None:
         """Move the cursor to a given position in the document."""
-        nChars = self.document().characterCount()
+        nChars = self._qDocument.characterCount()
         if nChars > 1 and isinstance(position, int):
             cursor = self.textCursor()
             cursor.setPosition(minmax(position, 0, nChars-1))
@@ -605,7 +583,7 @@ class GuiDocEditor(QPlainTextEdit):
     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.document().findBlockByNumber(line - 1)
+            block = self._qDocument.findBlockByNumber(line - 1)
             if block:
                 self.setCursorPosition(block.position())
                 logger.debug("Cursor moved to line %d", line)
@@ -618,29 +596,25 @@ class GuiDocEditor(QPlainTextEdit):
     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
-
-        if not CONFIG.hasEnchant:
-            if state:
-                SHARED.info(self.tr(
-                    "Spell checking requires the package PyEnchant. "
-                    "It does not appear to be installed."
-                ))
-            state = False
+            state = not SHARED.project.data.spellCheck
 
         if SHARED.spelling.spellLanguage is None:
             state = False
 
-        self._spellCheck = state
-        self.mainGui.mainMenu.setSpellCheck(state)
+        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
+
         SHARED.project.data.setSpellCheck(state)
-        self.highLight.setSpellCheck(state)
-        if state is False:
-            self.spellCheckDocument()
+        self.spellCheckStateChanged.emit(state)
+        self.spellCheckDocument()
 
         logger.debug("Spell check is set to '%s'", str(state))
 
@@ -655,7 +629,7 @@ class GuiDocEditor(QPlainTextEdit):
         logger.debug("Running spell checker")
         start = time()
         qApp.setOverrideCursor(QCursor(Qt.WaitCursor))
-        self.highLight.rehighlight()
+        self._qDocument.syntaxHighlighter.rehighlight()
         qApp.restoreOverrideCursor()
         logger.debug("Document highlighted in %.3f ms", 1000*(time() - start))
         self.statusMessage.emit(self.tr("Spell check complete"))
@@ -786,30 +760,30 @@ class GuiDocEditor(QPlainTextEdit):
         goAfter = False
 
         if isinstance(insert, str):
-            theText = insert
+            text = insert
         elif isinstance(insert, nwDocInsert):
             if insert == nwDocInsert.QUOTE_LS:
-                theText = self._typSQuoteO
+                text = self._typSQuoteO
             elif insert == nwDocInsert.QUOTE_RS:
-                theText = self._typSQuoteC
+                text = self._typSQuoteC
             elif insert == nwDocInsert.QUOTE_LD:
-                theText = self._typDQuoteO
+                text = self._typDQuoteO
             elif insert == nwDocInsert.QUOTE_RD:
-                theText = self._typDQuoteC
+                text = self._typDQuoteC
             elif insert == nwDocInsert.SYNOPSIS:
-                theText = "% Synopsis: "
+                text = "% Synopsis: "
                 newBlock = True
                 goAfter = True
             elif insert == nwDocInsert.NEW_PAGE:
-                theText = "[NEW PAGE]"
+                text = "[NEW PAGE]"
                 newBlock = True
                 goAfter = False
             elif insert == nwDocInsert.VSPACE_S:
-                theText = "[VSPACE]"
+                text = "[VSPACE]"
                 newBlock = True
                 goAfter = False
             elif insert == nwDocInsert.VSPACE_M:
-                theText = "[VSPACE:2]"
+                text = "[VSPACE:2]"
                 newBlock = True
                 goAfter = False
             else:
@@ -818,42 +792,42 @@ class GuiDocEditor(QPlainTextEdit):
             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, text: str, defaultAfter: bool = True) -> bool:
         """Insert a piece of text on a blank line."""
-        theCursor = self.textCursor()
-        theBlock = theCursor.block()
-        if not theBlock.isValid():
+        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(text)
+        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
 
@@ -913,14 +887,15 @@ class GuiDocEditor(QPlainTextEdit):
         if CONFIG.autoScroll:
             cPos = self.cursorRect().topLeft().y()
             super().keyPressEvent(event)
+            nPos = self.cursorRect().topLeft().y()
             kMod = event.modifiers()
             okMod = kMod == Qt.NoModifier or kMod == Qt.ShiftModifier
             okKey = event.key() not in self.MOVE_KEYS
-            if okMod and okKey:
+            if nPos != cPos and okMod and okKey:
                 mPos = CONFIG.autoScrollPos*0.01 * self.viewport().height()
                 if cPos > mPos:
                     vBar = self.verticalScrollBar()
-                    vBar.setValue(vBar.value() + 1)
+                    vBar.setValue(vBar.value() + (1 if nPos > cPos else -1))
         else:
             super().keyPressEvent(event)
 
@@ -946,8 +921,7 @@ class GuiDocEditor(QPlainTextEdit):
         follow tag function.
         """
         if qApp.keyboardModifiers() == Qt.ControlModifier:
-            theCursor = self.cursorForPosition(event.pos())
-            self._followTag(theCursor)
+            self._followTag(self.cursorForPosition(event.pos()))
         super().mouseReleaseEvent(event)
         self.docFooter.updateLineCount()
         return
@@ -994,7 +968,7 @@ class GuiDocEditor(QPlainTextEdit):
             self.wcTimerDoc.start()
 
         if self._doReplace and added == 1:
-            self._docAutoReplace(self.document().findBlock(pos))
+            self._docAutoReplace(self._qDocument.findBlock(pos))
 
         return
 
@@ -1003,100 +977,62 @@ class GuiDocEditor(QPlainTextEdit):
         """Triggered by right click to open the context menu. Also
         triggered by the Ctrl+. shortcut.
         """
-        userCursor = self.textCursor()
-        userSelection = userCursor.hasSelection()
-        posCursor = self.cursorForPosition(pos)
+        uCursor = self.textCursor()
+        pCursor = self.cursorForPosition(pos)
 
-        mnuContext = QMenu()
+        ctxMenu = QMenu()
 
-        # Follow, Cut, Copy and Paste
-        # ===========================
+        # Follow
+        if self._followTag(cursor=pCursor, loadTag=False):
+            aTag = ctxMenu.addAction(self.tr("Follow Tag"))
+            aTag.triggered.connect(lambda: self._followTag(cursor=pCursor))
+            ctxMenu.addSeparator()
 
-        if self._followTag(cursor=posCursor, loadTag=False):
-            mnuTag = QAction(self.tr("Follow Tag"), mnuContext)
-            mnuTag.triggered.connect(lambda: self._followTag(cursor=posCursor))
-            mnuContext.addAction(mnuTag)
-            mnuContext.addSeparator()
+        # Cut, Copy and Paste
+        if uCursor.hasSelection():
+            aCut = ctxMenu.addAction(self.tr("Cut"))
+            aCut.triggered.connect(lambda: self.docAction(nwDocAction.CUT))
+            aCopy = ctxMenu.addAction(self.tr("Copy"))
+            aCopy.triggered.connect(lambda: self.docAction(nwDocAction.COPY))
 
-        if userSelection:
-            mnuCut = QAction(self.tr("Cut"), mnuContext)
-            mnuCut.triggered.connect(lambda: self.docAction(nwDocAction.CUT))
-            mnuContext.addAction(mnuCut)
-
-            mnuCopy = QAction(self.tr("Copy"), mnuContext)
-            mnuCopy.triggered.connect(lambda: self.docAction(nwDocAction.COPY))
-            mnuContext.addAction(mnuCopy)
-
-        mnuPaste = QAction(self.tr("Paste"), mnuContext)
-        mnuPaste.triggered.connect(lambda: self.docAction(nwDocAction.PASTE))
-        mnuContext.addAction(mnuPaste)
-
-        mnuContext.addSeparator()
+        aPaste = ctxMenu.addAction(self.tr("Paste"))
+        aPaste.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, pos)
-        )
-        mnuContext.addAction(mnuSelWord)
-
-        mnuSelPara = QAction(self.tr("Select Paragraph"), mnuContext)
-        mnuSelPara.triggered.connect(
-            lambda: self._makePosSelection(QTextCursor.BlockUnderCursor, pos)
-        )
-        mnuContext.addAction(mnuSelPara)
+        aSAll = ctxMenu.addAction(self.tr("Select All"))
+        aSAll.triggered.connect(lambda: self.docAction(nwDocAction.SEL_ALL))
+        aSWrd = ctxMenu.addAction(self.tr("Select Word"))
+        aSWrd.triggered.connect(lambda: self._makePosSelection(QTextCursor.WordUnderCursor, pos))
+        aSPar = ctxMenu.addAction(self.tr("Select Paragraph"))
+        aSPar.triggered.connect(lambda: self._makePosSelection(QTextCursor.BlockUnderCursor, pos))
 
         # Spell Checking
-        # ==============
+        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.Right, QTextCursor.KeepAnchor, cLen)
+                if suggest:
+                    ctxMenu.addSeparator()
+                    ctxMenu.addAction(self.tr("Spelling Suggestion(s)"))
+                    for option in suggest[:15]:
+                        aFix = ctxMenu.addAction(f"{nwUnicode.U_ENDASH} {option}")
+                        aFix.triggered.connect(
+                            lambda _, option=option: self._correctWord(sCursor, option)
+                        )
+                else:
+                    ctxMenu.addAction("%s %s" % (nwUnicode.U_ENDASH, self.tr("No Suggestions")))
 
-        posCursor = self.cursorForPosition(pos)
-        spellCheck = self._spellCheck
-        theWord = ""
+                ctxMenu.addSeparator()
+                aAdd = ctxMenu.addAction(self.tr("Add Word to Dictionary"))
+                aAdd.triggered.connect(lambda: self._addWord(word, block))
 
-        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
-                )
-                mnuContext.addAction(mnuHead)
-
-            mnuContext.addSeparator()
-            mnuAdd = QAction(self.tr("Add Word to Dictionary"), mnuContext)
-            mnuAdd.triggered.connect(lambda thePos: self._addWord(posCursor))
-            mnuContext.addAction(mnuAdd)
-
-        # Open the context menu
-        mnuContext.exec_(self.viewport().mapToGlobal(pos))
+        # Execute the context menu
+        ctxMenu.exec_(self.viewport().mapToGlobal(pos))
 
         return
 
@@ -1105,24 +1041,23 @@ class GuiDocEditor(QPlainTextEdit):
         """Slot for the spell check context menu triggering the
         replacement of a word with the word from the dictionary.
         """
-        xPos = cursor.selectionStart()
+        pos = cursor.selectionStart()
         cursor.beginEditBlock()
         cursor.removeSelectedText()
         cursor.insertText(word)
         cursor.endEditBlock()
-        cursor.setPosition(xPos)
+        cursor.setPosition(pos)
         self.setTextCursor(cursor)
         return
 
-    @pyqtSlot("QTextCursor")
-    def _addWord(self, cursor: QTextCursor) -> None:
+    @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 = cursor.selectedText().strip().strip(self._nonWord)
-        logger.debug("Added '%s' to project dictionary", theWord)
-        SHARED.spelling.addWord(theWord)
-        self.highLight.rehighlightBlock(cursor.block())
+        logger.debug("Added '%s' to project dictionary", word)
+        SHARED.spelling.addWord(word)
+        self._qDocument.syntaxHighlighter.rehighlightBlock(block)
         return
 
     @pyqtSlot()
@@ -1137,9 +1072,9 @@ class GuiDocEditor(QPlainTextEdit):
             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
 
@@ -1151,10 +1086,6 @@ class GuiDocEditor(QPlainTextEdit):
 
         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)
@@ -1174,12 +1105,10 @@ class GuiDocEditor(QPlainTextEdit):
             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()
@@ -1192,7 +1121,7 @@ class GuiDocEditor(QPlainTextEdit):
             logger.debug("Selection word counter is busy")
             return
 
-        self.mainGui.threadPool.start(self.wCounterSel)
+        SHARED.runInThreadPool(self.wCounterSel)
 
         return
 
@@ -1214,9 +1143,9 @@ class GuiDocEditor(QPlainTextEdit):
 
     def beginSearch(self) -> None:
         """Set the selected text as the search text."""
-        theCursor = self.textCursor()
-        if theCursor.hasSelection():
-            self.docSearch.setSearchText(theCursor.selectedText())
+        cursor = self.textCursor()
+        if cursor.hasSelection():
+            self.docSearch.setSearchText(cursor.selectedText())
         else:
             self.docSearch.setSearchText(None)
         resS, _ = self.findAllOccurences()
@@ -1254,8 +1183,8 @@ class GuiDocEditor(QPlainTextEdit):
                 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
@@ -1276,9 +1205,9 @@ class GuiDocEditor(QPlainTextEdit):
             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.MoveAnchor)
+        cursor.setPosition(resE[resIdx], QTextCursor.KeepAnchor)
+        self.setTextCursor(cursor)
 
         self.docFooter.updateLineCount()
         self.docSearch.setResultCount(resIdx + 1, len(resS))
@@ -1292,14 +1221,14 @@ class GuiDocEditor(QPlainTextEdit):
         """
         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:
@@ -1308,27 +1237,27 @@ class GuiDocEditor(QPlainTextEdit):
             findOpt |= QTextDocument.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.MoveAnchor)
+            cursor.setPosition(origB, QTextCursor.KeepAnchor)
         else:
-            theCursor.setPosition(origA)
+            cursor.setPosition(origA)
 
-        self.setTextCursor(theCursor)
+        self.setTextCursor(cursor)
 
         return resS, resE
 
@@ -1346,24 +1275,24 @@ class GuiDocEditor(QPlainTextEdit):
             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.
@@ -1373,26 +1302,26 @@ class GuiDocEditor(QPlainTextEdit):
         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")
@@ -1410,40 +1339,40 @@ class GuiDocEditor(QPlainTextEdit):
         If more than one block is selected, the formatting is applied to
         the first block.
         """
-        theCursor = self._autoSelect()
-        if not theCursor.hasSelection():
+        cursor = self._autoSelect()
+        if not cursor.hasSelection():
             logger.warning("No selection made, nothing to do")
             return False
 
-        posS = theCursor.selectionStart()
-        posE = theCursor.selectionEnd()
+        posS = cursor.selectionStart()
+        posE = cursor.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.MoveAnchor)
+            cursor.setPosition(posE, QTextCursor.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)
+            self._clearSurrounding(cursor, fLen)
         else:
             self._wrapSelection(fChar*fLen)
 
@@ -1479,52 +1408,51 @@ class GuiDocEditor(QPlainTextEdit):
         if after is None:
             after = before
 
-        theCursor = self._autoSelect()
-        if not theCursor.hasSelection():
+        cursor = self._autoSelect()
+        if not cursor.hasSelection():
             logger.warning("No selection made, nothing to do")
             return False
 
-        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(after)
-        theCursor.setPosition(posS)
-        theCursor.insertText(before)
-        theCursor.endEditBlock()
+        cursor.clearSelection()
+        cursor.beginEditBlock()
+        cursor.setPosition(posE)
+        cursor.insertText(after)
+        cursor.setPosition(posS)
+        cursor.insertText(before)
+        cursor.endEditBlock()
 
-        theCursor.setPosition(posE + len(before), QTextCursor.MoveAnchor)
-        theCursor.setPosition(posS + len(before), QTextCursor.KeepAnchor)
-        self.setTextCursor(theCursor)
+        cursor.setPosition(posE + len(before), QTextCursor.MoveAnchor)
+        cursor.setPosition(posS + len(before), QTextCursor.KeepAnchor)
+        self.setTextCursor(cursor)
 
         return True
 
     def _replaceQuotes(self, sQuote: str, oQuote: str, cQuote: str) -> bool:
         """Replace all straight quotes in the selected text."""
-        theCursor = self.textCursor()
-        if not theCursor.hasSelection():
+        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.Left, QTextCursor.KeepAnchor, 2)
+            selText = cursor.selectedText()
 
             nS = len(selText)
             if nS == 2:
@@ -1539,18 +1467,18 @@ class GuiDocEditor(QPlainTextEdit):
             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.Left, QTextCursor.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.Left, QTextCursor.KeepAnchor, 1)
+                cursor.insertText(cQuote)
+                cursor.endEditBlock()
 
         self._allowAutoReplace(True)
 
@@ -1558,148 +1486,147 @@ class GuiDocEditor(QPlainTextEdit):
 
     def _formatBlock(self, action: nwDocAction) -> bool:
         """Change the block format of the block under the cursor."""
-        theCursor = self.textCursor()
-        theBlock = theCursor.block()
-        if not theBlock.isValid():
+        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 action == nwDocAction.BLOCK_COM:
                 action = nwDocAction.BLOCK_TXT
-        elif theText.startswith("%"):
-            newText = theText[1:]
+        elif setText.startswith("%"):
+            newText = setText[1:]
             cOffset = 1
             if action == nwDocAction.BLOCK_COM:
                 action = nwDocAction.BLOCK_TXT
-        elif theText.startswith("# "):
-            newText = theText[2:]
+        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 action != 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 action != 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 action != 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 action != nwDocAction.INDENT_L:
+        elif setText.endswith("<") and action != nwDocAction.INDENT_L:
             newText = newText[:-1]
 
         # Apply new format
         if action == nwDocAction.BLOCK_COM:
-            theText = "% "+newText
+            setText = "% "+newText
             cOffset -= 2
         elif action == nwDocAction.BLOCK_H1:
-            theText = "# "+newText
+            setText = "# "+newText
             cOffset -= 2
         elif action == nwDocAction.BLOCK_H2:
-            theText = "## "+newText
+            setText = "## "+newText
             cOffset -= 3
         elif action == nwDocAction.BLOCK_H3:
-            theText = "### "+newText
+            setText = "### "+newText
             cOffset -= 4
         elif action == nwDocAction.BLOCK_H4:
-            theText = "#### "+newText
+            setText = "#### "+newText
             cOffset -= 5
         elif action == nwDocAction.BLOCK_TTL:
-            theText = "#! "+newText
+            setText = "#! "+newText
             cOffset -= 3
         elif action == nwDocAction.BLOCK_UNN:
-            theText = "##! "+newText
+            setText = "##! "+newText
             cOffset -= 4
         elif action == nwDocAction.ALIGN_L:
-            theText = newText+" <<"
+            setText = newText+" <<"
         elif action == nwDocAction.ALIGN_C:
-            theText = ">> "+newText+" <<"
+            setText = ">> "+newText+" <<"
             cOffset -= 3
         elif action == nwDocAction.ALIGN_R:
-            theText = ">> "+newText
+            setText = ">> "+newText
             cOffset -= 3
         elif action == nwDocAction.INDENT_L:
-            theText = "> "+newText
+            setText = "> "+newText
             cOffset -= 2
         elif action == nwDocAction.INDENT_R:
-            theText = newText+" <"
+            setText = newText+" <"
         elif action == nwDocAction.BLOCK_TXT:
-            theText = newText
+            setText = newText
         else:
             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.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) -> None:
         """Strip line breaks within paragraphs in the selected text."""
-        theCursor = self.textCursor()
-        theDoc = self.document()
+        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()
@@ -1709,7 +1636,7 @@ class GuiDocEditor(QPlainTextEdit):
         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:
@@ -1726,12 +1653,12 @@ class GuiDocEditor(QPlainTextEdit):
             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.Right, QTextCursor.KeepAnchor, rE-rS)
+        cursor.insertText(cleanText.rstrip() + "\n")
+        cursor.endEditBlock()
 
         return
 
@@ -1749,37 +1676,37 @@ class GuiDocEditor(QPlainTextEdit):
         if cursor is None:
             cursor = self.textCursor()
 
-        theBlock = cursor.block()
-        theText = theBlock.text()
+        block = cursor.block()
+        text = block.text()
 
-        if len(theText) == 0:
+        if len(text) == 0:
             return False
 
-        if theText.startswith("@"):
+        if text.startswith("@"):
 
-            isGood, tBits, tPos = SHARED.project.index.scanThis(theText)
+            isGood, tBits, tPos = SHARED.project.index.scanThis(text)
             if not isGood:
                 return False
 
-            theTag = ""
-            cPos = cursor.selectionStart() - theBlock.position()
+            tag = ""
+            cPos = cursor.selectionStart() - block.position()
             for sTag, sPos in zip(reversed(tBits), reversed(tPos)):
                 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
                     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)
+                logger.debug("Attempting to follow tag '%s'", tag)
+                self.loadDocumentTagRequest.emit(tag, nwDocMode.VIEW)
             else:
-                logger.debug("Potential tag '%s'", theTag)
+                logger.debug("Potential tag '%s'", tag)
 
             return True
 
@@ -1795,94 +1722,93 @@ class GuiDocEditor(QPlainTextEdit):
         if not block.isValid():
             return
 
-        theText = block.text()
-        theCursor = self.textCursor()
-        thePos = theCursor.positionInBlock()
-        theLen = len(theText)
+        text = block.text()
+        cursor = self.textCursor()
+        tPos = cursor.positionInBlock()
+        tLen = len(text)
 
-        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.Left, QTextCursor.KeepAnchor, nDelete)
+            cursor.insertText(tInsert)
 
         return
 
@@ -1904,60 +1830,57 @@ class GuiDocEditor(QPlainTextEdit):
         """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()
+        cursor = self.textCursor()
+        if CONFIG.autoSelect and not cursor.hasSelection():
+            cursor.select(QTextCursor.WordUnderCursor)
+            posS = cursor.selectionStart()
+            posE = cursor.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) == "_":
+            if self._qDocument.characterAt(posS) == "_":
                 posS += 1
                 reSelect = True
-            if qDoc.characterAt(posE) == "_":
+            if self._qDocument.characterAt(posE) == "_":
                 posE -= 1
                 reSelect = True
             if reSelect:
-                theCursor.clearSelection()
-                theCursor.setPosition(posS, QTextCursor.MoveAnchor)
-                theCursor.setPosition(posE-1, QTextCursor.KeepAnchor)
+                cursor.clearSelection()
+                cursor.setPosition(posS, QTextCursor.MoveAnchor)
+                cursor.setPosition(posE-1, QTextCursor.KeepAnchor)
 
-            self.setTextCursor(theCursor)
+            self.setTextCursor(cursor)
 
-        return theCursor
+        return cursor
 
     def _makeSelection(self, mode: QTextCursor.SelectionType) -> None:
-        """Select text based on a selection mode."""
-        theCursor = self.textCursor()
-        theCursor.clearSelection()
-        theCursor.select(mode)
+        """Select text based on selection mode."""
+        cursor = self.textCursor()
+        cursor.clearSelection()
+        cursor.select(mode)
 
         if mode == QTextCursor.WordUnderCursor:
-            theCursor = self._autoSelect()
+            cursor = self._autoSelect()
 
         elif mode == QTextCursor.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.MoveAnchor)
+                cursor.setPosition(posE, QTextCursor.KeepAnchor)
 
-        self.setTextCursor(theCursor)
+        self.setTextCursor(cursor)
 
         return
 
     def _makePosSelection(self, mode: QTextCursor.SelectionType, pos: QPoint) -> None:
-        """Wrapper function to select text based on selection mode, but
-        first move cursor to given position.
-        """
-        theCursor = self.cursorForPosition(pos)
-        self.setTextCursor(theCursor)
+        """Select text based on selection mode, but first move cursor."""
+        cursor = self.cursorForPosition(pos)
+        self.setTextCursor(cursor)
         self._makeSelection(mode)
         return
 
@@ -2000,11 +1923,11 @@ class BackgroundWordCounter(QRunnable):
         """
         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
 
@@ -2035,7 +1958,6 @@ class GuiDocEditSearch(QFrame):
         logger.debug("Create: GuiDocEditSearch")
 
         self.docEditor = docEditor
-        self.mainGui   = docEditor.mainGui
 
         self.repVisible  = False
         self.isCaseSense = CONFIG.searchCase
@@ -2455,18 +2377,18 @@ class GuiDocEditHeader(QWidget):
         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)
+        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.AlignHCenter | Qt.AlignTop)
+        self.itemTitle.setFixedHeight(fPx)
 
-        lblFont = self.theTitle.font()
+        lblFont = self.itemTitle.font()
         lblFont.setPointSizeF(0.9*SHARED.theme.fontPointSize)
-        self.theTitle.setFont(lblFont)
+        self.itemTitle.setFont(lblFont)
 
         # Buttons
         self.editButton = QToolButton(self)
@@ -2510,7 +2432,7 @@ class GuiDocEditHeader(QWidget):
         self.outerBox.setSpacing(hSp)
         self.outerBox.addWidget(self.editButton, 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)
@@ -2557,13 +2479,13 @@ class GuiDocEditHeader(QWidget):
         """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.Window, QColor(*SHARED.theme.colBack))
+        palette.setColor(QPalette.WindowText, QColor(*SHARED.theme.colText))
+        palette.setColor(QPalette.Text, QColor(*SHARED.theme.colText))
 
-        self.setPalette(thePalette)
-        self.theTitle.setPalette(thePalette)
+        self.setPalette(palette)
+        self.itemTitle.setPalette(palette)
 
         return
 
@@ -2573,7 +2495,7 @@ class GuiDocEditHeader(QWidget):
         """
         self._docHandle = tHandle
         if tHandle is None:
-            self.theTitle.setText("")
+            self.itemTitle.setText("")
             self.editButton.setVisible(False)
             self.searchButton.setVisible(False)
             self.closeButton.setVisible(False)
@@ -2589,12 +2511,12 @@ 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.searchButton.setVisible(True)
@@ -2673,9 +2595,8 @@ class GuiDocEditFooter(QWidget):
         logger.debug("Create: GuiDocEditFooter")
 
         self.docEditor = docEditor
-        self.mainGui   = docEditor.mainGui
 
-        self._theItem   = None
+        self._tItem     = None
         self._docHandle = None
 
         self._docSelection = False
@@ -2781,15 +2702,15 @@ class GuiDocEditFooter(QWidget):
         """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.Window, QColor(*SHARED.theme.colBack))
+        palette.setColor(QPalette.WindowText, QColor(*SHARED.theme.colText))
+        palette.setColor(QPalette.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
 
@@ -2798,9 +2719,9 @@ class GuiDocEditFooter(QWidget):
         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()
@@ -2817,13 +2738,13 @@ class GuiDocEditFooter(QWidget):
 
     def updateInfo(self) -> None:
         """Update the content of text labels."""
-        if self._theItem is None:
+        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)
@@ -2832,13 +2753,13 @@ class GuiDocEditFooter(QWidget):
 
     def updateLineCount(self) -> None:
         """Update the line counter."""
-        if self._theItem is None:
+        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} %")
         )
@@ -2858,18 +2779,18 @@ class GuiDocEditFooter(QWidget):
 
     def _updateWordCounts(self) -> None:
         """Update the word count for the whole document."""
-        if self._theItem is None:
+        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}")
         )
diff --git a/novelwriter/gui/dochighlight.py b/novelwriter/gui/dochighlight.py
index 7cd67364..5acd7ef7 100644
--- a/novelwriter/gui/dochighlight.py
+++ b/novelwriter/gui/dochighlight.py
@@ -29,7 +29,8 @@ from time import time
 
 from PyQt5.QtCore import Qt, QRegularExpression
 from PyQt5.QtGui import (
-    QColor, QTextCharFormat, QFont, QSyntaxHighlighter, QBrush, QTextDocument
+    QBrush, QColor, QFont, QSyntaxHighlighter, QTextBlockUserData,
+    QTextCharFormat, QTextDocument
 )
 
 from novelwriter import CONFIG, SHARED
@@ -38,6 +39,9 @@ from novelwriter.constants import nwRegEx, nwUnicode
 
 logger = logging.getLogger(__name__)
 
+SPELLRX = QRegularExpression(r"\b[^\s\-\+\/–—]+\b")
+SPELLRX.setPatternOptions(QRegularExpression.UseUnicodePropertiesOption)
+
 
 class GuiDocHighlighter(QSyntaxHighlighter):
 
@@ -51,9 +55,9 @@ class GuiDocHighlighter(QSyntaxHighlighter):
 
         logger.debug("Create: GuiDocHighlighter")
 
+        self._tItem      = None
         self._tHandle    = None
         self._spellCheck = False
-        self._spellRx    = QRegularExpression()
 
         self._hRules: list[tuple[str, dict]] = []
         self._hStyles: dict[str, QTextCharFormat] = {}
@@ -79,11 +83,6 @@ class GuiDocHighlighter(QSyntaxHighlighter):
 
         return
 
-    @property
-    def spellCheck(self) -> bool:
-        """Check if spell checking is enabled."""
-        return self._spellCheck
-
     def initHighlighter(self) -> None:
         """Initialise the syntax highlighter, setting all the colour
         rules and building the RegExes.
@@ -227,13 +226,6 @@ class GuiDocHighlighter(QSyntaxHighlighter):
             hReg.setPatternOptions(QRegularExpression.UseUnicodePropertiesOption)
             self.rxRules.append((hReg, regRules))
 
-        # Build a QRegExp for the spell checker
-        # Include additional characters that the highlighter should
-        # consider to be word separators
-        uCode = nwUnicode.U_ENDASH + nwUnicode.U_EMDASH
-        self._spellRx = QRegularExpression(r"\b[^\s\-\+\/" + uCode + r"]+\b")
-        self._spellRx.setPatternOptions(QRegularExpression.UseUnicodePropertiesOption)
-
         return
 
     ##
@@ -248,6 +240,11 @@ class GuiDocHighlighter(QSyntaxHighlighter):
     def setHandle(self, tHandle: str) -> None:
         """Set the handle of the currently highlighted document."""
         self._tHandle = tHandle
+        self._tItem = SHARED.project.tree[tHandle]
+        logger.debug(
+            "Syntax highlighter %s for item '%s'",
+            "enabled" if self._tItem else "disabled", tHandle
+        )
         return
 
     ##
@@ -284,27 +281,24 @@ class GuiDocHighlighter(QSyntaxHighlighter):
 
         if text.startswith("@"):  # Keywords and commands
             self.setCurrentBlockState(self.BLOCK_META)
-            pIndex = SHARED.project.index
-            tItem = SHARED.project.tree[self._tHandle]
-            if tItem is None:
-                return
-
-            isValid, theBits, thePos = pIndex.scanThis(text)
-            isGood = pIndex.checkThese(theBits, tItem)
-            if isValid:
-                for n, theBit in enumerate(theBits):
-                    xPos = thePos[n]
-                    xLen = len(theBit)
-                    if isGood[n]:
-                        if n == 0:
-                            self.setFormat(xPos, xLen, self._hStyles["keyword"])
+            if self._tItem:
+                pIndex = SHARED.project.index
+                isValid, theBits, thePos = pIndex.scanThis(text)
+                isGood = pIndex.checkThese(theBits, self._tItem)
+                if isValid:
+                    for n, theBit in enumerate(theBits):
+                        xPos = thePos[n]
+                        xLen = len(theBit)
+                        if isGood[n]:
+                            if n == 0:
+                                self.setFormat(xPos, xLen, self._hStyles["keyword"])
+                            else:
+                                self.setFormat(xPos, xLen, self._hStyles["value"])
                         else:
-                            self.setFormat(xPos, xLen, self._hStyles["value"])
-                    else:
-                        kwFmt = self.format(xPos)
-                        kwFmt.setUnderlineColor(self._colError)
-                        kwFmt.setUnderlineStyle(QTextCharFormat.SpellCheckUnderline)
-                        self.setFormat(xPos, xLen, kwFmt)
+                            kwFmt = self.format(xPos)
+                            kwFmt.setUnderlineColor(self._colError)
+                            kwFmt.setUnderlineStyle(QTextCharFormat.SpellCheckUnderline)
+                            self.setFormat(xPos, xLen, kwFmt)
 
             # We never want to run the spell checker on keyword/values,
             # so we force a return here
@@ -382,17 +376,13 @@ class GuiDocHighlighter(QSyntaxHighlighter):
                                 spFmt.merge(xFmt[xM])
                                 self.setFormat(x, 1, spFmt)
 
-        if not self._spellCheck:
-            return
+        data = self.currentBlockUserData()
+        if not isinstance(data, TextBlockData):
+            data = TextBlockData()
+            self.setCurrentBlockUserData(data)
 
-        rxSpell = self._spellRx.globalMatch(text.replace("_", " "), 0)
-        while rxSpell.hasNext():
-            rxMatch = rxSpell.next()
-            if not SHARED.spelling.checkWord(rxMatch.captured(0)):
-                if not rxMatch.captured(0).isalpha() or rxMatch.captured(0).isupper():
-                    continue
-                xPos = rxMatch.capturedStart(0)
-                xLen = rxMatch.capturedLength(0)
+        if self._spellCheck:
+            for xPos, xLen in data.spellCheck(text):
                 for x in range(xPos, xPos+xLen):
                     spFmt = self.format(x)
                     spFmt.setUnderlineColor(self._colSpell)
@@ -437,3 +427,33 @@ class GuiDocHighlighter(QSyntaxHighlighter):
         return charFormat
 
 # END Class GuiDocHighlighter
+
+
+class TextBlockData(QTextBlockUserData):
+
+    __slots__ = ("_spellErrors")
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._spellErrors: list[tuple[int, int]] = []
+        return
+
+    @property
+    def spellErrors(self) -> list[tuple[int, int]]:
+        """Return spell error data from last check."""
+        return self._spellErrors
+
+    def spellCheck(self, text: str) -> list[tuple[int, int]]:
+        """Run the spell checker and cache the result, and return the
+        list of spell check errors.
+        """
+        self._spellErrors = []
+        rxSpell = SPELLRX.globalMatch(text.replace("_", " "), 0)
+        while rxSpell.hasNext():
+            rxMatch = rxSpell.next()
+            if not SHARED.spelling.checkWord(rxMatch.captured(0)):
+                if not rxMatch.captured(0).isnumeric() and not rxMatch.captured(0).isupper():
+                    self._spellErrors.append((rxMatch.capturedStart(0), rxMatch.capturedLength(0)))
+        return self._spellErrors
+
+# END Class TextBlockData
diff --git a/novelwriter/gui/editordocument.py b/novelwriter/gui/editordocument.py
new file mode 100644
index 00000000..160e85ed
--- /dev/null
+++ b/novelwriter/gui/editordocument.py
@@ -0,0 +1,126 @@
+"""
+novelWriter – GUI Text Document
+===============================
+
+File History:
+Created: 2023-09-07 [2.2b1]
+
+This file is a part of novelWriter
+Copyright 2018–2023, Veronica Berglyd Olsen
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.
+"""
+from __future__ import annotations
+
+import logging
+
+from time import time
+
+from PyQt5.QtGui import QTextCursor, QTextDocument
+from PyQt5.QtCore import QObject, pyqtSlot
+from PyQt5.QtWidgets import QPlainTextDocumentLayout, qApp
+from novelwriter import SHARED
+
+from novelwriter.gui.dochighlight import GuiDocHighlighter, TextBlockData
+
+logger = logging.getLogger(__name__)
+
+
+class GuiTextDocument(QTextDocument):
+
+    def __init__(self, parent: QObject) -> None:
+        super().__init__(parent=parent)
+
+        self._handle = None
+        self._syntax = GuiDocHighlighter(self)
+        self.setDocumentLayout(QPlainTextDocumentLayout(self))
+
+        logger.debug("Ready: GuiTextDocument")
+
+        return
+
+    def __del__(self):  # pragma: no cover
+        logger.debug("Delete: GuiTextDocument")
+        return
+
+    ##
+    #  Properties
+    ##
+
+    @property
+    def syntaxHighlighter(self) -> GuiDocHighlighter:
+        """Return the document's syntax highlighter object."""
+        return self._syntax
+
+    ##
+    #  Metods
+    ##
+
+    def setTextContent(self, text: str, tHandle: str) -> None:
+        """Set the text content of the document."""
+        self._syntax.setHandle(tHandle)
+
+        self.blockSignals(True)
+        self.setUndoRedoEnabled(False)
+        self.clear()
+
+        tStart = time()
+
+        self.setPlainText(text)
+        count = self.lineCount()
+
+        tMid = time()
+
+        self.setUndoRedoEnabled(True)
+        self.blockSignals(False)
+        self._syntax.rehighlight()
+        qApp.processEvents()
+
+        tEnd = time()
+
+        logger.debug("Loaded %d text blocks in %.3f ms", count, 1000*(tMid - tStart))
+        logger.debug("Highlighted document in %.3f ms", 1000*(tEnd - tMid))
+
+        return
+
+    def spellErrorAtPos(self, pos: int) -> tuple[str, int, int, list[str]]:
+        """Check if there is a misspelled word at a given position in
+        the document, and if so, return it.
+        """
+        cursor = QTextCursor(self)
+        cursor.setPosition(pos)
+        block = cursor.block()
+        data = block.userData()
+        if block.isValid() and isinstance(data, TextBlockData):
+            text = block.text()
+            check = pos - block.position()
+            if check >= 0:
+                for cPos, cLen in data.spellErrors:
+                    cEnd = cPos + cLen
+                    if cPos <= check <= cEnd:
+                        word = text[cPos:cEnd]
+                        return word, cPos, cLen, SHARED.spelling.suggestWords(word)
+        return "", -1, -1, []
+
+    ##
+    #  Public Slots
+    ##
+
+    @pyqtSlot(bool)
+    def setSpellCheckState(self, state: bool) -> None:
+        """Set the spell check state of the syntax highlighter."""
+        self._syntax.setSpellCheck(state)
+        return
+
+# END Class GuiTextDocument
diff --git a/novelwriter/gui/mainmenu.py b/novelwriter/gui/mainmenu.py
index 55813a71..45374ada 100644
--- a/novelwriter/gui/mainmenu.py
+++ b/novelwriter/gui/mainmenu.py
@@ -78,10 +78,11 @@ class GuiMainMenu(QMenuBar):
         return
 
     ##
-    #  Update Menu on Settings Changed
+    #  Public Slots
     ##
 
-    def setSpellCheck(self, state: bool) -> None:
+    @pyqtSlot(bool)
+    def setSpellCheckState(self, state: bool) -> None:
         """Forward spell check check state to its action."""
         self.aSpellCheck.setChecked(state)
         return
diff --git a/novelwriter/guimain.py b/novelwriter/guimain.py
index 8f89a9ed..a5c55fd7 100644
--- a/novelwriter/guimain.py
+++ b/novelwriter/guimain.py
@@ -30,7 +30,7 @@ from time import time
 from pathlib import Path
 from datetime import datetime
 
-from PyQt5.QtCore import Qt, QTimer, QThreadPool, pyqtSlot
+from PyQt5.QtCore import Qt, QTimer, pyqtSlot
 from PyQt5.QtGui import QCloseEvent, QCursor, QIcon, QKeySequence
 from PyQt5.QtWidgets import (
     QDialog, QFileDialog, QHBoxLayout, QMainWindow, QMessageBox, QShortcut,
@@ -95,7 +95,6 @@ class GuiMain(QMainWindow):
 
         logger.debug("Create: GUI")
         self.setObjectName("GuiMain")
-        self.threadPool = QThreadPool(self)
 
         # System Info
         # ===========
@@ -153,7 +152,7 @@ class GuiMain(QMainWindow):
 
         # Project Tree View
         self.treePane = QWidget(self)
-        self.treeBox = QVBoxLayout(self)
+        self.treeBox = QVBoxLayout()
         self.treeBox.setContentsMargins(0, 0, 0, 0)
         self.treeBox.setSpacing(mPx)
         self.treeBox.addWidget(self.projStack)
@@ -223,7 +222,7 @@ class GuiMain(QMainWindow):
         self.rebuildTrees()
 
         # Assemble Main Window Elements
-        self.mainBox = QHBoxLayout(self)
+        self.mainBox = QHBoxLayout()
         self.mainBox.addWidget(self.sideBar)
         self.mainBox.addWidget(self.mainStack)
         self.mainBox.setContentsMargins(0, 0, 0, 0)
@@ -267,6 +266,7 @@ class GuiMain(QMainWindow):
         self.docEditor.novelStructureChanged.connect(self.novelView.refreshTree)
         self.docEditor.novelItemMetaChanged.connect(self.novelView.updateNovelItemMeta)
         self.docEditor.statusMessage.connect(self.mainStatus.setStatusMessage)
+        self.docEditor.spellCheckStateChanged.connect(self.mainMenu.setSpellCheckState)
 
         self.docViewer.loadDocumentTagRequest.connect(self._followTag)
 
@@ -621,10 +621,10 @@ class GuiMain(QMainWindow):
                 break
 
         if nHandle is not None:
-            self.openDocument(nHandle, tLine=0, doScroll=True)
+            self.openDocument(nHandle, tLine=1, doScroll=True)
             return True
         elif wrapAround:
-            self.openDocument(fHandle, tLine=0, doScroll=True)
+            self.openDocument(fHandle, tLine=1, doScroll=True)
             return False
 
         return False
diff --git a/novelwriter/shared.py b/novelwriter/shared.py
index 2a186a75..8ee3099a 100644
--- a/novelwriter/shared.py
+++ b/novelwriter/shared.py
@@ -29,7 +29,7 @@ from time import time
 from typing import TYPE_CHECKING
 from pathlib import Path
 
-from PyQt5.QtCore import QObject, pyqtSignal
+from PyQt5.QtCore import QObject, QRunnable, QThreadPool, pyqtSignal
 from PyQt5.QtWidgets import QMessageBox, QWidget
 
 from novelwriter.core.spellcheck import NWSpellEnchant
@@ -55,14 +55,19 @@ class SharedData(QObject):
 
     def __init__(self) -> None:
         super().__init__()
+
+        # Objects
         self._gui = None
         self._theme = None
         self._project = None
         self._spelling = None
+
+        # Settings
         self._lockedBy = None
         self._alert = None
         self._idleTime = 0.0
         self._idleRefTime = time()
+
         return
 
     ##
@@ -129,7 +134,8 @@ class SharedData(QObject):
         self._gui = gui
         self._theme = theme
         self._resetProject()
-        logger.debug("SharedData instance initialised")
+        logger.debug("Ready: SharedData")
+        logger.debug("Thread Pool Max Count: %d", QThreadPool.globalInstance().maxThreadCount())
         return
 
     def openProject(self, path: str | Path, clearLock: bool = False) -> bool:
@@ -199,6 +205,11 @@ class SharedData(QObject):
         self.projectStatusChanged.emit(state)
         return
 
+    def runInThreadPool(self, runnable: QRunnable, priority: int = 0) -> None:
+        """Queue a runnable in the application thread pool."""
+        QThreadPool.globalInstance().start(runnable, priority=priority)
+        return
+
     ##
     #  Alert Boxes
     ##
diff --git a/sample/content/636b6aa9b697b.nwd b/sample/content/636b6aa9b697b.nwd
index f726f89d..de7f32d7 100644
--- a/sample/content/636b6aa9b697b.nwd
+++ b/sample/content/636b6aa9b697b.nwd
@@ -1,8 +1,8 @@
 %%~name: Making a Scene
 %%~path: 6a2d6d5f4f401/636b6aa9b697b
 %%~kind: NOVEL/DOCUMENT
-%%~hash: 053cc65631403c15ddc112849dc7fcae44eb9d63
-%%~date: Unknown/2023-08-25 16:56:11
+%%~hash: 7aae771de46c3cab06d8be0e860dc0bd383860a5
+%%~date: Unknown/2023-09-07 19:00:10
 ### Making a Scene
 
 @pov: Jane
@@ -15,7 +15,7 @@ Each paragraph in the scene is separated by a blank line. The text supports mini
 
 In addition, the editor supports automatic formatting of “quotes”, both double and ‘single’. Depending on the syntax highlighter settings and colour theme, these can be in different colours. “You can of course use **bold** and _italic_ text inside of quotes too.”
 
-If you have the need for it, you can also add text that can be automatically replaced by other text when you generate a preview or export the project. Now, let’s auto-replace this A with <A>, and this C with <C>. While <E> is just <E>. Press Ctrl+R to see what this looks like in the view pane. The list of auto-replaced text is sett in Project Settings.
+If you have the need for it, you can also add text that can be automatically replaced by other text when you generate a preview or export the project. Now, let’s auto-replace this A with <A>, and this C with <C>. While <E> is just <E>. Press Ctrl+R to see what this looks like in the view pane. The list of auto-replaced text is set in Project Settings.
 
 The editor also supports non breaking spaces, and the spell checker accepts long dashes—like this—as valid word separators. Regular dashes are also supported – and can be automatically inserted when typing two hyphens.
 
diff --git a/sample/nwProject.nwx b/sample/nwProject.nwx
index 8b65ed19..3128d766 100644
--- a/sample/nwProject.nwx
+++ b/sample/nwProject.nwx
@@ -1,6 +1,6 @@
 <?xml version='1.0' encoding='utf-8'?>
-<novelWriterXML appVersion="2.2-alpha1" hexVersion="0x020200a1" fileVersion="1.5" fileRevision="1" timeStamp="2023-09-01 20:48:55">
-  <project id="e2be99af-f9bf-4403-857a-c3d1ac25abea" saveCount="1522" autoCount="237" editTime="75353">
+<novelWriterXML appVersion="2.2-alpha1" hexVersion="0x020200a1" fileVersion="1.5" fileRevision="1" timeStamp="2023-09-07 19:14:50">
+  <project id="e2be99af-f9bf-4403-857a-c3d1ac25abea" saveCount="1531" autoCount="238" editTime="75619">
     <name>Sample Project</name>
     <title>Sample Project</title>
     <author>Jane Smith</author>
@@ -58,27 +58,27 @@
       <name status="sf24ce6" import="ia857f0" active="yes">Chapter One</name>
     </item>
     <item handle="636b6aa9b697b" parent="6a2d6d5f4f401" root="7031beac91f75" order="0" type="FILE" class="NOVEL" layout="DOCUMENT">
-      <meta expanded="no" heading="H3" charCount="2687" wordCount="479" paraCount="14" cursorPos="66" />
+      <meta expanded="no" heading="H3" charCount="2686" wordCount="479" paraCount="14" cursorPos="19" />
       <name status="s90e6c9" import="ia857f0" active="yes">Making a Scene</name>
     </item>
     <item handle="bc0cbd2a407f3" parent="6a2d6d5f4f401" root="7031beac91f75" order="1" type="FILE" class="NOVEL" layout="DOCUMENT">
-      <meta expanded="no" heading="H3" charCount="548" wordCount="108" paraCount="3" cursorPos="465" />
+      <meta expanded="no" heading="H3" charCount="548" wordCount="108" paraCount="3" cursorPos="531" />
       <name status="s90e6c9" import="ia857f0" active="yes">Another Scene</name>
     </item>
     <item handle="ba8a28a246524" parent="7031beac91f75" root="7031beac91f75" order="4" type="FILE" class="NOVEL" layout="DOCUMENT">
-      <meta expanded="no" heading="H2" charCount="617" wordCount="101" paraCount="3" cursorPos="310" />
+      <meta expanded="no" heading="H2" charCount="617" wordCount="101" paraCount="3" cursorPos="0" />
       <name status="s78ea90" import="ia857f0" active="yes">Interlude</name>
     </item>
     <item handle="96b68994dfa3d" parent="7031beac91f75" root="7031beac91f75" order="5" type="FILE" class="NOVEL" layout="NOTE">
-      <meta expanded="no" heading="H1" charCount="1909" wordCount="346" paraCount="7" cursorPos="0" />
+      <meta expanded="no" heading="H1" charCount="1909" wordCount="346" paraCount="7" cursorPos="1940" />
       <name status="sf24ce6" import="ia857f0" active="no">A Note on Structure</name>
     </item>
     <item handle="88706ddc78b1b" parent="7031beac91f75" root="7031beac91f75" order="6" type="FILE" class="NOVEL" layout="DOCUMENT">
-      <meta expanded="yes" heading="H2" charCount="139" wordCount="28" paraCount="1" cursorPos="188" />
+      <meta expanded="yes" heading="H2" charCount="139" wordCount="28" paraCount="1" cursorPos="356" />
       <name status="s90e6c9" import="ia857f0" active="yes">Chapter Two</name>
     </item>
     <item handle="ae7339df26ded" parent="88706ddc78b1b" root="7031beac91f75" order="0" type="FILE" class="NOVEL" layout="DOCUMENT">
-      <meta expanded="no" heading="H3" charCount="189" wordCount="37" paraCount="1" cursorPos="0" />
+      <meta expanded="no" heading="H3" charCount="189" wordCount="37" paraCount="1" cursorPos="237" />
       <name status="s90e6c9" import="ia857f0" active="yes">We Found John!</name>
     </item>
     <item handle="e5e47ebf63b1c" parent="None" root="e5e47ebf63b1c" order="1" type="ROOT" class="NOVEL">
@@ -90,7 +90,7 @@
       <name status="sc24b8f" import="ia857f0" active="yes">Title Page</name>
     </item>
     <item handle="a520879ca0b45" parent="e5e47ebf63b1c" root="e5e47ebf63b1c" order="1" type="FILE" class="NOVEL" layout="DOCUMENT">
-      <meta expanded="no" heading="H2" charCount="299" wordCount="55" paraCount="2" cursorPos="104" />
+      <meta expanded="no" heading="H2" charCount="299" wordCount="55" paraCount="2" cursorPos="387" />
       <name status="s90e6c9" import="ia857f0" active="yes">Chapter One</name>
     </item>
     <item handle="f6622b4617424" parent="None" root="f6622b4617424" order="2" type="ROOT" class="CHARACTER">
@@ -102,11 +102,11 @@
       <name status="sf12341" import="ia857f0">Main Characters</name>
     </item>
     <item handle="14298de4d9524" parent="f7e2d9f330615" root="f6622b4617424" order="0" type="FILE" class="CHARACTER" layout="NOTE">
-      <meta expanded="no" heading="H1" charCount="49" wordCount="9" paraCount="1" cursorPos="24" />
+      <meta expanded="no" heading="H1" charCount="49" wordCount="9" paraCount="1" cursorPos="65" />
       <name status="sf12341" import="icfb3a5" active="yes">John Smith</name>
     </item>
     <item handle="bb2c23b3c42cc" parent="f7e2d9f330615" root="f6622b4617424" order="1" type="FILE" class="CHARACTER" layout="NOTE">
-      <meta expanded="no" heading="H1" charCount="55" wordCount="9" paraCount="1" cursorPos="25" />
+      <meta expanded="no" heading="H1" charCount="55" wordCount="9" paraCount="1" cursorPos="71" />
       <name status="sf12341" import="i2d7a54" active="yes">Jane Smith</name>
     </item>
     <item handle="15c4492bd5107" parent="None" root="15c4492bd5107" order="3" type="ROOT" class="WORLD">
@@ -114,15 +114,15 @@
       <name status="sf12341" import="ia857f0">Locations</name>
     </item>
     <item handle="b3e74dbc1f584" parent="15c4492bd5107" root="15c4492bd5107" order="0" type="FILE" class="WORLD" layout="NOTE">
-      <meta expanded="no" heading="H1" charCount="76" wordCount="15" paraCount="1" cursorPos="20" />
+      <meta expanded="no" heading="H1" charCount="76" wordCount="15" paraCount="1" cursorPos="111" />
       <name status="sf12341" import="i56be10" active="yes">Earth</name>
     </item>
     <item handle="f1471bef9f2ae" parent="15c4492bd5107" root="15c4492bd5107" order="1" type="FILE" class="WORLD" layout="NOTE">
-      <meta expanded="no" heading="H1" charCount="115" wordCount="24" paraCount="1" cursorPos="133" />
+      <meta expanded="no" heading="H1" charCount="115" wordCount="24" paraCount="1" cursorPos="135" />
       <name status="sf12341" import="icfb3a5" active="yes">Space</name>
     </item>
     <item handle="5eaea4e8cdee8" parent="15c4492bd5107" root="15c4492bd5107" order="2" type="FILE" class="WORLD" layout="NOTE">
-      <meta expanded="no" heading="H1" charCount="28" wordCount="6" paraCount="1" cursorPos="45" />
+      <meta expanded="no" heading="H1" charCount="28" wordCount="6" paraCount="1" cursorPos="62" />
       <name status="sf12341" import="i2d7a54" active="yes">Mars</name>
     </item>
     <item handle="6827118336ac1" parent="None" root="6827118336ac1" order="4" type="ROOT" class="ARCHIVE">
diff --git a/tests/reference/guiEditor_Main_Final_000000000000f.nwd b/tests/reference/guiEditor_Main_Final_000000000000f.nwd
index 840d78eb..f5402f40 100644
--- a/tests/reference/guiEditor_Main_Final_000000000000f.nwd
+++ b/tests/reference/guiEditor_Main_Final_000000000000f.nwd
@@ -1,8 +1,8 @@
 %%~name: New Scene
 %%~path: 000000000000d/000000000000f
 %%~kind: NOVEL/DOCUMENT
-%%~hash: fd5dc2f0c9767cb124b1bf2300d7a33b7780045e
-%%~date: 2023-08-25 18:08:01/2023-08-25 18:08:04
+%%~hash: 2a863dc53e09b0b1b0294ae7ea001853dddd596d
+%%~date: 2023-10-17 20:52:56/2023-10-17 20:53:01
 # Novel
 
 ## Chapter
@@ -54,3 +54,5 @@ But don’t add a double space : See?
 
 >>‘Right-aligned text’
 
+Some text with tesst in it.
+
diff --git a/tests/reference/guiEditor_Main_Final_nwProject.nwx b/tests/reference/guiEditor_Main_Final_nwProject.nwx
index 104080e9..c56d9782 100644
--- a/tests/reference/guiEditor_Main_Final_nwProject.nwx
+++ b/tests/reference/guiEditor_Main_Final_nwProject.nwx
@@ -1,6 +1,6 @@
 <?xml version='1.0' encoding='utf-8'?>
-<novelWriterXML appVersion="2.0.7" hexVersion="0x020007f0" fileVersion="1.5" fileRevision="1" timeStamp="2023-06-03 18:23:02">
-  <project id="d0f3fe10-c6e6-4310-8bfd-181eb4224eed" saveCount="3" autoCount="2" editTime="3">
+<novelWriterXML appVersion="2.2-alpha1" hexVersion="0x020200a1" fileVersion="1.5" fileRevision="1" timeStamp="2023-10-17 20:52:34">
+  <project id="d0f3fe10-c6e6-4310-8bfd-181eb4224eed" saveCount="3" autoCount="2" editTime="4">
     <name>New Project</name>
     <title>New Novel</title>
     <author>Jane Doe</author>
@@ -29,7 +29,7 @@
       <entry key="i000007" count="0" red="50" green="200" blue="0">Main</entry>
     </importance>
   </settings>
-  <content items="11" novelWords="136" notesWords="27">
+  <content items="11" novelWords="142" notesWords="27">
     <item handle="0000000000008" parent="None" root="0000000000008" order="0" type="ROOT" class="NOVEL">
       <meta expanded="yes" />
       <name status="s000000" import="i000004">Novel</name>
@@ -47,7 +47,7 @@
       <name status="s000000" import="i000004" active="yes">New Chapter</name>
     </item>
     <item handle="000000000000f" parent="000000000000d" root="0000000000008" order="1" type="FILE" class="NOVEL" layout="DOCUMENT">
-      <meta expanded="no" heading="H1" charCount="781" wordCount="129" paraCount="14" cursorPos="1010" />
+      <meta expanded="no" heading="H1" charCount="808" wordCount="135" paraCount="15" cursorPos="1026" />
       <name status="s000000" import="i000004" active="yes">New Scene</name>
     </item>
     <item handle="0000000000009" parent="None" root="0000000000009" order="1" type="ROOT" class="PLOT">
diff --git a/tests/test_gui/test_gui_doceditor.py b/tests/test_gui/test_gui_doceditor.py
index 8bee4ab4..faa75027 100644
--- a/tests/test_gui/test_gui_doceditor.py
+++ b/tests/test_gui/test_gui_doceditor.py
@@ -24,7 +24,7 @@ import pytest
 from mocked import causeOSError
 from tools import C, buildTestProject
 
-from PyQt5.QtCore import Qt
+from PyQt5.QtCore import QThreadPool, Qt
 from PyQt5.QtGui import QTextBlock, QTextCursor, QTextOption
 from PyQt5.QtWidgets import QAction, qApp
 
@@ -1100,13 +1100,14 @@ def testGuiEditor_WordCounters(qtbot, monkeypatch, nwGUI, projPath, ipsumText, m
         def __init__(self):
             self._objID = None
 
-        def start(self, runObj):
+        def start(self, runObj, priority=0):
             self._objID = id(runObj)
 
         def objectID(self):
             return self._objID
 
-    nwGUI.threadPool = MockThreadPool()
+    threadPool = MockThreadPool()
+    monkeypatch.setattr(QThreadPool, "globalInstance", lambda *a: threadPool)
     nwGUI.docEditor.wcTimerDoc.blockSignals(True)
     nwGUI.docEditor.wcTimerSel.blockSignals(True)
 
@@ -1145,7 +1146,7 @@ def testGuiEditor_WordCounters(qtbot, monkeypatch, nwGUI, projPath, ipsumText, m
 
     # Run the full word counter
     nwGUI.docEditor._runDocCounter()
-    assert nwGUI.threadPool.objectID() == id(nwGUI.docEditor.wCounterDoc)
+    assert threadPool.objectID() == id(nwGUI.docEditor.wCounterDoc)
 
     nwGUI.docEditor.wCounterDoc.run()
     # nwGUI.docEditor._updateDocCounts(cC, wC, pC)
@@ -1161,7 +1162,7 @@ def testGuiEditor_WordCounters(qtbot, monkeypatch, nwGUI, projPath, ipsumText, m
 
     # Run the selection word counter
     nwGUI.docEditor._runSelCounter()
-    assert nwGUI.threadPool.objectID() == id(nwGUI.docEditor.wCounterSel)
+    assert threadPool.objectID() == id(nwGUI.docEditor.wCounterSel)
 
     nwGUI.docEditor.wCounterSel.run()
     # nwGUI.docEditor._updateSelCounts(cC, wC, pC)
diff --git a/tests/test_gui/test_gui_guimain.py b/tests/test_gui/test_gui_guimain.py
index 0a66ef13..30a17c5b 100644
--- a/tests/test_gui/test_gui_guimain.py
+++ b/tests/test_gui/test_gui_guimain.py
@@ -19,6 +19,7 @@ You should have received a copy of the GNU General Public License
 along with this program. If not, see <https://www.gnu.org/licenses/>.
 """
 
+import sys
 import pytest
 
 from shutil import copyfile
@@ -28,7 +29,7 @@ from tools import (
 )
 
 from PyQt5.QtCore import Qt
-from PyQt5.QtWidgets import QDialog, QMessageBox, QInputDialog
+from PyQt5.QtWidgets import QDialog, QMenu, QMessageBox, QInputDialog
 
 from novelwriter import CONFIG, SHARED
 from novelwriter.enum import nwItemType, nwView, nwWidget
@@ -47,8 +48,7 @@ KEY_DELAY = 1
 
 @pytest.mark.gui
 def testGuiMain_ProjectBlocker(nwGUI):
-    """Test the blocking of features when there's no project open.
-    """
+    """Test the blocking of features when there's no project open."""
     # Test no-project blocking
     assert nwGUI.closeProject() is True
     assert nwGUI.saveProject() is False
@@ -254,20 +254,25 @@ def testGuiMain_Editing(qtbot, monkeypatch, nwGUI, projPath, tstPaths, mockRnd):
     nwGUI.projView.projTree.newTreeItem(nwItemType.FILE, None, isNote=True)
     assert nwGUI.openSelectedItem()
 
+    # Text Editor
+    # ===========
+
+    docEditor: GuiDocEditor = nwGUI.docEditor
+
     # Type something into the document
     nwGUI.switchFocus(nwWidget.EDITOR)
-    qtbot.keyClick(nwGUI.docEditor, "a", modifier=Qt.ControlModifier, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, "a", modifier=Qt.ControlModifier, delay=KEY_DELAY)
     for c in "# Jane Doe":
-        qtbot.keyClick(nwGUI.docEditor, c, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
+        qtbot.keyClick(docEditor, c, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
     for c in "@tag: Jane":
-        qtbot.keyClick(nwGUI.docEditor, c, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
+        qtbot.keyClick(docEditor, c, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
     for c in "This is a file about Jane.":
-        qtbot.keyClick(nwGUI.docEditor, c, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
+        qtbot.keyClick(docEditor, c, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
 
     # Add a Plot File
     nwGUI.switchFocus(nwWidget.TREE)
@@ -278,18 +283,18 @@ def testGuiMain_Editing(qtbot, monkeypatch, nwGUI, projPath, tstPaths, mockRnd):
 
     # Type something into the document
     nwGUI.switchFocus(nwWidget.EDITOR)
-    qtbot.keyClick(nwGUI.docEditor, "a", modifier=Qt.ControlModifier, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, "a", modifier=Qt.ControlModifier, delay=KEY_DELAY)
     for c in "# Main Plot":
-        qtbot.keyClick(nwGUI.docEditor, c, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
+        qtbot.keyClick(docEditor, c, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
     for c in "@tag: MainPlot":
-        qtbot.keyClick(nwGUI.docEditor, c, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
+        qtbot.keyClick(docEditor, c, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
     for c in "This is a file detailing the main plot.":
-        qtbot.keyClick(nwGUI.docEditor, c, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
+        qtbot.keyClick(docEditor, c, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
 
     # Add a World File
     nwGUI.switchFocus(nwWidget.TREE)
@@ -299,24 +304,24 @@ def testGuiMain_Editing(qtbot, monkeypatch, nwGUI, projPath, tstPaths, mockRnd):
     assert nwGUI.openSelectedItem()
 
     # Add Some Text
-    nwGUI.docEditor.replaceText("Hello World!")
-    assert nwGUI.docEditor.getText() == "Hello World!"
-    nwGUI.docEditor.replaceText("")
+    docEditor.replaceText("Hello World!")
+    assert docEditor.getText() == "Hello World!"
+    docEditor.replaceText("")
 
     # Type something into the document
     nwGUI.switchFocus(nwWidget.EDITOR)
-    qtbot.keyClick(nwGUI.docEditor, "a", modifier=Qt.ControlModifier, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, "a", modifier=Qt.ControlModifier, delay=KEY_DELAY)
     for c in "# Main Location":
-        qtbot.keyClick(nwGUI.docEditor, c, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
+        qtbot.keyClick(docEditor, c, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
     for c in "@tag: Home":
-        qtbot.keyClick(nwGUI.docEditor, c, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
+        qtbot.keyClick(docEditor, c, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
     for c in "This is a file describing Jane's home.":
-        qtbot.keyClick(nwGUI.docEditor, c, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
+        qtbot.keyClick(docEditor, c, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
 
     # Trigger autosaves before making more changes
     nwGUI._autoSaveDocument()
@@ -332,67 +337,67 @@ def testGuiMain_Editing(qtbot, monkeypatch, nwGUI, projPath, tstPaths, mockRnd):
 
     # Type something into the document
     nwGUI.switchFocus(nwWidget.EDITOR)
-    qtbot.keyClick(nwGUI.docEditor, "a", modifier=Qt.ControlModifier, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, "a", modifier=Qt.ControlModifier, delay=KEY_DELAY)
     for c in "# Novel":
-        qtbot.keyClick(nwGUI.docEditor, c, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
+        qtbot.keyClick(docEditor, c, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
 
     for c in "## Chapter":
-        qtbot.keyClick(nwGUI.docEditor, c, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
+        qtbot.keyClick(docEditor, c, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
 
     for c in "@pov: Jane":
-        qtbot.keyClick(nwGUI.docEditor, c, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
+        qtbot.keyClick(docEditor, c, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
     for c in "@plot: MainPlot":
-        qtbot.keyClick(nwGUI.docEditor, c, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
+        qtbot.keyClick(docEditor, c, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
 
     for c in "### Scene":
-        qtbot.keyClick(nwGUI.docEditor, c, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
+        qtbot.keyClick(docEditor, c, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
 
     for c in "% How about a comment?":
-        qtbot.keyClick(nwGUI.docEditor, c, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
+        qtbot.keyClick(docEditor, c, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
     for c in "@pov: Jane":
-        qtbot.keyClick(nwGUI.docEditor, c, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
+        qtbot.keyClick(docEditor, c, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
     for c in "@plot: MainPlot":
-        qtbot.keyClick(nwGUI.docEditor, c, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
+        qtbot.keyClick(docEditor, c, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
     for c in "@location: Home":
-        qtbot.keyClick(nwGUI.docEditor, c, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
+        qtbot.keyClick(docEditor, c, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
 
     for c in "#### Some Section":
-        qtbot.keyClick(nwGUI.docEditor, c, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
+        qtbot.keyClick(docEditor, c, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
 
     for c in "@char: Jane":
-        qtbot.keyClick(nwGUI.docEditor, c, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
+        qtbot.keyClick(docEditor, c, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
 
     for c in "This is a paragraph of nonsense text.":
-        qtbot.keyClick(nwGUI.docEditor, c, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
+        qtbot.keyClick(docEditor, c, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
 
     # Don't allow Shift+Enter to insert a line separator (issue #1150)
     for c in "This is another paragraph":
-        qtbot.keyClick(nwGUI.docEditor, c, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Enter, modifier=Qt.ShiftModifier, delay=KEY_DELAY)
+        qtbot.keyClick(docEditor, c, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Enter, modifier=Qt.ShiftModifier, delay=KEY_DELAY)
     for c in "with a line separator in it.":
-        qtbot.keyClick(nwGUI.docEditor, c, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
+        qtbot.keyClick(docEditor, c, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
 
     # Auto-Replace
     # ============
@@ -401,111 +406,139 @@ def testGuiMain_Editing(qtbot, monkeypatch, nwGUI, projPath, tstPaths, mockRnd):
         "This is another paragraph of much longer nonsense text. "
         "It is in fact 1 very very NONSENSICAL nonsense text! "
     ):
-        qtbot.keyClick(nwGUI.docEditor, c, delay=KEY_DELAY)
+        qtbot.keyClick(docEditor, c, delay=KEY_DELAY)
     for c in "We can also try replacing \"quotes\", even single 'quotes' are replaced. ":
-        qtbot.keyClick(nwGUI.docEditor, c, delay=KEY_DELAY)
+        qtbot.keyClick(docEditor, c, delay=KEY_DELAY)
     for c in "Isn't that nice? ":
-        qtbot.keyClick(nwGUI.docEditor, c, delay=KEY_DELAY)
+        qtbot.keyClick(docEditor, c, delay=KEY_DELAY)
     for c in "We can hyphen-ate, make dashes -- and even longer dashes --- if we want. ":
-        qtbot.keyClick(nwGUI.docEditor, c, delay=KEY_DELAY)
+        qtbot.keyClick(docEditor, c, delay=KEY_DELAY)
     for c in "Ellipsis? Not a problem either ... ":
-        qtbot.keyClick(nwGUI.docEditor, c, delay=KEY_DELAY)
+        qtbot.keyClick(docEditor, c, delay=KEY_DELAY)
     for c in "How about three hyphens - -":
-        qtbot.keyClick(nwGUI.docEditor, c, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Left, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Backspace, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Right, delay=KEY_DELAY)
+        qtbot.keyClick(docEditor, c, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Left, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Backspace, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Right, delay=KEY_DELAY)
     for c in "- for long dash? It works too.":
-        qtbot.keyClick(nwGUI.docEditor, c, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
+        qtbot.keyClick(docEditor, c, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
 
     for c in "\"Full line double quoted text.\"":
-        qtbot.keyClick(nwGUI.docEditor, c, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
+        qtbot.keyClick(docEditor, c, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
 
     for c in "'Full line single quoted text.'":
-        qtbot.keyClick(nwGUI.docEditor, c, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
+        qtbot.keyClick(docEditor, c, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
 
     # Insert spaces before and after quotes
-    nwGUI.docEditor._typPadBefore = "\u201d"
-    nwGUI.docEditor._typPadAfter = "\u201c"
+    docEditor._typPadBefore = "\u201d"
+    docEditor._typPadAfter = "\u201c"
 
     for c in "Some \"double quoted text with spaces padded\".":
-        qtbot.keyClick(nwGUI.docEditor, c, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
+        qtbot.keyClick(docEditor, c, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
 
-    nwGUI.docEditor._typPadBefore = ""
-    nwGUI.docEditor._typPadAfter = ""
+    docEditor._typPadBefore = ""
+    docEditor._typPadAfter = ""
 
     # Insert spaces before colon, but ignore tags and synopsis
-    nwGUI.docEditor._typPadBefore = ":"
+    docEditor._typPadBefore = ":"
 
     for c in "@object: NoSpaceAdded":
-        qtbot.keyClick(nwGUI.docEditor, c, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
+        qtbot.keyClick(docEditor, c, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
 
     for c in "% synopsis: No space before this colon.":
-        qtbot.keyClick(nwGUI.docEditor, c, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
+        qtbot.keyClick(docEditor, c, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
 
     for c in "Add space before this colon: See?":
-        qtbot.keyClick(nwGUI.docEditor, c, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
+        qtbot.keyClick(docEditor, c, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
 
     for c in "But don't add a double space : See?":
-        qtbot.keyClick(nwGUI.docEditor, c, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
+        qtbot.keyClick(docEditor, c, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
 
-    nwGUI.docEditor._typPadBefore = ""
+    docEditor._typPadBefore = ""
 
     # Indent and Align
     # ================
 
     for c in "\t\"Tab-indented text\"":
-        qtbot.keyClick(nwGUI.docEditor, c, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
+        qtbot.keyClick(docEditor, c, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
 
     for c in ">\"Paragraph-indented text\"":
-        qtbot.keyClick(nwGUI.docEditor, c, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
+        qtbot.keyClick(docEditor, c, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
 
     for c in ">>\"Right-aligned text\"":
-        qtbot.keyClick(nwGUI.docEditor, c, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
+        qtbot.keyClick(docEditor, c, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
 
     for c in "\t'Tab-indented text'":
-        qtbot.keyClick(nwGUI.docEditor, c, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
+        qtbot.keyClick(docEditor, c, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
 
     for c in ">'Paragraph-indented text'":
-        qtbot.keyClick(nwGUI.docEditor, c, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
+        qtbot.keyClick(docEditor, c, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
 
     for c in ">>'Right-aligned text'":
-        qtbot.keyClick(nwGUI.docEditor, c, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
-    qtbot.keyClick(nwGUI.docEditor, Qt.Key_Return, delay=KEY_DELAY)
+        qtbot.keyClick(docEditor, c, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
 
-    nwGUI.docEditor.wCounterDoc.run()
+    docEditor.wCounterDoc.run()
+
+    # Spell Checking
+    # ==============
+
+    for c in "Some text with tesst in it.":
+        qtbot.keyClick(docEditor, c, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
+    qtbot.keyClick(docEditor, Qt.Key_Return, delay=KEY_DELAY)
+
+    currPos = docEditor.getCursorPosition()
+    assert docEditor._qDocument.spellErrorAtPos(currPos) == ("", -1, -1, [])
+
+    errPos = currPos - 13
+    if not sys.platform.startswith("win32"):
+        # Skip on Windows as spell checking is off there
+        word, cPos, cLen, suggest = docEditor._qDocument.spellErrorAtPos(errPos)
+        assert word == "tesst"
+        assert cPos == 15
+        assert cLen == 5
+        assert "test" in suggest
+
+    with monkeypatch.context() as mp:
+        mp.setattr(QMenu, "exec_", lambda *a: None)
+        docEditor.setCursorPosition(errPos)
+        docEditor._openSpellContext()
+
+    # Check Files
+    # ===========
 
     # Save the document
-    assert nwGUI.docEditor.docChanged
+    assert docEditor.docChanged
     assert nwGUI.saveDocument()
-    assert not nwGUI.docEditor.docChanged
+    assert not docEditor.docChanged
     nwGUI.rebuildIndex()
 
     # Open and view the edited document