novelWriter 2.4.2__py3-none-any.whl → 2.5b1__py3-none-any.whl

novelwriter/gui/dochighlight.py

@@ -28,26 +28,27 @@ import logging
 
 from time import time
 
-from PyQt5.QtCore import Qt, QRegularExpression
+from PyQt5.QtCore import QRegularExpression, Qt
 from PyQt5.QtGui import (
     QBrush, QColor, QFont, QSyntaxHighlighter, QTextBlockUserData,
     QTextCharFormat, QTextDocument
 )
 
 from novelwriter import CONFIG, SHARED
-from novelwriter.enum import nwComment
 from novelwriter.common import checkInt
-from novelwriter.constants import nwRegEx, nwUnicode
+from novelwriter.constants import nwHeaders, nwRegEx, nwUnicode
 from novelwriter.core.index import processComment
+from novelwriter.enum import nwComment
+from novelwriter.types import QRegExUnicode
 
 logger = logging.getLogger(__name__)
 
 SPELLRX = QRegularExpression(r"\b[^\s\-\+\/–—\[\]:]+\b")
-SPELLRX.setPatternOptions(QRegularExpression.UseUnicodePropertiesOption)
+SPELLRX.setPatternOptions(QRegExUnicode)
 SPELLSC = QRegularExpression(nwRegEx.FMT_SC)
-SPELLSC.setPatternOptions(QRegularExpression.UseUnicodePropertiesOption)
+SPELLSC.setPatternOptions(QRegExUnicode)
 SPELLSV = QRegularExpression(nwRegEx.FMT_SV)
-SPELLSV.setPatternOptions(QRegularExpression.UseUnicodePropertiesOption)
+SPELLSV.setPatternOptions(QRegExUnicode)
 
 BLOCK_NONE  = 0
 BLOCK_TEXT  = 1
@@ -57,8 +58,10 @@ BLOCK_TITLE = 4
 
 class GuiDocHighlighter(QSyntaxHighlighter):
 
-    __slots__ = ("_tHandle", "_isInactive", "_spellCheck", "_spellErr",
-                 "_hRules", "_hStyles", "_rxRules")
+    __slots__ = (
+        "_tHandle", "_isInactive", "_spellCheck", "_spellErr", "_hStyles",
+        "_txtRules", "_cmnRules",
+    )
 
     def __init__(self, document: QTextDocument) -> None:
         super().__init__(document)
@@ -70,9 +73,9 @@ class GuiDocHighlighter(QSyntaxHighlighter):
         self._spellCheck = False
         self._spellErr = QTextCharFormat()
 
-        self._hRules: list[tuple[str, dict]] = []
         self._hStyles: dict[str, QTextCharFormat] = {}
-        self._rxRules: list[tuple[QRegularExpression, dict[str, QTextCharFormat]]] = []
+        self._txtRules: list[tuple[QRegularExpression, dict[int, QTextCharFormat]]] = []
+        self._cmnRules: list[tuple[QRegularExpression, dict[int, QTextCharFormat]]] = []
 
         self.initHighlighter()
 
@@ -90,145 +93,178 @@ class GuiDocHighlighter(QSyntaxHighlighter):
         colBreak = QColor(SHARED.theme.colEmph)
         colBreak.setAlpha(64)
 
