novelWriter 2.4.3__py3-none-any.whl → 2.5__py3-none-any.whl

novelwriter/core/toodt.py

@@ -29,17 +29,20 @@ from __future__ import annotations
 import logging
 import xml.etree.ElementTree as ET
 
+from collections.abc import Sequence
+from datetime import datetime
 from hashlib import sha256
 from pathlib import Path
 from zipfile import ZipFile
-from datetime import datetime
-from collections.abc import Sequence
+
+from PyQt5.QtGui import QFont
 
 from novelwriter import __version__
 from novelwriter.common import xmlIndent
 from novelwriter.constants import nwHeadFmt, nwKeyWords, nwLabels
 from novelwriter.core.project import NWProject
-from novelwriter.core.tokenizer import Tokenizer, stripEscape
+from novelwriter.core.tokenizer import T_Formats, Tokenizer, stripEscape
+from novelwriter.types import FONT_STYLE, FONT_WEIGHTS
 
 logger = logging.getLogger(__name__)
 
@@ -79,13 +82,15 @@ TAG_SPAN = _mkTag("text", "span")
 TAG_STNM = _mkTag("text", "style-name")
 
 # Formatting Codes
-X_BLD = 0x01  # Bold format
-X_ITA = 0x02  # Italic format
-X_DEL = 0x04  # Strikethrough format
-X_UND = 0x08  # Underline format
-X_MRK = 0x10  # Marked format
-X_SUP = 0x20  # Superscript
-X_SUB = 0x40  # Subscript
+X_BLD = 0x001  # Bold format
+X_ITA = 0x002  # Italic format
+X_DEL = 0x004  # Strikethrough format
+X_UND = 0x008  # Underline format
+X_MRK = 0x010  # Marked format
+X_SUP = 0x020  # Superscript
+X_SUB = 0x040  # Subscript
+X_DLG = 0x080  # Dialogue
+X_DLA = 0x100  # Alt. Dialogue
 
 # Formatting Masks
 M_BLD = ~X_BLD
@@ -95,6 +100,24 @@ M_UND = ~X_UND
 M_MRK = ~X_MRK
 M_SUP = ~X_SUP
 M_SUB = ~X_SUB
+M_DLG = ~X_DLG
+M_DLA = ~X_DLA
+
+# ODT Styles
+S_TITLE = "Title"
+S_HEAD1 = "Heading_20_1"
+S_HEAD2 = "Heading_20_2"
+S_HEAD3 = "Heading_20_3"
+S_HEAD4 = "Heading_20_4"
+S_SEP   = "Separator"
+S_FIND  = "First_20_line_20_indent"
+S_TEXT  = "Text_20_body"
+S_META  = "Text_20_Meta"
+S_HNF   = "Header_20_and_20_Footer"
+
+# Font Data
+FONT_WEIGHT_NUM = ["100", "200", "300", "400", "500", "600", "700", "800", "900"]
+FONT_WEIGHT_MAP = {"400": "normal", "700": "bold"}
 
 
 class ToOdt(Tokenizer):
@@ -130,20 +153,25 @@ class ToOdt(Tokenizer):
         self._autoPara: dict[str, ODTParagraphStyle] = {}  # Auto-generated paragraph styles
         self._autoText: dict[int, ODTTextStyle] = {}       # Auto-generated text styles
 
+        # Footnotes
+        self._nNote = 0
+        self._etNotes: dict[str, ET.Element] = {}  # Generated note elements
+
         self._errData = []  # List of errors encountered
 
         # Properties
-        self._textFont     = "Liberation Serif"
-        self._textSize     = 12
-        self._textFixed    = False
+        self._textFont     = QFont("Liberation Serif", 12)
         self._colourHead   = False
-        self._firstIndent  = False
         self._headerFormat = ""
         self._pageOffset   = 0
 
         # Internal
-        self._fontFamily   = "'Liberation Serif'"
+        self._fontFamily   = "Liberation Serif"
+        self._fontSize     = 12
+        self._fontWeight   = "normal"
+        self._fontStyle    = "normal"
         self._fontPitch    = "variable"
+        self._fontBold     = "bold"
         self._fSizeTitle   = "30pt"
         self._fSizeHead1   = "24pt"
         self._fSizeHead2   = "20pt"
@@ -151,6 +179,7 @@ class ToOdt(Tokenizer):
         self._fSizeHead4   = "14pt"
         self._fSizeHead    = "14pt"
         self._fSizeText    = "12pt"
+        self._fSizeFoot    = "10pt"
         self._fLineHeight  = "115%"
         self._fBlockIndent = "1.693cm"
         self._fTextIndent  = "0.499cm"
@@ -167,6 +196,7 @@ class ToOdt(Tokenizer):
         self._mTopHead  = "0.423cm"
         self._mTopText  = "0.000cm"
         self._mTopMeta  = "0.000cm"
+        self._mTopSep   = "0.247cm"
 
         self._mBotTitle = "0.212cm"
         self._mBotHead1 = "0.212cm"
