novelWriter 2.5b1__py3-none-any.whl → 2.5rc1__py3-none-any.whl

novelwriter/dialogs/quotes.py

@@ -28,18 +28,22 @@ import logging
 from PyQt5.QtCore import QSize, pyqtSlot
 from PyQt5.QtGui import QFontMetrics
 from PyQt5.QtWidgets import (
-    QDialog, QDialogButtonBox, QFrame, QHBoxLayout, QLabel, QListWidget,
+    QDialogButtonBox, QFrame, QHBoxLayout, QLabel, QListWidget,
     QListWidgetItem, QVBoxLayout, QWidget
 )
 
 from novelwriter import CONFIG
 from novelwriter.constants import nwQuotes, trConst
-from novelwriter.types import QtAlignCenter, QtAlignTop, QtDialogCancel, QtDialogOk, QtUserRole
+from novelwriter.extensions.modified import NDialog
+from novelwriter.types import (
+    QtAccepted, QtAlignCenter, QtAlignTop, QtDialogCancel, QtDialogOk,
+    QtUserRole
+)
 
 logger = logging.getLogger(__name__)
 
 
-class GuiQuoteSelect(QDialog):
+class GuiQuoteSelect(NDialog):
 
     _selected = ""
 
@@ -126,8 +130,8 @@ class GuiQuoteSelect(QDialog):
         cls = GuiQuoteSelect(parent, current=current)
         cls.exec()
         quote = cls._selected
-        accepted = cls.result() == QDialog.DialogCode.Accepted
-        cls.deleteLater()
+        accepted = cls.result() == QtAccepted
+        cls.softDelete()
         return quote, accepted
 
     ##

novelwriter/dialogs/wordlist.py

@@ -30,7 +30,7 @@ from pathlib import Path
 from PyQt5.QtCore import Qt, pyqtSignal, pyqtSlot
 from PyQt5.QtGui import QCloseEvent
 from PyQt5.QtWidgets import (
-    QAbstractItemView, QApplication, QDialog, QDialogButtonBox, QFileDialog,
+    QAbstractItemView, QApplication, QDialogButtonBox, QFileDialog,
     QHBoxLayout, QLineEdit, QListWidget, QVBoxLayout, QWidget
 )
 
@@ -38,13 +38,13 @@ from novelwriter import CONFIG, SHARED
 from novelwriter.common import formatFileFilter
 from novelwriter.core.spellcheck import UserDictionary
 from novelwriter.extensions.configlayout import NColourLabel
-from novelwriter.extensions.modified import NIconToolButton
+from novelwriter.extensions.modified import NDialog, NIconToolButton
 from novelwriter.types import QtDialogClose, QtDialogSave
 
 logger = logging.getLogger(__name__)
 
 
-class GuiWordList(QDialog):
+class GuiWordList(NDialog):
 
     newWordListReady = pyqtSignal()
 
@@ -69,7 +69,7 @@ class GuiWordList(QDialog):
 
         # Header
         self.headLabel = NColourLabel(
-            self.tr("Project Word List"), SHARED.theme.helpText, parent=self,
+            self.tr("Project Word List"), self, color=SHARED.theme.helpText,
             scale=NColourLabel.HEADER_SCALE
         )
 
@@ -109,7 +109,7 @@ class GuiWordList(QDialog):
         # Buttons
         self.buttonBox = QDialogButtonBox(QtDialogSave | QtDialogClose, self)
         self.buttonBox.accepted.connect(self._doSave)
-        self.buttonBox.rejected.connect(self.close)
+        self.buttonBox.rejected.connect(self.reject)
 
         # Assemble
         self.outerBox = QVBoxLayout()
@@ -140,7 +140,7 @@ class GuiWordList(QDialog):
         """Capture the close event and perform cleanup."""
         self._saveGuiSettings()
         event.accept()
-        self.deleteLater()
+        self.softDelete()
         return
 
     ##

novelwriter/enum.py

@@ -148,12 +148,11 @@ class nwView(Enum):
     SEARCH  = 4
 
 
-class nwWidget(Enum):
+class nwFocus(Enum):
 
-    TREE    = 1
-    EDITOR  = 2
-    VIEWER  = 3
-    OUTLINE = 4
+    TREE     = 1
+    DOCUMENT = 2
+    OUTLINE  = 3
 
 
 class nwOutline(Enum):