-        self._hRules = []
-        self._hStyles = {
-            "header1":   self._makeFormat(SHARED.theme.colHead, "bold", 1.8),
-            "header2":   self._makeFormat(SHARED.theme.colHead, "bold", 1.6),
-            "header3":   self._makeFormat(SHARED.theme.colHead, "bold", 1.4),
-            "header4":   self._makeFormat(SHARED.theme.colHead, "bold", 1.2),
-            "head1h":    self._makeFormat(SHARED.theme.colHeadH, "bold", 1.8),
-            "head2h":    self._makeFormat(SHARED.theme.colHeadH, "bold", 1.6),
-            "head3h":    self._makeFormat(SHARED.theme.colHeadH, "bold", 1.4),
-            "head4h":    self._makeFormat(SHARED.theme.colHeadH, "bold", 1.2),
-            "bold":      self._makeFormat(colEmph, "bold"),
-            "italic":    self._makeFormat(colEmph, "italic"),
-            "strike":    self._makeFormat(SHARED.theme.colHidden, "strike"),
-            "mspaces":   self._makeFormat(SHARED.theme.colError, "errline"),
-            "nobreak":   self._makeFormat(colBreak, "background"),
-            "dialogue1": self._makeFormat(SHARED.theme.colDialN),
-            "dialogue2": self._makeFormat(SHARED.theme.colDialD),
-            "dialogue3": self._makeFormat(SHARED.theme.colDialS),
-            "replace":   self._makeFormat(SHARED.theme.colRepTag),
-            "hidden":    self._makeFormat(SHARED.theme.colHidden),
-            "code":      self._makeFormat(SHARED.theme.colCode),
-            "keyword":   self._makeFormat(SHARED.theme.colKey),
-            "modifier":  self._makeFormat(SHARED.theme.colMod),
-            "value":     self._makeFormat(SHARED.theme.colVal),
-            "optional":  self._makeFormat(SHARED.theme.colOpt),
-            "codevalue": self._makeFormat(SHARED.theme.colVal),
-            "codeinval": self._makeFormat(None, "errline"),
-        }
+        # Create Character Formats
+        self._addCharFormat("text",      SHARED.theme.colText)
+        self._addCharFormat("header1",   SHARED.theme.colHead, "b", nwHeaders.H_SIZES[1])
+        self._addCharFormat("header2",   SHARED.theme.colHead, "b", nwHeaders.H_SIZES[2])
+        self._addCharFormat("header3",   SHARED.theme.colHead, "b", nwHeaders.H_SIZES[3])
+        self._addCharFormat("header4",   SHARED.theme.colHead, "b", nwHeaders.H_SIZES[4])
+        self._addCharFormat("head1h",    SHARED.theme.colHeadH, "b", nwHeaders.H_SIZES[1])
+        self._addCharFormat("head2h",    SHARED.theme.colHeadH, "b", nwHeaders.H_SIZES[2])
+        self._addCharFormat("head3h",    SHARED.theme.colHeadH, "b", nwHeaders.H_SIZES[3])
+        self._addCharFormat("head4h",    SHARED.theme.colHeadH, "b", nwHeaders.H_SIZES[4])
+        self._addCharFormat("bold",      colEmph, "b")
+        self._addCharFormat("italic",    colEmph, "i")
+        self._addCharFormat("strike",    SHARED.theme.colHidden, "s")
+        self._addCharFormat("mspaces",   SHARED.theme.colError, "err")
+        self._addCharFormat("nobreak",   colBreak, "bg")
+        self._addCharFormat("altdialog", SHARED.theme.colDialA)
+        self._addCharFormat("dialog",    SHARED.theme.colDialN)
+        self._addCharFormat("replace",   SHARED.theme.colRepTag)
+        self._addCharFormat("hidden",    SHARED.theme.colHidden)
+        self._addCharFormat("markup",    SHARED.theme.colHidden)
+        self._addCharFormat("note",      SHARED.theme.colNote)
+        self._addCharFormat("code",      SHARED.theme.colCode)
+        self._addCharFormat("keyword",   SHARED.theme.colKey)
+        self._addCharFormat("tag",       SHARED.theme.colTag)
+        self._addCharFormat("modifier",  SHARED.theme.colMod)
+        self._addCharFormat("value",     SHARED.theme.colVal)
+        self._addCharFormat("optional",  SHARED.theme.colOpt)
+        self._addCharFormat("invalid",   None, "err")
 
         # Cache Spell Error Format
         self._spellErr = QTextCharFormat()
         self._spellErr.setUnderlineColor(SHARED.theme.colSpell)
         self._spellErr.setUnderlineStyle(QTextCharFormat.UnderlineStyle.SpellCheckUnderline)
 
+        self._txtRules.clear()
+        self._cmnRules.clear()
+
         # Multiple or Trailing Spaces
         if CONFIG.showMultiSpaces:
-            self._hRules.append((
-                r"[ ]{2,}|[ ]*$", {
-                    0: self._hStyles["mspaces"],
-                }
-            ))
+            rxRule = QRegularExpression(r"[ ]{2,}|[ ]*$")
+            rxRule.setPatternOptions(QRegExUnicode)
+            hlRule = {
+                0: self._hStyles["mspaces"],
+            }
+            self._txtRules.append((rxRule, hlRule))
+            self._cmnRules.append((rxRule, hlRule))
 
         # Non-Breaking Spaces
