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

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:

novelwriter/gui/docviewer.py

@@ -33,7 +33,7 @@ from enum import Enum
 from PyQt5.QtCore import QPoint, Qt, QUrl, pyqtSignal, pyqtSlot
 from PyQt5.QtGui import QCursor, QMouseEvent, QPalette, QResizeEvent, QTextCursor
 from PyQt5.QtWidgets import (
-    QAction, QApplication, QFrame, QHBoxLayout, QLabel, QMenu, QTextBrowser,
+    QAction, QApplication, QFrame, QHBoxLayout, QMenu, QTextBrowser,
     QToolButton, QWidget
 )
 
@@ -42,6 +42,7 @@ from novelwriter.constants import nwHeaders, nwUnicode
 from novelwriter.core.toqdoc import TextDocumentTheme, ToQTextDocument
 from novelwriter.enum import nwDocAction, nwDocMode, nwItemType
 from novelwriter.error import logException
+from novelwriter.extensions.configlayout import NColourLabel
 from novelwriter.extensions.eventfilters import WheelEventFilter
 from novelwriter.extensions.modified import NIconToolButton
 from novelwriter.gui.theme import STYLES_MIN_TOOLBUTTON
@@ -92,6 +93,9 @@ class GuiDocViewer(QTextBrowser):
         self.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
         self.customContextMenuRequested.connect(self._openContextMenu)
 
+        # Function Mapping
+        self.changeFocusState = self.docHeader.changeFocusState
+
         self.initViewer()
 
         logger.debug("Ready: GuiDocViewer")
@@ -165,6 +169,8 @@ class GuiDocViewer(QTextBrowser):
         self._docTheme.keyword   = SHARED.theme.colKey
         self._docTheme.tag       = SHARED.theme.colTag
         self._docTheme.optional  = SHARED.theme.colOpt
+        self._docTheme.dialog    = SHARED.theme.colDialN
+        self._docTheme.altdialog = SHARED.theme.colDialA
 
         # Set default text margins
         self.document().setDocumentMargin(0)
@@ -201,6 +207,7 @@ class GuiDocViewer(QTextBrowser):
         sPos = self.verticalScrollBar().value()
         qDoc = ToQTextDocument(SHARED.project)
         qDoc.setJustify(CONFIG.doJustify)
+        qDoc.setDialogueHighlight(True)
         qDoc.initDocument(CONFIG.textFont, self._docTheme)
         qDoc.setKeywords(True)
         qDoc.setComments(CONFIG.viewComments)
@@ -245,9 +252,6 @@ class GuiDocViewer(QTextBrowser):
         })
         self.updateDocMargins()
 
-        # Since we change the content while it may still be rendering, we mark
-        # the document dirty again to make sure it's re-rendered properly.
-        self.redrawText()
         QApplication.restoreOverrideCursor()
         self.documentLoaded.emit(tHandle)
 
@@ -259,12 +263,6 @@ class GuiDocViewer(QTextBrowser):
             self.loadText(self._docHandle, updateHistory=False)
         return
 
-    def redrawText(self) -> None:
-        """Redraw the text by marking the content as "dirty"."""
-        self.document().markContentsDirty(0, self.document().characterCount())
-        self.updateDocMargins()
-        return
-
     def docAction(self, action: nwDocAction) -> bool:
         """Process document actions on the current document."""
         logger.debug("Requesting action: '%s'", action.name)
@@ -284,6 +282,10 @@ class GuiDocViewer(QTextBrowser):
             return False
         return True
 
+    def anyFocus(self) -> bool:
+        """Check if any widget or child widget has focus."""
+        return self.hasFocus() or self.isAncestorOf(QApplication.focusWidget())
+
     def clearNavHistory(self) -> None:
         """Clear the navigation history."""
         self.docHistory.clear()
@@ -370,8 +372,10 @@ class GuiDocViewer(QTextBrowser):
         """Process a clicked link in the document."""
         if link := url.url():
             logger.debug("Clicked link: '%s'", link)
-            if (bits := link.partition("_")) and bits[2]:
+            if (bits := link.partition("_")) and bits[0] == "#tag" and bits[2]:
                 self.loadDocumentTagRequest.emit(bits[2], nwDocMode.VIEW)
+            else:
+                self.navigateTo(link)
         return
 
     @pyqtSlot("QPoint")
@@ -601,9 +605,7 @@ class GuiDocViewHeader(QWidget):
         self.setAutoFillBackground(True)
 
         # Title Label
-        self.itemTitle = QLabel(self)
-        self.itemTitle.setText("")
-        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)
@@ -739,7 +741,14 @@ class GuiDocViewHeader(QWidget):
         palette.setColor(QPalette.ColorRole.WindowText, SHARED.theme.colText)
         palette.setColor(QPalette.ColorRole.Text, SHARED.theme.colText)
         self.setPalette(palette)
-        self.itemTitle.setPalette(palette)
+        self.itemTitle.setTextColors(
+            color=palette.windowText().color(), faded=SHARED.theme.fadedText
+        )
+        return
+
+    def changeFocusState(self, state: bool) -> None:
+        """Toggle focus state."""
+        self.itemTitle.setColorState(state)
         return
 
     def setHandle(self, tHandle: str) -> None:

novelwriter/gui/docviewerpanel.py

@@ -189,6 +189,13 @@ class GuiDocViewerPanel(QWidget):
         self._updateTabVisibility()
         return
 
+    @pyqtSlot(str)
+    def updateStatusLabels(self, kind: str) -> None:
+        """Update the importance labels."""
+        if kind == "i":
+            self._loadAllTags()
+        return
+
     ##
     #  Private Slots
     ##

novelwriter/gui/mainmenu.py

