novelWriter 2.3.1__py3-none-any.whl → 2.4b1__py3-none-any.whl

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.fmtHardScene"),
+            self._build.getBool("headings.hideHardScene")
+        )
         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)

novelwriter/core/index.py

@@ -3,7 +3,6 @@ novelWriter – Project Index
 ===========================
 
 File History:
-Created: 2019-04-22 [0.0.1]  countWords
 Created: 2019-05-27 [0.1.4]  NWIndex
 Created: 2022-05-28 [2.0rc1] IndexItem
 Created: 2022-05-28 [2.0rc1] IndexHeading
@@ -34,13 +33,14 @@ import logging
 from time import time
 from typing import TYPE_CHECKING
 from pathlib import Path
-from collections.abc import ItemsView, Iterable, Iterator
+from collections.abc import ItemsView, Iterable
 
 from novelwriter import SHARED
 from novelwriter.enum import nwComment, nwItemClass, nwItemType, nwItemLayout
 from novelwriter.error import logException
 from novelwriter.common import checkInt, isHandle, isItemClass, isTitleTag, jsonEncode
-from novelwriter.constants import nwFiles, nwKeyWords, nwRegEx, nwUnicode, nwHeaders
+from novelwriter.constants import nwFiles, nwKeyWords, nwHeaders
+from novelwriter.text.counting import standardCounter
 
 if TYPE_CHECKING:  # pragma: no cover
     from novelwriter.core.item import NWItem
@@ -122,9 +122,8 @@ class NWIndex:
         self.clearIndex()
         for nwItem in self._project.tree:
             if nwItem.isFileType():
-                tHandle = nwItem.itemHandle
-                doc = self._project.storage.getDocument(tHandle)
-                self.scanText(tHandle, doc.readDocument() or "", blockSignal=True)
+                text = self._project.storage.getDocumentText(nwItem.itemHandle)
+                self.scanText(nwItem.itemHandle, text, blockSignal=True)
         self._indexBroken = False
         SHARED.indexSignalProxy({"event": "buildIndex"})
         return
@@ -142,17 +141,15 @@ class NWIndex:
         })
         return
 
-    def reIndexHandle(self, tHandle: str | None) -> bool:
+    def reIndexHandle(self, tHandle: str | None) -> None:
         """Put a file back into the index. This is used when files are
         moved from the archive or trash folders back into the active
         project.
         """
         if tHandle and self._project.tree.checkType(tHandle, nwItemType.FILE):
             logger.debug("Re-indexing item '%s'", tHandle)
-            doc = self._project.storage.getDocument(tHandle)
-            self.scanText(tHandle, doc.readDocument() or "")
-            return True
-        return False
+            self.scanText(tHandle, self._project.storage.getDocumentText(tHandle))
+        return
 
     def indexChangedSince(self, checkTime: int | float) -> bool:
         """Check if the index has changed since a given time."""
@@ -266,7 +263,7 @@ class NWIndex:
         self._itemIndex.add(tHandle, tItem)
 
         # Run word counter for the whole text
-        cC, wC, pC = countWords(text)
+        cC, wC, pC = standardCounter(text)
         tItem.setCharCount(cC)
         tItem.setWordCount(wC)
         tItem.setParaCount(pC)
@@ -307,7 +304,7 @@ class NWIndex:
         nTitle = 0           # Line Number of the previous title
         cTitle = TT_NONE     # Tag of the current title
         pTitle = TT_NONE     # Tag of the previous title
-        canSetHeader = True  # First header has not yet been set
+        canSetHead = True  # First heading has not yet been set
 
         lines = text.splitlines()
         for n, line in enumerate(lines, start=1):
@@ -320,9 +317,9 @@ class NWIndex:
                 if hDepth == "H0":
                     continue
 
-                if canSetHeader:
+                if canSetHead:
                     nwItem.setMainHeading(hDepth)
-                    canSetHeader = False
+                    canSetHead = False
 
                 cTitle = self._itemIndex.addItemHeading(tHandle, n, hDepth, hText)
                 if cTitle != TT_NONE:
@@ -383,7 +380,7 @@ class NWIndex:
         return
 
     def _splitHeading(self, line: str) -> tuple[str, str]:
-        """Split a heading into its header level and text value."""
+        """Split a heading into its heading level and text value."""
         if line.startswith("# "):
             return "H1", line[2:].strip()
         elif line.startswith("## "):
@@ -396,11 +393,13 @@ class NWIndex:
             return "H1", line[3:].strip()
         elif line.startswith("##! "):
             return "H2", line[4:].strip()
+        elif line.startswith("###! "):
+            return "H3", line[5:].strip()
         return "H0", ""
 
     def _indexWordCounts(self, tHandle: str, text: str, sTitle: str) -> None:
         """Count text stats and save the counts to the index."""
-        cC, wC, pC = countWords(text)
+        cC, wC, pC = standardCounter(text)
         self._itemIndex.setHeadingCounts(tHandle, sTitle, cC, wC, pC)
         return
 
@@ -515,16 +514,21 @@ class NWIndex:
         """Get the index data for a given item."""
         return self._itemIndex[tHandle]
 
-    def getItemHeader(self, tHandle: str, sTitle: str) -> IndexHeading | None:
-        """Get the header entry for a specific item and heading."""
-        tItem = self._itemIndex[tHandle]
-        if isinstance(tItem, IndexItem):
+    def getItemHeading(self, tHandle: str, sTitle: str) -> IndexHeading | None:
+        """Get the heading entry for a specific item and heading."""
+        if tItem := self._itemIndex[tHandle]:
             return tItem[sTitle]
         return None
 
+    def iterItemHeadings(self, tHandle: str) -> Iterable[tuple[str, IndexHeading]]:
+        """Get all headings for a specific item."""
+        if tItem := self._itemIndex[tHandle]:
+            yield from tItem.items()
+        return []
+
     def novelStructure(
         self, rootHandle: str | None = None, activeOnly: bool = True
-    ) -> Iterator[tuple[str, str, str, IndexHeading]]:
+    ) -> Iterable[tuple[str, str, str, IndexHeading]]:
         """Iterate over all titles in the novel, in the correct order as
         they appear in the tree view and in the respective document
         files, but skipping all note files.
@@ -666,7 +670,7 @@ class NWIndex:
 
     def getTagsData(
         self, activeOnly: bool = True
-    ) -> Iterator[tuple[str, str, str, IndexItem | None, IndexHeading | None]]:
+    ) -> Iterable[tuple[str, str, str, IndexItem | None, IndexHeading | None]]:
         """Return all known tags."""
         for tag, data in self._tagsIndex.items():
             iItem = self._itemIndex[data.get("handle")]
@@ -825,7 +829,7 @@ class ItemIndex:
     class around a single storage dictionary with a set of utility
     functions for setting and accessing the index data. Each indexed
     item is stored in an IndexItem object, which again holds an
-    IndexHeading object for each header of the text.
+    IndexHeading object for each heading of the text.
     """
 
     __slots__ = ("_project", "_items")
@@ -898,13 +902,11 @@ class ItemIndex:
 
             if rHandle is None:
                 for sTitle in self._items[tHandle].headings():
-                    hItem = self._items[tHandle][sTitle]
-                    if hItem:
+                    if hItem := self._items[tHandle][sTitle]:
                         yield tHandle, sTitle, hItem
             elif tItem.itemRoot == rHandle:
                 for sTitle in self._items[tHandle].headings():
-                    hItem = self._items[tHandle][sTitle]
-                    if hItem:
+                    if hItem := self._items[tHandle][sTitle]:
                         yield tHandle, sTitle, hItem
 
         return
@@ -1200,7 +1202,7 @@ class IndexHeading:
     ##
 
     def setLevel(self, level: str) -> None:
-        """Set the level of the header if it's a valid value."""
+        """Set the level of the heading if it's a valid value."""
         if level in nwHeaders.H_VALID:
             self._level = level
         return
@@ -1315,86 +1317,3 @@ def processComment(text: str) -> tuple[nwComment, str, int]:
     if content and (clean := classifier.strip().lower()) in CLASSIFIERS:
         return CLASSIFIERS[clean], content.strip(), text.find(":") + 1
     return nwComment.PLAIN, check, 0
