novelWriter 2.1.1__py3-none-any.whl → 2.2rc1__py3-none-any.whl

novelwriter/core/toodt.py

@@ -27,10 +27,11 @@ along with this program. If not, see <https://www.gnu.org/licenses/>.
 from __future__ import annotations
 
 import logging
-from pathlib import Path
 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
 
@@ -82,11 +83,17 @@ TAG_STNM = _mkTag("text", "style-name")
 X_BLD = 0x01  # Bold format
 X_ITA = 0x02  # Italic format
 X_DEL = 0x04  # Strikethrough format
+X_UND = 0x08  # Underline format
+X_SUP = 0x10  # Superscript
+X_SUB = 0x20  # Subscript
 
 # Formatting Masks
 M_BLD = ~X_BLD
 M_ITA = ~X_ITA
 M_DEL = ~X_DEL
+M_UND = ~X_UND
+M_SUP = ~X_SUP
+M_SUB = ~X_SUB
 
 
 class ToOdt(Tokenizer):
@@ -188,7 +195,7 @@ class ToOdt(Tokenizer):
     #  Setters
     ##
 
-    def setLanguage(self, language: str) -> None:
+    def setLanguage(self, language: str | None) -> None:
         """Set language for the document."""
         if language:
             langBits = language.split("_")
@@ -385,18 +392,9 @@ class ToOdt(Tokenizer):
         """Convert the list of text tokens into XML elements."""
         self._result = ""  # Not used, but cleared just in case
 
-        odtTags = {
-            self.FMT_B_B: "_B",  # Bold open format
-            self.FMT_B_E: "b_",  # Bold close format
-            self.FMT_I_B: "I",   # Italic open format
-            self.FMT_I_E: "i",   # Italic close format
-            self.FMT_D_B: "_S",  # Strikethrough open format
-            self.FMT_D_E: "s_",  # Strikethrough close format
-        }
-
-        thisPar = []
-        thisFmt = []
-        parStyle = None
+        pFmt = []
+        pText = []
+        pStyle = None
         for tType, _, tText, tFormat, tStyle in self._tokens:
 
             # Styles
@@ -429,20 +427,22 @@ class ToOdt(Tokenizer):
 
             # Process Text Types
             if tType == self.T_EMPTY:
-                if len(thisPar) > 1 and parStyle is not None:
+                if len(pText) > 1 and pStyle is not None:
                     if self._doJustify:
-                        parStyle.setTextAlign("left")
+                        pStyle.setTextAlign("left")
 
-                if len(thisPar) > 0 and parStyle is not None:
-                    tTemp = "\n".join(thisPar)
-                    fTemp = " ".join(thisFmt)
-                    tTxt = tTemp.rstrip()
-                    tFmt = fTemp[:len(tTxt)]
-                    self._addTextPar("Text_20_body", parStyle, tTxt, tFmt=tFmt)
+                if len(pText) > 0 and pStyle is not None:
+                    tTxt = ""
+                    tFmt = []
+                    for nText, nFmt in zip(pText, pFmt):
+                        tLen = len(tTxt)
+                        tTxt += f"{nText}\n"
+                        tFmt.extend((p+tLen, fmt) for p, fmt in nFmt)
+                    self._addTextPar("Text_20_body", pStyle, tTxt.rstrip(), tFmt=tFmt)
 
-                thisPar = []
-                thisFmt = []
-                parStyle = None
+                pFmt = []
+                pText = []
+                pStyle = None
 
             elif tType == self.T_TITLE:
                 tHead = tText.replace(nwHeadFmt.BR, "\n")
@@ -475,20 +475,17 @@ class ToOdt(Tokenizer):
                 self._addTextPar("Separator", oStyle, "")
 
             elif tType == self.T_TEXT:
-                if parStyle is None:
-                    parStyle = oStyle
-
-                tFmt = " "*len(tText)
-                for xPos, xLen, xFmt in tFormat:
-                    tFmt = tFmt[:xPos] + odtTags[xFmt] + tFmt[xPos+xLen:]
-
-                tTxt = tText.rstrip()
-                tFmt = tFmt[:len(tTxt)]
-                thisPar.append(tTxt)
-                thisFmt.append(tFmt)
+                if pStyle is None:
+                    pStyle = oStyle
+                pText.append(tText)
+                pFmt.append(tFormat)
 
             elif tType == self.T_SYNOPSIS and self._doSynopsis:
