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

novelwriter/gui/dochighlight.py

@@ -29,15 +29,21 @@ 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
 from novelwriter.common import checkInt
 from novelwriter.constants import nwRegEx, nwUnicode
+from novelwriter.core.index import processComment
+from novelwriter.enum import nwComment
 
 logger = logging.getLogger(__name__)
 
+SPELLRX = QRegularExpression(r"\b[^\s\-\+\/–—\[\]:]+\b")
+SPELLRX.setPatternOptions(QRegularExpression.UseUnicodePropertiesOption)
+
 
 class GuiDocHighlighter(QSyntaxHighlighter):
 
@@ -51,9 +57,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] = {}
@@ -65,6 +71,7 @@ class GuiDocHighlighter(QSyntaxHighlighter):
         self._colDialD  = QColor(0, 0, 0)
         self._colDialS  = QColor(0, 0, 0)
         self._colHidden = QColor(0, 0, 0)
+        self._colCode   = QColor(0, 0, 0)
         self._colKey    = QColor(0, 0, 0)
         self._colVal    = QColor(0, 0, 0)
         self._colSpell  = QColor(0, 0, 0)
@@ -79,11 +86,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.
@@ -96,6 +98,7 @@ class GuiDocHighlighter(QSyntaxHighlighter):
         self._colDialD  = QColor(*SHARED.theme.colDialD)
         self._colDialS  = QColor(*SHARED.theme.colDialS)
         self._colHidden = QColor(*SHARED.theme.colHidden)
+        self._colCode   = QColor(*SHARED.theme.colCode)
         self._colKey    = QColor(*SHARED.theme.colKey)
         self._colVal    = QColor(*SHARED.theme.colVal)
         self._colSpell  = QColor(*SHARED.theme.colSpell)
@@ -128,6 +131,7 @@ class GuiDocHighlighter(QSyntaxHighlighter):
             "dialogue3": self._makeFormat(self._colDialS),
             "replace":   self._makeFormat(self._colRepTag),
             "hidden":    self._makeFormat(self._colHidden),
+            "code":      self._makeFormat(self._colCode),
             "keyword":   self._makeFormat(self._colKey),
             "modifier":  self._makeFormat(self._colMod),
             "value":     self._makeFormat(self._colVal, "underline"),
@@ -206,6 +210,22 @@ class GuiDocHighlighter(QSyntaxHighlighter):
             }
         ))
 
+        # Shortcodes
+        self._hRules.append((
+            nwRegEx.FMT_SC, {
+                1: self._hStyles["code"],
+            }
+        ))
+
+        # Shortcodes w/Value
+        self._hRules.append((
+            nwRegEx.FMT_SV, {
+                1: self._hStyles["code"],
+                2: self._hStyles["codevalue"],
+                3: self._hStyles["code"],
+            }
+        ))
+
         # Alignment Tags
         self._hRules.append((
             r"(^>{1,2}|<{1,2}$)", {
@@ -227,13 +247,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 +261,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 +302,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
@@ -329,7 +344,7 @@ class GuiDocHighlighter(QSyntaxHighlighter):
                 self.setFormat(0, 4, self._hStyles["header4h"])
                 self.setFormat(4, len(text), self._hStyles["header4"])
 
-            if text.startswith("#! "):  # Title
+            elif text.startswith("#! "):  # Title
                 self.setFormat(0, 2, self._hStyles["header1h"])
                 self.setFormat(2, len(text), self._hStyles["header1"])
 
@@ -339,35 +354,30 @@ class GuiDocHighlighter(QSyntaxHighlighter):
 
         elif text.startswith("%"):  # Comments
             self.setCurrentBlockState(self.BLOCK_TEXT)
-            toCheck = text[1:].lstrip()
-            synTag  = toCheck[:9].lower()
-            tLen = len(text)
-            cLen = len(toCheck)
-            cOff = tLen - cLen
-            if synTag == "synopsis:":
-                self.setFormat(0, cOff+9, self._hStyles["modifier"])
-                self.setFormat(cOff+9, tLen, self._hStyles["hidden"])
+            cStyle, _, cPos = processComment(text)
+            if cStyle == nwComment.PLAIN:
+                self.setFormat(0, len(text), self._hStyles["hidden"])
             else:
-                self.setFormat(0, tLen, self._hStyles["hidden"])
+                self.setFormat(0, cPos, self._hStyles["modifier"])
+                self.setFormat(cPos, len(text), self._hStyles["hidden"])
 
         else:  # Text Paragraph
 
             if text.startswith("["):  # Special Command
-                sText = text.rstrip()
-                if sText in ("[NEWPAGE]", "[NEW PAGE]", "[VSPACE]"):
-                    self.setFormat(0, len(text), self._hStyles["keyword"])
+                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("]"):
+                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["keyword"])
+                    self.setFormat(0, 8, self._hStyles["code"])
                     self.setFormat(8, tLen-9, self._hStyles[cVal])
-                    self.setFormat(tLen-1, tLen, self._hStyles["keyword"])
+                    self.setFormat(tLen-1, tLen, self._hStyles["code"])
                     return
 
-            # Regular text
+            # Regular Text
             self.setCurrentBlockState(self.BLOCK_TEXT)
             for rX, xFmt in self.rxRules:
                 rxItt = rX.globalMatch(text, 0)
@@ -382,17 +392,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 rxMatch.captured(0).isupper() or rxMatch.captured(0).isnumeric():
-                    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 +443,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