novelWriter 2.5.3__py3-none-any.whl → 2.6b2__py3-none-any.whl

novelwriter/shared.py

@@ -26,20 +26,23 @@ from __future__ import annotations
 
 import logging
 
+from enum import Enum
 from pathlib import Path
 from time import time
 from typing import TYPE_CHECKING, TypeVar
 
-from PyQt5.QtCore import QObject, QRunnable, QThreadPool, QTimer, pyqtSignal
-from PyQt5.QtGui import QFont
+from PyQt5.QtCore import QObject, QRunnable, QThreadPool, QTimer, QUrl, pyqtSignal, pyqtSlot
+from PyQt5.QtGui import QDesktopServices, QFont
 from PyQt5.QtWidgets import QFileDialog, QFontDialog, QMessageBox, QWidget
 
 from novelwriter.common import formatFileFilter
 from novelwriter.constants import nwFiles
 from novelwriter.core.spellcheck import NWSpellEnchant
+from novelwriter.enum import nwChange, nwItemClass
 
 if TYPE_CHECKING:  # pragma: no cover
     from novelwriter.core.project import NWProject
+    from novelwriter.core.status import T_StatusKind
     from novelwriter.gui.theme import GuiTheme
     from novelwriter.guimain import GuiMain
 
@@ -55,15 +58,16 @@ class SharedData(QObject):
         "_idleTime", "_idleRefTime",
     )
 
-    projectStatusChanged = pyqtSignal(bool)
-    projectStatusMessage = pyqtSignal(str)
-    spellLanguageChanged = pyqtSignal(str, str)
     focusModeChanged = pyqtSignal(bool)
-    indexScannedText = pyqtSignal(str)
+    indexAvailable = pyqtSignal()
     indexChangedTags = pyqtSignal(list, list)
     indexCleared = pyqtSignal()
-    indexAvailable = pyqtSignal()
     mainClockTick = pyqtSignal()
+    projectItemChanged = pyqtSignal(str, Enum)
+    rootFolderChanged = pyqtSignal(str, Enum)
+    projectStatusChanged = pyqtSignal(bool)
+    projectStatusMessage = pyqtSignal(str)
+    spellLanguageChanged = pyqtSignal(str, str)
     statusLabelsChanged = pyqtSignal(str)
 
     def __init__(self) -> None:
@@ -173,10 +177,12 @@ class SharedData(QObject):
         logger.debug("Thread Pool Max Count: %d", QThreadPool.globalInstance().maxThreadCount())
         return
 
-    def closeEditor(self, tHandle: str | None = None) -> None:
+    def closeDocument(self, tHandle: str | None = None) -> None:
         """Close the document editor, optionally a specific document."""
         if tHandle is None or tHandle == self.mainGui.docEditor.docHandle:
             self.mainGui.closeDocument()
+        if tHandle is None or tHandle == self.mainGui.docViewer.docHandle:
+            self.mainGui.closeViewerPanel()
         return
 
     def saveEditor(self, tHandle: str | None = None) -> None:
@@ -293,29 +299,61 @@ class SharedData(QObject):
         return None
 
     ##
-    #  Signal Proxy
+    #  Public Slots
     ##
 
-    def indexSignalProxy(self, data: dict) -> None:
-        """Emit signals on behalf of the index."""
-        event = data.get("event")
-        logger.debug("Received '%s' event from the index", event)
-        if event == "updateTags":
-            self.indexChangedTags.emit(data.get("updated", []), data.get("deleted", []))
-        elif event == "scanText":
-            self.indexScannedText.emit(data.get("handle", ""))
-        elif event == "clearIndex":
+    @pyqtSlot(str)
+    def openWebsite(self, url: str) -> None:
+        """Open a URL in the system's default browser."""
+        QDesktopServices.openUrl(QUrl(url))
+        return
+
+    @pyqtSlot(str, nwItemClass)
+    def createNewNote(self, tag: str, itemClass: nwItemClass) -> None:
+        """Process new note request."""
+        self.project.createNewNote(tag, itemClass)
+        return
+
+    ##
+    #  Signal Proxies
+    ##
+
+    def emitIndexChangedTags(
+        self, project: NWProject, updated: list[str], deleted: list[str]
+    ) -> None:
+        """Emit the indexChangedTags signal."""
+        if self._project and self._project.data.uuid == project.data.uuid:
+            self.indexChangedTags.emit(updated, deleted)
+        return
+
+    def emitIndexCleared(self, project: NWProject) -> None:
+        """Emit the indexCleared signal."""
+        if self._project and self._project.data.uuid == project.data.uuid:
             self.indexCleared.emit()