-                tTemp, fTemp = self._formatSynopsis(tText)
+                tTemp, fTemp = self._formatSynopsis(tText, True)
+                self._addTextPar("Text_20_Meta", oStyle, tTemp, tFmt=fTemp)
+
+            elif tType == self.T_SHORT and self._doSynopsis:
+                tTemp, fTemp = self._formatSynopsis(tText, False)
                 self._addTextPar("Text_20_Meta", oStyle, tTemp, tFmt=fTemp)
 
             elif tType == self.T_COMMENT and self._doComments:
@@ -501,8 +498,8 @@ class ToOdt(Tokenizer):
 
         return
 
-    def closeDocument(self):
-        """Return the serialised XML document"""
+    def closeDocument(self) -> None:
+        """Pack the styles of the XML document."""
         # Build the auto-generated styles
         for styleName, styleObj in self._autoPara.values():
             styleObj.packXML(self._xAuto, styleName)
@@ -510,7 +507,7 @@ class ToOdt(Tokenizer):
             styleObj.packXML(self._xAuto, styleName)
         return
 
-    def saveFlatXML(self, path: str | Path):
+    def saveFlatXML(self, path: str | Path) -> None:
         """Save the data to an .fodt file."""
         with open(path, mode="wb") as fObj:
             xml = ET.ElementTree(self._dFlat)
@@ -519,7 +516,7 @@ class ToOdt(Tokenizer):
         logger.info("Wrote file: %s", path)
         return
 
-    def saveOpenDocText(self, path: str | Path):
+    def saveOpenDocText(self, path: str | Path) -> None:
         """Save the data to an .odt file."""
         mMani = _mkTag("manifest", "manifest")
         mVers = _mkTag("manifest", "version")
@@ -559,46 +556,42 @@ class ToOdt(Tokenizer):
     #  Internal Functions
     ##
 
-    def _formatSynopsis(self, text: str) -> tuple[str, str]:
+    def _formatSynopsis(self, text: str, synopsis: bool) -> tuple[str, list[tuple[int, int]]]:
         """Apply formatting to synopsis lines."""
-        sSynop = self._localLookup("Synopsis")
-        rTxt = "**{0}:** {1}".format(sSynop, text)
-        rFmt = "_B{0} b_ {1}".format(" "*len(sSynop), " "*len(text))
+        if synopsis:
+            name = self._localLookup("Synopsis")
+        else:
+            name = self._localLookup("Short Description")
+        rTxt = f"{name}: {text}"
+        rFmt = [(0, self.FMT_B_B), (len(name) + 1, self.FMT_B_E)]
         return rTxt, rFmt
 
-    def _formatComments(self, text: str) -> tuple[str, str]:
+    def _formatComments(self, text: str) -> tuple[str, list[tuple[int, int]]]:
         """Apply formatting to comments."""
-        sComm = self._localLookup("Comment")
-        rTxt = "**{0}:** {1}".format(sComm, text)
-        rFmt = "_B{0} b_ {1}".format(" "*len(sComm), " "*len(text))
+        name = self._localLookup("Comment")
+        rTxt = f"{name}: {text}"
+        rFmt = [(0, self.FMT_B_B), (len(name) + 1, self.FMT_B_E)]
         return rTxt, rFmt
 
-    def _formatKeywords(self, text: str) -> tuple[str, str]:
+    def _formatKeywords(self, text: str) -> tuple[str, list[tuple[int, int]]]:
         """Apply formatting to keywords."""
         valid, bits, _ = self._project.index.scanThis("@"+text)
-        if not valid or not bits:
-            return "", ""
-
-        rTxt = ""
-        rFmt = ""
-        if bits[0] in nwLabels.KEY_NAME:
-            text = nwLabels.KEY_NAME[bits[0]]
-            rTxt += "**{0}:** ".format(text)
-            rFmt += "_B{0} b_ ".format(" "*len(text))
-            if len(bits) > 1:
-                if bits[0] == nwKeyWords.TAG_KEY:
-                    rTxt += bits[1]
-                    rFmt += " "*len(bits[1])
-                else:
-                    tTags = ", ".join(bits[1:])
-                    rTxt += tTags
-                    rFmt += (" "*len(tTags))
+        if not valid or not bits or bits[0] not in nwLabels.KEY_NAME:
+            return "", []
+
+        rTxt = f"{self._localLookup(nwLabels.KEY_NAME[bits[0]])}: "
+        rFmt = [(0, self.FMT_B_B), (len(rTxt) - 1, self.FMT_B_E)]
+        if len(bits) > 1:
+            if bits[0] == nwKeyWords.TAG_KEY:
+                rTxt += bits[1]
+            else:
+                rTxt += ", ".join(bits[1:])
 
         return rTxt, rFmt
 
     def _addTextPar(
-        self, styleName: str, oStyle: ODTParagraphStyle, tText: str, tFmt: str = "",
-        isHead: bool = False, oLevel: str | None = None
+        self, styleName: str, oStyle: ODTParagraphStyle, tText: str,
+        tFmt: Sequence[tuple[int, int]] = [], isHead: bool = False, oLevel: str | None = None
     ) -> None:
         """Add a text paragraph to the text XML element."""
         tAttr = {}