@@ -35,7 +35,7 @@ from PyQt5.QtWidgets import QAction, QMenuBar
 from novelwriter import CONFIG, SHARED
 from novelwriter.common import openExternalPath
 from novelwriter.constants import nwConst, nwKeyWords, nwLabels, nwUnicode, trConst
-from novelwriter.enum import nwDocAction, nwDocInsert, nwView, nwWidget
+from novelwriter.enum import nwDocAction, nwDocInsert, nwFocus, nwView
 from novelwriter.extensions.eventfilters import StatusTipFilter
 
 if TYPE_CHECKING:  # pragma: no cover
@@ -54,7 +54,7 @@ class GuiMainMenu(QMenuBar):
     requestDocInsert = pyqtSignal(nwDocInsert)
     requestDocInsertText = pyqtSignal(str)
     requestDocKeyWordInsert = pyqtSignal(str)
-    requestFocusChange = pyqtSignal(nwWidget)
+    requestFocusChange = pyqtSignal(nwFocus)
     requestViewChange = pyqtSignal(nwView)
 
     def __init__(self, mainGui: GuiMain) -> None:
@@ -167,7 +167,7 @@ class GuiMainMenu(QMenuBar):
         # Project > Edit
         self.aEditItem = self.projMenu.addAction(self.tr("Rename Item"))
         self.aEditItem.setShortcut("F2")
-        self.aEditItem.triggered.connect(lambda: self.mainGui.editItemLabel(None))
+        self.aEditItem.triggered.connect(lambda: self.mainGui.projView.renameTreeItem(None))
 
         # Project > Delete
         self.aDeleteItem = self.projMenu.addAction(self.tr("Delete Item"))
@@ -303,24 +303,24 @@ class GuiMainMenu(QMenuBar):
         self.viewMenu = self.addMenu(self.tr("&View"))
 
         # View > TreeView
-        self.aFocusTree = self.viewMenu.addAction(self.tr("Go to Project Tree"))
+        self.aFocusTree = self.viewMenu.addAction(self.tr("Go to Tree View"))
         self.aFocusTree.setShortcut("Ctrl+T")
         self.aFocusTree.triggered.connect(
-            lambda: self.requestFocusChange.emit(nwWidget.TREE)
+            lambda: self.requestFocusChange.emit(nwFocus.TREE)
         )
 
         # View > Document Editor
-        self.aFocusEditor = self.viewMenu.addAction(self.tr("Go to Document Editor"))
-        self.aFocusEditor.setShortcut("Ctrl+E")
-        self.aFocusEditor.triggered.connect(
-            lambda: self.requestFocusChange.emit(nwWidget.EDITOR)
+        self.aFocusDocument = self.viewMenu.addAction(self.tr("Go to Document"))
+        self.aFocusDocument.setShortcut("Ctrl+E")
+        self.aFocusDocument.triggered.connect(
+            lambda: self.requestFocusChange.emit(nwFocus.DOCUMENT)
         )
 
         # View > Outline
         self.aFocusOutline = self.viewMenu.addAction(self.tr("Go to Outline"))
         self.aFocusOutline.setShortcut("Ctrl+Shift+T")
         self.aFocusOutline.triggered.connect(
-            lambda: self.requestFocusChange.emit(nwWidget.OUTLINE)
+            lambda: self.requestFocusChange.emit(nwFocus.OUTLINE)
         )
 
         # View > Separator
@@ -422,7 +422,7 @@ class GuiMainMenu(QMenuBar):
         self.aInsMSApos = self.mInsQuotes.addAction(self.tr("Alternative Apostrophe"))
         self.aInsMSApos.setShortcut("Ctrl+K, '")
         self.aInsMSApos.triggered.connect(
-            lambda: self.requestDocInsertText.emit(nwUnicode.U_MAPOSS)
+            lambda: self.requestDocInsertText.emit(nwUnicode.U_MAPOS)
         )
 
         # Insert > Symbols

novelwriter/gui/outline.py

@@ -215,7 +215,7 @@ class GuiOutlineToolBar(QToolBar):
 
         # Novel Selector
         self.novelLabel = NColourLabel(
-            self.tr("Outline of"), parent=self, scale=NColourLabel.HEADER_SCALE, bold=True
+            self.tr("Outline of"), self, scale=NColourLabel.HEADER_SCALE, bold=True
         )
         self.novelLabel.setContentsMargins(0, 0, CONFIG.pxInt(12), 0)
 
@@ -268,6 +268,7 @@ class GuiOutlineToolBar(QToolBar):
         self.aExport.setIcon(SHARED.theme.getIcon("export"))
         self.tbColumns.setIcon(SHARED.theme.getIcon("menu"))
         self.tbColumns.setStyleSheet("QToolButton::menu-indicator {image: none;}")
+        self.novelLabel.setTextColors(color=self.palette().windowText().color())
         return
 
     def populateNovelList(self) -> None:
@@ -523,12 +524,12 @@ class GuiOutlineTree(QTreeWidget):
     @pyqtSlot()
     def exportOutline(self) -> None:
         """Export the outline as a CSV file."""
-        path = CONFIG.lastPath() / f"{makeFileNameSafe(SHARED.project.data.name)}.csv"
+        path = CONFIG.lastPath("outline") / f"{makeFileNameSafe(SHARED.project.data.name)}.csv"
         path, _ = QFileDialog.getSaveFileName(
             self, self.tr("Save Outline As"), str(path), formatFileFilter(["*.csv", "*"])
         )
         if path:
-            CONFIG.setLastPath(path)
+            CONFIG.setLastPath("outline", path)
             logger.info("Writing CSV file: %s", path)
             cols = [col for col in self._treeOrder if not self._colHidden[col]]
             order = [self._colIdx[col] for col in cols]