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

novelwriter/core/docbuild.py

@@ -35,13 +35,15 @@ from novelwriter.constants import nwLabels
 from novelwriter.core.buildsettings import BuildSettings
 from novelwriter.core.item import NWItem
 from novelwriter.core.project import NWProject
-from novelwriter.core.tohtml import ToHtml
-from novelwriter.core.tokenizer import Tokenizer
-from novelwriter.core.tomarkdown import ToMarkdown
-from novelwriter.core.toodt import ToOdt
-from novelwriter.core.toqdoc import TextDocumentTheme, ToQTextDocument
 from novelwriter.enum import nwBuildFmt
 from novelwriter.error import formatException, logException
+from novelwriter.formats.todocx import ToDocX
+from novelwriter.formats.tohtml import ToHtml
+from novelwriter.formats.tokenizer import Tokenizer
+from novelwriter.formats.tomarkdown import ToMarkdown
+from novelwriter.formats.toodt import ToOdt
+from novelwriter.formats.toqdoc import ToQTextDocument
+from novelwriter.formats.toraw import ToRaw
 
 logger = logging.getLogger(__name__)
 
@@ -85,20 +87,6 @@ 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
-
     ##
     #  Special Methods
     ##
@@ -125,182 +113,117 @@ class NWBuildDocument:
                 self._queue.append(item.itemHandle)
         return
 
-    def iterBuildPreview(self, theme: TextDocumentTheme) -> Iterable[tuple[int, bool]]:
+    def iterBuildPreview(self, newPage: bool) -> Iterable[tuple[int, bool]]:
         """Build a preview QTextDocument."""
         makeObj = ToQTextDocument(self._project)
         filtered = self._setupBuild(makeObj)
-
-        self._outline = True
-        self._count = True
-
-        font = QFont()
-        font.fromString(self._build.getStr("format.textFont"))
-
-        makeObj.initDocument(font, theme)
-        for i, tHandle in enumerate(self._queue):
-            self._error = None
-            if filtered.get(tHandle, (False, 0))[0]:
-                yield i, self._doBuild(makeObj, tHandle)
-            else:
-                yield i, False
-
-        makeObj.appendFootnotes()
-
-        self._error = None
-        self._cache = makeObj
-
-        return
-
-    def iterBuild(self, path: Path, bFormat: nwBuildFmt) -> Iterable[tuple[int, bool]]:
-        """Wrapper for builders based on format."""
-        if bFormat in (nwBuildFmt.ODT, nwBuildFmt.FODT):
-            yield from self.iterBuildOpenDocument(path, bFormat == nwBuildFmt.FODT)
-        elif bFormat in (nwBuildFmt.HTML, nwBuildFmt.J_HTML):
-            yield from self.iterBuildHTML(path, asJson=bFormat == nwBuildFmt.J_HTML)
-        elif bFormat in (nwBuildFmt.STD_MD, nwBuildFmt.EXT_MD):
-            yield from self.iterBuildMarkdown(path, bFormat == nwBuildFmt.EXT_MD)
-        elif bFormat in (nwBuildFmt.NWD, nwBuildFmt.J_NWD):
-            yield from self.iterBuildNWD(path, asJson=bFormat == nwBuildFmt.J_NWD)
-        return
-
-    def iterBuildOpenDocument(self, path: Path, isFlat: bool) -> Iterable[tuple[int, bool]]:
-        """Build an Open Document file."""
-        makeObj = ToOdt(self._project, isFlat=isFlat)
-        filtered = self._setupBuild(makeObj)
         makeObj.initDocument()
-
-        for i, tHandle in enumerate(self._queue):
-            self._error = None
-            if filtered.get(tHandle, (False, 0))[0]:
-                yield i, self._doBuild(makeObj, tHandle)
-            else:
-                yield i, False
-
+        makeObj.setShowNewPage(newPage)
+        self._outline = True
+        yield from self._iterBuild(makeObj, filtered)
         makeObj.closeDocument()