@@ -616,58 +609,59 @@ class ToOdt(Tokenizer):
         if not tText:
             return
 
-        ##
-        #  Process Formatting
-        ##
-
-        if len(tText) != len(tFmt):
-            # Generate an empty format if there isn't any or it doesn't match
-            tFmt = " "*len(tText)
-
-        # The formatting loop
-        tTemp = ""
-        xFmt = 0x00
-        pFmt = 0x00
-        pErr = 0
+        # Loop Over Fragments
+        # ===================
 
         parProc = XMLParagraph(xElem)
 
-        for i, c in enumerate(tText):
+        pErr = 0
+        xFmt = 0x00
+        tFrag = ""
+        fLast = 0
+        for fPos, fFmt in tFmt:
+
+            # Add the text up to the current fragment
+            if tFrag := tText[fLast:fPos]:
+                if xFmt == 0x00:
+                    parProc.appendText(tFrag)
+                else:
+                    parProc.appendSpan(tFrag, self._textStyle(xFmt))
 
-            if tFmt[i] == " ":
-                tTemp += c
-            elif tFmt[i] == "_":
-                continue
-            elif tFmt[i] == "B":
+            # Calculate the change of format
+            if fFmt == self.FMT_B_B:
                 xFmt |= X_BLD
-            elif tFmt[i] == "b":
+            elif fFmt == self.FMT_B_E:
                 xFmt &= M_BLD
-            elif tFmt[i] == "I":
+            elif fFmt == self.FMT_I_B:
                 xFmt |= X_ITA
-            elif tFmt[i] == "i":
+            elif fFmt == self.FMT_I_E:
                 xFmt &= M_ITA
-            elif tFmt[i] == "S":
+            elif fFmt == self.FMT_D_B:
                 xFmt |= X_DEL
-            elif tFmt[i] == "s":
+            elif fFmt == self.FMT_D_E:
                 xFmt &= M_DEL
+            elif fFmt == self.FMT_U_B:
+                xFmt |= X_UND
+            elif fFmt == self.FMT_U_E:
+                xFmt &= M_UND
+            elif fFmt == self.FMT_SUP_B:
+                xFmt |= X_SUP
+            elif fFmt == self.FMT_SUP_E:
+                xFmt &= M_SUP
+            elif fFmt == self.FMT_SUB_B:
+                xFmt |= X_SUB
+            elif fFmt == self.FMT_SUB_E:
+                xFmt &= M_SUB
             else:
                 pErr += 1
 
-            if xFmt != pFmt:
-                if pFmt == 0x00:
-                    parProc.appendText(tTemp)
-                    tTemp = ""
-                else:
-                    parProc.appendSpan(tTemp, self._textStyle(pFmt))
-                    tTemp = ""
-
-            pFmt = xFmt
+            fLast = fPos
 
-        # Save what remains in the buffer
-        if pFmt == 0x00:
-            parProc.appendText(tTemp)
-        else:
-            parProc.appendSpan(tTemp, self._textStyle(pFmt))
+        if tFrag := tText[fLast:]:
+            if xFmt == 0x00:
+                parProc.appendText(tFrag)
+            else:
+                parProc.appendSpan(tFrag, self._textStyle(xFmt))
 
         if pErr > 0:
             self._errData.append("Unknown format tag encountered")
@@ -713,14 +707,22 @@ class ToOdt(Tokenizer):
         if hFmt & X_DEL:
             newStyle.setStrikeStyle("solid")
             newStyle.setStrikeType("single")
+        if hFmt & X_UND:
+            newStyle.setUnderlineStyle("solid")
+            newStyle.setUnderlineWidth("auto")
+            newStyle.setUnderlineColour("font-color")
+        if hFmt & X_SUP:
+            newStyle.setTextPosition("super")
+        if hFmt & X_SUB:
+            newStyle.setTextPosition("sub")
 
         self._autoText[hFmt] = (newName, newStyle)
 
         return newName
 
