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

novelwriter/guimain.py

@@ -44,7 +44,7 @@ from novelwriter.dialogs.about import GuiAbout
 from novelwriter.dialogs.preferences import GuiPreferences
 from novelwriter.dialogs.projectsettings import GuiProjectSettings
 from novelwriter.dialogs.wordlist import GuiWordList
-from novelwriter.enum import nwDocAction, nwDocInsert, nwDocMode, nwFocus, nwItemType, nwView
+from novelwriter.enum import nwDocAction, nwDocInsert, nwDocMode, nwFocus, nwView
 from novelwriter.gui.doceditor import GuiDocEditor
 from novelwriter.gui.docviewer import GuiDocViewer
 from novelwriter.gui.docviewerpanel import GuiDocViewerPanel
@@ -249,11 +249,13 @@ class GuiMain(QMainWindow):
         self.projSearch.openDocumentSelectRequest.connect(self._openDocumentSelection)
         self.projSearch.selectedItemChanged.connect(self.itemDetails.updateViewBox)
 
-        self.docEditor.closeDocumentRequest.connect(self.closeDocEditor)
+        self.docEditor.closeEditorRequest.connect(self.closeDocEditor)
         self.docEditor.docCountsChanged.connect(self.itemDetails.updateCounts)
         self.docEditor.docCountsChanged.connect(self.projView.updateCounts)
         self.docEditor.docTextChanged.connect(self.projSearch.textChanged)
         self.docEditor.editedStatusChanged.connect(self.mainStatus.updateDocumentStatus)
+        self.docEditor.itemHandleChanged.connect(self.novelView.setActiveHandle)
+        self.docEditor.itemHandleChanged.connect(self.projView.setActiveHandle)
         self.docEditor.loadDocumentTagRequest.connect(self._followTag)
         self.docEditor.novelItemMetaChanged.connect(self.novelView.updateNovelItemMeta)
         self.docEditor.novelStructureChanged.connect(self.novelView.refreshTree)
@@ -262,12 +264,13 @@ class GuiMain(QMainWindow):
         self.docEditor.requestProjectItemRenamed.connect(self.projView.renameTreeItem)
         self.docEditor.requestProjectItemSelected.connect(self.projView.setSelectedHandle)
         self.docEditor.spellCheckStateChanged.connect(self.mainMenu.setSpellCheckState)
-        self.docEditor.statusMessage.connect(self.mainStatus.setStatusMessage)
         self.docEditor.toggleFocusModeRequest.connect(self.toggleFocusMode)
+        self.docEditor.updateStatusMessage.connect(self.mainStatus.setStatusMessage)
 
         self.docViewer.closeDocumentRequest.connect(self.closeDocViewer)
         self.docViewer.documentLoaded.connect(self.docViewerPanel.updateHandle)
         self.docViewer.loadDocumentTagRequest.connect(self._followTag)
+        self.docViewer.openDocumentRequest.connect(self._openDocument)
         self.docViewer.reloadDocumentRequest.connect(self._reloadViewer)
         self.docViewer.requestProjectItemSelected.connect(self.projView.setSelectedHandle)
         self.docViewer.togglePanelVisibility.connect(self._toggleViewerPanelVisibility)
@@ -289,19 +292,17 @@ class GuiMain(QMainWindow):
         self.asDocTimer = QTimer(self)
         self.asDocTimer.timeout.connect(self._autoSaveDocument)
 
-        # Shortcuts and Actions
-        self._connectMenuActions()
-
+        # Shortcuts
         self.keyReturn = QShortcut(self)
-        self.keyReturn.setKey(Qt.Key.Key_Return)
+        self.keyReturn.setKey("Return")
         self.keyReturn.activated.connect(self._keyPressReturn)
 
         self.keyEnter = QShortcut(self)
-        self.keyEnter.setKey(Qt.Key.Key_Enter)
+        self.keyEnter.setKey("Enter")
         self.keyEnter.activated.connect(self._keyPressReturn)
 
         self.keyEscape = QShortcut(self)
-        self.keyEscape.setKey(Qt.Key.Key_Escape)
+        self.keyEscape.setKey("Esc")
         self.keyEscape.activated.connect(self._keyPressEscape)
 
         # Initialise Main GUI