-
-
-def countWords(text: str) -> tuple[int, int, int]:
-    """Count words in a piece of text, skipping special syntax and
-    comments.
-    """
-    charCount = 0
-    wordCount = 0
-    paraCount = 0
-    prevEmpty = True
-
-    if not isinstance(text, str):
-        return charCount, wordCount, paraCount
-
-    # We need to treat dashes as word separators for counting words.
-    # The check+replace approach is much faster than direct replace for
-    # large texts, and a bit slower for small texts, but in the latter
-    # case it doesn't really matter.
-    if nwUnicode.U_ENDASH in text:
-        text = text.replace(nwUnicode.U_ENDASH, " ")
-    if nwUnicode.U_EMDASH in text:
-        text = text.replace(nwUnicode.U_EMDASH, " ")
-
-    # Strip shortcodes
-    if "[" in text:
-        text = nwRegEx.RX_SC.sub("", text)
-
-    for line in text.splitlines():
-
-        countPara = True
-
-        if not line:
-            prevEmpty = True
-            continue
-
-        if line[0] == "@" or line[0] == "%":
-            continue
-
-        if line[0] == "[":
-            check = line.lower()
-            if check.startswith(("[newpage]", "[new page]", "[vspace]")):
-                continue
-            elif check.startswith("[vspace:") and line.endswith("]"):
-                continue
-
-        elif line[0] == "#":
-            if line[:5] == "#### ":
-                line = line[5:]
-                countPara = False
-            elif line[:4] == "### ":
-                line = line[4:]
-                countPara = False
-            elif line[:3] == "## ":
-                line = line[3:]
-                countPara = False
-            elif line[:2] == "# ":
-                line = line[2:]
-                countPara = False
-            elif line[:3] == "#! ":
-                line = line[3:]
-                countPara = False
-            elif line[:4] == "##! ":
-                line = line[4:]
-                countPara = False
-
-        elif line[0] == ">" or line[-1] == "<":
-            if line[:2] == ">>":
-                line = line[2:].lstrip(" ")
-            elif line[:1] == ">":
-                line = line[1:].lstrip(" ")
-            if line[-2:] == "<<":
-                line = line[:-2].rstrip(" ")
-            elif line[-1:] == "<":
-                line = line[:-1].rstrip(" ")
-
-        wordCount += len(line.split())
-        charCount += len(line)
-        if countPara and prevEmpty:
-            paraCount += 1
-
-        prevEmpty = not countPara
-
-    return charCount, wordCount, paraCount

novelwriter/core/project.py

@@ -31,7 +31,7 @@ from time import time
 from typing import TYPE_CHECKING
 from pathlib import Path
 from functools import partial
-from collections.abc import Iterator
+from collections.abc import Iterable
 
 from PyQt5.QtCore import QCoreApplication
 
@@ -175,12 +175,10 @@ class NWProject:
         """Write content to a new document after it is created. This
         will not run if the file exists and is not empty.
         """
-        tItem = self._tree[tHandle]
-        if not (tItem and tItem.isFileType()):
+        if not ((tItem := self._tree[tHandle]) and tItem.isFileType()):
             return False
 
-        newDoc = self._storage.getDocument(tHandle)
-        if (newDoc.readDocument() or "").strip():
+        if self._storage.getDocumentText(tHandle).strip():
             return False
 
         indent = "#"*minmax(hLevel, 1, 4)
@@ -191,7 +189,7 @@ class NWProject:
         else:
             tItem.setLayout(nwItemLayout.NOTE)
 
-        newDoc.writeDocument(text)
+        self._storage.getDocument(tHandle).writeDocument(text)
         self._index.scanText(tHandle, text)
 
         return True
@@ -200,21 +198,18 @@ class NWProject:
         """Copy content to a new document after it is created. This
         will not run if the file exists and is not empty.
         """
-        tItem = self._tree[tHandle]
-        if not (tItem and tItem.isFileType()):
+        if not ((tItem := self._tree[tHandle]) and tItem.isFileType()):
             return False
 
-        sItem = self._tree[sHandle]
-        if not (sItem and sItem.isFileType()):
+        if not ((sItem := self._tree[sHandle]) and sItem.isFileType()):
             return False
 
-        newDoc = self._storage.getDocument(tHandle)
-        if (newDoc.readDocument() or "").strip():
+        if self._storage.getDocumentText(tHandle).strip():
             return False
 
         logger.debug("Populating '%s' with text from '%s'", tHandle, sHandle)