@@ -176,6 +206,10 @@ class ToOdt(Tokenizer):
         self._mBotHead  = "0.212cm"
         self._mBotText  = "0.247cm"
         self._mBotMeta  = "0.106cm"
+        self._mBotSep   = "0.247cm"
+
+        self._mBotFoot  = "0.106cm"
+        self._mLeftFoot = "0.600cm"
 
         # Document Size and Margins
         self._mDocWidth  = "21.0cm"
@@ -186,13 +220,15 @@ class ToOdt(Tokenizer):
         self._mDocRight  = "2.000cm"
 
         # Colour
-        self._colHead12 = None
-        self._opaHead12 = None
-        self._colHead34 = None
-        self._opaHead34 = None
-        self._colMetaTx = None
-        self._opaMetaTx = None
-        self._markText  = "#ffffa6"
+        self._colHead12  = None
+        self._opaHead12  = None
+        self._colHead34  = None
+        self._opaHead34  = None
+        self._colMetaTx  = None
+        self._opaMetaTx  = None
+        self._colDialogM = None
+        self._colDialogA = None
+        self._markText   = "#ffffa6"
 
         return
 
@@ -232,11 +268,6 @@ class ToOdt(Tokenizer):
         self._pageOffset = offset
         return
 
-    def setFirstLineIndent(self, state: bool) -> None:
-        """Enable or disable first line indent."""
-        self._firstIndent = state
-        return
-
     ##
     #  Class Methods
     ##
@@ -246,18 +277,25 @@ class ToOdt(Tokenizer):
         # Initialise Variables
         # ====================
 
-        self._fontFamily = self._textFont
-        if len(self._textFont.split()) > 1:
-            self._fontFamily = f"'{self._textFont}'"
-        self._fontPitch = "fixed" if self._textFixed else "variable"
-
-        self._fSizeTitle = f"{round(2.50 * self._textSize):d}pt"
-        self._fSizeHead1 = f"{round(2.00 * self._textSize):d}pt"
-        self._fSizeHead2 = f"{round(1.60 * self._textSize):d}pt"
-        self._fSizeHead3 = f"{round(1.30 * self._textSize):d}pt"
-        self._fSizeHead4 = f"{round(1.15 * self._textSize):d}pt"
-        self._fSizeHead  = f"{round(1.15 * self._textSize):d}pt"
-        self._fSizeText  = f"{self._textSize:d}pt"
+        intWeight = FONT_WEIGHTS.get(self._textFont.weight(), 400)
+        fontWeight = str(intWeight)
+        fontBold = str(min(intWeight + 300, 900))
+
+        self._fontFamily = self._textFont.family()
+        self._fontSize   = self._textFont.pointSize()
+        self._fontWeight = FONT_WEIGHT_MAP.get(fontWeight, fontWeight)
+        self._fontStyle  = FONT_STYLE.get(self._textFont.style(), "normal")
+        self._fontPitch  = "fixed" if self._textFont.fixedPitch() else "variable"
+        self._fontBold   = FONT_WEIGHT_MAP.get(fontBold, fontBold)
+
+        self._fSizeTitle = f"{round(2.50 * self._fontSize):d}pt"
+        self._fSizeHead1 = f"{round(2.00 * self._fontSize):d}pt"
+        self._fSizeHead2 = f"{round(1.60 * self._fontSize):d}pt"
+        self._fSizeHead3 = f"{round(1.30 * self._fontSize):d}pt"
+        self._fSizeHead4 = f"{round(1.15 * self._fontSize):d}pt"
+        self._fSizeHead  = f"{round(1.15 * self._fontSize):d}pt"
+        self._fSizeText  = f"{self._fontSize:d}pt"
+        self._fSizeFoot  = f"{round(0.8*self._fontSize):d}pt"
 
         mScale = self._lineHeight/1.15
 
@@ -269,6 +307,7 @@ class ToOdt(Tokenizer):
         self._mTopHead  = self._emToCm(mScale * self._marginHead4[0])
         self._mTopText  = self._emToCm(mScale * self._marginText[0])
         self._mTopMeta  = self._emToCm(mScale * self._marginMeta[0])
+        self._mTopSep   = self._emToCm(mScale * self._marginSep[0])
 
         self._mBotTitle = self._emToCm(mScale * self._marginTitle[1])
         self._mBotHead1 = self._emToCm(mScale * self._marginHead1[1])
@@ -278,6 +317,10 @@ class ToOdt(Tokenizer):
         self._mBotHead  = self._emToCm(mScale * self._marginHead4[1])
         self._mBotText  = self._emToCm(mScale * self._marginText[1])
         self._mBotMeta  = self._emToCm(mScale * self._marginMeta[1])
+        self._mBotSep   = self._emToCm(mScale * self._marginSep[1])
+
+        self._mLeftFoot = self._emToCm(self._marginFoot[0])
+        self._mBotFoot  = self._emToCm(self._marginFoot[1])
 
         if self._colourHead:
             self._colHead12 = "#2a6099"
@@ -287,8 +330,13 @@ class ToOdt(Tokenizer):
             self._colMetaTx = "#813709"
             self._opaMetaTx = "100%"
 