@@ -481,8 +482,7 @@ class GuiMain(QMainWindow):
             QApplication.processEvents()
             self.openDocument(lastEdited, doScroll=True)
 
-        lastViewed = SHARED.project.data.getLastHandle("viewer")
-        if lastViewed is not None:
+        if lastViewed := SHARED.project.data.getLastHandle("viewer"):
             QApplication.processEvents()
             self.viewDocument(lastViewed)
 
@@ -512,7 +512,7 @@ class GuiMain(QMainWindow):
     #  Document Actions
     ##
 
-    def closeDocument(self, beforeOpen: bool = False) -> None:
+    def closeDocument(self) -> None:
         """Close the document and clear the editor and title field."""
         if SHARED.hasProject:
             # Disable focus mode if it is active
@@ -520,8 +520,6 @@ class GuiMain(QMainWindow):
                 SHARED.setFocusMode(False)
             self.saveDocument()
             self.docEditor.clearEditor()
-            if not beforeOpen:
-                self.novelView.setActiveHandle(None)
         return
 
     def openDocument(
@@ -533,12 +531,8 @@ class GuiMain(QMainWindow):
         doScroll: bool = False
     ) -> bool:
         """Open a specific document, optionally at a given line."""
-        if not SHARED.hasProject:
-            logger.error("No project open")
-            return False
-
-        if not tHandle or not SHARED.project.tree.checkType(tHandle, nwItemType.FILE):
-            logger.debug("Requested item '%s' is not a document", tHandle)
+        if not (SHARED.hasProject and tHandle):
+            logger.error("Nothing to open open")
             return False
 
         if sTitle and tLine is None:
@@ -548,19 +542,15 @@ class GuiMain(QMainWindow):
         self._changeView(nwView.EDITOR)
         if tHandle == self.docEditor.docHandle:
             self.docEditor.setCursorLine(tLine)
-            if changeFocus:
-                self.docEditor.setFocus()
-            return True
-
-        self.closeDocument(beforeOpen=True)
-        if self.docEditor.loadText(tHandle, tLine):
-            SHARED.project.data.setLastHandle(tHandle, "editor")
-            self.projView.setSelectedHandle(tHandle, doScroll=doScroll)
-            self.novelView.setActiveHandle(tHandle, doScroll=doScroll)
-            if changeFocus:
-                self.docEditor.setFocus()
         else:
-            return False
+            self.closeDocument()
+            if self.docEditor.loadText(tHandle, tLine):
+                self.projView.setSelectedHandle(tHandle, doScroll=doScroll)
+            else:
+                return False
+
+        if changeFocus:
+            self.docEditor.setFocus()
 
         return True
 
@@ -855,13 +845,11 @@ class GuiMain(QMainWindow):
 
     def closeMain(self) -> bool:
         """Save everything, and close novelWriter."""
-        if SHARED.hasProject:
-            msgYes = SHARED.question("%s<br>%s" % (
-                self.tr("Do you want to exit novelWriter?"),
-                self.tr("Changes are saved automatically.")
-            ))
-            if not msgYes:
-                return False
+        if SHARED.hasProject and not SHARED.question("%s<br>%s" % (
+            self.tr("Do you want to exit novelWriter?"),
+            self.tr("Changes are saved automatically.")
+        )):
+            return False
 
         logger.info("Exiting novelWriter")
 
@@ -906,11 +894,6 @@ class GuiMain(QMainWindow):
 
         return not self.splitView.isVisible()
 
-    def toggleFullScreenMode(self) -> None:
-        """Toggle full screen mode"""
-        self.setWindowState(self.windowState() ^ Qt.WindowState.WindowFullScreen)
-        return
-
     ##
     #  Events
     ##
@@ -926,6 +909,12 @@ class GuiMain(QMainWindow):
     #  Public Slots
     ##
 
+    @pyqtSlot()
+    def toggleFullScreenMode(self) -> None:
+        """Toggle full screen mode"""
+        self.setWindowState(self.windowState() ^ Qt.WindowState.WindowFullScreen)
+        return
+
     @pyqtSlot()
     def closeDocEditor(self) -> None:
         """Close the document editor. This does not hide the editor."""