-        self._hRules.append((
-            f"[{nwUnicode.U_NBSP}{nwUnicode.U_THNBSP}]+", {
-                0: self._hStyles["nobreak"],
+        rxRule = QRegularExpression(f"[{nwUnicode.U_NBSP}{nwUnicode.U_THNBSP}]+")
+        rxRule.setPatternOptions(QRegExUnicode)
+        hlRule = {
+            0: self._hStyles["nobreak"],
+        }
+        self._txtRules.append((rxRule, hlRule))
+        self._cmnRules.append((rxRule, hlRule))
+
+        # Dialogue
+        if CONFIG.dialogStyle > 0:
+            symO = ""
+            symC = ""
+            if CONFIG.dialogStyle in (1, 3):
+                symO += CONFIG.fmtSQuoteOpen
+                symC += CONFIG.fmtSQuoteClose
+            if CONFIG.dialogStyle in (2, 3):
+                symO += CONFIG.fmtDQuoteOpen
+                symC += CONFIG.fmtDQuoteClose
+
+            rxEnd = "|$" if CONFIG.allowOpenDial else ""
+            rxRule = QRegularExpression(f"\\B[{symO}].*?[{symC}]\\B{rxEnd}")
+            rxRule.setPatternOptions(QRegExUnicode)
+            hlRule = {
+                0: self._hStyles["dialog"],
             }
-        ))
-
-        # Quoted Strings
-        if CONFIG.highlightQuotes:
-            fmtDblO = CONFIG.fmtDQuoteOpen
-            fmtDblC = CONFIG.fmtDQuoteClose
-            fmtSngO = CONFIG.fmtSQuoteOpen
-            fmtSngC = CONFIG.fmtSQuoteClose
-
-            # Straight Quotes
-            if not (fmtDblO == fmtDblC == "\""):
-                self._hRules.append((
-                    "(\\B\")(.*?)(\"\\B)", {
-                        0: self._hStyles["dialogue1"],
-                    }
-                ))
-
-            # Double Quotes
-            dblEnd = "|$" if CONFIG.allowOpenDQuote else ""
-            self._hRules.append((
-                f"(\\B{fmtDblO})(.*?)({fmtDblC}\\B{dblEnd})", {
-                    0: self._hStyles["dialogue2"],
-                }
-            ))
-
-            # Single Quotes
-            sngEnd = "|$" if CONFIG.allowOpenSQuote else ""
-            self._hRules.append((
-                f"(\\B{fmtSngO})(.*?)({fmtSngC}\\B{sngEnd})", {
-                    0: self._hStyles["dialogue3"],
-                }
-            ))
-
-        # Markdown Syntax
-        self._hRules.append((
-            nwRegEx.FMT_EI, {
-                1: self._hStyles["hidden"],
-                2: self._hStyles["italic"],
-                3: self._hStyles["hidden"],
+            self._txtRules.append((rxRule, hlRule))
+
+        if CONFIG.dialogLine:
+            sym = QRegularExpression.escape(CONFIG.dialogLine)
+            rxRule = QRegularExpression(f"^{sym}.*?$")
+            rxRule.setPatternOptions(QRegExUnicode)
+            hlRule = {
+                0: self._hStyles["dialog"],
             }
-        ))
-        self._hRules.append((
-            nwRegEx.FMT_EB, {
-                1: self._hStyles["hidden"],
-                2: self._hStyles["bold"],
-                3: self._hStyles["hidden"],
+            self._txtRules.append((rxRule, hlRule))
+
+        if CONFIG.narratorBreak:
+            sym = QRegularExpression.escape(CONFIG.narratorBreak)
+            rxRule = QRegularExpression(f"({sym}\\b)(.*?)(\\b{sym})")
+            rxRule.setPatternOptions(QRegExUnicode)
+            hlRule = {
+                0: self._hStyles["text"],
             }
-        ))
-        self._hRules.append((
-            nwRegEx.FMT_ST, {
-                1: self._hStyles["hidden"],
-                2: self._hStyles["strike"],
-                3: self._hStyles["hidden"],
+            self._txtRules.append((rxRule, hlRule))
+
+        if CONFIG.altDialogOpen and CONFIG.altDialogClose:
+            symO = QRegularExpression.escape(CONFIG.altDialogOpen)
+            symC = QRegularExpression.escape(CONFIG.altDialogClose)
+            rxRule = QRegularExpression(f"\\B{symO}.*?{symC}\\B")
+            rxRule.setPatternOptions(QRegExUnicode)
+            hlRule = {
+                0: self._hStyles["altdialog"],
             }
-        ))
+            self._txtRules.append((rxRule, hlRule))
+
+        # Markdown Italic
+        rxRule = QRegularExpression(nwRegEx.FMT_EI)
+        rxRule.setPatternOptions(QRegExUnicode)
+        hlRule = {
+            1: self._hStyles["markup"],
+            2: self._hStyles["italic"],
+            3: self._hStyles["markup"],
+        }
+        self._txtRules.append((rxRule, hlRule))
+        self._cmnRules.append((rxRule, hlRule))
+
+        # Markdown Bold
+        rxRule = QRegularExpression(nwRegEx.FMT_EB)
+        rxRule.setPatternOptions(QRegExUnicode)
+        hlRule = {
+            1: self._hStyles["markup"],
+            2: self._hStyles["bold"],
+            3: self._hStyles["markup"],
+        }
+        self._txtRules.append((rxRule, hlRule))
+        self._cmnRules.append((rxRule, hlRule))
+
+        # Markdown Strikethrough
+        rxRule = QRegularExpression(nwRegEx.FMT_ST)
+        rxRule.setPatternOptions(QRegExUnicode)
+        hlRule = {
+            1: self._hStyles["markup"],
+            2: self._hStyles["strike"],
+            3: self._hStyles["markup"],
+        }
+        self._txtRules.append((rxRule, hlRule))
+        self._cmnRules.append((rxRule, hlRule))
 
         # Shortcodes
-        self._hRules.append((
-            nwRegEx.FMT_SC, {
-                1: self._hStyles["code"],
-            }
-        ))
+        rxRule = QRegularExpression(nwRegEx.FMT_SC)
+        rxRule.setPatternOptions(QRegExUnicode)
+        hlRule = {
+            1: self._hStyles["code"],
+        }
+        self._txtRules.append((rxRule, hlRule))
+        self._cmnRules.append((rxRule, hlRule))
 
         # Shortcodes w/Value
-        self._hRules.append((
-            nwRegEx.FMT_SV, {
-                1: self._hStyles["code"],
-                2: self._hStyles["codevalue"],
-                3: self._hStyles["code"],
-            }
-        ))
+        rxRule = QRegularExpression(nwRegEx.FMT_SV)
+        rxRule.setPatternOptions(QRegExUnicode)
+        hlRule = {
+            1: self._hStyles["code"],
+            2: self._hStyles["value"],
+            3: self._hStyles["code"],
+        }
+        self._txtRules.append((rxRule, hlRule))
+        self._cmnRules.append((rxRule, hlRule))
 
         # Alignment Tags
-        self._hRules.append((
-            r"(^>{1,2}|<{1,2}$)", {
-                1: self._hStyles["hidden"],
-            }
-        ))
+        rxRule = QRegularExpression(r"(^>{1,2}|<{1,2}$)")
+        rxRule.setPatternOptions(QRegExUnicode)
+        hlRule = {
+            1: self._hStyles["markup"],
+        }
+        self._txtRules.append((rxRule, hlRule))
 
         # Auto-Replace Tags
-        self._hRules.append((
-            r"<(\S+?)>", {
-                0: self._hStyles["replace"],
-            }
-        ))
-
-        # Build a QRegExp for each highlight pattern
-        self._rxRules = []
-        for regEx, regRules in self._hRules:
-            hReg = QRegularExpression(regEx)
-            hReg.setPatternOptions(QRegularExpression.UseUnicodePropertiesOption)
-            self._rxRules.append((hReg, regRules))
+        rxRule = QRegularExpression(r"<(\S+?)>")
+        rxRule.setPatternOptions(QRegExUnicode)
+        hlRule = {
+            0: self._hStyles["replace"],
+        }
+        self._txtRules.append((rxRule, hlRule))
+        self._cmnRules.append((rxRule, hlRule))
 
         return
 
@@ -282,6 +318,8 @@ class GuiDocHighlighter(QSyntaxHighlighter):
         if self._tHandle is None or not text:
             return
 
+        xOff = 0
+        hRules = None
         if text.startswith("@"):  # Keywords and commands
             self.setCurrentBlockState(BLOCK_META)
             index = SHARED.project.index
@@ -295,12 +333,12 @@ class GuiDocHighlighter(QSyntaxHighlighter):
                         self.setFormat(xPos, xLen, self._hStyles["keyword"])
                     elif isGood[n] and not self._isInactive:
                         one, two = index.parseValue(bit)
-                        self.setFormat(xPos, len(one), self._hStyles["value"])
+                        self.setFormat(xPos, len(one), self._hStyles["tag"])
                         if two:
                             yPos = xPos + len(bit) - len(two)
                             self.setFormat(yPos, len(two), self._hStyles["optional"])
                     elif not self._isInactive:
-                        self.setFormat(xPos, xLen, self._hStyles["codeinval"])
+                        self.setFormat(xPos, xLen, self._hStyles["invalid"])
 
             # We never want to run the spell checker on keyword/values,
             # so we force a return here
@@ -339,43 +377,58 @@ class GuiDocHighlighter(QSyntaxHighlighter):
 
         elif text.startswith("%"):  # Comments
             self.setCurrentBlockState(BLOCK_TEXT)
-            cStyle, _, cPos = processComment(text)
+            hRules = self._cmnRules
+
+            cStyle, cMod, _, cDot, cPos = processComment(text)
+            cLen = len(text) - cPos
+            xOff = cPos
             if cStyle == nwComment.PLAIN:
-                self.setFormat(0, len(text), self._hStyles["hidden"])
+                self.setFormat(0, cLen, self._hStyles["hidden"])
+            elif cStyle == nwComment.IGNORE:
+                self.setFormat(0, cLen, self._hStyles["strike"])
+                return  # No more processing for these
+            elif cMod:
+                self.setFormat(0, cDot, self._hStyles["modifier"])
+                self.setFormat(cDot, cPos - cDot, self._hStyles["value"])
+                self.setFormat(cPos, cLen, self._hStyles["note"])
             else:
                 self.setFormat(0, cPos, self._hStyles["modifier"])
-                self.setFormat(cPos, len(text), self._hStyles["hidden"])
+                self.setFormat(cPos, cLen, self._hStyles["note"])
 
-        else:  # Text Paragraph
+        elif text.startswith("["):  # Special Command
+            self.setCurrentBlockState(BLOCK_TEXT)
+            hRules = self._txtRules
+
+            sText = text.rstrip().lower()
+            if sText in ("[newpage]", "[new page]", "[vspace]"):
+                self.setFormat(0, len(text), self._hStyles["code"])
+                return
+            elif sText.startswith("[vspace:") and sText.endswith("]"):
+                tLen = len(sText)
+                tVal = checkInt(sText[8:-1], 0)
+                cVal = "value" if tVal > 0 else "invalid"
+                self.setFormat(0, 8, self._hStyles["code"])
+                self.setFormat(8, tLen-9, self._hStyles[cVal])
+                self.setFormat(tLen-1, tLen, self._hStyles["code"])
+                return
 
-            if text.startswith("["):  # Special Command
-                sText = text.rstrip().lower()
-                if sText in ("[newpage]", "[new page]", "[vspace]"):
-                    self.setFormat(0, len(text), self._hStyles["code"])
-                    return
-                elif sText.startswith("[vspace:") and sText.endswith("]"):
-                    tLen = len(sText)
-                    tVal = checkInt(sText[8:-1], 0)
-                    cVal = "codevalue" if tVal > 0 else "codeinval"
-                    self.setFormat(0, 8, self._hStyles["code"])
-                    self.setFormat(8, tLen-9, self._hStyles[cVal])
-                    self.setFormat(tLen-1, tLen, self._hStyles["code"])
-                    return
-
-            # Regular Text
+        else:  # Text Paragraph
             self.setCurrentBlockState(BLOCK_TEXT)
-            for rX, xFmt in self._rxRules:
-                rxItt = rX.globalMatch(text, 0)
+            hRules = self._txtRules
+
+        if hRules:
+            for rX, hRule in hRules:
+                rxItt = rX.globalMatch(text, xOff)
                 while rxItt.hasNext():
                     rxMatch = rxItt.next()
-                    for xM in xFmt:
+                    for xM, hFmt in hRule.items():
                         xPos = rxMatch.capturedStart(xM)
-                        xLen = rxMatch.capturedLength(xM)
-                        for x in range(xPos, xPos+xLen):
-                            spFmt = self.format(x)
-                            if spFmt != self._hStyles["hidden"]:
-                                spFmt.merge(xFmt[xM])
-                                self.setFormat(x, 1, spFmt)
+                        xEnd = rxMatch.capturedEnd(xM)
+                        for x in range(xPos, xEnd):
+                            cFmt = self.format(x)
+                            if cFmt.fontStyleName() != "markup":
+                                cFmt.merge(hFmt)
+                                self.setFormat(x, 1, cFmt)
 
         data = self.currentBlockUserData()
         if not isinstance(data, TextBlockData):
@@ -383,11 +436,11 @@ class GuiDocHighlighter(QSyntaxHighlighter):
             self.setCurrentBlockUserData(data)
 
         if self._spellCheck:
-            for xPos, xLen in data.spellCheck(text):
+            for xPos, xLen in data.spellCheck(text, xOff):
                 for x in range(xPos, xPos+xLen):
-                    spFmt = self.format(x)
-                    spFmt.merge(self._spellErr)
-                    self.setFormat(x, 1, spFmt)
+                    cFmt = self.format(x)
+                    cFmt.merge(self._spellErr)
+                    self.setFormat(x, 1, cFmt)
 
         return
 
@@ -395,36 +448,37 @@ class GuiDocHighlighter(QSyntaxHighlighter):
     #  Internal Functions
     ##
 
-    def _makeFormat(self, color: QColor | None = None, style: str | None = None,
-                    size: float | None = None) -> QTextCharFormat:
-        """Generate a valid character format to be applied to the text
-        that is to be highlighted.
-        """
+    def _addCharFormat(
+        self, name: str, color: QColor | None = None,
+        style: str | None = None, size: float | None = None
+    ) -> None:
+        """Generate a highlighter character format."""
         charFormat = QTextCharFormat()
+        charFormat.setFontStyleName(name)
 
-        if color is not None:
+        if color:
             charFormat.setForeground(color)
 
-        if style is not None:
+        if style:
             styles = style.split(",")
-            if "bold" in styles:
+            if "b" in styles:
                 charFormat.setFontWeight(QFont.Weight.Bold)
-            if "italic" in styles:
+            if "i" in styles:
                 charFormat.setFontItalic(True)
-            if "strike" in styles:
+            if "s" in styles:
                 charFormat.setFontStrikeOut(True)
-            if "errline" in styles:
+            if "err" in styles:
                 charFormat.setUnderlineColor(SHARED.theme.colError)
                 charFormat.setUnderlineStyle(QTextCharFormat.UnderlineStyle.SpellCheckUnderline)
-            if "background" in styles and color is not None:
+            if "bg" in styles and color is not None:
                 charFormat.setBackground(QBrush(color, Qt.BrushStyle.SolidPattern))
 
-        if size is not None:
-            charFormat.setFontPointSize(int(round(size*CONFIG.textSize)))
+        if size:
+            charFormat.setFontPointSize(round(size*CONFIG.textFont.pointSize()))
 
-        return charFormat
+        self._hStyles[name] = charFormat
 
-# END Class GuiDocHighlighter
+        return
 
 
 class TextBlockData(QTextBlockUserData):
@@ -441,14 +495,14 @@ class TextBlockData(QTextBlockUserData):
         """Return spell error data from last check."""
         return self._spellErrors
 
-    def spellCheck(self, text: str) -> list[tuple[int, int]]:
+    def spellCheck(self, text: str, offset: int) -> list[tuple[int, int]]:
         """Run the spell checker and cache the result, and return the
         list of spell check errors.
         """
         if "[" in text:
             # Strip shortcodes
             for rX in [SPELLSC, SPELLSV]:
-                rxItt = rX.globalMatch(text, 0)
+                rxItt = rX.globalMatch(text, offset)
                 while rxItt.hasNext():
                     rxMatch = rxItt.next()
                     xPos = rxMatch.capturedStart(0)
@@ -457,12 +511,12 @@ class TextBlockData(QTextBlockUserData):
                     text = text[:xPos] + " "*xLen + text[xEnd:]
 
         self._spellErrors = []
-        rxSpell = SPELLRX.globalMatch(text.replace("_", " "), 0)
+        rxSpell = SPELLRX.globalMatch(text.replace("_", " "), offset)
         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)))
+                    self._spellErrors.append(
+                        (rxMatch.capturedStart(0), rxMatch.capturedLength(0))
+                    )
         return self._spellErrors
-
-# END Class TextBlockData