-        text = self._storage.getDocument(sHandle).readDocument() or ""
-        newDoc.writeDocument(text)
+        text = self._storage.getDocumentText(sHandle)
+        self._storage.getDocument(tHandle).writeDocument(text)
         sItem.setLayout(tItem.itemLayout)
         self._index.scanText(tHandle, text)
 
@@ -517,7 +512,7 @@ class NWProject:
     #  Class Methods
     ##
 
-    def iterProjectItems(self) -> Iterator[NWItem]:
+    def iterProjectItems(self) -> Iterable[NWItem]:
         """This function ensures that the item tree loaded is sent to
         the GUI tree view in such a way that the tree can be built. That
         is, the parent item must be sent before its child. In principle,

novelwriter/core/sessions.py

@@ -29,7 +29,7 @@ import logging
 from time import time
 from typing import TYPE_CHECKING
 from pathlib import Path
-from collections.abc import Iterator
+from collections.abc import Iterable
 
 from novelwriter.error import logException
 from novelwriter.common import formatTimeStamp
@@ -110,7 +110,7 @@ class NWSessionLog:
 
         return True
 
-    def iterRecords(self) -> Iterator[dict]:
+    def iterRecords(self) -> Iterable[dict]:
         """Iterate through all records in the log."""
         sessFile = self._project.storage.getMetaFile(nwFiles.SESS_FILE)
         if isinstance(sessFile, Path) and sessFile.is_file():

novelwriter/core/status.py

@@ -28,10 +28,10 @@ import random
 import logging
 
 from typing import TYPE_CHECKING, Literal
-from collections.abc import ItemsView, Iterator, KeysView, ValuesView
+from collections.abc import ItemsView, Iterable, Iterator, KeysView, ValuesView
 
 from PyQt5.QtGui import QIcon, QPainter, QPainterPath, QPixmap, QColor
-from PyQt5.QtCore import QRectF, Qt
+from PyQt5.QtCore import QRectF
 
 from novelwriter import CONFIG
 from novelwriter.common import minmax, simplified
@@ -193,7 +193,7 @@ class NWStatus:
             self._store[key]["count"] += 1
         return
 
-    def pack(self) -> Iterator[tuple[str, dict]]:
+    def pack(self) -> Iterable[tuple[str, dict]]:
         """Pack the status entries into a dictionary."""
         for key, data in self._store.items():
             yield (data["name"], {
@@ -248,7 +248,7 @@ class NWStatus:
     def _createIcon(self, red: int, green: int, blue: int) -> QIcon:
         """Generate an icon for a status label."""
         pixmap = QPixmap(self._iPX, self._iPX)
-        pixmap.fill(Qt.transparent)
+        pixmap.fill(QColor(0, 0, 0, 0))
 
         painter = QPainter(pixmap)
         painter.setRenderHint(QPainter.Antialiasing)

novelwriter/core/storage.py

@@ -27,18 +27,18 @@ import json
 import logging
 
 from enum import Enum
+from pathlib import Path
 from time import time
 from typing import TYPE_CHECKING
-from pathlib import Path
 from zipfile import ZIP_DEFLATED, ZIP_STORED, ZipFile
 
 from novelwriter import CONFIG
-from novelwriter.error import logException
 from novelwriter.common import isHandle, minmax
 from novelwriter.constants import nwFiles
 from novelwriter.core.document import NWDocument
 from novelwriter.core.projectxml import ProjectXMLReader, ProjectXMLWriter
 from novelwriter.core.spellcheck import UserDictionary
+from novelwriter.error import logException
 
 if TYPE_CHECKING:  # pragma: no cover
     from novelwriter.core.project import NWProject
@@ -287,6 +287,12 @@ class NWStorage:
             return self._runtimePath / "meta" / fileName
         return None
 
+    def getDocumentText(self, tHandle: str) -> str:
+        """Return the text of a document in a fast and efficient way."""
+        if isinstance(self._runtimePath, Path):
+            return NWDocument.quickReadText(self._runtimePath / "content", tHandle)
+        return ""
+
     def scanContent(self) -> list[str]:
         """Scan the content folder and return the handle of all files
         found in it. Files that do not match the pattern are ignored.