-
         self._error = None
         self._cache = makeObj
-
-        try:
-            if isFlat:
-                makeObj.saveFlatXML(path)
-            else:
-                makeObj.saveOpenDocText(path)
-        except Exception as exc:
-            logException()
-            self._error = formatException(exc)
-
         return
 
-    def iterBuildHTML(self, path: Path | None, asJson: bool = False) -> Iterable[tuple[int, bool]]:
-        """Build an HTML file. If path is None, no file is saved. This
-        is used for generating build previews.
-        """
-        makeObj = ToHtml(self._project)
-        filtered = self._setupBuild(makeObj)
-
-        for i, tHandle in enumerate(self._queue):
-            self._error = None
-            if filtered.get(tHandle, (False, 0))[0]:
-                yield i, self._doBuild(makeObj, tHandle)
-            else:
-                yield i, False
-
-        makeObj.appendFootnotes()
-
-        if not self._build.getBool("html.preserveTabs"):
-            makeObj.replaceTabs()
-
+    def iterBuildDocument(self, path: Path, bFormat: nwBuildFmt) -> Iterable[tuple[int, bool]]:
+        """Wrapper for builders based on format."""
         self._error = None
-        self._cache = makeObj
-
-        if isinstance(path, Path):
-            try:
-                if asJson:
-                    makeObj.saveHtmlJson(path)
-                else:
-                    makeObj.saveHtml5(path)
-            except Exception as exc:
-                logException()
-                self._error = formatException(exc)
+        self._cache = None
 
-        return
+        if bFormat in (nwBuildFmt.J_HTML, nwBuildFmt.J_NWD):
+            # Ensure that JSON output has the correct extension
+            path = path.with_suffix(".json")
 
-    def iterBuildMarkdown(self, path: Path, extendedMd: bool) -> Iterable[tuple[int, bool]]:
-        """Build a Markdown file."""
-        makeObj = ToMarkdown(self._project)
-        filtered = self._setupBuild(makeObj)
+        if bFormat in (nwBuildFmt.ODT, nwBuildFmt.FODT):
+            makeObj = ToOdt(self._project, bFormat == nwBuildFmt.FODT)
+            filtered = self._setupBuild(makeObj)
+            makeObj.initDocument()
+            yield from self._iterBuild(makeObj, filtered)
+            makeObj.closeDocument()
 
-        makeObj.setExtendedMarkdown(extendedMd)
-        if self._build.getBool("format.replaceTabs"):
-            makeObj.replaceTabs(nSpaces=4, spaceChar=" ")
+        elif bFormat in (nwBuildFmt.HTML, nwBuildFmt.J_HTML):
+            makeObj = ToHtml(self._project)
+            filtered = self._setupBuild(makeObj)
+            makeObj.initDocument()
+            yield from self._iterBuild(makeObj, filtered)
+            makeObj.closeDocument()
+            if not self._build.getBool("html.preserveTabs"):
+                makeObj.replaceTabs()
 
-        for i, tHandle in enumerate(self._queue):
-            self._error = None
-            if filtered.get(tHandle, (False, 0))[0]:
-                yield i, self._doBuild(makeObj, tHandle)
-            else:
-                yield i, False
+        elif bFormat in (nwBuildFmt.STD_MD, nwBuildFmt.EXT_MD):
+            makeObj = ToMarkdown(self._project, bFormat == nwBuildFmt.EXT_MD)
+            filtered = self._setupBuild(makeObj)
+            yield from self._iterBuild(makeObj, filtered)
+            makeObj.closeDocument()
+            if self._build.getBool("format.replaceTabs"):
+                makeObj.replaceTabs(nSpaces=4, spaceChar=" ")
 
