novelWriter 2.3rc1__py3-none-any.whl → 2.4__py3-none-any.whl

novelwriter/core/buildsettings.py

@@ -49,39 +49,54 @@ logger = logging.getLogger(__name__)
 # (type, default, [min value, max value])
 
 SETTINGS_TEMPLATE = {
-    "filter.includeNovel":    (bool, True),
-    "filter.includeNotes":    (bool, False),
-    "filter.includeInactive": (bool, False),
-    "headings.fmtTitle":      (str, nwHeadFmt.TITLE),
-    "headings.fmtChapter":    (str, nwHeadFmt.TITLE),
-    "headings.fmtUnnumbered": (str, nwHeadFmt.TITLE),
-    "headings.fmtScene":      (str, "* * *"),
-    "headings.fmtSection":    (str, ""),
-    "headings.hideScene":     (bool, False),
-    "headings.hideSection":   (bool, True),
-    "text.includeSynopsis":   (bool, False),
-    "text.includeComments":   (bool, False),
-    "text.includeKeywords":   (bool, False),
-    "text.includeBodyText":   (bool, True),
-    "text.addNoteHeadings":   (bool, True),
-    "format.textFont":        (str, CONFIG.textFont),
-    "format.textSize":        (int, 12),
-    "format.lineHeight":      (float, 1.15, 0.75, 3.0),
-    "format.justifyText":     (bool, False),
-    "format.stripUnicode":    (bool, False),
-    "format.replaceTabs":     (bool, False),
-    "format.pageUnit":        (str, "cm"),
-    "format.pageSize":        (str, "A4"),
-    "format.pageWidth":       (float, 21.0),
-    "format.pageHeight":      (float, 29.7),
-    "format.topMargin":       (float, 2.0),
-    "format.bottomMargin":    (float, 2.0),
-    "format.leftMargin":      (float, 2.0),
-    "format.rightMargin":     (float, 2.0),
-    "odt.addColours":         (bool, True),
-    "odt.pageHeader":         (str, nwHeadFmt.ODT_AUTO),
-    "odt.pageCountOffset":    (int, 0),
-    "html.addStyles":         (bool, True),
+    "filter.includeNovel":     (bool, True),
+    "filter.includeNotes":     (bool, False),
+    "filter.includeInactive":  (bool, False),
+    "headings.fmtTitle":       (str, nwHeadFmt.TITLE),
+    "headings.fmtChapter":     (str, nwHeadFmt.TITLE),
+    "headings.fmtUnnumbered":  (str, nwHeadFmt.TITLE),
+    "headings.fmtScene":       (str, "* * *"),
+    "headings.fmtAltScene":    (str, ""),
+    "headings.fmtSection":     (str, ""),
+    "headings.hideTitle":      (bool, False),
+    "headings.hideChapter":    (bool, False),
+    "headings.hideUnnumbered": (bool, False),
+    "headings.hideScene":      (bool, False),
+    "headings.hideAltScene":   (bool, False),
+    "headings.hideSection":    (bool, True),
+    "headings.centerTitle":    (bool, True),
+    "headings.centerChapter":  (bool, False),
+    "headings.centerScene":    (bool, False),
+    "headings.breakTitle":     (bool, True),
+    "headings.breakChapter":   (bool, True),
+    "headings.breakScene":     (bool, False),
+    "text.includeSynopsis":    (bool, False),
+    "text.includeComments":    (bool, False),
+    "text.includeKeywords":    (bool, False),
+    "text.includeBodyText":    (bool, True),
+    "text.ignoredKeywords":    (str, ""),
+    "text.addNoteHeadings":    (bool, True),
+    "format.textFont":         (str, CONFIG.textFont),
+    "format.textSize":         (int, 12),
+    "format.lineHeight":       (float, 1.15, 0.75, 3.0),
+    "format.justifyText":      (bool, False),
+    "format.stripUnicode":     (bool, False),
+    "format.replaceTabs":      (bool, False),
+    "format.pageUnit":         (str, "cm"),
+    "format.pageSize":         (str, "A4"),
+    "format.pageWidth":        (float, 21.0),
+    "format.pageHeight":       (float, 29.7),
+    "format.topMargin":        (float, 2.0),
+    "format.bottomMargin":     (float, 2.0),
+    "format.leftMargin":       (float, 2.0),
+    "format.rightMargin":      (float, 2.0),
+    "odt.addColours":          (bool, True),
+    "odt.pageHeader":          (str, nwHeadFmt.ODT_AUTO),
+    "odt.pageCountOffset":     (int, 0),
+    "odt.firstLineIndent":     (bool, False),
+    "md.preserveBreaks":       (bool, True),
+    "html.addStyles":          (bool, True),
+    "html.preserveTabs":       (bool, False),
 }
 
 SETTINGS_LABELS = {
@@ -91,19 +106,19 @@ SETTINGS_LABELS = {
     "filter.includeInactive": QT_TRANSLATE_NOOP("Builds", "Inactive Documents"),
 
     "headings":               QT_TRANSLATE_NOOP("Builds", "Headings"),
-    "headings.fmtTitle":      QT_TRANSLATE_NOOP("Builds", "Title Headings"),
-    "headings.fmtChapter":    QT_TRANSLATE_NOOP("Builds", "Chapter Headings"),
-    "headings.fmtUnnumbered": QT_TRANSLATE_NOOP("Builds", "Unnumbered Headings"),
-    "headings.fmtScene":      QT_TRANSLATE_NOOP("Builds", "Scene Headings"),
-    "headings.fmtSection":    QT_TRANSLATE_NOOP("Builds", "Section Headings"),
-    "headings.hideScene":     QT_TRANSLATE_NOOP("Builds", "Hide Scene Headings"),
-    "headings.hideSection":   QT_TRANSLATE_NOOP("Builds", "Hide Section Headings"),
+    "headings.fmtTitle":      QT_TRANSLATE_NOOP("Builds", "Partition Format"),
+    "headings.fmtChapter":    QT_TRANSLATE_NOOP("Builds", "Chapter Format"),
+    "headings.fmtUnnumbered": QT_TRANSLATE_NOOP("Builds", "Unnumbered Format"),
+    "headings.fmtScene":      QT_TRANSLATE_NOOP("Builds", "Scene Format"),
+    "headings.fmtAltScene":   QT_TRANSLATE_NOOP("Builds", "Alt. Scene Format"),
+    "headings.fmtSection":    QT_TRANSLATE_NOOP("Builds", "Section Format"),
 
     "text.grpContent":        QT_TRANSLATE_NOOP("Builds", "Text Content"),
     "text.includeSynopsis":   QT_TRANSLATE_NOOP("Builds", "Include Synopsis"),
     "text.includeComments":   QT_TRANSLATE_NOOP("Builds", "Include Comments"),
     "text.includeKeywords":   QT_TRANSLATE_NOOP("Builds", "Include Keywords"),
     "text.includeBodyText":   QT_TRANSLATE_NOOP("Builds", "Include Body Text"),
+    "text.ignoredKeywords":   QT_TRANSLATE_NOOP("Builds", "Ignore These Keywords"),
     "text.grpInsert":         QT_TRANSLATE_NOOP("Builds", "Insert Content"),
     "text.addNoteHeadings":   QT_TRANSLATE_NOOP("Builds", "Add Titles for Notes"),
 
@@ -129,9 +144,14 @@ SETTINGS_LABELS = {
     "odt.addColours":         QT_TRANSLATE_NOOP("Builds", "Add Highlight Colours"),
     "odt.pageHeader":         QT_TRANSLATE_NOOP("Builds", "Page Header"),
     "odt.pageCountOffset":    QT_TRANSLATE_NOOP("Builds", "Page Counter Offset"),
+    "odt.firstLineIndent":    QT_TRANSLATE_NOOP("Builds", "First Line Indent"),
+
+    "md":                     QT_TRANSLATE_NOOP("Builds", "Markdown (.md)"),
+    "md.preserveBreaks":      QT_TRANSLATE_NOOP("Builds", "Preserve Hard Line Breaks"),
 
     "html":                   QT_TRANSLATE_NOOP("Builds", "HTML (.html)"),
     "html.addStyles":         QT_TRANSLATE_NOOP("Builds", "Add CSS Styles"),
+    "html.preserveTabs":      QT_TRANSLATE_NOOP("Builds", "Preserve Tab Characters"),
 }
 
 
@@ -158,7 +178,7 @@ class BuildSettings:
     def __init__(self) -> None:
         self._name = ""
         self._uuid = str(uuid.uuid4())
-        self._path = Path.home()
+        self._path = CONFIG.homePath()
         self._build = ""
         self._order = 0
         self._format = nwBuildFmt.ODT
@@ -200,7 +220,7 @@ class BuildSettings:
         """The last used build path."""
         if self._path.is_dir():
             return self._path
-        return Path.home()
+        return CONFIG.homePath()
 
     @property
     def lastBuildName(self) -> str:
@@ -277,7 +297,7 @@ class BuildSettings:
         if isinstance(path, Path) and path.is_dir():
             self._path = path
         else:
-            self._path = Path.home()
+            self._path = CONFIG.homePath()
         self._changed = True
         return
 
@@ -362,7 +382,7 @@ class BuildSettings:
 
         postponed = []
 
-        def allowRoot(rHandle):
+        def allowRoot(rHandle: str | None) -> None:
             if rHandle in postponed and rHandle in result and rHandle is not None:
                 result[rHandle] = (True, FilterMode.ROOT)
                 postponed.remove(rHandle)

novelwriter/core/coretools.py

@@ -26,19 +26,19 @@ along with this program. If not, see <https://www.gnu.org/licenses/>.
 """
 from __future__ import annotations
 
-import shutil
 import logging
+import shutil
 
-from pathlib import Path
+from collections.abc import Iterable
 from functools import partial
+from pathlib import Path
 from zipfile import ZipFile, is_zipfile
-from collections.abc import Iterable
 
-from PyQt5.QtCore import QCoreApplication
+from PyQt5.QtCore import QCoreApplication, QRegularExpression
 
 from novelwriter import CONFIG, SHARED
 from novelwriter.common import isHandle, minmax, simplified
-from novelwriter.constants import nwFiles, nwItemClass
+from novelwriter.constants import nwConst, nwFiles, nwItemClass
 from novelwriter.core.item import NWItem
 from novelwriter.core.project import NWProject
 from novelwriter.core.storage import NWStorageCreate
@@ -101,9 +101,7 @@ class DocMerger:
         if srcItem is None:
             return False
 
-        inDoc = self._project.storage.getDocument(srcHandle)
-        docText = (inDoc.readDocument() or "").rstrip("\n")
-
+        docText = self._project.storage.getDocumentText(srcHandle).rstrip("\n")
         if addComment:
             docInfo = srcItem.describeMe()
             docSt, _ = srcItem.getImportStatus(incIcon=False)
@@ -122,9 +120,8 @@ class DocMerger:
             return False
 
         outDoc = self._project.storage.getDocument(self._targetDoc)
-        docText = (outDoc.readDocument() or "").rstrip("\n")
-        if docText:
-            self._targetText.insert(0, docText)
+        if text := (outDoc.readDocument() or "").rstrip("\n"):
+            self._targetText.insert(0, text)
 
         status = outDoc.writeDocument("\n\n".join(self._targetText) + "\n\n")
         if not status:
@@ -292,11 +289,10 @@ class DocDuplicator:
                     newItem.setParent(hMap[newItem.itemParent])
                     self._project.tree.updateItemData(newItem.itemHandle)
                 if newItem.isFileType():
-                    oldDoc = self._project.storage.getDocument(tHandle)
                     newDoc = self._project.storage.getDocument(newItem.itemHandle)
                     if newDoc.fileExists():
                         return
-                    newDoc.writeDocument(oldDoc.readDocument() or "")
+                    newDoc.writeDocument(self._project.storage.getDocumentText(tHandle))
                 yield newItem.itemHandle, nHandle
                 nHandle = None
         return
@@ -304,6 +300,94 @@ class DocDuplicator:
 # END Class DocDuplicator
 
 
+class DocSearch:
+
+    def __init__(self) -> None:
+        self._regEx = QRegularExpression()
+        self.setCaseSensitive(False)
+        self._words = False
+        self._escape = True
+        return
+
+    ##
+    #  Methods
+    ##
+
+    def setCaseSensitive(self, state: bool) -> None:
+        """Set the case sensitive search flag."""
+        opts = QRegularExpression.PatternOption.UseUnicodePropertiesOption
+        if not state:
+            opts |= QRegularExpression.PatternOption.CaseInsensitiveOption
+        self._regEx.setPatternOptions(opts)
+        return
+
+    def setWholeWords(self, state: bool) -> None:
+        """Set the whole words search flag."""
+        self._words = state
+        return
+
+    def setUserRegEx(self, state: bool) -> None:
+        """Set the escape flag to the opposite state."""
+        self._escape = not state
+        return
+
+    def iterSearch(
+        self, project: NWProject, search: str
+    ) -> Iterable[tuple[NWItem, list[tuple[int, int, str]], bool]]:
+        """Iteratively search through documents in a project."""
+        self._regEx.setPattern(self._buildPattern(search))
+        logger.debug("Searching with pattern '%s'", self._regEx.pattern())
+        storage = project.storage
+        for item in project.tree:
+            if item.isFileType():
+                results, capped = self.searchText(storage.getDocumentText(item.itemHandle))
+                yield item, results, capped
+        return
+
+    def searchText(self, text: str) -> tuple[list[tuple[int, int, str]], bool]:
+        """Search a piece of text for RegEx matches."""
+        rxItt = self._regEx.globalMatch(text)
+        count = 0
+        capped = False
+        results = []
+        while rxItt.hasNext():
+            rxMatch = rxItt.next()
+            pos = rxMatch.capturedStart()
+            num = rxMatch.capturedLength()
+            context = text[pos:pos+100].partition("\n")[0]
+            if context:
+                results.append((pos, num, context))
+                count += 1
+                if count >= nwConst.MAX_SEARCH_RESULT:
+                    capped = True
+                    break
+        return results, capped
+
+    ##
+    #  Internal Functions
+    ##
+
+    def _buildPattern(self, search: str) -> str:
+        """Build the search pattern string."""
+        if self._escape:
+            if CONFIG.verQtValue >= 0x050f00:
+                search = QRegularExpression.escape(search)
+            else:
+                # For older Qt versions, we escape manually
+                escaped = ""
+                for c in search:
+                    if c.isalnum() or c == "_":
+                        escaped += c
+                    else:
+                        escaped += f"\\{c}"
+                search = escaped
+        if self._words:
+            search = f"(?:^|\\b){search}(?:$|\\b)"
+        return search
+
+# END Class DocSearch
+
+
 class ProjectBuilder:
     """A class to build a new project from a set of user-defined
     parameter provided by the New Project Wizard.

novelwriter/core/docbuild.py

@@ -52,7 +52,10 @@ class NWBuildDocument:
     manuscript, based on a build definition object (BuildSettings).
     """
 
-    __slots__ = ("_project", "_build", "_queue", "_error", "_cache")
+    __slots__ = (
+        "_project", "_build", "_queue", "_error", "_cache", "_count",
+        "_outline", "_preview"
+    )
 
     def __init__(self, project: NWProject, build: BuildSettings) -> None:
         self._project = project
@@ -60,6 +63,9 @@ class NWBuildDocument:
         self._queue = []
         self._error = None
         self._cache = None
+        self._count = False
+        self._outline = False
+        self._preview = False
         return
 
     ##
@@ -79,6 +85,29 @@ class NWBuildDocument:
         """
         return self._cache
 
+    ##
+    #  Setters
+    ##
+
+    def setCountEnabled(self, state: bool) -> None:
+        """Turn on/off stats for builds."""
+        self._count = state
+        return
+
+    def setBuildOutline(self, state: bool) -> None:
+        """Turn on/off outline for builds."""
+        self._outline = state
+        return
+
+    def setPreviewMode(self, state: bool) -> None:
+        """Set the preview mode of the build. This also enables stats
+        count and outline mode.
+        """
+        self._preview = state
+        self._outline = state
+        self._count = state
+        return
+
     ##
     #  Special Methods
     ##
@@ -153,6 +182,8 @@ class NWBuildDocument:
         makeObj = ToHtml(self._project)
         filtered = self._setupBuild(makeObj)
 
+        makeObj.setPreview(self._preview)
+        makeObj.setLinkHeadings(self._preview)
         for i, tHandle in enumerate(self._queue):
             self._error = None
             if filtered.get(tHandle, (False, 0))[0]:
@@ -160,7 +191,7 @@ class NWBuildDocument:
             else:
                 yield i, False
 
-        if self._build.getBool("format.replaceTabs"):
+        if not (self._build.getBool("html.preserveTabs") or self._preview):
             makeObj.replaceTabs()
 
         self._error = None
@@ -191,6 +222,8 @@ class NWBuildDocument:
         if self._build.getBool("format.replaceTabs"):
             makeObj.replaceTabs(nSpaces=4, spaceChar=" ")
 
+        makeObj.setPreserveBreaks(self._build.getBool("md.preserveBreaks"))
+
         for i, tHandle in enumerate(self._queue):
             self._error = None
             if filtered.get(tHandle, (False, 0))[0]:
@@ -256,26 +289,52 @@ class NWBuildDocument:
         fontInfo = QFontInfo(bldFont)
         textFixed = fontInfo.fixedPitch()
 
-        bldObj.setTitleFormat(self._build.getStr("headings.fmtTitle"))
-        bldObj.setChapterFormat(self._build.getStr("headings.fmtChapter"))
-        bldObj.setUnNumberedFormat(self._build.getStr("headings.fmtUnnumbered"))
+        bldObj.setTitleFormat(
+            self._build.getStr("headings.fmtTitle"),
+            self._build.getBool("headings.hideTitle")
+        )
+        bldObj.setChapterFormat(
+            self._build.getStr("headings.fmtChapter"),
+            self._build.getBool("headings.hideChapter")
+        )
+        bldObj.setUnNumberedFormat(
+            self._build.getStr("headings.fmtUnnumbered"),
+            self._build.getBool("headings.hideUnnumbered")
+        )
         bldObj.setSceneFormat(
             self._build.getStr("headings.fmtScene"),
             self._build.getBool("headings.hideScene")
         )
+        bldObj.setHardSceneFormat(
+            self._build.getStr("headings.fmtAltScene"),
+            self._build.getBool("headings.hideAltScene")
+        )
         bldObj.setSectionFormat(
             self._build.getStr("headings.fmtSection"),
             self._build.getBool("headings.hideSection")
         )
+        bldObj.setTitleStyle(
+            self._build.getBool("headings.centerTitle"),
+            self._build.getBool("headings.breakTitle")
+        )
+        bldObj.setChapterStyle(
+            self._build.getBool("headings.centerChapter"),
+            self._build.getBool("headings.breakChapter")
+        )
+        bldObj.setSceneStyle(
+            self._build.getBool("headings.centerScene"),
+            self._build.getBool("headings.breakScene")
+        )
 
         bldObj.setFont(fontFamily, textSize, textFixed)
         bldObj.setJustify(self._build.getBool("format.justifyText"))
         bldObj.setLineHeight(self._build.getFloat("format.lineHeight"))
 
+        bldObj.setBodyText(self._build.getBool("text.includeBodyText"))
         bldObj.setSynopsis(self._build.getBool("text.includeSynopsis"))
         bldObj.setComments(self._build.getBool("text.includeComments"))
         bldObj.setKeywords(self._build.getBool("text.includeKeywords"))
-        bldObj.setBodyText(self._build.getBool("text.includeBodyText"))
+        bldObj.setIgnoredKeywords(self._build.getStr("text.ignoredKeywords"))
 
         if isinstance(bldObj, ToHtml):
             bldObj.setStyles(self._build.getBool("html.addStyles"))
@@ -287,6 +346,7 @@ class NWBuildDocument:
             bldObj.setHeaderFormat(
                 self._build.getStr("odt.pageHeader"), self._build.getInt("odt.pageCountOffset")
             )
+            bldObj.setFirstLineIndent(self._build.getBool("odt.firstLineIndent"))
 
             scale = nwLabels.UNIT_SCALE.get(self._build.getStr("format.pageUnit"), 1.0)
             pW, pH = nwLabels.PAPER_SIZE.get(self._build.getStr("format.pageSize"), (-1.0, -1.0))
@@ -314,11 +374,18 @@ class NWBuildDocument:
                     bldObj.addRootHeading(tHandle)
                     if convert:
                         bldObj.doConvert()
+                    if self._count:
+                        bldObj.countStats()
+                    if self._outline:
+                        bldObj.buildOutline()
                 elif tItem.isFileType():
                     bldObj.setText(tHandle)
                     bldObj.doPreProcessing()
                     bldObj.tokenizeText()
-                    bldObj.doHeaders()
+                    if self._count:
+                        bldObj.countStats()
+                    if self._outline:
+                        bldObj.buildOutline()
                     if convert:
                         bldObj.doConvert()
                 else:

novelwriter/core/document.py

@@ -31,7 +31,7 @@ from typing import TYPE_CHECKING
 from pathlib import Path
 
 from novelwriter.enum import nwItemLayout, nwItemClass
-from novelwriter.error import formatException
+from novelwriter.error import formatException, logException
 from novelwriter.common import formatTimeStamp, isHandle
 from novelwriter.core.item import NWItem
 
@@ -106,7 +106,28 @@ class NWDocument:
         return self._item
 
     ##
-    #  Class Methods
+    #  Static Methods
+    ##
+
+    @staticmethod
+    def quickReadText(content: Path, tHandle: str) -> str:
+        """Return the text of a document in a fast and efficient way."""
+        if (path := content / f"{tHandle}.nwd").is_file():
+            try:
+                with open(path, mode="r", encoding="utf-8") as inFile:
+                    line = ""
+                    for _ in range(10):
+                        if not (line := inFile.readline()).startswith(r"%%~"):
+                            break
+                    return line + inFile.read()
+            except Exception:
+                logger.error("Cannot read document with handle '%s'", tHandle)
+                logException()
+                return ""
+        return ""
+
+    ##
+    #  Methods
     ##
 
     def fileExists(self) -> bool:
@@ -155,7 +176,7 @@ class NWDocument:
             try:
                 with open(docPath, mode="r", encoding="utf-8") as inFile:
                     # Check the first <= 10 lines for metadata
-                    for i in range(10):
+                    for _ in range(10):
                         line = inFile.readline()
                         if line.startswith(r"%%~"):
                             self._parseMeta(line)