-    def _emToCm(self, emVal: float) -> str:
+    def _emToCm(self, value: float) -> str:
         """Converts an em value to centimetres."""
-        return f"{emVal*2.54/72*self._textSize:.3f}cm"
+        return f"{value*2.54/72*self._textSize:.3f}cm"
 
     ##
     #  Style Elements
@@ -1193,56 +1195,56 @@ class ODTParagraphStyle:
     #  Methods
     ##
 
-    def checkNew(self, refStyle: ODTParagraphStyle) -> bool:
+    def checkNew(self, style: ODTParagraphStyle) -> bool:
         """Check if there are new settings in refStyle that differ from
         those in the current object.
         """
-        for aName, (_, aVal) in refStyle._mAttr.items():
-            if aVal is not None and aVal != self._mAttr[aName][1]:
+        for name, (_, aVal) in style._mAttr.items():
+            if aVal is not None and aVal != self._mAttr[name][1]:
                 return True
-        for aName, (_, aVal) in refStyle._pAttr.items():
-            if aVal is not None and aVal != self._pAttr[aName][1]:
+        for name, (_, aVal) in style._pAttr.items():
+            if aVal is not None and aVal != self._pAttr[name][1]:
                 return True
-        for aName, (_, aVal) in refStyle._tAttr.items():
-            if aVal is not None and aVal != self._tAttr[aName][1]:
+        for name, (_, aVal) in style._tAttr.items():
+            if aVal is not None and aVal != self._tAttr[name][1]:
                 return True
         return False
 
     def getID(self) -> str:
         """Generate a unique ID from the settings."""