@@ -1111,8 +1100,16 @@ class GuiMain(QMainWindow):
     @pyqtSlot(str, nwDocMode)
     def _followTag(self, tag: str, mode: nwDocMode) -> None:
         """Follow a tag after user interaction with a link."""
-        tHandle, sTitle = self._getTagSource(tag)
-        if tHandle is not None:
+        tHandle, sTitle = SHARED.project.index.getTagSource(tag)
+        if tHandle is None:
+            SHARED.error(self.tr(
+                "Could not find the reference for tag '{0}'. It either doesn't "
+                "exist, or the index is out of date. The index can be updated "
+                "from the Tools menu, or by pressing {1}."
+            ).format(
+                tag, "F9"
+            ))
+        else:
             if mode == nwDocMode.EDIT:
                 self.openDocument(tHandle, sTitle=sTitle)
             elif mode == nwDocMode.VIEW:
@@ -1299,116 +1296,7 @@ class GuiMain(QMainWindow):
     #  Internal Functions
     ##
 
-    def _connectMenuActions(self) -> None:
-        """Connect to the main window all menu actions that need to be
-        available also when the main menu is hidden.
-        """
-        # Project
-        self.addAction(self.mainMenu.aSaveProject)
-        self.addAction(self.mainMenu.aEditItem)
-        self.addAction(self.mainMenu.aExitNW)
-
-        # Document
-        self.addAction(self.mainMenu.aSaveDoc)
-        self.addAction(self.mainMenu.aCloseDoc)
-
-        # Edit
-        self.addAction(self.mainMenu.aEditUndo)
-        self.addAction(self.mainMenu.aEditRedo)
-        self.addAction(self.mainMenu.aEditCut)
-        self.addAction(self.mainMenu.aEditCopy)
-        self.addAction(self.mainMenu.aEditPaste)
-        self.addAction(self.mainMenu.aSelectAll)
-        self.addAction(self.mainMenu.aSelectPar)
-
-        # View
-        self.addAction(self.mainMenu.aFocusMode)
-        self.addAction(self.mainMenu.aFullScreen)
-
-        # Insert
-        self.addAction(self.mainMenu.aInsENDash)
-        self.addAction(self.mainMenu.aInsEMDash)
-        self.addAction(self.mainMenu.aInsHorBar)
-        self.addAction(self.mainMenu.aInsFigDash)
-        self.addAction(self.mainMenu.aInsQuoteLS)
-        self.addAction(self.mainMenu.aInsQuoteRS)
-        self.addAction(self.mainMenu.aInsQuoteLD)
-        self.addAction(self.mainMenu.aInsQuoteRD)
-        self.addAction(self.mainMenu.aInsMSApos)
-        self.addAction(self.mainMenu.aInsEllipsis)
-        self.addAction(self.mainMenu.aInsPrime)
-        self.addAction(self.mainMenu.aInsDPrime)
-        self.addAction(self.mainMenu.aInsNBSpace)
-        self.addAction(self.mainMenu.aInsThinSpace)
-        self.addAction(self.mainMenu.aInsThinNBSpace)
-        self.addAction(self.mainMenu.aInsBullet)
-        self.addAction(self.mainMenu.aInsHyBull)
-        self.addAction(self.mainMenu.aInsFlower)
-        self.addAction(self.mainMenu.aInsPerMille)
-        self.addAction(self.mainMenu.aInsDegree)
-        self.addAction(self.mainMenu.aInsMinus)
-        self.addAction(self.mainMenu.aInsTimes)
-        self.addAction(self.mainMenu.aInsDivide)
-        self.addAction(self.mainMenu.aInsSynopsis)
-        self.addAction(self.mainMenu.aInsShort)
-
-        for mAction, _ in self.mainMenu.mInsKWItems.values():
-            self.addAction(mAction)
-
-        # Search
-        self.addAction(self.mainMenu.aFind)
-        self.addAction(self.mainMenu.aReplace)
-        self.addAction(self.mainMenu.aFindNext)
-        self.addAction(self.mainMenu.aFindPrev)
-        self.addAction(self.mainMenu.aReplaceNext)
-
-        # Format
-        self.addAction(self.mainMenu.aFmtItalic)
-        self.addAction(self.mainMenu.aFmtBold)
-        self.addAction(self.mainMenu.aFmtStrike)
-        self.addAction(self.mainMenu.aFmtDQuote)
-        self.addAction(self.mainMenu.aFmtSQuote)
-        self.addAction(self.mainMenu.aFmtHead1)
-        self.addAction(self.mainMenu.aFmtHead2)
-        self.addAction(self.mainMenu.aFmtHead3)
-        self.addAction(self.mainMenu.aFmtHead4)
-        self.addAction(self.mainMenu.aFmtAlignLeft)
-        self.addAction(self.mainMenu.aFmtAlignCentre)
-        self.addAction(self.mainMenu.aFmtAlignRight)
-        self.addAction(self.mainMenu.aFmtIndentLeft)
-        self.addAction(self.mainMenu.aFmtIndentRight)
-        self.addAction(self.mainMenu.aFmtComment)
-        self.addAction(self.mainMenu.aFmtNoFormat)
-
-        # Tools
-        self.addAction(self.mainMenu.aSpellCheck)
-        self.addAction(self.mainMenu.aReRunSpell)
-        self.addAction(self.mainMenu.aPreferences)
-
-        # Help
-        self.addAction(self.mainMenu.aHelpDocs)
-        if isinstance(CONFIG.pdfDocs, Path):
-            self.addAction(self.mainMenu.aPdfDocs)
-
-        return
-
     def _updateWindowTitle(self, projName: str | None = None) -> None:
         """Set the window title and add the project's name."""
         self.setWindowTitle(" - ".join(filter(None, [projName, CONFIG.appName])))
         return