novelwriter/extensions/configlayout.py

@@ -203,7 +203,7 @@ class NScrollableForm(QScrollArea):
 
         if helpText:
             qHelp = NColourLabel(
-                str(helpText), color=self._helpCol, parent=self,
+                str(helpText), self, color=self._helpCol,
                 scale=self._fontScale, wrap=True, indent=self._indent
             )
             labelBox = QVBoxLayout()
@@ -252,11 +252,20 @@ class NColourLabel(QLabel):
     HELP_SCALE = DEFAULT_SCALE
     HEADER_SCALE = 1.25
 
-    def __init__(self, text: str, color: QColor | None = None, parent: QWidget | None = None,
-                 scale: float = HELP_SCALE, wrap: bool = False, indent: int = 0,
-                 bold: bool = False) -> None:
+    _state = None
+
+    def __init__(
+        self, text: str, parent: QWidget, *,
+        color: QColor | None = None, faded: QColor | None = None,
+        scale: float = HELP_SCALE, wrap: bool = False, indent: int = 0,
+        bold: bool = False
+    ) -> None:
         super().__init__(text, parent=parent)
 
+        default = self.palette().windowText().color()
+        self._color = color or default
+        self._faded = faded or default
+
         font = self.font()
         font.setPointSizeF(scale*font.pointSizeF())
         font.setWeight(QFont.Weight.Bold if bold else QFont.Weight.Normal)
@@ -268,7 +277,17 @@ class NColourLabel(QLabel):
         self.setFont(font)
         self.setIndent(indent)
         self.setWordWrap(wrap)
+        self.setColorState(True)
+
+        return
 
+    def setColorState(self, state: bool) -> None:
+        """Change the colour state."""
+        if self._state is not state:
+            self._state = state
+            colour = self.palette()
+            colour.setColor(QPalette.ColorRole.WindowText, self._color if state else self._faded)
+            self.setPalette(colour)
         return
 
 

novelwriter/extensions/modified.py

@@ -30,7 +30,7 @@ from __future__ import annotations
 from enum import Enum
 from typing import TYPE_CHECKING
 