-        theString = (
+        string = (
             f"Paragraph:Main:{str(self._mAttr)}:"
             f"Paragraph:Para:{str(self._pAttr)}:"
             f"Paragraph:Text:{str(self._tAttr)}:"
         )
-        return sha256(theString.encode()).hexdigest()
+        return sha256(string.encode()).hexdigest()
 
     def packXML(self, xParent: ET.Element, name: str) -> None:
         """Pack the content into an xml element."""
-        theAttr = {}
-        theAttr[_mkTag("style", "name")] = name
-        theAttr[_mkTag("style", "family")] = "paragraph"
+        attr = {}
+        attr[_mkTag("style", "name")] = name
+        attr[_mkTag("style", "family")] = "paragraph"
         for aName, (aNm, aVal) in self._mAttr.items():
             if aVal is not None:
-                theAttr[_mkTag(aNm, aName)] = aVal
+                attr[_mkTag(aNm, aName)] = aVal
 
-        xEntry = ET.SubElement(xParent, _mkTag("style", "style"), attrib=theAttr)
+        xEntry = ET.SubElement(xParent, _mkTag("style", "style"), attrib=attr)
 
-        theAttr = {}
+        attr = {}
         for aName, (aNm, aVal) in self._pAttr.items():
             if aVal is not None:
-                theAttr[_mkTag(aNm, aName)] = aVal
+                attr[_mkTag(aNm, aName)] = aVal
 
-        if theAttr:
-            ET.SubElement(xEntry, _mkTag("style", "paragraph-properties"), attrib=theAttr)
+        if attr:
+            ET.SubElement(xEntry, _mkTag("style", "paragraph-properties"), attrib=attr)
 
-        theAttr = {}
+        attr = {}
         for aName, (aNm, aVal) in self._tAttr.items():
             if aVal is not None:
-                theAttr[_mkTag(aNm, aName)] = aVal
+                attr[_mkTag(aNm, aName)] = aVal
 
-        if theAttr:
-            ET.SubElement(xEntry, _mkTag("style", "text-properties"), attrib=theAttr)
+        if attr:
+            ET.SubElement(xEntry, _mkTag("style", "text-properties"), attrib=attr)
 
         return
 
@@ -1256,16 +1258,23 @@ class ODTTextStyle:
     """
     VALID_WEIGHT = ["normal", "inherit", "bold"]
     VALID_STYLE  = ["normal", "inherit", "italic"]
+    VALID_POS    = ["super", "sub"]
     VALID_LSTYLE = ["none", "solid"]
-    VALID_LTYPE  = ["none", "single", "double"]
+    VALID_LTYPE  = ["single", "double"]
+    VALID_LWIDTH = ["auto"]
+    VALID_LCOL   = ["font-color"]
 
     def __init__(self) -> None:
         # Text Attributes
         self._tAttr = {
             "font-weight":             ["fo",    None],
             "font-style":              ["fo",    None],
+            "text-position":           ["style", None],
             "text-line-through-style": ["style", None],
             "text-line-through-type":  ["style", None],
+            "text-underline-style":    ["style", None],
+            "text-underline-width":    ["style", None],
+            "text-underline-color":    ["style", None],
         }
         return
 
@@ -1287,6 +1296,13 @@ class ODTTextStyle:
             self._tAttr["font-style"][1] = None
         return
 
+    def setTextPosition(self, value: str | None) -> None:
+        if value in self.VALID_POS:
+            self._tAttr["text-position"][1] = f"{value} 58%"
+        else:
+            self._tAttr["text-position"][1] = None
+        return
+
     def setStrikeStyle(self, value: str | None) -> None:
         if value in self.VALID_LSTYLE:
             self._tAttr["text-line-through-style"][1] = value
@@ -1301,24 +1317,45 @@ class ODTTextStyle:
             self._tAttr["text-line-through-type"][1] = None
         return
 
+    def setUnderlineStyle(self, value: str | None) -> None:
+        if value in self.VALID_LSTYLE:
+            self._tAttr["text-underline-style"][1] = value
+        else:
+            self._tAttr["text-underline-style"][1] = None
+        return
+
+    def setUnderlineWidth(self, value: str | None) -> None:
+        if value in self.VALID_LWIDTH:
+            self._tAttr["text-underline-width"][1] = value
+        else:
+            self._tAttr["text-underline-width"][1] = None
+        return
+
+    def setUnderlineColour(self, value: str | None) -> None:
+        if value in self.VALID_LCOL:
+            self._tAttr["text-underline-color"][1] = value
+        else:
+            self._tAttr["text-underline-color"][1] = None
+        return
+
     ##
     #  Methods
     ##
 
     def packXML(self, xParent: ET.Element, name: str) -> None:
         """Pack the content into an xml element."""
-        theAttr = {}
-        theAttr[_mkTag("style", "name")] = name
-        theAttr[_mkTag("style", "family")] = "text"
-        xEntry = ET.SubElement(xParent, _mkTag("style", "style"), attrib=theAttr)
+        attr = {}
+        attr[_mkTag("style", "name")] = name
+        attr[_mkTag("style", "family")] = "text"
+        xEntry = ET.SubElement(xParent, _mkTag("style", "style"), attrib=attr)
 
-        theAttr = {}
+        attr = {}
         for aName, (aNm, aVal) in self._tAttr.items():
             if aVal is not None:
-                theAttr[_mkTag(aNm, aName)] = aVal
+                attr[_mkTag(aNm, aName)] = aVal
 
-        if theAttr:
-            ET.SubElement(xEntry, _mkTag("style", "text-properties"), attrib=theAttr)
+        if attr:
+            ET.SubElement(xEntry, _mkTag("style", "text-properties"), attrib=attr)
 
         return
 
@@ -1368,17 +1405,17 @@ class XMLParagraph:
 
         return
 
-    def appendText(self, tText: str) -> None:
+    def appendText(self, text: str) -> None:
         """Append text to the XML element. We do this one character at
         the time in order to be able to process line breaks, tabs and
         spaces separately. Multiple spaces are concatenated into a
         single tag, and must therefore be processed separately.
         """
-        tText = stripEscape(tText)
+        text = stripEscape(text)
         nSpaces = 0
-        self._rawTxt += tText
+        self._rawTxt += text
 
-        for c in tText:
+        for c in text:
             if c == " ":
                 nSpaces += 1
                 continue
@@ -1433,17 +1470,17 @@ class XMLParagraph:
 
         return
 
-    def appendSpan(self, tText: str, tFmt: str) -> None:
+    def appendSpan(self, text: str, fmt: str) -> None:
         """Append a text span to the XML element. The span is always
         closed since we do not allow nested spans (like Libre Office).
         Therefore we return to the root element level when we're done
         processing the text of the span.
         """
-        self._xTail = ET.SubElement(self._xRoot, TAG_SPAN, attrib={TAG_STNM: tFmt})
+        self._xTail = ET.SubElement(self._xRoot, TAG_SPAN, attrib={TAG_STNM: fmt})
         self._xTail.text = ""  # Defaults to None
         self._xTail.tail = ""  # Defaults to None
         self._nState = X_SPAN_TEXT
-        self.appendText(tText)
+        self.appendText(text)
         self._nState = X_ROOT_TAIL
         return