-        makeObj.appendFootnotes()
+        elif bFormat in (nwBuildFmt.NWD, nwBuildFmt.J_NWD):
+            makeObj = ToRaw(self._project)
+            filtered = self._setupBuild(makeObj)
+            yield from self._iterBuild(makeObj, filtered)
+            makeObj.closeDocument()
+            if self._build.getBool("format.replaceTabs"):
+                makeObj.replaceTabs(nSpaces=4, spaceChar=" ")
+
+        elif bFormat == nwBuildFmt.DOCX:
+            makeObj = ToDocX(self._project)
+            filtered = self._setupBuild(makeObj)
+            makeObj.initDocument()
+            yield from self._iterBuild(makeObj, filtered)
+            makeObj.closeDocument()
+
+        elif bFormat == nwBuildFmt.PDF:
+            makeObj = ToQTextDocument(self._project)
+            makeObj.disableAnchors()
+            filtered = self._setupBuild(makeObj)
+            makeObj.initDocument(pdf=True)
+            yield from self._iterBuild(makeObj, filtered)
+            makeObj.closeDocument()
+
+        else:
+            logger.error("Unsupported document format")
+            return
 
         self._error = None
         self._cache = makeObj
 
         try:
-            makeObj.saveMarkdown(path)
+            makeObj.saveDocument(path)
         except Exception as exc:
             logException()
             self._error = formatException(exc)
 
         return
 
-    def iterBuildNWD(self, path: Path | None, asJson: bool = False) -> Iterable[tuple[int, bool]]:
-        """Build a novelWriter Markdown file."""
-        makeObj = ToMarkdown(self._project)
-        filtered = self._setupBuild(makeObj)
-
-        makeObj.setKeepMarkdown(True)
+    ##
+    #  Internal Functions
+    ##
 
+    def _iterBuild(self, makeObj: Tokenizer, filtered: dict) -> Iterable[tuple[int, bool]]:
+        """Iterate over buildable documents."""
+        self._count = True
         for i, tHandle in enumerate(self._queue):
             self._error = None
             if filtered.get(tHandle, (False, 0))[0]:
-                yield i, self._doBuild(makeObj, tHandle, convert=False)
+                yield i, self._doBuild(makeObj, tHandle)
             else:
                 yield i, False
-
-        if self._build.getBool("format.replaceTabs"):
-            makeObj.replaceTabs(nSpaces=4, spaceChar=" ")
-
-        self._error = None
-        self._cache = makeObj
-
-        if isinstance(path, Path):
-            try:
-                if asJson:
-                    makeObj.saveRawMarkdownJSON(path)
-                else:
-                    makeObj.saveRawMarkdown(path)
-            except Exception as exc:
-                logException()
-                self._error = formatException(exc)
-
         return
 
-    ##
-    #  Internal Functions
-    ##
-
     def _setupBuild(self, bldObj: Tokenizer) -> dict:
         """Configure the build object."""
         # Get Settings
         textFont = QFont(CONFIG.textFont)
         textFont.fromString(self._build.getStr("format.textFont"))
-        bldObj.setFont(textFont)
 