-from PyQt5.QtCore import QSize, Qt
+from PyQt5.QtCore import QSize, Qt, pyqtSlot
 from PyQt5.QtGui import QWheelEvent
 from PyQt5.QtWidgets import (
     QApplication, QComboBox, QDialog, QDoubleSpinBox, QSpinBox, QToolButton,
@@ -43,7 +43,26 @@ if TYPE_CHECKING:  # pragma: no cover
     from novelwriter.guimain import GuiMain
 
 
-class NToolDialog(QDialog):
+class NDialog(QDialog):
+
+    def softDelete(self) -> None:
+        """Since calling deleteLater is sometimes not safe from Python,
+        as the C++ object can be deleted before the Python process is
+        done with the object, we instead set the dialog's parent to None
+        so that it gets garbage collected when it runs out of scope.
+        """
+        self.setParent(None)  # type: ignore
+        return
+
+    @pyqtSlot()
+    def reject(self) -> None:
+        """Overload the reject slot and also call close."""
+        super().reject()
+        self.close()
+        return
+
+
+class NToolDialog(NDialog):
 
     def __init__(self, parent: GuiMain) -> None:
         super().__init__(parent=parent)
@@ -62,7 +81,7 @@ class NToolDialog(QDialog):
         return
 
 
-class NNonBlockingDialog(QDialog):
+class NNonBlockingDialog(NDialog):
 
     def __init__(self, parent: QWidget | None = None) -> None:
         super().__init__(parent=parent)

novelwriter/extensions/{circularprogress.py → progressbars.py}

@@ -1,9 +1,10 @@
 """
-novelWriter – Custom Widget: Progress Circle
-============================================
+novelWriter – Custom Widget: Progress Bars
+==========================================
 
 File History:
-Created: 2023-06-07 [2.1b1]
+Created: 2023-06-07 [2.1b1] NProgressCircle
+Created: 2023-06-09 [2.1b1] NProgressSimple
 
 This file is a part of novelWriter
 Copyright 2018–2024, Veronica Berglyd Olsen
@@ -101,3 +102,25 @@ class NProgressCircle(QProgressBar):
         painter.setPen(self._tColor)
         painter.drawText(self._cRect, QtAlignCenter, self._text or f"{progress:.1f} %")
         return
+
+
+class NProgressSimple(QProgressBar):
+    """Extension: Simple Progress Widget
+
+    A custom widget that paints a plain bar with no other styling.
+    """
+
+    def __init__(self, parent: QWidget) -> None:
+        super().__init__(parent=parent)
+        return
+
+    def paintEvent(self, event: QPaintEvent) -> None:
+        """Custom painter for the progress bar."""
+        if (value := self.value()) > 0:
+            progress = ceil(self.width()*float(value)/self.maximum())
+            painter = QPainter(self)
+            painter.setRenderHint(QtPaintAnitAlias, True)
+            painter.setPen(self.palette().highlight().color())
+            painter.setBrush(self.palette().highlight())
+            painter.drawRect(0, 0, progress, self.height())
+        return

novelwriter/extensions/statusled.py

@@ -25,44 +25,50 @@ from __future__ import annotations
 
 import logging
 
-from typing import Literal
-
 from PyQt5.QtGui import QColor, QPainter, QPaintEvent
 from PyQt5.QtWidgets import QAbstractButton, QWidget
 
-from novelwriter.types import QtPaintAnitAlias
+from novelwriter.enum import nwTrinary
+from novelwriter.types import QtBlack, QtPaintAnitAlias
 
 logger = logging.getLogger(__name__)
 
 
 class StatusLED(QAbstractButton):
 
-    S_NONE = 0
-    S_BAD  = 1
-    S_GOOD = 2
-
-    def __init__(self, colNone: QColor, colGood: QColor, colBad: QColor,
-                 sW: int, sH: int, parent: QWidget | None = None) -> None:
+    def __init__(self, sW: int, sH: int, parent: QWidget | None = None) -> None:
         super().__init__(parent=parent)
-
-        self._colNone = colNone
-        self._colGood = colGood
-        self._colBad = colBad
-        self._theCol = colNone
-
+        self._neutral = QtBlack
+        self._postitve = QtBlack
+        self._negative = QtBlack
+        self._color = QtBlack
+        self._state = nwTrinary.NEUTRAL
         self.setFixedWidth(sW)
         self.setFixedHeight(sH)
+        return
 
+    @property
+    def state(self) -> nwTrinary:
+        """The current state of the LED."""
+        return self._state
+
+    def setColors(self, neutral: QColor, positive: QColor, negative: QColor) -> None:
+        """Set the three colours for the status values."""
+        self._neutral = neutral
+        self._postitve = positive
+        self._negative = negative
+        self.setState(self._state)
         return
 
-    def setState(self, state: Literal[0, 1, 2]) -> None:
+    def setState(self, state: nwTrinary) -> None:
         """Set the colour state."""
-        if state == self.S_GOOD:
-            self._theCol = self._colGood
-        elif state == self.S_BAD:
-            self._theCol = self._colBad
+        if state == nwTrinary.POSITIVE:
+            self._color = self._postitve
+        elif state == nwTrinary.NEGATIVE:
+            self._color = self._negative
         else:
-            self._theCol = self._colNone
+            self._color = self._neutral
+        self._state = state
         self.update()
         return
 
@@ -71,7 +77,7 @@ class StatusLED(QAbstractButton):
         painter = QPainter(self)
         painter.setRenderHint(QtPaintAnitAlias, True)
         painter.setPen(self.palette().dark().color())
-        painter.setBrush(self._theCol)
+        painter.setBrush(self._color)
         painter.setOpacity(1.0)
         painter.drawEllipse(1, 1, self.width() - 2, self.height() - 2)
         return

novelwriter/gui/doceditor.py

@@ -55,6 +55,7 @@ from novelwriter.common import minmax, transferCase
 from novelwriter.constants import nwConst, nwKeyWords, nwShortcode, nwUnicode
 from novelwriter.core.document import NWDocument
 from novelwriter.enum import nwComment, nwDocAction, nwDocInsert, nwDocMode, nwItemClass, nwTrinary
+from novelwriter.extensions.configlayout import NColourLabel
 from novelwriter.extensions.eventfilters import WheelEventFilter
 from novelwriter.extensions.modified import NIconToggleButton, NIconToolButton
 from novelwriter.gui.dochighlight import BLOCK_META, BLOCK_TITLE
@@ -64,7 +65,7 @@ from novelwriter.text.counting import standardCounter
 from novelwriter.tools.lipsum import GuiLipsum
 from novelwriter.types import (
     QtAlignCenterTop, QtAlignJustify, QtAlignLeft, QtAlignLeftTop,
-    QtAlignRight, QtKeepAnchor, QtModCtrl, QtModeNone, QtModShift, QtMouseLeft,
+    QtAlignRight, QtKeepAnchor, QtModCtrl, QtModNone, QtModShift, QtMouseLeft,
     QtMoveAnchor, QtMoveLeft, QtMoveRight
 )
 
@@ -210,6 +211,7 @@ class GuiDocEditor(QPlainTextEdit):
         # Function Mapping
         self.closeSearch = self.docSearch.closeSearch
         self.searchVisible = self.docSearch.isVisible
+        self.changeFocusState = self.docHeader.changeFocusState
 
         # Finalise
         self.updateSyntaxColours()
@@ -436,11 +438,6 @@ class GuiDocEditor(QPlainTextEdit):
 
         return True
 
-    def updateTagHighLighting(self) -> None:
-        """Rerun the syntax highlighter on all meta data lines."""
-        self._qDocument.syntaxHighlighter.rehighlightByType(BLOCK_META)
-        return
-
     def replaceText(self, text: str) -> None:
         """Replace the text of the current document with the provided
         text. This also clears undo history.
@@ -956,7 +953,7 @@ class GuiDocEditor(QPlainTextEdit):
             super().keyPressEvent(event)
             nPos = self.cursorRect().topLeft().y()
             kMod = event.modifiers()
-            okMod = kMod in (QtModeNone, QtModShift)
+            okMod = kMod in (QtModNone, QtModShift)
             okKey = event.key() not in self.MOVE_KEYS
             if nPos != cPos and okMod and okKey:
                 mPos = CONFIG.autoScrollPos*0.01 * self.viewport().height()
@@ -1034,6 +1031,13 @@ class GuiDocEditor(QPlainTextEdit):
             self.beginSearch()
         return
 
+    @pyqtSlot(list, list)
+    def updateChangedTags(self, updated: list[str], deleted: list[str]) -> None:
+        """Tags have changed, so just in case we rehighlight them."""
+        if updated or deleted:
+            self._qDocument.syntaxHighlighter.rehighlightByType(BLOCK_META)
+        return
+
     ##
     #  Private Slots
     ##
@@ -1922,8 +1926,6 @@ class GuiDocEditor(QPlainTextEdit):
                 ).format(tag)):
                     itemClass = nwKeyWords.KEY_CLASS.get(tBits[0], nwItemClass.NO_CLASS)
                     self.requestNewNoteCreation.emit(tag, itemClass)