-
-    def _getTagSource(self, tag: str) -> tuple[str | None, str | None]:
-        """Handle the index lookup of a tag and display an alert if the
-        tag cannot be found.
-        """
-        tHandle, sTitle = SHARED.project.index.getTagSource(tag)
-        if tHandle is None:
-            SHARED.error(self.tr(
-                "Could not find the reference for tag '{0}'. It either doesn't "
-                "exist, or the index is out of date. The index can be updated "
-                "from the Tools menu, or by pressing {1}."
-            ).format(
-                tag, "F9"
-            ))
-            return None, None
-        return tHandle, sTitle

novelwriter/shared.py

@@ -30,8 +30,8 @@ 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
@@ -292,6 +292,16 @@ class SharedData(QObject):
                 return widget
         return None
 
+    ##
+    #  Public Slots
+    ##
+
+    @pyqtSlot(str)
+    def openWebsite(self, url: str) -> None:
+        """Open a URL in the system's default browser."""
+        QDesktopServices.openUrl(QUrl(url))
+        return
+
     ##
     #  Signal Proxy
     ##
@@ -441,9 +451,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,186 @@ 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.common import compact, uniqueCompact
 from novelwriter.constants import nwRegEx
-from novelwriter.types import QRegExUnicode
 
 
 class RegExPatterns:
 
+    # 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 url(self) -> re.Pattern:
+        """Find URLs."""
+        return self._rxUrl
+
+    @property
+    def wordSplit(self) -> re.Pattern:
+        """Split text into words."""
+        return self._rxWords
+
     @property
-    def markdownItalic(self) -> QRegularExpression:
+    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
+        if CONFIG.dialogStyle > 0:
+            end = "|$" if CONFIG.allowOpenDial else ""
+            rx = []
+            if CONFIG.dialogStyle in (1, 3):
+                qO = CONFIG.fmtSQuoteOpen.strip()[:1]
+                qC = CONFIG.fmtSQuoteClose.strip()[:1]
+                rx.append(f"(?:\\B{qO}.*?(?:{qC}\\B{end}))")
+            if CONFIG.dialogStyle in (2, 3):
+                qO = CONFIG.fmtDQuoteOpen.strip()[:1]
+                qC = CONFIG.fmtDQuoteClose.strip()[:1]
+                rx.append(f"(?:\\B{qO}.*?(?:{qC}\\B{end}))")
+            return re.compile("|".join(rx), re.UNICODE)
+        return None
 
     @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
-
-    @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))
+            return re.compile(f"\\B{qO}.*?{qC}\\B", 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

@@ -333,7 +333,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)