novelWriter 2.2.1__py3-none-any.whl → 2.3__py3-none-any.whl

novelwriter/core/tokenizer.py

@@ -34,11 +34,13 @@ from pathlib import Path
 from functools import partial
 
 from PyQt5.QtCore import QCoreApplication, QRegularExpression
-from novelwriter.core.index import processComment
 
 from novelwriter.enum import nwComment, nwItemLayout
 from novelwriter.common import formatTimeStamp, numberToRoman, checkInt
-from novelwriter.constants import nwHeadFmt, nwRegEx, nwShortcode, nwUnicode
+from novelwriter.constants import (
+    nwHeadFmt, nwKeyWords, nwLabels, nwRegEx, nwShortcode, nwUnicode, trConst
+)
+from novelwriter.core.index import processComment
 from novelwriter.core.project import NWProject
 
 logger = logging.getLogger(__name__)
@@ -87,7 +89,7 @@ class Tokenizer(ABC):
     T_UNNUM    = 7   # Unnumbered
     T_HEAD1    = 8   # Header 1
     T_HEAD2    = 9   # Header 2
-    T_HEAD3    = 10   # Header 3
+    T_HEAD3    = 10  # Header 3
     T_HEAD4    = 11  # Header 4
     T_TEXT     = 12  # Text line
     T_SEP      = 13  # Scene separator
@@ -112,13 +114,15 @@ class Tokenizer(ABC):
 
         # Data Variables
         self._text   = ""    # The raw text to be tokenized
-        self._nwItem = None  # The NWItem associated with the handle
-        self._tokens = []    # The list of the processed tokens
+        self._nwItem = None  # The NWItem currently being processed
         self._result = ""    # The result of the last document
 
         self._keepMarkdown = False  # Whether to keep the markdown text
         self._allMarkdown  = []     # The result novelWriter markdown of all documents
 
+        # Processed Tokens
+        self._tokens: list[tuple[int, int, str, list[tuple[int, int]], int]] = []
+
         # User Settings
         self._textFont    = "Serif"  # Output text font
         self._textSize    = 11       # Output text size
@@ -154,7 +158,7 @@ class Tokenizer(ABC):
 
         # Instance Variables
         self._hFormatter = HeadingFormatter(self._project)
-        self._firstScene = False  # Flag to indicate that the first scene of the chapter
+        self._skipSeparator = False  # Flag to indicate that we skip the scene separator
 
         # This File
         self._isNone  = False  # Document has unknown layout
@@ -194,12 +198,12 @@ class Tokenizer(ABC):
     ##
 
     @property
-    def theResult(self) -> str:
+    def result(self) -> str:
         """The result of the build process."""
         return self._result
 
     @property
-    def theMarkdown(self) -> list:
+    def allMarkdown(self) -> list:
         """The combined novelWriter Markdown text."""
         return self._allMarkdown
 
@@ -350,7 +354,7 @@ class Tokenizer(ABC):
         title = f"{trNotes}: {tItem.itemName}"
         self._tokens = []
         self._tokens.append((
-            self.T_TITLE, 0, title, None, textAlign
+            self.T_TITLE, 0, title, [], textAlign
         ))
         if self._keepMarkdown:
             self._allMarkdown.append(f"# {title}\n\n")
@@ -358,8 +362,8 @@ class Tokenizer(ABC):
         return True
 
     def setText(self, tHandle: str, text: str | None = None) -> bool:
-        """Set the text for the tokenizer from a handle. If theText is
-        not set, load it from the file.
+        """Set the text for the tokenizer from a handle. If text is not
+        set, load it from the file.
         """
         self._nwItem = self._project.tree[tHandle]
         if self._nwItem is None:
@@ -418,7 +422,7 @@ class Tokenizer(ABC):
             # Check for blank lines
             if len(sLine) == 0:
                 self._tokens.append((
-                    self.T_EMPTY, nHead, "", None, self.A_NONE
+                    self.T_EMPTY, nHead, "", [], self.A_NONE
                 ))
                 if self._keepMarkdown:
                     tmpMarkdown.append("\n")
@@ -446,7 +450,7 @@ class Tokenizer(ABC):
 
                 elif sLine == "[vspace]":
                     self._tokens.append(
-                        (self.T_SKIP, nHead, "", None, sAlign)
+                        (self.T_SKIP, nHead, "", [], sAlign)
                     )
                     continue
 
@@ -454,38 +458,42 @@ class Tokenizer(ABC):
                     nSkip = checkInt(sLine[8:-1], 0)
                     if nSkip >= 1:
                         self._tokens.append(
-                            (self.T_SKIP, nHead, "", None, sAlign)
+                            (self.T_SKIP, nHead, "", [], sAlign)
                         )
                     if nSkip > 1:
                         self._tokens += (nSkip - 1) * [
-                            (self.T_SKIP, nHead, "", None, self.A_NONE)
+                            (self.T_SKIP, nHead, "", [], self.A_NONE)
                         ]
                     continue
 
             if aLine[0] == "%":
+                if aLine[1] == "~":
+                    # Completely ignore the paragraph
+                    continue
+
                 cStyle, cText, _ = processComment(aLine)
                 if cStyle == nwComment.SYNOPSIS:
                     self._tokens.append((
-                        self.T_SYNOPSIS, nHead, cText, None, sAlign
+                        self.T_SYNOPSIS, nHead, cText, [], sAlign
                     ))
                     if self._doSynopsis and self._keepMarkdown:
                         tmpMarkdown.append("%s\n" % aLine)
                 elif cStyle == nwComment.SHORT:
                     self._tokens.append((
-                        self.T_SHORT, nHead, cText, None, sAlign
+                        self.T_SHORT, nHead, cText, [], sAlign
                     ))
                     if self._doSynopsis and self._keepMarkdown:
                         tmpMarkdown.append("%s\n" % aLine)
                 else:
                     self._tokens.append((
-                        self.T_COMMENT, nHead, cText, None, sAlign
+                        self.T_COMMENT, nHead, cText, [], sAlign
                     ))
                     if self._doComments and self._keepMarkdown:
                         tmpMarkdown.append("%s\n" % aLine)
 
             elif aLine[0] == "@":
                 self._tokens.append((
-                    self.T_KEYWORD, nHead, aLine[1:].strip(), None, sAlign
+                    self.T_KEYWORD, nHead, aLine[1:].strip(), [], sAlign
                 ))
                 if self._doKeywords and self._keepMarkdown:
                     tmpMarkdown.append("%s\n" % aLine)
@@ -497,7 +505,7 @@ class Tokenizer(ABC):
 
                 nHead += 1
                 self._tokens.append((
-                    self.T_HEAD1, nHead, aLine[2:].strip(), None, sAlign
+                    self.T_HEAD1, nHead, aLine[2:].strip(), [], sAlign
                 ))
                 if self._keepMarkdown:
                     tmpMarkdown.append("%s\n" % aLine)
@@ -508,7 +516,7 @@ class Tokenizer(ABC):
 
                 nHead += 1
                 self._tokens.append((
-                    self.T_HEAD2, nHead, aLine[3:].strip(), None, sAlign
+                    self.T_HEAD2, nHead, aLine[3:].strip(), [], sAlign
                 ))
                 if self._keepMarkdown:
                     tmpMarkdown.append("%s\n" % aLine)
@@ -516,7 +524,7 @@ class Tokenizer(ABC):
             elif aLine[:4] == "### ":
                 nHead += 1
                 self._tokens.append((
-                    self.T_HEAD3, nHead, aLine[4:].strip(), None, sAlign
+                    self.T_HEAD3, nHead, aLine[4:].strip(), [], sAlign
                 ))
                 if self._keepMarkdown:
                     tmpMarkdown.append("%s\n" % aLine)
@@ -524,7 +532,7 @@ class Tokenizer(ABC):
             elif aLine[:5] == "#### ":
                 nHead += 1
                 self._tokens.append((
-                    self.T_HEAD4, nHead, aLine[5:].strip(), None, sAlign
+                    self.T_HEAD4, nHead, aLine[5:].strip(), [], sAlign
                 ))
                 if self._keepMarkdown:
                     tmpMarkdown.append("%s\n" % aLine)
@@ -537,7 +545,7 @@ class Tokenizer(ABC):
                     tStyle = self.T_HEAD1
 
                 self._tokens.append((
-                    tStyle, nHead, aLine[3:].strip(), None, sAlign | self.A_CENTRE
+                    tStyle, nHead, aLine[3:].strip(), [], sAlign | self.A_CENTRE
                 ))
                 if self._keepMarkdown:
                     tmpMarkdown.append("%s\n" % aLine)
@@ -551,7 +559,7 @@ class Tokenizer(ABC):
                     tStyle = self.T_HEAD2
 
                 self._tokens.append((
-                    tStyle, nHead, aLine[4:].strip(), None, sAlign
+                    tStyle, nHead, aLine[4:].strip(), [], sAlign
                 ))
                 if self._keepMarkdown:
                     tmpMarkdown.append("%s\n" % aLine)
@@ -607,14 +615,14 @@ class Tokenizer(ABC):
             # Make sure the token array doesn't start with a page break
             # on the very first page, adding a blank first page.
             if self._tokens[0][4] & self.A_PBB:
-                tToken = self._tokens[0]
+                token = self._tokens[0]
                 self._tokens[0] = (
-                    tToken[0], tToken[1], tToken[2], tToken[3], tToken[4] & ~self.A_PBB
+                    token[0], token[1], token[2], token[3], token[4] & ~self.A_PBB
                 )
 
         # Always add an empty line at the end of the file
         self._tokens.append((
-            self.T_EMPTY, nHead, "", None, self.A_NONE
+            self.T_EMPTY, nHead, "", [], self.A_NONE
         ))
         if self._keepMarkdown:
             tmpMarkdown.append("\n")
@@ -626,25 +634,23 @@ class Tokenizer(ABC):
         # ===========
         # Some items need a second pass
 
-        pToken = (self.T_EMPTY, 0, "", None, self.A_NONE)
-        nToken = (self.T_EMPTY, 0, "", None, self.A_NONE)
+        pToken = (self.T_EMPTY, 0, "", [], self.A_NONE)
+        nToken = (self.T_EMPTY, 0, "", [], self.A_NONE)
         tCount = len(self._tokens)
-        for n, tToken in enumerate(self._tokens):
+        for n, token in enumerate(self._tokens):
 
             if n > 0:
                 pToken = self._tokens[n-1]
             if n < tCount - 1:
                 nToken = self._tokens[n+1]
 
-            if tToken[0] == self.T_KEYWORD:
-                aStyle = tToken[4]
+            if token[0] == self.T_KEYWORD:
+                aStyle = token[4]
                 if pToken[0] == self.T_KEYWORD:
                     aStyle |= self.A_Z_TOPMRG
                 if nToken[0] == self.T_KEYWORD:
                     aStyle |= self.A_Z_BTMMRG
-                self._tokens[n] = (
-                    tToken[0], tToken[1], tToken[2], tToken[3], aStyle
-                )
+                self._tokens[n] = (token[0], token[1], token[2], token[3], aStyle)
 
         return
 
@@ -655,93 +661,89 @@ class Tokenizer(ABC):
         if not self._isNovel:
             return False
 
-        for n, tToken in enumerate(self._tokens):
+        self._hFormatter.setHandle(self._nwItem.itemHandle if self._nwItem else None)
 
-            # In case we see text before a scene, we reset the flag
-            if tToken[0] == self.T_TEXT:
-                self._firstScene = False
+        for n, token in enumerate(self._tokens):
 
-            elif tToken[0] == self.T_HEAD1:
-                # Partition
+            if token[0] == self.T_TITLE:  # Title
+                # For new titles, we reset all counters
+                self._skipSeparator = True
+                self._hFormatter.resetAll()
 
-                tTemp = self._hFormatter.apply(self._fmtTitle, tToken[2])
+            elif token[0] == self.T_HEAD1:  # Partition
+
+                tTemp = self._hFormatter.apply(self._fmtTitle, token[2], token[1])
                 self._tokens[n] = (
-                    tToken[0], tToken[1], tTemp, None, tToken[4]
+                    token[0], token[1], tTemp, [], token[4]
                 )
 
-            elif tToken[0] in (self.T_HEAD2, self.T_UNNUM):
-                # Chapter
+                # Set scene variables
+                self._skipSeparator = True
+                self._hFormatter.resetScene()
+
+            elif token[0] in (self.T_HEAD2, self.T_UNNUM):  # Chapter, Unnumbered
 
                 # Numbered or Unnumbered
-                if tToken[0] == self.T_UNNUM:
-                    tTemp = self._hFormatter.apply(self._fmtUnNum, tToken[2])
+                if token[0] == self.T_UNNUM:
+                    tTemp = self._hFormatter.apply(self._fmtUnNum, token[2], token[1])
                 else:
                     self._hFormatter.incChapter()
-                    tTemp = self._hFormatter.apply(self._fmtChapter, tToken[2])
+                    tTemp = self._hFormatter.apply(self._fmtChapter, token[2], token[1])
 
                 # Format the chapter header
                 self._tokens[n] = (
-                    tToken[0], tToken[1], tTemp, None, tToken[4]
+                    token[0], token[1], tTemp, [], token[4]
                 )
 
                 # Set scene variables
-                self._firstScene = True
+                self._skipSeparator = True
                 self._hFormatter.resetScene()
 
-            elif tToken[0] == self.T_HEAD3:
-                # Scene
+            elif token[0] == self.T_HEAD3:  # Scene
 
                 self._hFormatter.incScene()
 
-                tTemp = self._hFormatter.apply(self._fmtScene, tToken[2])
+                tTemp = self._hFormatter.apply(self._fmtScene, token[2], token[1])
                 if tTemp == "" and self._hideScene:
                     self._tokens[n] = (
-                        self.T_EMPTY, tToken[1], "", None, self.A_NONE
+                        self.T_EMPTY, token[1], "", [], self.A_NONE
                     )
                 elif tTemp == "" and not self._hideScene:
-                    if self._firstScene:
-                        self._tokens[n] = (
-                            self.T_EMPTY, tToken[1], "", None, self.A_NONE
-                        )
-                    else:
-                        self._tokens[n] = (
-                            self.T_SKIP, tToken[1], "", None, tToken[4]
-                        )
+                    self._tokens[n] = (
+                        self.T_EMPTY if self._skipSeparator else self.T_SKIP, token[1],
+                        "", [], self.A_NONE if self._skipSeparator else token[4]
+                    )
                 elif tTemp == self._fmtScene:
-                    if self._firstScene:
-                        self._tokens[n] = (
-                            self.T_EMPTY, tToken[1], "", None, self.A_NONE
-                        )
-                    else:
-                        self._tokens[n] = (
-                            self.T_SEP, tToken[1], tTemp, None, tToken[4] | self.A_CENTRE
-                        )
+                    self._tokens[n] = (
+                        self.T_EMPTY if self._skipSeparator else self.T_SEP, token[1],
+                        "" if self._skipSeparator else tTemp, [],
+                        self.A_NONE if self._skipSeparator else (token[4] | self.A_CENTRE)
+                    )
                 else:
                     self._tokens[n] = (
-                        tToken[0], tToken[1], tTemp, None, tToken[4]
+                        token[0], token[1], tTemp, [], token[4]
                     )
 
-                self._firstScene = False
+                self._skipSeparator = False
 
-            elif tToken[0] == self.T_HEAD4:
-                # Section
+            elif token[0] == self.T_HEAD4:  # Section
 
-                tTemp = self._hFormatter.apply(self._fmtSection, tToken[2])
+                tTemp = self._hFormatter.apply(self._fmtSection, token[2], token[1])
                 if tTemp == "" and self._hideSection:
                     self._tokens[n] = (
-                        self.T_EMPTY, tToken[1], "", None, self.A_NONE
+                        self.T_EMPTY, token[1], "", [], self.A_NONE
                     )
                 elif tTemp == "" and not self._hideSection:
                     self._tokens[n] = (
-                        self.T_SKIP, tToken[1], "", None, tToken[4]
+                        self.T_SKIP, token[1], "", [], token[4]
                     )
                 elif tTemp == self._fmtSection:
                     self._tokens[n] = (
-                        self.T_SEP, tToken[1], tTemp, None, tToken[4] | self.A_CENTRE
+                        self.T_SEP, token[1], tTemp, [], token[4] | self.A_CENTRE
                     )
                 else:
                     self._tokens[n] = (
-                        tToken[0], tToken[1], tTemp, None, tToken[4]
+                        token[0], token[1], tTemp, [], token[4]
                     )
 
         return True
@@ -759,7 +761,6 @@ class Tokenizer(ABC):
         data = {
             "meta": {
                 "projectName": self._project.data.name,
-                "novelTitle": self._project.data.title,
                 "novelAuthor": self._project.data.author,
                 "buildTime": int(timeStamp),
                 "buildTimeStr": formatTimeStamp(timeStamp),
@@ -818,11 +819,17 @@ class HeadingFormatter:
 
     def __init__(self, project: NWProject) -> None:
         self._project = project
+        self._handle = None
         self._chCount = 0
         self._scChCount = 0
         self._scAbsCount = 0
         return
 
+    def setHandle(self, tHandle: str | None) -> None:
+        """Set the handle currently being processed."""
+        self._handle = tHandle
+        return
+
     def incChapter(self) -> None:
         """Increment the chapter counter."""
         self._chCount += 1
@@ -834,12 +841,19 @@ class HeadingFormatter:
         self._scAbsCount += 1
         return
 
+    def resetAll(self) -> None:
+        """Reset all counters."""
+        self._chCount = 0
+        self._scChCount = 0
+        self._scAbsCount = 0
+        return
+
     def resetScene(self) -> None:
         """Reset the chapter scene counter."""
         self._scChCount = 0
         return
 
-    def apply(self, hFormat: str, text: str) -> str:
+    def apply(self, hFormat: str, text: str, nHead: int) -> str:
         """Apply formatting to a specific heading."""
         hFormat = hFormat.replace(nwHeadFmt.TITLE, text)
         hFormat = hFormat.replace(nwHeadFmt.CH_NUM, str(self._chCount))
@@ -855,6 +869,19 @@ class HeadingFormatter:
             chRom = numberToRoman(self._chCount, toLower=False)
             hFormat = hFormat.replace(nwHeadFmt.CH_ROMU, chRom)
 
+        if nwHeadFmt.CHAR_POV in hFormat or nwHeadFmt.CHAR_FOCUS in hFormat:
+            if self._handle and nHead > 0:
+                index = self._project.index
+                pList = index.getReferenceForHeader(self._handle, nHead, nwKeyWords.POV_KEY)
+                fList = index.getReferenceForHeader(self._handle, nHead, nwKeyWords.FOCUS_KEY)
+                pText = pList[0] if pList else nwUnicode.U_ENDASH
+                fText = fList[0] if fList else nwUnicode.U_ENDASH
+            else:
+                pText = trConst(nwLabels.KEY_NAME[nwKeyWords.POV_KEY])
+                fText = trConst(nwLabels.KEY_NAME[nwKeyWords.FOCUS_KEY])
+            hFormat = hFormat.replace(nwHeadFmt.CHAR_POV, pText)
+            hFormat = hFormat.replace(nwHeadFmt.CHAR_FOCUS, fText)
+
         return hFormat
 
 # END Class HeadingFormatter

novelwriter/core/toodt.py

@@ -29,11 +29,11 @@ from __future__ import annotations
 import logging
 import xml.etree.ElementTree as ET
 
-from typing import Sequence
 from hashlib import sha256
 from pathlib import Path
 from zipfile import ZipFile
 from datetime import datetime
+from collections.abc import Sequence
 
 from novelwriter import __version__
 from novelwriter.common import xmlIndent
@@ -132,11 +132,12 @@ class ToOdt(Tokenizer):
         self._errData = []  # List of errors encountered
 
         # Properties
-        self._textFont   = "Liberation Serif"
-        self._textSize   = 12
-        self._textFixed  = False
-        self._colourHead = False
-        self._headerText = ""
+        self._textFont     = "Liberation Serif"
+        self._textSize     = 12
+        self._textFixed    = False
+        self._colourHead   = False
+        self._headerFormat = ""
+        self._pageOffset   = 0
 
         # Internal
         self._fontFamily   = "'Liberation Serif'"
@@ -222,6 +223,12 @@ class ToOdt(Tokenizer):
         self._mDocRight  = f"{right/10.0:.3f}cm"
         return
 
+    def setHeaderFormat(self, format: str, offset: int) -> None:
+        """Set the document header format."""
+        self._headerFormat = format.strip()
+        self._pageOffset = offset
+        return
+
     ##
     #  Class Methods
     ##
@@ -279,14 +286,6 @@ class ToOdt(Tokenizer):
         # Clear Errors
         self._errData = []
 
-        # Document Header
-        # ===============
-
-        if self._headerText == "":
-            theTitle = self._project.data.title or self._project.data.name
-            theAuth = self._project.data.author
-            self._headerText = f"{theTitle} / {theAuth} /"
-
         # Create Roots
         # ============
 
@@ -373,7 +372,7 @@ class ToOdt(Tokenizer):
 
         # Dublin Core Meta Data
         xMeta = ET.SubElement(self._xMeta, _mkTag("dc", "title"))
-        xMeta.text = self._project.data.title or self._project.data.name
+        xMeta.text = self._project.data.name
 
         xMeta = ET.SubElement(self._xMeta, _mkTag("dc", "date"))
         xMeta.text = timeStamp
@@ -684,12 +683,12 @@ class ToOdt(Tokenizer):
             return parName
 
         oStyle.setParentStyleName(parName)
-        theID = oStyle.getID()
-        if theID in self._autoPara:
-            return self._autoPara[theID][0]
+        pID = oStyle.getID()
+        if pID in self._autoPara:
+            return self._autoPara[pID][0]
 
         newName = "P%d" % (len(self._autoPara) + 1)
-        self._autoPara[theID] = (newName, oStyle)
+        self._autoPara[pID] = (newName, oStyle)
 
         return newName
 
@@ -1012,17 +1011,28 @@ class ToOdt(Tokenizer):
         xPage = ET.SubElement(self._xMast, _mkTag("style", "master-page"), attrib=tAttr)
 
         # Standard Page Header
-        xHead = ET.SubElement(xPage, _mkTag("style", "header"))
-        xPar = ET.SubElement(xHead, _mkTag("text", "p"), attrib={
-            _mkTag("text", "style-name"): "Header"
-        })
-        xPar.text = self._headerText.strip() + " "
-
-        xTail = ET.SubElement(xPar, _mkTag("text", "page-number"), attrib={
-            _mkTag("text", "select-page"): "current"
-        })
-        xTail.text = "2"
-        xTail.tail = ""  # Prevent line break in indented XML
+        if self._headerFormat:
+            pre, page, post = self._headerFormat.partition(nwHeadFmt.ODT_PAGE)
+
+            pre = pre.replace(nwHeadFmt.ODT_PROJECT, self._project.data.name)
+            pre = pre.replace(nwHeadFmt.ODT_AUTHOR, self._project.data.author)
+            post = post.replace(nwHeadFmt.ODT_PROJECT, self._project.data.name)
+            post = post.replace(nwHeadFmt.ODT_AUTHOR, self._project.data.author)
+
+            xHead = ET.SubElement(xPage, _mkTag("style", "header"))
+            xPar = ET.SubElement(xHead, _mkTag("text", "p"), attrib={
+                _mkTag("text", "style-name"): "Header"
+            })
+            xPar.text = pre
+            if page:
+                attrib = {_mkTag("text", "select-page"): "current"}
+                if self._pageOffset > 0:
+                    attrib = {_mkTag("text", "page-adjust"): str(0 - self._pageOffset)}
+                xTail = ET.SubElement(xPar, _mkTag("text", "page-number"), attrib=attrib)
+                xTail.text = "2"
+                xTail.tail = post
+            else:
+                xPar.text += post
 
         # First Page Header
         xHead = ET.SubElement(xPage, _mkTag("style", "header-first"))

novelwriter/core/tree.py

@@ -26,8 +26,9 @@ from __future__ import annotations
 import random
 import logging
 
-from typing import TYPE_CHECKING, Iterator, Literal, overload
+from typing import TYPE_CHECKING, Literal, overload
 from pathlib import Path
+from collections.abc import Iterator
 
 from novelwriter.enum import nwItemClass, nwItemLayout, nwItemType
 from novelwriter.error import logException
@@ -500,7 +501,7 @@ class NWTree:
     ##
 
     def _setTreeChanged(self, state: bool) -> None:
-        """Set the changed flag to theState, and if being set to True,
+        """Set the changed flag to state, and if being set to True,
         propagate that state change to the parent NWProject class.
         """
         self._changed = state