-        bldObj.setTitleFormat(
-            self._build.getStr("headings.fmtTitle"),
-            self._build.getBool("headings.hideTitle")
+        bldObj.setTextFont(textFont)
+        bldObj.setLanguage(self._project.data.language)
+
+        bldObj.setPartitionFormat(
+            self._build.getStr("headings.fmtPart"),
+            self._build.getBool("headings.hidePart")
         )
         bldObj.setChapterFormat(
             self._build.getStr("headings.fmtChapter"),
@@ -326,6 +249,10 @@ class NWBuildDocument:
             self._build.getBool("headings.centerTitle"),
             self._build.getBool("headings.breakTitle")
         )
+        bldObj.setPartitionStyle(
+            self._build.getBool("headings.centerPart"),
+            self._build.getBool("headings.breakPart")
+        )
         bldObj.setChapterStyle(
             self._build.getBool("headings.centerChapter"),
             self._build.getBool("headings.breakChapter")
@@ -338,12 +265,46 @@ class NWBuildDocument:
         bldObj.setJustify(self._build.getBool("format.justifyText"))
         bldObj.setLineHeight(self._build.getFloat("format.lineHeight"))
         bldObj.setKeepLineBreaks(self._build.getBool("format.keepBreaks"))
-        bldObj.setDialogueHighlight(self._build.getBool("format.showDialogue"))
+        bldObj.setDialogHighlight(self._build.getBool("format.showDialogue"))
         bldObj.setFirstLineIndent(
             self._build.getBool("format.firstLineIndent"),
             self._build.getFloat("format.firstIndentWidth"),
             self._build.getBool("format.indentFirstPar"),
         )
+        bldObj.setHeadingStyles(
+            self._build.getBool("doc.colorHeadings"),
+            self._build.getBool("doc.scaleHeadings"),
+            self._build.getBool("doc.boldHeadings"),
+        )
+
+        bldObj.setTitleMargins(
+            self._build.getFloat("format.titleMarginT"),
+            self._build.getFloat("format.titleMarginB"),
+        )
+        bldObj.setHead1Margins(
+            self._build.getFloat("format.h1MarginT"),
+            self._build.getFloat("format.h1MarginB"),
+        )
+        bldObj.setHead2Margins(
+            self._build.getFloat("format.h2MarginT"),
+            self._build.getFloat("format.h2MarginB"),
+        )
+        bldObj.setHead3Margins(
+            self._build.getFloat("format.h3MarginT"),
+            self._build.getFloat("format.h3MarginB"),
+        )
+        bldObj.setHead4Margins(
+            self._build.getFloat("format.h4MarginT"),
+            self._build.getFloat("format.h4MarginB"),
+        )
+        bldObj.setTextMargins(
+            self._build.getFloat("format.textMarginT"),
+            self._build.getFloat("format.textMarginB"),
+        )
+        bldObj.setSeparatorMargins(
+            self._build.getFloat("format.sepMarginT"),
+            self._build.getFloat("format.sepMarginB"),
+        )
 
         bldObj.setBodyText(self._build.getBool("text.includeBodyText"))
         bldObj.setSynopsis(self._build.getBool("text.includeSynopsis"))
@@ -355,13 +316,13 @@ class NWBuildDocument:
             bldObj.setStyles(self._build.getBool("html.addStyles"))
             bldObj.setReplaceUnicode(self._build.getBool("format.stripUnicode"))
 
-        if isinstance(bldObj, ToOdt):
-            bldObj.setColourHeaders(self._build.getBool("odt.addColours"))
-            bldObj.setLanguage(self._project.data.language)
+        if isinstance(bldObj, (ToOdt, ToDocX)):
             bldObj.setHeaderFormat(
-                self._build.getStr("odt.pageHeader"), self._build.getInt("odt.pageCountOffset")
+                self._build.getStr("doc.pageHeader"),
+                self._build.getInt("doc.pageCountOffset"),
             )
 
+        if isinstance(bldObj, (ToOdt, ToDocX, ToQTextDocument)):
             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))
             bldObj.setPageLayout(
@@ -384,14 +345,17 @@ class NWBuildDocument:
         tItem = self._project.tree[tHandle]
         if isinstance(tItem, NWItem):
             try:
-                if tItem.isRootType() and not tItem.isNovelLike():
-                    bldObj.addRootHeading(tHandle)
-                    if convert:
-                        bldObj.doConvert()
-                    if self._count:
-                        bldObj.countStats()
-                    if self._outline:
-                        bldObj.buildOutline()
+                if tItem.isRootType():
+                    if tItem.isNovelLike():
+                        bldObj.setBreakNext()
+                    else:
+                        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()
@@ -402,8 +366,6 @@ class NWBuildDocument:
                         bldObj.buildOutline()
                     if convert:
                         bldObj.doConvert()
-                else:
-                    logger.info(f"Build: Skipping '{tHandle}'")
 
             except Exception:
                 self._error = f"Build: Failed to build '{tHandle}'"

novelwriter/core/index.py

@@ -40,7 +40,7 @@ from novelwriter import SHARED
 from novelwriter.common import (
     checkInt, isHandle, isItemClass, isListInstance, isTitleTag, jsonEncode
 )
-from novelwriter.constants import nwFiles, nwHeaders, nwKeyWords
+from novelwriter.constants import nwFiles, nwKeyWords, nwStyles
 from novelwriter.enum import nwComment, nwItemClass, nwItemLayout, nwItemType
 from novelwriter.error import logException
 from novelwriter.text.counting import standardCounter
@@ -116,24 +116,24 @@ class NWIndex:
     #  Public Methods
     ##
 
-    def clearIndex(self) -> None:
+    def clear(self) -> None:
         """Clear the index dictionaries and time stamps."""
         self._tagsIndex.clear()
         self._itemIndex.clear()
         self._indexChange = 0.0
         self._rootChange = {}
-        SHARED.indexSignalProxy({"event": "clearIndex"})
+        SHARED.emitIndexCleared(self._project)
         return
 
-    def rebuildIndex(self) -> None:
+    def rebuild(self) -> None:
         """Rebuild the entire index from scratch."""
-        self.clearIndex()
+        self.clear()
         for nwItem in self._project.tree:
             if nwItem.isFileType():
                 text = self._project.storage.getDocumentText(nwItem.itemHandle)
                 self.scanText(nwItem.itemHandle, text, blockSignal=True)
         self._indexBroken = False
-        SHARED.indexSignalProxy({"event": "buildIndex"})
+        SHARED.emitIndexAvailable(self._project)
         return
 
     def deleteHandle(self, tHandle: str) -> None:
@@ -143,10 +143,7 @@ class NWIndex:
         for tTag in delTags:
             del self._tagsIndex[tTag]
         del self._itemIndex[tHandle]
-        SHARED.indexSignalProxy({
-            "event": "updateTags",
-            "deleted": delTags,
-        })
+        SHARED.emitIndexChangedTags(self._project, [], delTags)
         return
 
     def reIndexHandle(self, tHandle: str | None) -> None:
@@ -212,7 +209,7 @@ class NWIndex:
                 self.reIndexHandle(fHandle)
 
         self._indexChange = time()
-        SHARED.indexSignalProxy({"event": "buildIndex"})
+        SHARED.emitIndexAvailable(self._project)
 
         logger.debug("Index loaded in %.3f ms", (time() - tStart)*1000)
 
@@ -296,10 +293,7 @@ class NWIndex:
         self._indexChange = nowTime
         self._rootChange[tItem.itemRoot] = nowTime
         if not blockSignal:
-            SHARED.indexSignalProxy({
-                "event": "scanText",
-                "handle": tHandle,
-            })
+            tItem.notifyToRefresh()
 
         return True
 
@@ -370,11 +364,7 @@ class NWIndex:
                 del self._tagsIndex[tTag]
                 deleted.append(tTag)
             if updated or deleted:
-                SHARED.indexSignalProxy({
-                    "event": "updateTags",
-                    "updated": updated,
-                    "deleted": deleted,
-                })
+                SHARED.emitIndexChangedTags(self._project, updated, deleted)
 
         return
 
@@ -487,13 +477,14 @@ class NWIndex:
         if nBits == 0:
             return []
 
-        # Check that the key is valid
-        isGood[0] = tBits[0] in nwKeyWords.VALID_KEYS
+        # Check that the keyword is valid
+        kBit = tBits[0]
+        isGood[0] = kBit in nwKeyWords.VALID_KEYS
         if not isGood[0] or nBits == 1:
             return isGood
 
         # For a tag, only the first value is accepted, the rest are ignored
-        if tBits[0] == nwKeyWords.TAG_KEY and nBits > 1:
+        if kBit == nwKeyWords.TAG_KEY and nBits > 1:
             check, _ = self.parseValue(tBits[1])
             if check in self._tagsIndex:
                 isGood[1] = self._tagsIndex.tagHandle(check) == tHandle
@@ -501,12 +492,16 @@ class NWIndex:
                 isGood[1] = True
             return isGood
 
+        if kBit == nwKeyWords.MENTION_KEY and nBits > 1:
+            isGood[1:nBits] = [aBit in self._tagsIndex for aBit in tBits[1:nBits]]
+            return isGood
+
         # If we're still here, we check that the references exist
         # Class references cannot have the | symbol in them
-        refKey = nwKeyWords.KEY_CLASS[tBits[0]].name
-        for n in range(1, nBits):
-            if (aBit := tBits[n]) in self._tagsIndex:
-                isGood[n] = self._tagsIndex.tagClass(aBit) == refKey and "|" not in aBit
+        if rClass := nwKeyWords.KEY_CLASS.get(kBit):
+            for n in range(1, nBits):
+                if (aBit := tBits[n]) in self._tagsIndex:
+                    isGood[n] = self._tagsIndex.tagClass(aBit) == rClass.name and "|" not in aBit
 
         return isGood
 
@@ -569,7 +564,7 @@ class NWIndex:
         for _, _, hItem in self._itemIndex.iterNovelStructure(
             rHandle=rootHandle, activeOnly=activeOnly
         ):
-            iLevel = nwHeaders.H_LEVEL.get(hItem.level, 0)
+            iLevel = nwStyles.H_LEVEL.get(hItem.level, 0)
             hCount[iLevel] += 1
         return hCount
 
@@ -591,7 +586,7 @@ class NWIndex:
             rHandle=rHandle, activeOnly=activeOnly
         ):
             tKey = f"{tHandle}:{sTitle}"
