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

novelwriter/core/buildsettings.py

@@ -36,7 +36,7 @@ from PyQt5.QtCore import QT_TRANSLATE_NOOP, QCoreApplication
 
 from novelwriter import CONFIG
 from novelwriter.common import checkUuid, isHandle, jsonEncode
-from novelwriter.constants import nwFiles, nwHeadFmt
+from novelwriter.constants import nwFiles, nwHeadFmt, nwStyles
 from novelwriter.core.project import NWProject
 from novelwriter.enum import nwBuildFmt
 from novelwriter.error import logException
@@ -45,29 +45,30 @@ logger = logging.getLogger(__name__)
 
 # The Settings Template
 # =====================
-# Each entry contains a tuple on the form:
-# (type, default, [min value, max value])
+# Each entry contains a tuple on the form: (type, default)
 
-SETTINGS_TEMPLATE = {
+SETTINGS_TEMPLATE: dict[str, tuple[type, str | int | float | bool]] = {
     "filter.includeNovel":     (bool, True),
     "filter.includeNotes":     (bool, False),
     "filter.includeInactive":  (bool, False),
-    "headings.fmtTitle":       (str, nwHeadFmt.TITLE),
+    "headings.fmtPart":        (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.hidePart":       (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.centerPart":     (bool, True),
     "headings.centerChapter":  (bool, False),
     "headings.centerScene":    (bool, False),
-    "headings.breakTitle":     (bool, True),
+    "headings.breakTitle":     (bool, False),
+    "headings.breakPart":      (bool, True),
     "headings.breakChapter":   (bool, True),
     "headings.breakScene":     (bool, False),
     "text.includeSynopsis":    (bool, False),
@@ -77,7 +78,7 @@ SETTINGS_TEMPLATE = {
     "text.ignoredKeywords":    (str, ""),
     "text.addNoteHeadings":    (bool, True),
     "format.textFont":         (str, CONFIG.textFont.toString()),
-    "format.lineHeight":       (float, 1.15, 0.75, 3.0),
+    "format.lineHeight":       (float, 1.15),
     "format.justifyText":      (bool, False),
     "format.stripUnicode":     (bool, False),
     "format.replaceTabs":      (bool, False),
@@ -86,6 +87,20 @@ SETTINGS_TEMPLATE = {
     "format.firstLineIndent":  (bool, False),
     "format.firstIndentWidth": (float, 1.4),
     "format.indentFirstPar":   (bool, False),
+    "format.titleMarginT":     (float, nwStyles.T_MARGIN["H0"][0]),
+    "format.titleMarginB":     (float, nwStyles.T_MARGIN["H0"][1]),
+    "format.h1MarginT":        (float, nwStyles.T_MARGIN["H1"][0]),
+    "format.h1MarginB":        (float, nwStyles.T_MARGIN["H1"][1]),
+    "format.h2MarginT":        (float, nwStyles.T_MARGIN["H2"][0]),
+    "format.h2MarginB":        (float, nwStyles.T_MARGIN["H2"][1]),
+    "format.h3MarginT":        (float, nwStyles.T_MARGIN["H3"][0]),
+    "format.h3MarginB":        (float, nwStyles.T_MARGIN["H3"][1]),
+    "format.h4MarginT":        (float, nwStyles.T_MARGIN["H4"][0]),
+    "format.h4MarginB":        (float, nwStyles.T_MARGIN["H4"][1]),
+    "format.textMarginT":      (float, nwStyles.T_MARGIN["TT"][0]),
+    "format.textMarginB":      (float, nwStyles.T_MARGIN["TT"][1]),
+    "format.sepMarginT":       (float, nwStyles.T_MARGIN["SP"][0]),
+    "format.sepMarginB":       (float, nwStyles.T_MARGIN["SP"][1]),
     "format.pageUnit":         (str, "cm"),
     "format.pageSize":         (str, "A4"),
     "format.pageWidth":        (float, 21.0),
@@ -94,9 +109,11 @@ SETTINGS_TEMPLATE = {
     "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),
+    "doc.pageHeader":          (str, nwHeadFmt.DOC_AUTO),
+    "doc.pageCountOffset":     (int, 0),
+    "doc.colorHeadings":       (bool, True),
+    "doc.scaleHeadings":       (bool, True),
+    "doc.boldHeadings":        (bool, True),
     "html.addStyles":          (bool, True),
     "html.preserveTabs":       (bool, False),
 }
@@ -108,12 +125,16 @@ SETTINGS_LABELS = {
     "filter.includeInactive":  QT_TRANSLATE_NOOP("Builds", "Inactive Documents"),
 
     "headings":                QT_TRANSLATE_NOOP("Builds", "Headings"),
-    "headings.fmtTitle":       QT_TRANSLATE_NOOP("Builds", "Partition Format"),
+    "headings.fmtPart":        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"),
+    "headings.styleTitle":     QT_TRANSLATE_NOOP("Builds", "Title Styling"),
+    "headings.stylePart":      QT_TRANSLATE_NOOP("Builds", "Partition Styling"),
+    "headings.styleChapter":   QT_TRANSLATE_NOOP("Builds", "Chapter Styling"),
+    "headings.styleScene":     QT_TRANSLATE_NOOP("Builds", "Scene Styling"),
 
     "text.grpContent":         QT_TRANSLATE_NOOP("Builds", "Text Content"),
     "text.includeSynopsis":    QT_TRANSLATE_NOOP("Builds", "Include Synopsis"),
@@ -121,13 +142,11 @@ SETTINGS_LABELS = {
     "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"),
 
     "format.grpFormat":        QT_TRANSLATE_NOOP("Builds", "Text Format"),
     "format.textFont":         QT_TRANSLATE_NOOP("Builds", "Text Font"),
     "format.lineHeight":       QT_TRANSLATE_NOOP("Builds", "Line Height"),
-    "format.grpOptions":       QT_TRANSLATE_NOOP("Builds", "Text Options"),
     "format.justifyText":      QT_TRANSLATE_NOOP("Builds", "Justify Text Margins"),
     "format.stripUnicode":     QT_TRANSLATE_NOOP("Builds", "Replace Unicode Characters"),
     "format.replaceTabs":      QT_TRANSLATE_NOOP("Builds", "Replace Tabs with Spaces"),
@@ -139,26 +158,31 @@ SETTINGS_LABELS = {
     "format.firstIndentWidth": QT_TRANSLATE_NOOP("Builds", "Indent Width"),
     "format.indentFirstPar":   QT_TRANSLATE_NOOP("Builds", "Indent First Paragraph"),
 
+    "format.grpMargins":       QT_TRANSLATE_NOOP("Builds", "Text Margins"),
+
     "format.grpPage":          QT_TRANSLATE_NOOP("Builds", "Page Layout"),
     "format.pageUnit":         QT_TRANSLATE_NOOP("Builds", "Unit"),
     "format.pageSize":         QT_TRANSLATE_NOOP("Builds", "Page Size"),
-    "format.pageWidth":        QT_TRANSLATE_NOOP("Builds", "Page Width"),
-    "format.pageHeight":       QT_TRANSLATE_NOOP("Builds", "Page Height"),
-    "format.topMargin":        QT_TRANSLATE_NOOP("Builds", "Top Margin"),
-    "format.bottomMargin":     QT_TRANSLATE_NOOP("Builds", "Bottom Margin"),
-    "format.leftMargin":       QT_TRANSLATE_NOOP("Builds", "Left Margin"),
-    "format.rightMargin":      QT_TRANSLATE_NOOP("Builds", "Right Margin"),
-
-    "odt":                     QT_TRANSLATE_NOOP("Builds", "Open Document (.odt)"),
-    "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"),
-
-    "html":                    QT_TRANSLATE_NOOP("Builds", "HTML (.html)"),
+    "format.pageMargins":      QT_TRANSLATE_NOOP("Builds", "Page Margins"),
+
+    "doc":                     QT_TRANSLATE_NOOP("Builds", "Document Style"),
+    "doc.pageHeader":          QT_TRANSLATE_NOOP("Builds", "Page Header"),
+    "doc.pageCountOffset":     QT_TRANSLATE_NOOP("Builds", "Page Counter Offset"),
+    "doc.colorHeadings":       QT_TRANSLATE_NOOP("Builds", "Add Colours to Headings"),
+    "doc.scaleHeadings":       QT_TRANSLATE_NOOP("Builds", "Increase Size of Headings"),
+    "doc.boldHeadings":        QT_TRANSLATE_NOOP("Builds", "Bold Headings"),
+
+    "html":                    QT_TRANSLATE_NOOP("Builds", "HTML Options"),
     "html.addStyles":          QT_TRANSLATE_NOOP("Builds", "Add CSS Styles"),
     "html.preserveTabs":       QT_TRANSLATE_NOOP("Builds", "Preserve Tab Characters"),
 }
 
+RENAMED = {
+    "odt.addColours": "doc.addColours",
+    "odt.pageHeader": "doc.pageHeader",
+    "odt.pageCountOffset": "doc.pageCountOffset",
+}
+
 
 class FilterMode(Enum):
     """The decision reason for an item in a filtered project."""
@@ -348,18 +372,12 @@ class BuildSettings:
             self._changed = True
         return
 
-    def setValue(self, key: str, value: str | int | bool | float) -> bool:
+    def setValue(self, key: str, value: str | int | float | bool) -> None:
         """Set a specific value for a build setting."""
-        if key not in SETTINGS_TEMPLATE:
-            return False
-        definition = SETTINGS_TEMPLATE[key]
-        if not isinstance(value, definition[0]):
-            return False
-        if len(definition) == 4 and isinstance(value, (int, float)):
-            value = min(max(value, definition[2]), definition[3])
-        self._changed = value != self._settings[key]
-        self._settings[key] = value
-        return True
+        if (d := SETTINGS_TEMPLATE.get(key)) and len(d) == 2 and isinstance(value, d[0]):
+            self._changed = value != self._settings[key]
+            self._settings[key] = value
+        return
 
     ##
     #  Methods
@@ -478,12 +496,21 @@ class BuildSettings:
         self._settings = {k: v[1] for k, v in SETTINGS_TEMPLATE.items()}
         if isinstance(settings, dict):
             for key, value in settings.items():
-                self.setValue(key, value)
+                self.setValue(RENAMED.get(key, key), value)
 
         self._changed = False
 
         return
 
+    @classmethod
+    def duplicate(cls, source: BuildSettings) -> BuildSettings:
+        """Make a copy of another build."""
+        cls = BuildSettings()
+        cls.unpack(source.pack())
+        cls._uuid = str(uuid.uuid4())
+        cls._name = f"{source.name} 2"
+        return cls
+
 
 class BuildCollection:
     """Core: Build Collection Class

novelwriter/core/coretools.py

@@ -27,6 +27,7 @@ along with this program. If not, see <https://www.gnu.org/licenses/>.
 from __future__ import annotations
 
 import logging
+import re
 import shutil
 
 from collections.abc import Iterable
@@ -34,11 +35,11 @@ from functools import partial
 from pathlib import Path
 from zipfile import ZipFile, is_zipfile
 
-from PyQt5.QtCore import QCoreApplication, QRegularExpression
+from PyQt5.QtCore import QCoreApplication
 
 from novelwriter import CONFIG, SHARED
 from novelwriter.common import isHandle, minmax, simplified
-from novelwriter.constants import nwConst, nwFiles, nwItemClass
+from novelwriter.constants import nwConst, nwFiles, nwItemClass, nwStats
 from novelwriter.core.item import NWItem
 from novelwriter.core.project import NWProject
 from novelwriter.core.storage import NWStorageCreate
@@ -55,10 +56,17 @@ class DocMerger:
     def __init__(self, project: NWProject) -> None:
         self._project = project
         self._error = ""
-        self._targetDoc = None
-        self._targetText = []
+        self._target = None
+        self._text = []
         return
 
+    @property
+    def targetHandle(self) -> str | None:
+        """Get the handle of the target document."""
+        if self._target:
+            return self._target.itemHandle
+        return None
+
     ##
     #  Methods
     ##
@@ -71,63 +79,56 @@ class DocMerger:
         """Set the target document for the merging. Calling this
         function resets the class.
         """
-        self._targetDoc = tHandle
-        self._targetText = []
+        self._target = self._project.tree[tHandle]
+        self._text = []
         return
 
-    def newTargetDoc(self, srcHandle: str, docLabel: str) -> str | None:
+    def newTargetDoc(self, sHandle: str, label: str) -> None:
         """Create a brand new target document based on a source handle
         and a new doc label. Calling this function resets the class.
         """
-        srcItem = self._project.tree[srcHandle]
-        if srcItem is None or srcItem.itemParent is None:
-            return None
-
-        newHandle = self._project.newFile(docLabel, srcItem.itemParent)
-        newItem = self._project.tree[newHandle]
-        if isinstance(newItem, NWItem):
-            newItem.setLayout(srcItem.itemLayout)
-            newItem.setStatus(srcItem.itemStatus)
-            newItem.setImport(srcItem.itemImport)
-
-        self._targetDoc = newHandle
-        self._targetText = []
-
-        return newHandle
+        sItem = self._project.tree[sHandle]
+        if sItem and sItem.itemParent:
+            tHandle = self._project.newFile(label, sItem.itemParent)
+            if nwItem := self._project.tree[tHandle]:
+                nwItem.setLayout(sItem.itemLayout)
+                nwItem.setStatus(sItem.itemStatus)
+                nwItem.setImport(sItem.itemImport)
+                nwItem.notifyToRefresh()
+                self._target = nwItem
+                self._text = []
+        return
 
-    def appendText(self, srcHandle: str, addComment: bool, cmtPrefix: str) -> bool:
+    def appendText(self, sHandle: str, addComment: bool, cmtPrefix: str) -> None:
         """Append text from an existing document to the text buffer."""
-        srcItem = self._project.tree[srcHandle]
-        if srcItem is None:
-            return False
-
-        docText = self._project.storage.getDocumentText(srcHandle).rstrip("\n")
-        if addComment:
-            docInfo = srcItem.describeMe()
-            docSt, _ = srcItem.getImportStatus()
-            cmtLine = f"% {cmtPrefix} {docInfo}: {srcItem.itemName} [{docSt}]\n\n"
-            docText = cmtLine + docText
-
-        self._targetText.append(docText)
-
-        return True
+        if item := self._project.tree[sHandle]:
+            text = self._project.storage.getDocumentText(sHandle).rstrip("\n")
+            if addComment:
+                info = item.describeMe()
+                status, _ = item.getImportStatus()
+                text = f"% {cmtPrefix} {info}: {item.itemName} [{status}]\n\n{text}"
+            self._text.append(text)
+        return
 
     def writeTargetDoc(self) -> bool:
         """Write the accumulated text into the designated target
         document, appending any existing text.
         """
-        if self._targetDoc is None:
-            return False
+        if self._target:
+            outDoc = self._project.storage.getDocument(self._target.itemHandle)
+            if text := (outDoc.readDocument() or "").rstrip("\n"):
+                self._text.insert(0, text)
+
+            status = outDoc.writeDocument("\n\n".join(self._text) + "\n\n")
+            if not status:
+                self._error = outDoc.getError()
 
-        outDoc = self._project.storage.getDocument(self._targetDoc)
-        if text := (outDoc.readDocument() or "").rstrip("\n"):
-            self._targetText.insert(0, text)
+            self._project.index.reIndexHandle(self._target.itemHandle)
+            self._target.notifyToRefresh()
 
-        status = outDoc.writeDocument("\n\n".join(self._targetText) + "\n\n")
-        if not status:
-            self._error = outDoc.getError()
+            return status
 
-        return status
+        return False
 
 
 class DocSplitter:
@@ -171,23 +172,19 @@ class DocSplitter:
         self._inFolder = False
         return
 
-    def newParentFolder(self, pHandle: str, folderLabel: str) -> str | None:
+    def newParentFolder(self, pHandle: str, folderLabel: str) -> None:
         """Create a new folder that will be the top level parent item
         for the new documents.
         """
-        if self._srcItem is None:
-            return None
-
-        newHandle = self._project.newFolder(folderLabel, pHandle)
-        newItem = self._project.tree[newHandle]
-        if isinstance(newItem, NWItem):
-            newItem.setStatus(self._srcItem.itemStatus)
-            newItem.setImport(self._srcItem.itemImport)
-
-        self._parHandle = newHandle
-        self._inFolder = True
-
-        return newHandle
+        if self._srcItem:
+            nHandle = self._project.newFolder(folderLabel, pHandle)
+            if nwItem := self._project.tree[nHandle]:
+                nwItem.setStatus(self._srcItem.itemStatus)
+                nwItem.setImport(self._srcItem.itemImport)
+                nwItem.notifyToRefresh()
+            self._parHandle = nHandle
+            self._inFolder = True
+        return
 
     def splitDocument(self, splitData: list, splitText: list[str]) -> None:
         """Loop through the split data record and perform the split job
@@ -201,58 +198,50 @@ class DocSplitter:
             self._rawData.insert(0, (chunk, hLevel, hLabel))
         return
 
-    def writeDocuments(self, docHierarchy: bool) -> Iterable[tuple[bool, str | None, str | None]]:
+    def writeDocuments(self, docHierarchy: bool) -> Iterable[bool]:
         """An iterator that will write each document in the buffer, and
         return its new handle, parent handle, and sibling handle.
         """
-        if self._srcHandle is None or self._srcItem is None or self._parHandle is None:
-            return
-
-        pHandle = self._parHandle
-        nHandle = self._parHandle if self._inFolder else self._srcHandle
-        hHandle = [self._parHandle, None, None, None, None]
-
-        pLevel = 0
-        for docText, hLevel, docLabel in self._rawData:
-
-            hLevel = minmax(hLevel, 1, 4)
-            if pLevel == 0:
-                pLevel = hLevel
-
-            if docHierarchy:
-                if hLevel == 1:
-                    pHandle = self._parHandle
-                elif hLevel == 2:
-                    pHandle = hHandle[1] or hHandle[0]
-                elif hLevel == 3:
-                    pHandle = hHandle[2] or hHandle[1] or hHandle[0]
-                elif hLevel == 4:
-                    pHandle = hHandle[3] or hHandle[2] or hHandle[1] or hHandle[0]
-
-                if hLevel < pLevel:
-                    nHandle = hHandle[hLevel] or hHandle[0]
-                elif hLevel > pLevel:
-                    nHandle = pHandle
-
-            dHandle = self._project.newFile(docLabel, pHandle)
-            hHandle[hLevel] = dHandle
-
-            newItem = self._project.tree[dHandle]
-            if isinstance(newItem, NWItem):
-                newItem.setStatus(self._srcItem.itemStatus)
-                newItem.setImport(self._srcItem.itemImport)
-
-            outDoc = self._project.storage.getDocument(dHandle)
-            status = outDoc.writeDocument("\n".join(docText))
-            if not status:
-                self._error = outDoc.getError()
-
-            yield status, dHandle, nHandle
-
-            hHandle[hLevel] = dHandle
-            nHandle = dHandle
-            pLevel = hLevel
-
+        if self._srcHandle and self._srcItem and self._parHandle:
+            pHandle = self._parHandle
+            hHandle = [self._parHandle, None, None, None, None]
+            pLevel = 0
+            for docText, hLevel, docLabel in self._rawData:
+
+                hLevel = minmax(hLevel, 1, 4)
+                if pLevel == 0:
+                    pLevel = hLevel
+
+                if docHierarchy:
+                    if hLevel == 1:
+                        pHandle = self._parHandle
+                    elif hLevel == 2:
+                        pHandle = hHandle[1] or hHandle[0]
+                    elif hLevel == 3:
+                        pHandle = hHandle[2] or hHandle[1] or hHandle[0]
+                    elif hLevel == 4:
+                        pHandle = hHandle[3] or hHandle[2] or hHandle[1] or hHandle[0]
+
+                if (
+                    (dHandle := self._project.newFile(docLabel, pHandle))
+                    and (nwItem := self._project.tree[dHandle])
+                ):
+                    hHandle[hLevel] = dHandle
+                    nwItem.setStatus(self._srcItem.itemStatus)
+                    nwItem.setImport(self._srcItem.itemImport)
+
+                    outDoc = self._project.storage.getDocument(dHandle)
+                    status = outDoc.writeDocument("\n".join(docText))
+                    if not status:
+                        self._error = outDoc.getError()
+
+                    self._project.index.reIndexHandle(dHandle)
+                    nwItem.notifyToRefresh()
+
+                    yield status
+
+                    hHandle[hLevel] = dHandle
+                    pLevel = hLevel
         return
 
 
@@ -269,36 +258,34 @@ class DocDuplicator:
     #  Methods
     ##
 
-    def duplicate(self, items: list[str]) -> Iterable[tuple[str, str | None]]:
+    def duplicate(self, items: list[str]) -> list[str]:
         """Run through a list of items, duplicate them, and copy the
         text content if they are documents.
         """
+        result = []
+        after = True
         if items:
-            nHandle = items[0]
             hMap: dict[str, str | None] = {t: None for t in items}
             for tHandle in items:
-                newItem = self._project.tree.duplicate(tHandle)
-                if newItem is None:
-                    return
-                hMap[tHandle] = newItem.itemHandle
-                if newItem.itemParent in hMap:
-                    newItem.setParent(hMap[newItem.itemParent])
-                    self._project.tree.updateItemData(newItem.itemHandle)
-                if newItem.isFileType():
-                    newDoc = self._project.storage.getDocument(newItem.itemHandle)
-                    if newDoc.fileExists():
-                        return
-                    newDoc.writeDocument(self._project.storage.getDocumentText(tHandle))
-                yield newItem.itemHandle, nHandle
-                nHandle = None
-        return
+                if oldItem := self._project.tree[tHandle]:
+                    pHandle = hMap.get(oldItem.itemParent or "") or oldItem.itemParent
+                    if newItem := self._project.tree.duplicate(tHandle, pHandle, after):
+                        hMap[tHandle] = newItem.itemHandle
+                        if newItem.isFileType():
+                            self._project.copyFileContent(newItem.itemHandle, tHandle)
+                        newItem.notifyToRefresh()
+                        result.append(newItem.itemHandle)
+                    after = False
+                else:
+                    break
+        return result
 
 
 class DocSearch:
 
     def __init__(self) -> None:
-        self._regEx = QRegularExpression()
-        self.setCaseSensitive(False)
+        self._regEx = re.compile("")
+        self._opts = re.UNICODE | re.IGNORECASE
         self._words = False
         self._escape = True
         return
@@ -309,10 +296,9 @@ class DocSearch:
 
     def setCaseSensitive(self, state: bool) -> None:
         """Set the case sensitive search flag."""
-        opts = QRegularExpression.PatternOption.UseUnicodePropertiesOption
+        self._opts = re.UNICODE
         if not state:
-            opts |= QRegularExpression.PatternOption.CaseInsensitiveOption
-        self._regEx.setPatternOptions(opts)
+            self._opts |= re.IGNORECASE
         return
 
     def setWholeWords(self, state: bool) -> None:
@@ -329,8 +315,8 @@ class DocSearch:
         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())
+        self._regEx = re.compile(self._buildPattern(search), self._opts)
+        logger.debug("Searching with pattern '%s'", self._regEx.pattern)
         storage = project.storage
         for item in project.tree:
             if item.isFileType():
@@ -340,14 +326,12 @@ class DocSearch:
 
     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()
+        for res in self._regEx.finditer(text):
+            pos = res.start(0)
+            num = len(res.group(0))
             lim = text[:pos].rfind("\n") + 1
             cut = text[lim:pos].rfind(" ") + lim + 1
             context = text[cut:cut+100].partition("\n")[0]
@@ -366,7 +350,7 @@ class DocSearch:
     def _buildPattern(self, search: str) -> str:
         """Build the search pattern string."""
         if self._escape:
-            search = QRegularExpression.escape(search)
+            search = re.escape(search)
         if self._words:
             search = f"(?:^|\\b){search}(?:$|\\b)"
         return search
@@ -430,7 +414,6 @@ class ProjectBuilder:
 
         lblNewProject = self.tr("New Project")
         lblTitlePage  = self.tr("Title Page")
-        lblByAuthors  = self.tr("By")
 
         # Settings
         project.data.setUuid(None)
@@ -443,14 +426,29 @@ class ProjectBuilder:
         # Add Root Folders
         hNovelRoot = project.newRoot(nwItemClass.NOVEL)
         hTitlePage = project.newFile(lblTitlePage, hNovelRoot)
-        novelTitle = project.data.name
-
-        titlePage = f"#! {novelTitle}\n\n"
-        if project.data.author:
-            titlePage += f">> {lblByAuthors} {project.data.author} <<\n\n"
 
+        # Generate Title Page
         aDoc = project.storage.getDocument(hTitlePage)
-        aDoc.writeDocument(titlePage)
+        aDoc.writeDocument((
+            "{author}[br]\n"
+            "{address} 1[br]\n"
+            "{address} 2 <<\n"
+            "\n"
+            "[vspace:5]\n"
+            "\n"
+            "#! {title}\n"
+            "\n"
+            ">> **{by} {author}** <<\n"
+            "\n"
+            ">> {count}: [field:{field}] <<\n"
+        ).format(
+            author=project.data.author or "None",
+            address=self.tr("Address"),
+            title=project.data.name or "None",
+            by=self.tr("By"),
+            count=self.tr("Word Count"),
+            field=nwStats.WORDS_TEXT,
+        ))
 
         # Create a project structure based on selected root folders
         # and a number of chapters and scenes selected in the
@@ -511,7 +509,7 @@ class ProjectBuilder:
 
         # Also add the archive and trash folders
         project.newRoot(nwItemClass.ARCHIVE)
-        project.trashFolder()
+        project.tree.trash  # Triggers the creation of Trash
 
         project.saveProject()
         project.closeProject()