+        if self._showDialog:
+            self._colDialogM = "#2a6099"
+            self._colDialogA = "#813709"
+
         self._fLineHeight  = f"{round(100 * self._lineHeight):d}%"
         self._fBlockIndent = self._emToCm(self._blockIndent)
+        self._fTextIndent  = self._emToCm(self._firstWidth)
         self._textAlign    = "justify" if self._doJustify else "left"
 
         # Clear Errors
@@ -301,7 +349,7 @@ class ToOdt(Tokenizer):
         tAttr[_mkTag("office", "version")] = X_VERS
 
         fAttr = {}
-        fAttr[_mkTag("style", "name")] = self._textFont
+        fAttr[_mkTag("style", "name")] = self._fontFamily
         fAttr[_mkTag("style", "font-pitch")] = self._fontPitch
 
         if self._isFlat:
@@ -399,10 +447,7 @@ class ToOdt(Tokenizer):
         """Convert the list of text tokens into XML elements."""
         self._result = ""  # Not used, but cleared just in case
 
-        pFmt = []
-        pText = []
-        pStyle = None
-        pIndent = True
+        xText = self._xText
         for tType, _, tText, tFormat, tStyle in self._tokens:
 
             # Styles
@@ -419,7 +464,6 @@ class ToOdt(Tokenizer):
 
                 if tStyle & self.A_PBB:
                     oStyle.setBreakBefore("page")
-
                 if tStyle & self.A_PBA:
                     oStyle.setBreakAfter("page")
 
@@ -433,82 +477,57 @@ class ToOdt(Tokenizer):
                 if tStyle & self.A_IND_R:
                     oStyle.setMarginRight(self._fBlockIndent)
 
-            if tType not in (self.T_EMPTY, self.T_TEXT):
-                pIndent = False
-
             # Process Text Types
-            if tType == self.T_EMPTY:
-                if len(pText) > 1 and pStyle is not None:
-                    if self._doJustify:
-                        pStyle.setTextAlign("left")
-
-                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)
-
-                    # Don't indent a paragraph if it has alignment set
-                    tIndent = self._firstIndent and pIndent and pStyle.isUnaligned()
-                    self._addTextPar(
-                        "First_20_line_20_indent" if tIndent else "Text_20_body",
-                        pStyle, tTxt.rstrip(), tFmt=tFmt
-                    )
-                    pIndent = True
-
-                pFmt = []
-                pText = []
-                pStyle = None
+            if tType == self.T_TEXT:
+                # Text indentation is processed here because there is a
+                # dedicated pre-defined style for it
+                if tStyle & self.A_IND_T:
+                    self._addTextPar(xText, S_FIND, oStyle, tText, tFmt=tFormat)
+                else:
+                    self._addTextPar(xText, S_TEXT, oStyle, tText, tFmt=tFormat)
 
             elif tType == self.T_TITLE:
+                # Title must be text:p
                 tHead = tText.replace(nwHeadFmt.BR, "\n")
-                self._addTextPar("Title", oStyle, tHead, isHead=False)  # Title must be text:p
+                self._addTextPar(xText, S_TITLE, oStyle, tHead, isHead=False)
 
             elif tType == self.T_HEAD1:
                 tHead = tText.replace(nwHeadFmt.BR, "\n")
-                self._addTextPar("Heading_20_1", oStyle, tHead, isHead=True, oLevel="1")
+                self._addTextPar(xText, S_HEAD1, oStyle, tHead, isHead=True, oLevel="1")
 
             elif tType == self.T_HEAD2:
                 tHead = tText.replace(nwHeadFmt.BR, "\n")
-                self._addTextPar("Heading_20_2", oStyle, tHead, isHead=True, oLevel="2")
+                self._addTextPar(xText, S_HEAD2, oStyle, tHead, isHead=True, oLevel="2")
 
             elif tType == self.T_HEAD3:
                 tHead = tText.replace(nwHeadFmt.BR, "\n")
-                self._addTextPar("Heading_20_3", oStyle, tHead, isHead=True, oLevel="3")
+                self._addTextPar(xText, S_HEAD3, oStyle, tHead, isHead=True, oLevel="3")
 
             elif tType == self.T_HEAD4:
                 tHead = tText.replace(nwHeadFmt.BR, "\n")
-                self._addTextPar("Heading_20_4", oStyle, tHead, isHead=True, oLevel="4")
+                self._addTextPar(xText, S_HEAD4, oStyle, tHead, isHead=True, oLevel="4")
 
             elif tType == self.T_SEP:
-                self._addTextPar("Separator", oStyle, tText)
+                self._addTextPar(xText, S_SEP, oStyle, tText)
 
             elif tType == self.T_SKIP:
-                self._addTextPar("Separator", oStyle, "")
-
-            elif tType == self.T_TEXT:
-                if pStyle is None:
-                    pStyle = oStyle
-                pText.append(tText)
-                pFmt.append(tFormat)
+                self._addTextPar(xText, S_TEXT, oStyle, "")
 
             elif tType == self.T_SYNOPSIS and self._doSynopsis:
-                tTemp, fTemp = self._formatSynopsis(tText, True)
-                self._addTextPar("Text_20_Meta", oStyle, tTemp, tFmt=fTemp)
+                tTemp, tFmt = self._formatSynopsis(tText, tFormat, True)
+                self._addTextPar(xText, S_META, oStyle, tTemp, tFmt=tFmt)
 
             elif tType == self.T_SHORT and self._doSynopsis:
-                tTemp, fTemp = self._formatSynopsis(tText, False)
-                self._addTextPar("Text_20_Meta", oStyle, tTemp, tFmt=fTemp)
+                tTemp, tFmt = self._formatSynopsis(tText, tFormat, False)
+                self._addTextPar(xText, S_META, oStyle, tTemp, tFmt=tFmt)
 
             elif tType == self.T_COMMENT and self._doComments:
-                tTemp, fTemp = self._formatComments(tText)
-                self._addTextPar("Text_20_Meta", oStyle, tTemp, tFmt=fTemp)
+                tTemp, tFmt = self._formatComments(tText, tFormat)
+                self._addTextPar(xText, S_META, oStyle, tTemp, tFmt=tFmt)
 
             elif tType == self.T_KEYWORD and self._doKeywords:
-                tTemp, fTemp = self._formatKeywords(tText)
-                self._addTextPar("Text_20_Meta", oStyle, tTemp, tFmt=fTemp)
+                tTemp, tFmt = self._formatKeywords(tText)
+                self._addTextPar(xText, S_META, oStyle, tTemp, tFmt=tFmt)
 
         return
 
@@ -569,28 +588,32 @@ class ToOdt(Tokenizer):
     #  Internal Functions
     ##
 
-    def _formatSynopsis(self, text: str, synopsis: bool) -> tuple[str, list[tuple[int, int]]]:
+    def _formatSynopsis(self, text: str, fmt: T_Formats, synopsis: bool) -> tuple[str, T_Formats]:
         """Apply formatting to synopsis lines."""
         name = self._localLookup("Synopsis" if synopsis else "Short Description")
+        shift = len(name) + 2
         rTxt = f"{name}: {text}"
-        rFmt = [(0, self.FMT_B_B), (len(name) + 1, self.FMT_B_E)]
+        rFmt: T_Formats = [(0, self.FMT_B_B, ""), (len(name) + 1, self.FMT_B_E, "")]
+        rFmt.extend((p + shift, f, d) for p, f, d in fmt)
         return rTxt, rFmt
 
-    def _formatComments(self, text: str) -> tuple[str, list[tuple[int, int]]]:
+    def _formatComments(self, text: str, fmt: T_Formats) -> tuple[str, T_Formats]:
         """Apply formatting to comments."""
         name = self._localLookup("Comment")
+        shift = len(name) + 2
         rTxt = f"{name}: {text}"
-        rFmt = [(0, self.FMT_B_B), (len(name) + 1, self.FMT_B_E)]
+        rFmt: T_Formats = [(0, self.FMT_B_B, ""), (len(name) + 1, self.FMT_B_E, "")]
+        rFmt.extend((p + shift, f, d) for p, f, d in fmt)
         return rTxt, rFmt
 
-    def _formatKeywords(self, text: str) -> tuple[str, list[tuple[int, int]]]:
+    def _formatKeywords(self, text: str) -> tuple[str, T_Formats]:
         """Apply formatting to keywords."""
         valid, bits, _ = self._project.index.scanThis("@"+text)
         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)]
+        rFmt: T_Formats = [(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]
@@ -600,8 +623,8 @@ class ToOdt(Tokenizer):
         return rTxt, rFmt
 
     def _addTextPar(
-        self, styleName: str, oStyle: ODTParagraphStyle, tText: str,
-        tFmt: Sequence[tuple[int, int]] = [], isHead: bool = False, oLevel: str | None = None
+        self, xParent: ET.Element, styleName: str, oStyle: ODTParagraphStyle, tText: str,
+        tFmt: Sequence[tuple[int, int, str]] = [], isHead: bool = False, oLevel: str | None = None
     ) -> None:
         """Add a text paragraph to the text XML element."""
         tAttr = {_mkTag("text", "style-name"): self._paraStyle(styleName, oStyle)}
@@ -609,7 +632,7 @@ class ToOdt(Tokenizer):
             tAttr[_mkTag("text", "outline-level")] = oLevel
 
         pTag = "h" if isHead else "p"
-        xElem = ET.SubElement(self._xText, _mkTag("text", pTag), attrib=tAttr)
+        xElem = ET.SubElement(xParent, _mkTag("text", pTag), attrib=tAttr)
 
         # It's important to set the initial text field to empty, otherwise
         # xmlIndent will add a line break if the first subelement is a span.
@@ -627,7 +650,13 @@ class ToOdt(Tokenizer):
         xFmt = 0x00
         tFrag = ""
         fLast = 0
-        for fPos, fFmt in tFmt:
+        xNode = None
+        for fPos, fFmt, fData in tFmt:
+
+            # Add any extra nodes
+            if xNode is not None:
+                parProc.appendNode(xNode)
+                xNode = None
 
             # Add the text up to the current fragment
             if tFrag := tText[fLast:fPos]:
@@ -665,11 +694,26 @@ class ToOdt(Tokenizer):
                 xFmt |= X_SUB
             elif fFmt == self.FMT_SUB_E:
                 xFmt &= M_SUB
+            elif fFmt == self.FMT_DL_B:
+                xFmt |= X_DLG
+            elif fFmt == self.FMT_DL_E:
+                xFmt &= M_DLG
+            elif fFmt == self.FMT_ADL_B:
+                xFmt |= X_DLA
+            elif fFmt == self.FMT_ADL_E:
+                xFmt &= M_DLA
+            elif fFmt == self.FMT_FNOTE:
+                xNode = self._generateFootnote(fData)
+            elif fFmt == self.FMT_STRIP:
+                pass
             else:
                 pErr += 1
 
             fLast = fPos
 
+        if xNode is not None:
+            parProc.appendNode(xNode)
+
         if tFrag := tText[fLast:]:
             if xFmt == 0x00:
                 parProc.appendText(tFrag)
@@ -715,7 +759,7 @@ class ToOdt(Tokenizer):
 
         style = ODTTextStyle(f"T{len(self._autoText)+1:d}")
         if hFmt & X_BLD:
-            style.setFontWeight("bold")
+            style.setFontWeight(self._fontBold)
         if hFmt & X_ITA:
             style.setFontStyle("italic")
         if hFmt & X_DEL:
@@ -731,13 +775,33 @@ class ToOdt(Tokenizer):
             style.setTextPosition("super")
         if hFmt & X_SUB:
             style.setTextPosition("sub")
+        if hFmt & X_DLG:
+            style.setColour(self._colDialogM)
+        if hFmt & X_DLA:
+            style.setColour(self._colDialogA)
         self._autoText[hFmt] = style
 
         return style.name
 
+    def _generateFootnote(self, key: str) -> ET.Element | None:
+        """Generate a footnote XML object."""
+        if content := self._footnotes.get(key):
+            self._nNote += 1
+            nStyle = ODTParagraphStyle("New")
+            xNote = ET.Element(_mkTag("text", "note"), attrib={
+                _mkTag("text", "id"): f"ftn{self._nNote}",
+                _mkTag("text", "note-class"): "footnote",
+            })
+            xCite = ET.SubElement(xNote, _mkTag("text", "note-citation"))
+            xCite.text = str(self._nNote)
+            xBody = ET.SubElement(xNote, _mkTag("text", "note-body"))
+            self._addTextPar(xBody, "Footnote", nStyle, content[0], tFmt=content[1])
+            return xNote
+        return None
+
     def _emToCm(self, value: float) -> str:
         """Converts an em value to centimetres."""
-        return f"{value*2.54/72*self._textSize:.3f}cm"
+        return f"{value*2.54/72*self._fontSize:.3f}cm"
 
     ##
     #  Style Elements
@@ -757,7 +821,6 @@ class ToOdt(Tokenizer):
             _mkTag("fo", "margin-bottom"): self._mDocBtm,
             _mkTag("fo", "margin-left"): self._mDocLeft,
             _mkTag("fo", "margin-right"): self._mDocRight,
-            _mkTag("fo", "print-orientation"): "portrait",
         })
 
         xHead = ET.SubElement(xPage, _mkTag("style", "header-style"))
@@ -782,8 +845,10 @@ class ToOdt(Tokenizer):
             _mkTag("style", "writing-mode"): "page",
         })
         ET.SubElement(xStyl, _mkTag("style", "text-properties"), attrib={
-            _mkTag("style", "font-name"): self._textFont,
+            _mkTag("style", "font-name"): self._fontFamily,
             _mkTag("fo", "font-family"): self._fontFamily,
+            _mkTag("fo", "font-weight"): self._fontWeight,
+            _mkTag("fo", "font-style"): self._fontStyle,
             _mkTag("fo", "font-size"): self._fSizeText,
             _mkTag("fo", "language"): self._dLanguage,
             _mkTag("fo", "country"): self._dCountry,
@@ -796,8 +861,10 @@ class ToOdt(Tokenizer):
             _mkTag("style", "class"): "text",
         })
         ET.SubElement(xStyl, _mkTag("style", "text-properties"), attrib={
-            _mkTag("style", "font-name"): self._textFont,
+            _mkTag("style", "font-name"): self._fontFamily,
             _mkTag("fo", "font-family"): self._fontFamily,
+            _mkTag("fo", "font-weight"): self._fontWeight,
+            _mkTag("fo", "font-style"): self._fontStyle,
             _mkTag("fo", "font-size"): self._fSizeText,
         })
 
@@ -806,7 +873,7 @@ class ToOdt(Tokenizer):
             _mkTag("style", "name"): "Heading",
             _mkTag("style", "family"): "paragraph",
             _mkTag("style", "parent-style-name"): "Standard",