-                    QApplication.processEvents()
-                    self._qDocument.syntaxHighlighter.rehighlightBlock(block)
 
             return nwTrinary.POSITIVE if exist else nwTrinary.NEGATIVE
 
@@ -2030,6 +2032,9 @@ class GuiDocEditor(QPlainTextEdit):
             cursor.movePosition(QtMoveLeft, QtKeepAnchor, nDelete)
             cursor.insertText(tInsert)
 
+        # Re-highlight, since the auto-replace sometimes interferes with it
+        self._qDocument.syntaxHighlighter.rehighlightBlock(cursor.block())
+
         return
 
     @staticmethod
@@ -2782,8 +2787,7 @@ class GuiDocEditHeader(QWidget):
         self.setAutoFillBackground(True)
 
         # Title Label
-        self.itemTitle = QLabel("", self)
-        self.itemTitle.setIndent(0)
+        self.itemTitle = NColourLabel("", self, faded=SHARED.theme.fadedText)
         self.itemTitle.setMargin(0)
         self.itemTitle.setContentsMargins(0, 0, 0, 0)
         self.itemTitle.setAutoFillBackground(True)
@@ -2921,6 +2925,11 @@ class GuiDocEditHeader(QWidget):
 
         return
 
+    def changeFocusState(self, state: bool) -> None:
+        """Toggle focus state."""
+        self.itemTitle.setColorState(state)
+        return
+
     def setHandle(self, tHandle: str) -> None:
         """Set the document title from the handle, or alternatively, set
         the whole document path within the project.

novelwriter/gui/dochighlight.py

@@ -39,6 +39,7 @@ from novelwriter.common import checkInt
 from novelwriter.constants import nwHeaders, nwRegEx, nwUnicode
 from novelwriter.core.index import processComment
 from novelwriter.enum import nwComment
+from novelwriter.text.patterns import REGEX_PATTERNS
 from novelwriter.types import QRegExUnicode
 
 logger = logging.getLogger(__name__)
@@ -59,8 +60,8 @@ BLOCK_TITLE = 4
 class GuiDocHighlighter(QSyntaxHighlighter):
 
     __slots__ = (
-        "_tHandle", "_isInactive", "_spellCheck", "_spellErr", "_hStyles",
-        "_txtRules", "_cmnRules",
+        "_tHandle", "_isNovel", "_isInactive", "_spellCheck", "_spellErr",
+        "_hStyles", "_minRules", "_txtRules", "_cmnRules",
     )
 
     def __init__(self, document: QTextDocument) -> None:
@@ -69,11 +70,13 @@ class GuiDocHighlighter(QSyntaxHighlighter):
         logger.debug("Create: GuiDocHighlighter")
 
         self._tHandle = None
+        self._isNovel = False
         self._isInactive = False
         self._spellCheck = False
         self._spellErr = QTextCharFormat()
 
         self._hStyles: dict[str, QTextCharFormat] = {}
+        self._minRules: list[tuple[QRegularExpression, dict[int, QTextCharFormat]]] = []
         self._txtRules: list[tuple[QRegularExpression, dict[int, QTextCharFormat]]] = []
         self._cmnRules: list[tuple[QRegularExpression, dict[int, QTextCharFormat]]] = []
 
@@ -137,6 +140,7 @@ class GuiDocHighlighter(QSyntaxHighlighter):
             hlRule = {
                 0: self._hStyles["mspaces"],
             }
+            self._minRules.append((rxRule, hlRule))
             self._txtRules.append((rxRule, hlRule))
             self._cmnRules.append((rxRule, hlRule))
 
@@ -146,106 +150,89 @@ class GuiDocHighlighter(QSyntaxHighlighter):
         hlRule = {
             0: self._hStyles["nobreak"],
         }
+        self._minRules.append((rxRule, hlRule))
         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)
+            rxRule = REGEX_PATTERNS.dialogStyle
             hlRule = {
                 0: self._hStyles["dialog"],
             }
             self._txtRules.append((rxRule, hlRule))
 
         if CONFIG.dialogLine:
-            sym = QRegularExpression.escape(CONFIG.dialogLine)
-            rxRule = QRegularExpression(f"^{sym}.*?$")
-            rxRule.setPatternOptions(QRegExUnicode)
+            rxRule = REGEX_PATTERNS.dialogLine
             hlRule = {
                 0: self._hStyles["dialog"],
             }
             self._txtRules.append((rxRule, hlRule))
 
         if CONFIG.narratorBreak:
-            sym = QRegularExpression.escape(CONFIG.narratorBreak)
-            rxRule = QRegularExpression(f"({sym}\\b)(.*?)(\\b{sym})")
-            rxRule.setPatternOptions(QRegExUnicode)
+            rxRule = REGEX_PATTERNS.narratorBreak
             hlRule = {
                 0: self._hStyles["text"],
             }
             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)
+            rxRule = REGEX_PATTERNS.altDialogStyle
             hlRule = {
                 0: self._hStyles["altdialog"],
             }
             self._txtRules.append((rxRule, hlRule))
 
         # Markdown Italic
-        rxRule = QRegularExpression(nwRegEx.FMT_EI)
-        rxRule.setPatternOptions(QRegExUnicode)
+        rxRule = REGEX_PATTERNS.markdownItalic
         hlRule = {
             1: self._hStyles["markup"],
             2: self._hStyles["italic"],
             3: self._hStyles["markup"],
         }
+        self._minRules.append((rxRule, hlRule))
         self._txtRules.append((rxRule, hlRule))
         self._cmnRules.append((rxRule, hlRule))
 
         # Markdown Bold
-        rxRule = QRegularExpression(nwRegEx.FMT_EB)
-        rxRule.setPatternOptions(QRegExUnicode)
+        rxRule = REGEX_PATTERNS.markdownBold
         hlRule = {
             1: self._hStyles["markup"],
             2: self._hStyles["bold"],
             3: self._hStyles["markup"],
         }
+        self._minRules.append((rxRule, hlRule))
         self._txtRules.append((rxRule, hlRule))
         self._cmnRules.append((rxRule, hlRule))
 
         # Markdown Strikethrough
-        rxRule = QRegularExpression(nwRegEx.FMT_ST)
-        rxRule.setPatternOptions(QRegExUnicode)
+        rxRule = REGEX_PATTERNS.markdownStrike
         hlRule = {
             1: self._hStyles["markup"],
             2: self._hStyles["strike"],
             3: self._hStyles["markup"],
         }
+        self._minRules.append((rxRule, hlRule))
         self._txtRules.append((rxRule, hlRule))
         self._cmnRules.append((rxRule, hlRule))
 
         # Shortcodes
-        rxRule = QRegularExpression(nwRegEx.FMT_SC)
-        rxRule.setPatternOptions(QRegExUnicode)
+        rxRule = REGEX_PATTERNS.shortcodePlain
         hlRule = {
             1: self._hStyles["code"],
         }
+        self._minRules.append((rxRule, hlRule))
         self._txtRules.append((rxRule, hlRule))
         self._cmnRules.append((rxRule, hlRule))
 
         # Shortcodes w/Value
-        rxRule = QRegularExpression(nwRegEx.FMT_SV)
-        rxRule.setPatternOptions(QRegExUnicode)
+        rxRule = REGEX_PATTERNS.shortcodeValue
         hlRule = {
             1: self._hStyles["code"],
             2: self._hStyles["value"],
             3: self._hStyles["code"],
         }
+        self._minRules.append((rxRule, hlRule))
         self._txtRules.append((rxRule, hlRule))
         self._cmnRules.append((rxRule, hlRule))
 
@@ -255,6 +242,7 @@ class GuiDocHighlighter(QSyntaxHighlighter):
         hlRule = {
             1: self._hStyles["markup"],
         }
+        self._minRules.append((rxRule, hlRule))
         self._txtRules.append((rxRule, hlRule))
 
         # Auto-Replace Tags
@@ -263,6 +251,7 @@ class GuiDocHighlighter(QSyntaxHighlighter):
         hlRule = {
             0: self._hStyles["replace"],
         }
+        self._minRules.append((rxRule, hlRule))
         self._txtRules.append((rxRule, hlRule))
         self._cmnRules.append((rxRule, hlRule))
 
@@ -280,9 +269,11 @@ class GuiDocHighlighter(QSyntaxHighlighter):
     def setHandle(self, tHandle: str) -> None:
         """Set the handle of the currently highlighted document."""
         self._tHandle = tHandle
-        self._isInactive = (
-            item.isInactiveClass() if (item := SHARED.project.tree[tHandle]) else False
-        )
+        self._isNovel = False
+        self._isInactive = False
+        if item := SHARED.project.tree[tHandle]:
+            self._isNovel = item.isDocumentLayout()
+            self._isInactive = item.isInactiveClass()
         logger.debug("Syntax highlighter enabled for item '%s'", tHandle)
         return
 
@@ -397,7 +388,7 @@ class GuiDocHighlighter(QSyntaxHighlighter):
 
         elif text.startswith("["):  # Special Command
             self.setCurrentBlockState(BLOCK_TEXT)
-            hRules = self._txtRules
+            hRules = self._txtRules if self._isNovel else self._minRules
 
             sText = text.rstrip().lower()
             if sText in ("[newpage]", "[new page]", "[vspace]"):
@@ -414,7 +405,7 @@ class GuiDocHighlighter(QSyntaxHighlighter):
 
         else:  # Text Paragraph
             self.setCurrentBlockState(BLOCK_TEXT)
-            hRules = self._txtRules
+            hRules = self._txtRules if self._isNovel else self._minRules
 
         if hRules:
             for rX, hRule in hRules: