novelWriter 2.2.1__py3-none-any.whl → 2.3b1__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__)
@@ -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
@@ -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)
@@ -614,7 +622,7 @@ class Tokenizer(ABC):
 
         # 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,8 +634,8 @@ 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):
 
@@ -655,6 +663,8 @@ class Tokenizer(ABC):
         if not self._isNovel:
             return False
 
+        self._hFormatter.setHandle(self._nwItem.itemHandle if self._nwItem else None)
+
         for n, tToken in enumerate(self._tokens):
 
             # In case we see text before a scene, we reset the flag
@@ -664,9 +674,9 @@ class Tokenizer(ABC):
             elif tToken[0] == self.T_HEAD1:
                 # Partition
 
-                tTemp = self._hFormatter.apply(self._fmtTitle, tToken[2])
+                tTemp = self._hFormatter.apply(self._fmtTitle, tToken[2], tToken[1])
                 self._tokens[n] = (
-                    tToken[0], tToken[1], tTemp, None, tToken[4]
+                    tToken[0], tToken[1], tTemp, [], tToken[4]
                 )
 
             elif tToken[0] in (self.T_HEAD2, self.T_UNNUM):
@@ -674,14 +684,14 @@ class Tokenizer(ABC):
 
                 # Numbered or Unnumbered
                 if tToken[0] == self.T_UNNUM:
-                    tTemp = self._hFormatter.apply(self._fmtUnNum, tToken[2])
+                    tTemp = self._hFormatter.apply(self._fmtUnNum, tToken[2], tToken[1])
                 else:
                     self._hFormatter.incChapter()
-                    tTemp = self._hFormatter.apply(self._fmtChapter, tToken[2])
+                    tTemp = self._hFormatter.apply(self._fmtChapter, tToken[2], tToken[1])
 
                 # Format the chapter header
                 self._tokens[n] = (
-                    tToken[0], tToken[1], tTemp, None, tToken[4]
+                    tToken[0], tToken[1], tTemp, [], tToken[4]
                 )
 
                 # Set scene variables
@@ -693,32 +703,32 @@ class Tokenizer(ABC):
 
                 self._hFormatter.incScene()
 
-                tTemp = self._hFormatter.apply(self._fmtScene, tToken[2])
+                tTemp = self._hFormatter.apply(self._fmtScene, tToken[2], tToken[1])
                 if tTemp == "" and self._hideScene:
                     self._tokens[n] = (
-                        self.T_EMPTY, tToken[1], "", None, self.A_NONE
+                        self.T_EMPTY, tToken[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
+                            self.T_EMPTY, tToken[1], "", [], self.A_NONE
                         )
                     else:
                         self._tokens[n] = (
-                            self.T_SKIP, tToken[1], "", None, tToken[4]
+                            self.T_SKIP, tToken[1], "", [], tToken[4]
                         )
                 elif tTemp == self._fmtScene:
                     if self._firstScene:
                         self._tokens[n] = (
-                            self.T_EMPTY, tToken[1], "", None, self.A_NONE
+                            self.T_EMPTY, tToken[1], "", [], self.A_NONE
                         )
                     else:
                         self._tokens[n] = (
-                            self.T_SEP, tToken[1], tTemp, None, tToken[4] | self.A_CENTRE
+                            self.T_SEP, tToken[1], tTemp, [], tToken[4] | self.A_CENTRE
                         )
                 else:
                     self._tokens[n] = (
-                        tToken[0], tToken[1], tTemp, None, tToken[4]
+                        tToken[0], tToken[1], tTemp, [], tToken[4]
                     )
 
                 self._firstScene = False
@@ -726,22 +736,22 @@ class Tokenizer(ABC):
             elif tToken[0] == self.T_HEAD4:
                 # Section
 
-                tTemp = self._hFormatter.apply(self._fmtSection, tToken[2])
+                tTemp = self._hFormatter.apply(self._fmtSection, tToken[2], tToken[1])
                 if tTemp == "" and self._hideSection:
                     self._tokens[n] = (
-                        self.T_EMPTY, tToken[1], "", None, self.A_NONE
+                        self.T_EMPTY, tToken[1], "", [], self.A_NONE
                     )
                 elif tTemp == "" and not self._hideSection:
                     self._tokens[n] = (
-                        self.T_SKIP, tToken[1], "", None, tToken[4]
+                        self.T_SKIP, tToken[1], "", [], tToken[4]
                     )
                 elif tTemp == self._fmtSection:
                     self._tokens[n] = (
-                        self.T_SEP, tToken[1], tTemp, None, tToken[4] | self.A_CENTRE
+                        self.T_SEP, tToken[1], tTemp, [], tToken[4] | self.A_CENTRE
                     )
                 else:
                     self._tokens[n] = (
-                        tToken[0], tToken[1], tTemp, None, tToken[4]
+                        tToken[0], tToken[1], tTemp, [], tToken[4]
                     )
 
         return True
@@ -759,7 +769,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 +827,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
@@ -839,7 +854,7 @@ class HeadingFormatter:
         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 +870,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