-            iLevel = nwHeaders.H_LEVEL.get(hItem.level, 0)
+            iLevel = nwStyles.H_LEVEL.get(hItem.level, 0)
             if iLevel > maxDepth:
                 if pKey in tData:
                     tData[pKey]["words"] += hItem.wordCount
@@ -635,7 +630,7 @@ class NWIndex:
         """Extract all references made in a file, and optionally title
         section.
         """
-        tRefs = {x: [] for x in nwKeyWords.KEY_CLASS}
+        tRefs = {x: [] for x in nwKeyWords.VALID_KEYS}
         for rTitle, hItem in self._itemIndex.iterItemHeaders(tHandle):
             if sTitle is None or sTitle == rTitle:
                 for aTag, refTypes in hItem.references.items():
@@ -681,9 +676,10 @@ class NWIndex:
         """Return all tags used by a specific document."""
         return self._itemIndex.allItemTags(tHandle) if tHandle else []
 
-    def getClassTags(self, itemClass: nwItemClass) -> list[str]:
+    def getClassTags(self, itemClass: nwItemClass | None) -> list[str]:
         """Return all tags based on itemClass."""
-        return self._tagsIndex.filterTagNames(itemClass.name)
+        name = None if itemClass is None else itemClass.name
+        return self._tagsIndex.filterTagNames(name)
 
     def getTagsData(
         self, activeOnly: bool = True
@@ -780,11 +776,16 @@ class TagsIndex:
         """Get the class of a given tag."""
         return self._tags.get(tagKey.lower(), {}).get("class", None)
 
-    def filterTagNames(self, className: str) -> list[str]:
+    def filterTagNames(self, className: str | None) -> list[str]:
         """Get a list of tag names for a given class."""
-        return [
-            x.get("name", "") for x in self._tags.values() if x.get("class", "") == className
-        ]
+        if className is None:
+            return [
+                x.get("name", "") for x in self._tags.values()
+            ]
+        else:
+            return [
+                x.get("name", "") for x in self._tags.values() if x.get("class", "") == className
+            ]
 
     ##
     #  Pack/Unpack
@@ -1251,7 +1252,7 @@ class IndexHeading:
 
     def setLevel(self, level: str) -> None:
         """Set the level of the heading if it's a valid value."""
-        if level in nwHeaders.H_VALID:
+        if level in nwStyles.H_VALID:
             self._level = level
         return