-        elif event == "buildIndex":
+        return
+
+    def emitIndexAvailable(self, project: NWProject) -> None:
+        """Emit the indexAvailable signal."""
+        if self._project and self._project.data.uuid == project.data.uuid:
             self.indexAvailable.emit()
         return
 
-    def projectSingalProxy(self, data: dict) -> None:
-        """Emit signals on project data change."""
-        event = data.get("event")
-        logger.debug("Received '%s' event from project data", event)
-        if event == "statusLabels":
-            self.statusLabelsChanged.emit(data.get("kind", ""))
+    def emitStatusLabelsChanged(self, project: NWProject, kind: T_StatusKind) -> None:
+        """Emit the statusLabelsChanged signal."""
+        if self._project and self._project.data.uuid == project.data.uuid:
+            self.statusLabelsChanged.emit(kind)
+        return
+
+    def emitProjectItemChanged(self, project: NWProject, handle: str, change: nwChange) -> None:
+        """Emit the projectItemChanged signal."""
+        if self._project and self._project.data.uuid == project.data.uuid:
+            self.projectItemChanged.emit(handle, change)
+        return
+
+    def emitRootFolderChanged(self, project: NWProject, handle: str, change: nwChange) -> None:
+        """Emit the rootFolderChanged signal."""
+        if self._project and self._project.data.uuid == project.data.uuid:
+            self.rootFolderChanged.emit(handle, change)
         return
 
     ##
@@ -376,6 +414,7 @@ class SharedData(QObject):
         """Create a new project and spell checking instance."""
         from novelwriter.core.project import NWProject
         if isinstance(self._project, NWProject):
+            self._project.clear()
             del self._project
             del self._spelling
         self._project = NWProject()
@@ -441,9 +480,9 @@ class _GuiAlert(QMessageBox):
         Yes/No buttons or just an Ok button.
         """
         if isYesNo:
-            self.setStandardButtons(QMessageBox.Yes | QMessageBox.No)
+            self.setStandardButtons(QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No)
         else:
-            self.setStandardButtons(QMessageBox.Ok)
+            self.setStandardButtons(QMessageBox.StandardButton.Ok)
         pSz = 2*self._theme.baseIconHeight
         if level == self.INFO:
             self.setIconPixmap(self._theme.getPixmap("alert_info", (pSz, pSz)))

novelwriter/text/counting.py

@@ -30,6 +30,7 @@ import re
 from novelwriter.constants import nwRegEx, nwUnicode
 
 RX_SC = re.compile(nwRegEx.FMT_SC)
+RX_SV = re.compile(nwRegEx.FMT_SV)
 RX_LO = re.compile(r"(?i)(?<!\\)(\[(?:vspace|newpage|new page)(:\d+)?)(?<!\\)(\])")
 
 
@@ -64,6 +65,7 @@ def preProcessText(text: str, keepHeaders: bool = True) -> list[str]:
                 # Strip shortcodes and special formatting
                 # RegEx is slow, so we do this only when necessary
                 line = RX_SC.sub("", line)
+                line = RX_SV.sub("", line)
                 line = RX_LO.sub("", line)
 
         result.append(line)

novelwriter/text/patterns.py

@@ -3,7 +3,8 @@ novelWriter – Text Pattern Functions
 ====================================
 
 File History:
-Created: 2024-06-01 [2.5ec1]
+Created: 2024-06-01 [2.5rc1] RegExPatterns
+Created: 2024-11-04 [2.6b1]  DialogParser
 
 This file is a part of novelWriter
 Copyright 2018–2024, Veronica Berglyd Olsen
@@ -23,91 +24,198 @@ along with this program. If not, see <https://www.gnu.org/licenses/>.
 """
 from __future__ import annotations
 
-from PyQt5.QtCore import QRegularExpression
+import re
 
 from novelwriter import CONFIG
-from novelwriter.constants import nwRegEx
-from novelwriter.types import QRegExUnicode
+from novelwriter.common import compact, uniqueCompact
+from novelwriter.constants import nwRegEx, nwUnicode
 
 
 class RegExPatterns:
 