-            _mkTag("style", "next-style-name"): "Text_20_body",
+            _mkTag("style", "next-style-name"): S_TEXT,
             _mkTag("style", "class"): "text",
         })
         ET.SubElement(xStyl, _mkTag("style", "paragraph-properties"), attrib={
@@ -815,14 +882,16 @@ class ToOdt(Tokenizer):
             _mkTag("fo", "keep-with-next"): "always",
         })
         ET.SubElement(xStyl, _mkTag("style", "text-properties"), attrib={
-            _mkTag("style", "font-name"): self._textFont,
+            _mkTag("style", "font-name"): self._fontFamily,
             _mkTag("fo", "font-family"): self._fontFamily,
+            _mkTag("fo", "font-weight"): self._fontWeight,
+            _mkTag("fo", "font-style"): self._fontStyle,
             _mkTag("fo", "font-size"): self._fSizeHead,
         })
 
         # Add Header and Footer Styles
         ET.SubElement(self._xStyl, _mkTag("style", "style"), attrib={
-            _mkTag("style", "name"): "Header_20_and_20_Footer",
+            _mkTag("style", "name"): S_HNF,
             _mkTag("style", "display-name"): "Header and Footer",
             _mkTag("style", "family"): "paragraph",
             _mkTag("style", "parent-style-name"): "Standard",
@@ -834,7 +903,7 @@ class ToOdt(Tokenizer):
     def _useableStyles(self) -> None:
         """Set the usable styles."""
         # Add Text Body Style
-        style = ODTParagraphStyle("Text_20_body")
+        style = ODTParagraphStyle(S_TEXT)
         style.setDisplayName("Text body")
         style.setParentStyleName("Standard")
         style.setClass("text")
@@ -842,136 +911,139 @@ class ToOdt(Tokenizer):
         style.setMarginBottom(self._mBotText)
         style.setLineHeight(self._fLineHeight)
         style.setTextAlign(self._textAlign)
-        style.setFontName(self._textFont)
+        style.setFontName(self._fontFamily)
         style.setFontFamily(self._fontFamily)
         style.setFontSize(self._fSizeText)
+        style.setFontWeight(self._fontWeight)
         style.packXML(self._xStyl)
         self._mainPara[style.name] = style
 
         # Add First Line Indent Style
-        style = ODTParagraphStyle("First_20_line_20_indent")
+        style = ODTParagraphStyle(S_FIND)
         style.setDisplayName("First line indent")
-        style.setParentStyleName("Text_20_body")
+        style.setParentStyleName(S_TEXT)
         style.setClass("text")
         style.setTextIndent(self._fTextIndent)
         style.packXML(self._xStyl)
         self._mainPara[style.name] = style
 
         # Add Text Meta Style
-        style = ODTParagraphStyle("Text_20_Meta")
+        style = ODTParagraphStyle(S_META)
         style.setDisplayName("Text Meta")
         style.setParentStyleName("Standard")
         style.setClass("text")
         style.setMarginTop(self._mTopMeta)
         style.setMarginBottom(self._mBotMeta)
         style.setLineHeight(self._fLineHeight)
-        style.setFontName(self._textFont)
+        style.setFontName(self._fontFamily)
         style.setFontFamily(self._fontFamily)
         style.setFontSize(self._fSizeText)
+        style.setFontWeight(self._fontWeight)
         style.setColour(self._colMetaTx)
         style.setOpacity(self._opaMetaTx)
         style.packXML(self._xStyl)
         self._mainPara[style.name] = style
 
         # Add Title Style
-        style = ODTParagraphStyle("Title")
+        style = ODTParagraphStyle(S_TITLE)
         style.setDisplayName("Title")
         style.setParentStyleName("Heading")
-        style.setNextStyleName("Text_20_body")
+        style.setNextStyleName(S_TEXT)
         style.setClass("chapter")
         style.setMarginTop(self._mTopTitle)
         style.setMarginBottom(self._mBotTitle)
         style.setTextAlign("center")
-        style.setFontName(self._textFont)
+        style.setFontName(self._fontFamily)
         style.setFontFamily(self._fontFamily)
         style.setFontSize(self._fSizeTitle)
-        style.setFontWeight("bold")
+        style.setFontWeight(self._fontBold)
         style.packXML(self._xStyl)
         self._mainPara[style.name] = style
 
         # Add Separator Style
-        style = ODTParagraphStyle("Separator")
+        style = ODTParagraphStyle(S_SEP)
         style.setDisplayName("Separator")
         style.setParentStyleName("Standard")
-        style.setNextStyleName("Text_20_body")
+        style.setNextStyleName(S_TEXT)
         style.setClass("text")
-        style.setMarginTop(self._mTopText)
-        style.setMarginBottom(self._mBotText)
+        style.setMarginTop(self._mTopSep)
+        style.setMarginBottom(self._mBotSep)
         style.setLineHeight(self._fLineHeight)
         style.setTextAlign("center")
-        style.setFontName(self._textFont)
+        style.setFontName(self._fontFamily)
         style.setFontFamily(self._fontFamily)
         style.setFontSize(self._fSizeText)
+        style.setFontWeight(self._fontWeight)
         style.packXML(self._xStyl)
         self._mainPara[style.name] = style
 
         # Add Heading 1 Style
-        style = ODTParagraphStyle("Heading_20_1")
+        style = ODTParagraphStyle(S_HEAD1)
         style.setDisplayName("Heading 1")
         style.setParentStyleName("Heading")
-        style.setNextStyleName("Text_20_body")
+        style.setNextStyleName(S_TEXT)
         style.setOutlineLevel("1")
         style.setClass("text")
         style.setMarginTop(self._mTopHead1)
         style.setMarginBottom(self._mBotHead1)
-        style.setFontName(self._textFont)
+        style.setFontName(self._fontFamily)
         style.setFontFamily(self._fontFamily)
         style.setFontSize(self._fSizeHead1)
-        style.setFontWeight("bold")
+        style.setFontWeight(self._fontBold)
         style.setColour(self._colHead12)
         style.setOpacity(self._opaHead12)
         style.packXML(self._xStyl)
         self._mainPara[style.name] = style
 
         # Add Heading 2 Style
-        style = ODTParagraphStyle("Heading_20_2")
+        style = ODTParagraphStyle(S_HEAD2)
         style.setDisplayName("Heading 2")
         style.setParentStyleName("Heading")
-        style.setNextStyleName("Text_20_body")
+        style.setNextStyleName(S_TEXT)
         style.setOutlineLevel("2")
         style.setClass("text")
         style.setMarginTop(self._mTopHead2)
         style.setMarginBottom(self._mBotHead2)
-        style.setFontName(self._textFont)
+        style.setFontName(self._fontFamily)
         style.setFontFamily(self._fontFamily)
         style.setFontSize(self._fSizeHead2)
-        style.setFontWeight("bold")
+        style.setFontWeight(self._fontBold)
         style.setColour(self._colHead12)
         style.setOpacity(self._opaHead12)
         style.packXML(self._xStyl)
         self._mainPara[style.name] = style
 
         # Add Heading 3 Style
-        style = ODTParagraphStyle("Heading_20_3")
+        style = ODTParagraphStyle(S_HEAD3)
         style.setDisplayName("Heading 3")
         style.setParentStyleName("Heading")
-        style.setNextStyleName("Text_20_body")
+        style.setNextStyleName(S_TEXT)
         style.setOutlineLevel("3")
         style.setClass("text")
         style.setMarginTop(self._mTopHead3)
         style.setMarginBottom(self._mBotHead3)
-        style.setFontName(self._textFont)
+        style.setFontName(self._fontFamily)
         style.setFontFamily(self._fontFamily)
         style.setFontSize(self._fSizeHead3)
-        style.setFontWeight("bold")
+        style.setFontWeight(self._fontBold)
         style.setColour(self._colHead34)
         style.setOpacity(self._opaHead34)
         style.packXML(self._xStyl)
         self._mainPara[style.name] = style
 
         # Add Heading 4 Style
-        style = ODTParagraphStyle("Heading_20_4")
+        style = ODTParagraphStyle(S_HEAD4)
         style.setDisplayName("Heading 4")
         style.setParentStyleName("Heading")
-        style.setNextStyleName("Text_20_body")
+        style.setNextStyleName(S_TEXT)
         style.setOutlineLevel("4")
         style.setClass("text")
         style.setMarginTop(self._mTopHead4)
         style.setMarginBottom(self._mBotHead4)
-        style.setFontName(self._textFont)
+        style.setFontName(self._fontFamily)
         style.setFontFamily(self._fontFamily)
         style.setFontSize(self._fSizeHead4)
-        style.setFontWeight("bold")
+        style.setFontWeight(self._fontBold)
         style.setColour(self._colHead34)
         style.setOpacity(self._opaHead34)
         style.packXML(self._xStyl)
@@ -980,11 +1052,23 @@ class ToOdt(Tokenizer):
         # Add Header Style
         style = ODTParagraphStyle("Header")
         style.setDisplayName("Header")
-        style.setParentStyleName("Header_20_and_20_Footer")
+        style.setParentStyleName(S_HNF)
         style.setTextAlign("right")
         style.packXML(self._xStyl)
         self._mainPara[style.name] = style
 
+        # Add Footnote Style
+        style = ODTParagraphStyle("Footnote")
+        style.setDisplayName("Footnote")
+        style.setParentStyleName("Standard")
+        style.setClass("extra")
+        style.setMarginLeft(self._mLeftFoot)
+        style.setMarginBottom(self._mBotFoot)
+        style.setTextIndent("-"+self._mLeftFoot)
+        style.setFontSize(self._fSizeFoot)
+        style.packXML(self._xStyl)
+        self._mainPara[style.name] = style
+
         return
 
     def _writeHeader(self) -> None:
@@ -1026,12 +1110,9 @@ class ToOdt(Tokenizer):
 
         return
 
-# END Class ToOdt
-
 
-# =============================================================================================== #
-#  Auto-Style Classes
-# =============================================================================================== #
+# Auto-Style Classes
+# ==================
 
 class ODTParagraphStyle:
     """Wrapper class for the paragraph style setting used by the
@@ -1041,8 +1122,8 @@ class ODTParagraphStyle:
     VALID_ALIGN  = ["start", "center", "end", "justify", "inside", "outside", "left", "right"]
     VALID_BREAK  = ["auto", "column", "page", "even-page", "odd-page", "inherit"]
     VALID_LEVEL  = ["1", "2", "3", "4"]
-    VALID_CLASS  = ["text", "chapter"]
-    VALID_WEIGHT = ["normal", "inherit", "bold"]
+    VALID_CLASS  = ["text", "chapter", "extra"]
+    VALID_WEIGHT = ["normal", "bold"] + FONT_WEIGHT_NUM
 
     def __init__(self, name: str) -> None:
 
@@ -1279,16 +1360,14 @@ class ODTParagraphStyle:
 
         return
 
-# END Class ODTParagraphStyle
-
 
 class ODTTextStyle:
     """Wrapper class for the text style setting used by the exporter.
     Only the used settings are exposed here to keep the class minimal
     and fast.
     """
-    VALID_WEIGHT = ["normal", "inherit", "bold"]
-    VALID_STYLE  = ["normal", "inherit", "italic"]
+    VALID_WEIGHT = ["normal", "bold"] + FONT_WEIGHT_NUM
+    VALID_STYLE  = ["normal", "italic", "oblique"]
     VALID_POS    = ["super", "sub"]
     VALID_LSTYLE = ["none", "solid"]
     VALID_LTYPE  = ["single", "double"]
@@ -1300,6 +1379,7 @@ class ODTTextStyle:
         self._tAttr = {
             "font-weight":             ["fo",    None],
             "font-style":              ["fo",    None],
+            "color":                   ["fo",    None],
             "background-color":        ["fo",    None],
             "text-position":           ["style", None],
             "text-line-through-style": ["style", None],
@@ -1334,6 +1414,14 @@ class ODTTextStyle:
             self._tAttr["font-style"][1] = None
         return
 
+    def setColour(self, value: str | None) -> None:
+        """Set text colour."""
+        if value and len(value) == 7 and value[0] == "#":
+            self._tAttr["color"][1] = value
+        else:
+            self._tAttr["color"][1] = None
+        return
+
     def setBackgroundColour(self, value: str | None) -> None:
         """Set text background colour."""
         if value and len(value) == 7 and value[0] == "#":
@@ -1404,12 +1492,9 @@ class ODTTextStyle:
             ET.SubElement(xEntry, _mkTag("style", "text-properties"), attrib=attr)
         return
 
-# END Class ODTTextStyle
-
 
-# =============================================================================================== #
-#  XML Complex Element Helper Class
-# =============================================================================================== #
+# XML Complex Element Helper Class
+# ================================
 
 X_ROOT_TEXT = 0
 X_ROOT_TAIL = 1
@@ -1464,7 +1549,6 @@ class XMLParagraph:
             if c == " ":
                 nSpaces += 1
                 continue
-
             elif nSpaces > 0:
                 self._processSpaces(nSpaces)
                 nSpaces = 0
@@ -1475,26 +1559,22 @@ class XMLParagraph:
                     self._xTail.tail = ""
                     self._nState = X_ROOT_TAIL
                     self._chrPos += 1
-
                 elif self._nState in (X_SPAN_TEXT, X_SPAN_SING):
                     self._xSing = ET.SubElement(self._xTail, TAG_BR)
                     self._xSing.tail = ""
                     self._nState = X_SPAN_SING
                     self._chrPos += 1
-
             elif c == "\t":
                 if self._nState in (X_ROOT_TEXT, X_ROOT_TAIL):
                     self._xTail = ET.SubElement(self._xRoot, TAG_TAB)
                     self._xTail.tail = ""
                     self._nState = X_ROOT_TAIL
                     self._chrPos += 1
-
                 elif self._nState in (X_SPAN_TEXT, X_SPAN_SING):
                     self._xSing = ET.SubElement(self._xTail, TAG_TAB)
                     self._xSing.tail = ""
                     self._chrPos += 1
                     self._nState = X_SPAN_SING
-
             else:
                 if self._nState == X_ROOT_TEXT:
                     self._xRoot.text = (self._xRoot.text or "") + c
@@ -1529,6 +1609,19 @@ class XMLParagraph:
         self._nState = X_ROOT_TAIL
         return
 
+    def appendNode(self, xNode: ET.Element | None) -> None:
+        """Append an XML node to the paragraph. We only check for the
+        X_ROOT_TEXT and X_ROOT_TAIL states. X_SPAN_TEXT is not possible
+        at all, and X_SPAN_SING only happens internally in an appendSpan
+        call, returning us to an X_ROOT_TAIL state.
+        """
+        if xNode is not None and self._nState in (X_ROOT_TEXT, X_ROOT_TAIL):
+            self._xRoot.append(xNode)
+            self._xTail = xNode
+            self._xTail.tail = ""
+            self._nState = X_ROOT_TAIL
+        return
+
     def checkError(self) -> tuple[int, str]:
         """Check that the number of characters written matches the
         number of characters received.
@@ -1600,5 +1693,3 @@ class XMLParagraph:
                 self._chrPos += nSpaces - 1
 
         return
-
-# END Class XMLParagraph