+    AMBIGUOUS = (nwUnicode.U_APOS, nwUnicode.U_RSQUO)
+
+    # Static RegExes
+    _rxUrl     = re.compile(nwRegEx.URL, re.ASCII)
+    _rxWords   = re.compile(nwRegEx.WORDS, re.UNICODE)
+    _rxBreak   = re.compile(nwRegEx.BREAK, re.UNICODE)
+    _rxItalic  = re.compile(nwRegEx.FMT_EI, re.UNICODE)
+    _rxBold    = re.compile(nwRegEx.FMT_EB, re.UNICODE)
+    _rxStrike  = re.compile(nwRegEx.FMT_ST, re.UNICODE)
+    _rxSCPlain = re.compile(nwRegEx.FMT_SC, re.UNICODE)
+    _rxSCValue = re.compile(nwRegEx.FMT_SV, re.UNICODE)
+
     @property
-    def markdownItalic(self) -> QRegularExpression:
+    def url(self) -> re.Pattern:
+        """Find URLs."""
+        return self._rxUrl
+
+    @property
+    def wordSplit(self) -> re.Pattern:
+        """Split text into words."""
+        return self._rxWords
+
+    @property
+    def lineBreak(self) -> re.Pattern:
+        """Find forced line break."""
+        return self._rxBreak
+
+    @property
+    def markdownItalic(self) -> re.Pattern:
         """Markdown italic style."""
-        rxRule = QRegularExpression(nwRegEx.FMT_EI)
-        rxRule.setPatternOptions(QRegExUnicode)
-        return rxRule
+        return self._rxItalic
 
     @property
-    def markdownBold(self) -> QRegularExpression:
+    def markdownBold(self) -> re.Pattern:
         """Markdown bold style."""
-        rxRule = QRegularExpression(nwRegEx.FMT_EB)
-        rxRule.setPatternOptions(QRegExUnicode)
-        return rxRule
+        return self._rxBold
 
     @property
-    def markdownStrike(self) -> QRegularExpression:
+    def markdownStrike(self) -> re.Pattern:
         """Markdown strikethrough style."""
-        rxRule = QRegularExpression(nwRegEx.FMT_ST)
-        rxRule.setPatternOptions(QRegExUnicode)
-        return rxRule
+        return self._rxStrike
 
     @property
-    def shortcodePlain(self) -> QRegularExpression:
+    def shortcodePlain(self) -> re.Pattern:
         """Plain shortcode style."""
-        rxRule = QRegularExpression(nwRegEx.FMT_SC)
-        rxRule.setPatternOptions(QRegExUnicode)
-        return rxRule
+        return self._rxSCPlain
 
     @property
-    def shortcodeValue(self) -> QRegularExpression:
+    def shortcodeValue(self) -> re.Pattern:
         """Plain shortcode style."""
-        rxRule = QRegularExpression(nwRegEx.FMT_SV)
-        rxRule.setPatternOptions(QRegExUnicode)
-        return rxRule
+        return self._rxSCValue
 
     @property
-    def dialogStyle(self) -> QRegularExpression:
+    def dialogStyle(self) -> re.Pattern | None:
         """Dialogue detection rule based on user settings."""
-        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)
-        return rxRule
-
-    @property
-    def dialogLine(self) -> QRegularExpression:
-        """Dialogue line rule based on user settings."""
-        sym = QRegularExpression.escape(CONFIG.dialogLine)
-        rxRule = QRegularExpression(f"^{sym}.*?$")
-        rxRule.setPatternOptions(QRegExUnicode)
-        return rxRule
-
-    @property
-    def narratorBreak(self) -> QRegularExpression:
-        """Dialogue narrator break rule based on user settings."""
-        sym = QRegularExpression.escape(CONFIG.narratorBreak)
-        rxRule = QRegularExpression(f"\\B{sym}\\S.*?\\S{sym}\\B")
-        rxRule.setPatternOptions(QRegExUnicode)
-        return rxRule
+        if CONFIG.dialogStyle > 0:
+            rx = []
+            if CONFIG.dialogStyle in (1, 3):
+                qO = CONFIG.fmtSQuoteOpen.strip()[:1]
+                qC = CONFIG.fmtSQuoteClose.strip()[:1]
+                if qO == qC:
+                    rx.append(f"(?:\\B{qO}.+?{qC}\\B)")
+                else:
+                    rx.append(f"(?:{qO}[^{qO}]+{qC})")
+                if CONFIG.allowOpenDial:
+                    rx.append(f"(?:{qO}.+?$)")
+            if CONFIG.dialogStyle in (2, 3):
+                qO = CONFIG.fmtDQuoteOpen.strip()[:1]
+                qC = CONFIG.fmtDQuoteClose.strip()[:1]
+                if qO == qC:
+                    rx.append(f"(?:\\B{qO}.+?{qC}\\B)")
+                else:
+                    rx.append(f"(?:{qO}[^{qO}]+{qC})")
+                if CONFIG.allowOpenDial:
+                    rx.append(f"(?:{qO}.+?$)")
+            return re.compile("|".join(rx), re.UNICODE)
+        return None
 
     @property
-    def altDialogStyle(self) -> QRegularExpression:
+    def altDialogStyle(self) -> re.Pattern | None:
         """Dialogue alternative rule based on user settings."""
-        symO = QRegularExpression.escape(CONFIG.altDialogOpen)
-        symC = QRegularExpression.escape(CONFIG.altDialogClose)
-        rxRule = QRegularExpression(f"\\B{symO}.*?{symC}\\B")
-        rxRule.setPatternOptions(QRegExUnicode)
-        return rxRule
+        if CONFIG.altDialogOpen and CONFIG.altDialogClose:
+            qO = re.escape(compact(CONFIG.altDialogOpen))
+            qC = re.escape(compact(CONFIG.altDialogClose))
+            qB = r"\B" if (qO == qC or qC in self.AMBIGUOUS) else ""
+            return re.compile(f"{qO}.*?{qC}{qB}", re.UNICODE)
+        return None
 
 
 REGEX_PATTERNS = RegExPatterns()
+
+
+class DialogParser:
+
+    __slots__ = (
+        "_quotes", "_dialog", "_alternate", "_enabled",
+        "_narrator", "_breakD", "_breakQ", "_mode",
+    )
+
+    def __init__(self) -> None:
+        self._quotes = None
+        self._dialog = ""
+        self._alternate = ""
+        self._enabled = False
+        self._narrator = ""
+        self._breakD = None
+        self._breakQ = None
+        self._mode = ""
+        return
+
+    @property
+    def enabled(self) -> bool:
+        """Return True if there are any settings to parse."""
+        return self._enabled
+
+    def initParser(self) -> None:
+        """Init parser settings. This method must also be called when
+        the config changes.
+        """
+        self._quotes = REGEX_PATTERNS.dialogStyle
+        self._dialog = uniqueCompact(CONFIG.dialogLine)
+        self._alternate = CONFIG.narratorDialog.strip()[:1]
+
+        # One of the three modes are needed for the class to have
+        # anything to do
+        self._enabled = bool(self._quotes or self._dialog or self._alternate)
+
+        # Build narrator break RegExes
+        if narrator := CONFIG.narratorBreak.strip()[:1]:
+            punct = re.escape(".,:;!?")
+            self._breakD = re.compile(f"{narrator}.*?(?:{narrator}[{punct}]?|$)", re.UNICODE)
+            self._breakQ = re.compile(f"{narrator}.*?(?:{narrator}[{punct}]?)", re.UNICODE)
+            self._narrator = narrator
+            self._mode = f" {narrator}"
+
+        return
+
+    def __call__(self, text: str) -> list[tuple[int, int]]:
+        """Caller wrapper for dialogue processing."""
+        temp: list[int] = []
+        result: list[tuple[int, int]] = []
+        if text:
+            plain = True
+            if self._dialog and text[0] in self._dialog:
+                # The whole line is dialogue
+                plain = False
+                temp.append(0)
+                temp.append(len(text))
+                if self._breakD:
+                    # Process narrator breaks in the dialogue
+                    for res in self._breakD.finditer(text, 1):
+                        temp.append(res.start(0))
+                        temp.append(res.end(0))
+            elif self._quotes:
+                # Quoted dialogue is enabled, so we look for them
+                for res in self._quotes.finditer(text):
+                    plain = False
+                    temp.append(res.start(0))
+                    temp.append(res.end(0))
+                    if self._breakQ:
+                        for sub in self._breakQ.finditer(text, res.start(0), res.end(0)):
+                            temp.append(sub.start(0))
+                            temp.append(sub.end(0))
+
+            if plain and self._alternate:
+                # The main rules found no dialogue, so we check for
+                # alternating dialogue sections, if enabled
+                pos = 0
+                for num, bit in enumerate(text.split(self._alternate)):
+                    length = len(bit) + (1 if num > 0 else 0)
+                    if num%2:
+                        temp.append(pos)
+                        temp.append(pos + length)
+                    pos += length
+
+            if temp:
+                # Sort unique edges in increasing order, and add them in pairs
+                start = None
+                for pos in sorted(set(temp)):
+                    if start is None:
+                        start = pos
+                    else:
+                        result.append((start, pos))
+                        start = None
+
+        return result

novelwriter/tools/manusbuild.py

@@ -179,14 +179,20 @@ class GuiManuscriptBuild(NDialog):
         self.buildBox.setVerticalSpacing(sp4)
 
         # Dialog Buttons
+        self.buttonBox = QDialogButtonBox(self)
+
         self.btnOpen = QPushButton(SHARED.theme.getIcon("browse"), self.tr("Open Folder"), self)
         self.btnOpen.setIconSize(bSz)
+        self.btnOpen.setAutoDefault(False)
+        self.buttonBox.addButton(self.btnOpen, QtRoleAction)
+
         self.btnBuild = QPushButton(SHARED.theme.getIcon("export"), self.tr("&Build"), self)
         self.btnBuild.setIconSize(bSz)
+        self.btnBuild.setAutoDefault(True)
+        self.buttonBox.addButton(self.btnBuild, QtRoleAction)
 
-        self.dlgButtons = QDialogButtonBox(QtDialogClose, self)
-        self.dlgButtons.addButton(self.btnOpen, QtRoleAction)
-        self.dlgButtons.addButton(self.btnBuild, QtRoleAction)
+        self.btnClose = self.buttonBox.addButton(QtDialogClose)
+        self.btnClose.setAutoDefault(False)
 
         # Assemble GUI
         # ============
@@ -213,7 +219,7 @@ class GuiManuscriptBuild(NDialog):
         self.outerBox.addSpacing(sp4)
         self.outerBox.addLayout(self.buildBox, 0)
         self.outerBox.addSpacing(sp16)
-        self.outerBox.addWidget(self.dlgButtons, 0)
+        self.outerBox.addWidget(self.buttonBox, 0)
         self.outerBox.setSpacing(0)
 
         self.setLayout(self.outerBox)
@@ -229,7 +235,7 @@ class GuiManuscriptBuild(NDialog):
         # Signals
         self.btnReset.clicked.connect(self._doResetBuildName)
         self.btnBrowse.clicked.connect(self._doSelectPath)
-        self.dlgButtons.clicked.connect(self._dialogButtonClicked)
+        self.buttonBox.clicked.connect(self._dialogButtonClicked)
         self.listFormats.itemSelectionChanged.connect(self._resetProgress)
 
         logger.debug("Ready: GuiManuscriptBuild")
@@ -260,7 +266,7 @@ class GuiManuscriptBuild(NDialog):
     @pyqtSlot("QAbstractButton*")
     def _dialogButtonClicked(self, button: QAbstractButton) -> None:
         """Handle button clicks from the dialog button box."""
-        role = self.dlgButtons.buttonRole(button)
+        role = self.buttonBox.buttonRole(button)
         if role == QtRoleAction:
             if button == self.btnBuild:
                 self._runBuild()
@@ -333,7 +339,7 @@ class GuiManuscriptBuild(NDialog):
         docBuild.queueAll()
 
         self.buildProgress.setMaximum(len(docBuild))
-        for i, _ in docBuild.iterBuild(buildPath, bFormat):
+        for i, _ in docBuild.iterBuildDocument(buildPath, bFormat):
             self.buildProgress.setValue(i+1)
 
         self._build.setLastBuildPath(bPath)
@@ -388,13 +394,9 @@ class GuiManuscriptBuild(NDialog):
                     if isinstance(rItem, NWItem):
                         rootMap[rHandle] = rItem.itemName
 
-                itemIcon = SHARED.theme.getItemIcon(
-                    nwItem.itemType, nwItem.itemClass,
-                    nwItem.itemLayout, nwItem.mainHeading
-                )
                 rootName = rootMap.get(rHandle, "??????")
                 item = QListWidgetItem(f"{rootName}: {nwItem.itemName}")
-                item.setIcon(itemIcon)
+                item.setIcon(nwItem.getMainIcon())
                 self.listContent.addItem(item)
 
         return