novelWriter 2.5b1__py3-none-any.whl → 2.5.1__py3-none-any.whl

novelwriter/core/tohtml.py

@@ -29,7 +29,6 @@ import logging
 from pathlib import Path
 from time import time
 
-from novelwriter import CONFIG
 from novelwriter.common import formatTimeStamp
 from novelwriter.constants import nwHeadFmt, nwHtmlUnicode, nwKeyWords, nwLabels
 from novelwriter.core.project import NWProject
@@ -38,24 +37,35 @@ from novelwriter.types import FONT_STYLE, FONT_WEIGHTS
 
 logger = logging.getLogger(__name__)
 
-HTML5_TAGS = {
-    Tokenizer.FMT_B_B: "<strong>",
-    Tokenizer.FMT_B_E: "</strong>",
-    Tokenizer.FMT_I_B: "<em>",
-    Tokenizer.FMT_I_E: "</em>",
-    Tokenizer.FMT_D_B: "<del>",
-    Tokenizer.FMT_D_E: "</del>",
-    Tokenizer.FMT_U_B: "<span style='text-decoration: underline;'>",
-    Tokenizer.FMT_U_E: "</span>",
-    Tokenizer.FMT_M_B: "<mark>",
-    Tokenizer.FMT_M_E: "</mark>",
-    Tokenizer.FMT_SUP_B: "<sup>",
-    Tokenizer.FMT_SUP_E: "</sup>",
-    Tokenizer.FMT_SUB_B: "<sub>",
-    Tokenizer.FMT_SUB_E: "</sub>",
-    Tokenizer.FMT_STRIP: "",
+# Each opener tag, with the id of its corresponding closer and tag format
+HTML_OPENER: dict[int, tuple[int, str]] = {
+    Tokenizer.FMT_B_B:   (Tokenizer.FMT_B_E,   "<strong>"),
+    Tokenizer.FMT_I_B:   (Tokenizer.FMT_I_E,   "<em>"),
+    Tokenizer.FMT_D_B:   (Tokenizer.FMT_D_E,   "<del>"),
+    Tokenizer.FMT_U_B:   (Tokenizer.FMT_U_E,   "<span style='text-decoration: underline;'>"),
+    Tokenizer.FMT_M_B:   (Tokenizer.FMT_M_E,   "<mark>"),
+    Tokenizer.FMT_SUP_B: (Tokenizer.FMT_SUP_E, "<sup>"),
+    Tokenizer.FMT_SUB_B: (Tokenizer.FMT_SUB_E, "<sub>"),
+    Tokenizer.FMT_DL_B:  (Tokenizer.FMT_DL_E,  "<span class='dialog'>"),
+    Tokenizer.FMT_ADL_B: (Tokenizer.FMT_ADL_E, "<span class='altdialog'>"),
 }
 
+# Each closer tag, with the id of its corresponding opener and tag format
+HTML_CLOSER: dict[int, tuple[int, str]] = {
+    Tokenizer.FMT_B_E:   (Tokenizer.FMT_B_B,   "</strong>"),
+    Tokenizer.FMT_I_E:   (Tokenizer.FMT_I_B,   "</em>"),
+    Tokenizer.FMT_D_E:   (Tokenizer.FMT_D_B,   "</del>"),
+    Tokenizer.FMT_U_E:   (Tokenizer.FMT_U_B,   "</span>"),
+    Tokenizer.FMT_M_E:   (Tokenizer.FMT_M_B,   "</mark>"),
+    Tokenizer.FMT_SUP_E: (Tokenizer.FMT_SUP_B, "</sup>"),
+    Tokenizer.FMT_SUB_E: (Tokenizer.FMT_SUB_B, "</sub>"),
+    Tokenizer.FMT_DL_E:  (Tokenizer.FMT_DL_B,  "</span>"),
+    Tokenizer.FMT_ADL_E: (Tokenizer.FMT_ADL_B, "</span>"),
+}
+
+# Empty HTML tag record
+HTML_NONE = (0, "")
+
 
 class ToHtml(Tokenizer):
     """Core: HTML Document Writer
@@ -184,7 +194,6 @@ class ToHtml(Tokenizer):
 
                 if tStyle & self.A_PBB:
                     aStyle.append("page-break-before: always;")
-
                 if tStyle & self.A_PBA:
                     aStyle.append("page-break-after: always;")
 
@@ -194,11 +203,13 @@ class ToHtml(Tokenizer):
                     aStyle.append("margin-top: 0;")
 
                 if tStyle & self.A_IND_L:
-                    aStyle.append(f"margin-left: {CONFIG.tabWidth:d}px;")
+                    aStyle.append(f"margin-left: {self._blockIndent:.2f}em;")
                 if tStyle & self.A_IND_R:
-                    aStyle.append(f"margin-right: {CONFIG.tabWidth:d}px;")
+                    aStyle.append(f"margin-right: {self._blockIndent:.2f}em;")
+                if tStyle & self.A_IND_T:
+                    aStyle.append(f"text-indent: {self._firstWidth:.2f}em;")
 
-            if len(aStyle) > 0:
+            if aStyle:
                 stVals = " ".join(aStyle)
                 hStyle = f" style='{stVals}'"
             else:
@@ -431,6 +442,8 @@ class ToHtml(Tokenizer):
         styles.append(".break {text-align: left;}")
         styles.append(".synopsis {font-style: italic;}")
         styles.append(".comment {font-style: italic; color: rgb(100, 100, 100);}")
+        styles.append(".dialog {color: rgb(66, 113, 174);}")
+        styles.append(".altdialog {color: rgb(129, 55, 9);}")
 
         return styles
 
@@ -441,19 +454,46 @@ class ToHtml(Tokenizer):
     def _formatText(self, text: str, tFmt: T_Formats) -> str:
         """Apply formatting tags to text."""
         temp = text
-        for pos, fmt, data in reversed(tFmt):
-            html = ""
-            if fmt == self.FMT_FNOTE:
+
+        # Build a list of all html tags that need to be inserted in the text.
+        # This is done in the forward direction, and a tag is only opened if it
+        # isn't already open, and only closed if it has previously been opened.
+        tags: list[tuple[int, str]] = []
+        state = dict.fromkeys(HTML_OPENER, False)
+        for pos, fmt, data in tFmt:
+            if m := HTML_OPENER.get(fmt):
+                if not state.get(fmt, True):
+                    tags.append((pos, m[1]))
+                    state[fmt] = True
+            elif m := HTML_CLOSER.get(fmt):
+                if state.get(m[0], False):
+                    tags.append((pos, m[1]))
+                    state[m[0]] = False
+            elif fmt == self.FMT_FNOTE:
                 if data in self._footnotes:
                     index = len(self._usedNotes) + 1
                     self._usedNotes[data] = index
-                    html = f"<sup><a href='#footnote_{index}'>{index}</a></sup>"
+                    tags.append((pos, f"<sup><a href='#footnote_{index}'>{index}</a></sup>"))
                 else:
-                    html = "<sup>ERR</sup>"
-            else:
-                html = HTML5_TAGS.get(fmt, "ERR")
-            temp = f"{temp[:pos]}{html}{temp[pos:]}"
+                    tags.append((pos, "<sup>ERR</sup>"))
+
+        # Check all format types and close any tag that is still open. This
+        # ensures that unclosed tags don't spill over to the next paragraph.
+        end = len(text)
+        for opener, active in state.items():
+            if active:
+                closer = HTML_OPENER.get(opener, HTML_NONE)[0]
+                tags.append((end, HTML_CLOSER.get(closer, HTML_NONE)[1]))
+
+        # Insert all tags at their correct position, starting from the back.
+        # The reverse order ensures that the positions are not shifted while we
+        # insert tags.
+        for pos, tag in reversed(tags):
+            temp = f"{temp[:pos]}{tag}{temp[pos:]}"
+
+        # Replace all line breaks with proper HTML break tags
         temp = temp.replace("\n", "<br>")
+
         return stripEscape(temp)
 
     def _formatSynopsis(self, text: str, synopsis: bool) -> str:

novelwriter/core/tokenizer.py

@@ -36,13 +36,13 @@ from time import time
 from PyQt5.QtCore import QCoreApplication, QRegularExpression
 from PyQt5.QtGui import QFont
 
+from novelwriter import CONFIG
 from novelwriter.common import checkInt, formatTimeStamp, numberToRoman
-from novelwriter.constants import (
-    nwHeadFmt, nwKeyWords, nwLabels, nwRegEx, nwShortcode, nwUnicode, trConst
-)
+from novelwriter.constants import nwHeadFmt, nwKeyWords, nwLabels, nwShortcode, nwUnicode, trConst
 from novelwriter.core.index import processComment
 from novelwriter.core.project import NWProject
 from novelwriter.enum import nwComment, nwItemLayout
+from novelwriter.text.patterns import REGEX_PATTERNS
 
 logger = logging.getLogger(__name__)
 
@@ -85,8 +85,12 @@ class Tokenizer(ABC):
     FMT_SUP_E = 12  # End superscript
     FMT_SUB_B = 13  # Begin subscript
     FMT_SUB_E = 14  # End subscript
-    FMT_FNOTE = 15  # Footnote marker
-    FMT_STRIP = 16  # Strip the format code
+    FMT_DL_B  = 15  # Begin dialogue
+    FMT_DL_E  = 16  # End dialogue
+    FMT_ADL_B = 17  # Begin alt dialogue
+    FMT_ADL_E = 18  # End alt dialogue
+    FMT_FNOTE = 19  # Footnote marker
+    FMT_STRIP = 20  # Strip the format code
 
     # Block Type
     T_EMPTY    = 1   # Empty line (new paragraph)
@@ -115,6 +119,10 @@ class Tokenizer(ABC):
     A_Z_BTMMRG = 0x0080  # Zero bottom margin
     A_IND_L    = 0x0100  # Left indentation
     A_IND_R    = 0x0200  # Right indentation
+    A_IND_T    = 0x0400  # Text indentation
+
+    # Masks
+    M_ALIGNED = A_LEFT | A_RIGHT | A_CENTRE | A_JUSTIFY
 
     # Lookups
     L_HEADINGS = [T_TITLE, T_HEAD1, T_HEAD2, T_HEAD3, T_HEAD4]
@@ -189,7 +197,9 @@ class Tokenizer(ABC):
 
         # Instance Variables
         self._hFormatter = HeadingFormatter(self._project)
-        self._noSep      = True  # Flag to indicate that we don't want a scene separator
+        self._noSep      = True   # Flag to indicate that we don't want a scene separator
+        self._noIndent   = False  # Flag to disable text indent on next paragraph
+        self._showDialog = False  # Flag for dialogue highlighting
 
         # This File
         self._isNovel = False  # Document is a novel document
@@ -204,12 +214,12 @@ class Tokenizer(ABC):
 
         # Format RegEx
         self._rxMarkdown = [
-            (QRegularExpression(nwRegEx.FMT_EI), [0, self.FMT_I_B, 0, self.FMT_I_E]),
-            (QRegularExpression(nwRegEx.FMT_EB), [0, self.FMT_B_B, 0, self.FMT_B_E]),
-            (QRegularExpression(nwRegEx.FMT_ST), [0, self.FMT_D_B, 0, self.FMT_D_E]),
+            (REGEX_PATTERNS.markdownItalic, [0, self.FMT_I_B, 0, self.FMT_I_E]),
+            (REGEX_PATTERNS.markdownBold,   [0, self.FMT_B_B, 0, self.FMT_B_E]),
+            (REGEX_PATTERNS.markdownStrike, [0, self.FMT_D_B, 0, self.FMT_D_E]),
         ]
-        self._rxShortCodes = QRegularExpression(nwRegEx.FMT_SC)
-        self._rxShortCodeVals = QRegularExpression(nwRegEx.FMT_SV)
+        self._rxShortCodes = REGEX_PATTERNS.shortcodePlain
+        self._rxShortCodeVals = REGEX_PATTERNS.shortcodeValue
 
         self._shortCodeFmt = {
             nwShortcode.ITALIC_O: self.FMT_I_B,   nwShortcode.ITALIC_C: self.FMT_I_E,
@@ -224,6 +234,8 @@ class Tokenizer(ABC):
             nwShortcode.FOOTNOTE_B: self.FMT_FNOTE,
         }
 
+        self._rxDialogue: list[tuple[QRegularExpression, int, int]] = []
+
         return
 
     ##
@@ -345,6 +357,29 @@ class Tokenizer(ABC):
         self._doJustify = state
         return
 
+    def setDialogueHighlight(self, state: bool) -> None:
+        """Enable or disable dialogue highlighting."""
+        self._rxDialogue = []
+        self._showDialog = state
+        if state:
+            if CONFIG.dialogStyle > 0:
+                self._rxDialogue.append((
+                    REGEX_PATTERNS.dialogStyle, self.FMT_DL_B, self.FMT_DL_E
+                ))
+            if CONFIG.dialogLine:
+                self._rxDialogue.append((
+                    REGEX_PATTERNS.dialogLine, self.FMT_DL_B, self.FMT_DL_E
+                ))
+            if CONFIG.narratorBreak:
+                self._rxDialogue.append((
+                    REGEX_PATTERNS.narratorBreak, self.FMT_DL_E, self.FMT_DL_B
+                ))
+            if CONFIG.altDialogOpen and CONFIG.altDialogClose:
+                self._rxDialogue.append((
+                    REGEX_PATTERNS.altDialogStyle, self.FMT_ADL_B, self.FMT_ADL_E
+                ))
+        return
+
     def setTitleMargins(self, upper: float, lower: float) -> None:
         """Set the upper and lower title margin."""
         self._marginTitle = (float(upper), float(lower))
@@ -481,7 +516,7 @@ class Tokenizer(ABC):
             self._text = xRep.sub(lambda x: repDict[x.group(0)], self._text)
 
         # Process the character translation map
-        trDict = {nwUnicode.U_MAPOSS: nwUnicode.U_RSQUO}
+        trDict = {nwUnicode.U_MAPOS: nwUnicode.U_RSQUO}
         self._text = self._text.translate(str.maketrans(trDict))
 
         return
@@ -846,6 +881,12 @@ class Tokenizer(ABC):
             if n < tCount - 1:
                 nToken = tokens[n+1]  # Look ahead
 
+            if cToken[0] in self.L_SKIP_INDENT and not self._indentFirst:
+                # Unless the indentFirst flag is set, we set up the next
+                # paragraph to not be indented if we see a block of a
+                # specific type
+                self._noIndent = True
+
             if cToken[0] == self.T_EMPTY:
                 # We don't need to keep the empty lines after this pass
                 pass
@@ -864,11 +905,27 @@ class Tokenizer(ABC):
             elif cToken[0] == self.T_TEXT:
                 # Combine lines from the same paragraph
                 pLines.append(cToken)
+
                 if nToken[0] != self.T_TEXT:
+                    # Next token is not text, so we add the buffer to tokens
                     nLines = len(pLines)
+                    cStyle = pLines[0][4]
+                    if self._firstIndent and not (self._noIndent or cStyle & self.M_ALIGNED):
+                        # If paragraph indentation is enabled, not temporarily
+                        # turned off, and the block is not aligned, we add the
+                        # text indentation flag
+                        cStyle |= self.A_IND_T
+
                     if nLines == 1:
-                        self._tokens.append(pLines[0])
+                        # The paragraph contains a single line, so we just
+                        # save that directly to the token list
+                        self._tokens.append((
+                            self.T_TEXT, pLines[0][1], pLines[0][2], pLines[0][3], cStyle
+                        ))
                     elif nLines > 1:
+                        # The paragraph contains multiple lines, so we need to
+                        # join them according to the line break policy, and
+                        # recompute all the formatting markers
                         tTxt = ""
                         tFmt: T_Formats = []
                         for aToken in pLines:
@@ -876,9 +933,12 @@ class Tokenizer(ABC):
                             tTxt += f"{aToken[2]}{lineSep}"
                             tFmt.extend((p+tLen, fmt, key) for p, fmt, key in aToken[3])
                         self._tokens.append((
-                            self.T_TEXT, pLines[0][1], tTxt[:-1], tFmt, pLines[0][4]
+                            self.T_TEXT, pLines[0][1], tTxt[:-1], tFmt, cStyle
                         ))
+
+                    # Reset buffer and make sure text indent is on for next pass
                     pLines = []
+                    self._noIndent = False
 
             else:
                 self._tokens.append(cToken)
@@ -1076,6 +1136,15 @@ class Tokenizer(ABC):
                 f"{tHandle}:{rxMatch.captured(2)}",
             ))
 
+        # Match Dialogue
+        if self._rxDialogue:
+            for regEx, fmtB, fmtE in self._rxDialogue:
+                rxItt = regEx.globalMatch(text, 0)
+                while rxItt.hasNext():
+                    rxMatch = rxItt.next()
+                    temp.append((rxMatch.capturedStart(0), 0, fmtB, ""))
+                    temp.append((rxMatch.capturedEnd(0), 0, fmtE, ""))
+
         # Post-process text and format
         result = text
         formats = []

novelwriter/core/toodt.py

@@ -82,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
@@ -98,6 +100,8 @@ 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"
@@ -216,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
 
@@ -324,6 +330,10 @@ 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)
@@ -438,7 +448,6 @@ class ToOdt(Tokenizer):
         self._result = ""  # Not used, but cleared just in case
 
         xText = self._xText
-        pIndent = True
         for tType, _, tText, tFormat, tStyle in self._tokens:
 
             # Styles
@@ -455,7 +464,6 @@ class ToOdt(Tokenizer):
 
                 if tStyle & self.A_PBB:
                     oStyle.setBreakBefore("page")
-
                 if tStyle & self.A_PBA:
                     oStyle.setBreakAfter("page")
 
@@ -469,16 +477,14 @@ class ToOdt(Tokenizer):
                 if tStyle & self.A_IND_R:
                     oStyle.setMarginRight(self._fBlockIndent)
 
-            if not self._indentFirst and tType in self.L_SKIP_INDENT:
-                pIndent = False
-
             # Process Text Types
             if tType == self.T_TEXT:
-                if self._firstIndent and pIndent and oStyle.isUnaligned():
+                # 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)
-                pIndent = True
 
             elif tType == self.T_TITLE:
                 # Title must be text:p
@@ -688,6 +694,14 @@ 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:
@@ -761,6 +775,10 @@ 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
@@ -1361,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],
@@ -1395,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] == "#":

novelwriter/core/toqdoc.py

@@ -26,7 +26,7 @@ from __future__ import annotations
 import logging
 
 from PyQt5.QtGui import (
-    QColor, QFont, QFontMetrics, QTextBlockFormat, QTextCharFormat,
+    QColor, QFont, QFontMetricsF, QTextBlockFormat, QTextCharFormat,
     QTextCursor, QTextDocument
 )
 
@@ -45,16 +45,18 @@ T_TextStyle = tuple[QTextBlockFormat, QTextCharFormat]
 
 
 class TextDocumentTheme:
-    text: QColor = QtBlack
+    text:      QColor = QtBlack
     highlight: QColor = QtTransparent
-    head: QColor = QtBlack
-    comment: QColor = QtBlack
-    note: QColor = QtBlack
-    code: QColor = QtBlack
-    modifier: QColor = QtBlack
-    keyword: QColor = QtBlack
-    tag: QColor = QtBlack
-    optional: QColor = QtBlack
+    head:      QColor = QtBlack
+    comment:   QColor = QtBlack
+    note:      QColor = QtBlack
+    code:      QColor = QtBlack
+    modifier:  QColor = QtBlack
+    keyword:   QColor = QtBlack
+    tag:       QColor = QtBlack
+    optional:  QColor = QtBlack
+    dialog:    QColor = QtBlack
+    altdialog: QColor = QtBlack
 
 
 def newBlock(cursor: QTextCursor, bFmt: QTextBlockFormat) -> None:
@@ -97,19 +99,19 @@ class ToQTextDocument(Tokenizer):
         self._document.clear()
         self._document.setDefaultFont(self._textFont)
 
-        qMetric = QFontMetrics(self._textFont)
-        mScale = qMetric.height()
+        qMetric = QFontMetricsF(self._textFont)
+        mPx = qMetric.ascent()  # 1 em in pixels
         fPt = self._textFont.pointSizeF()
 
         # Scaled Sizes
         # ============
 
         self._mHead = {
-            self.T_TITLE: (mScale * self._marginTitle[0], mScale * self._marginTitle[1]),
-            self.T_HEAD1: (mScale * self._marginHead1[0], mScale * self._marginHead1[1]),
-            self.T_HEAD2: (mScale * self._marginHead2[0], mScale * self._marginHead2[1]),
-            self.T_HEAD3: (mScale * self._marginHead3[0], mScale * self._marginHead3[1]),
-            self.T_HEAD4: (mScale * self._marginHead4[0], mScale * self._marginHead4[1]),
+            self.T_TITLE: (mPx * self._marginTitle[0], mPx * self._marginTitle[1]),
+            self.T_HEAD1: (mPx * self._marginHead1[0], mPx * self._marginHead1[1]),
+            self.T_HEAD2: (mPx * self._marginHead2[0], mPx * self._marginHead2[1]),
+            self.T_HEAD3: (mPx * self._marginHead3[0], mPx * self._marginHead3[1]),
+            self.T_HEAD4: (mPx * self._marginHead4[0], mPx * self._marginHead4[1]),
         }
 
         self._sHead = {
@@ -120,11 +122,12 @@ class ToQTextDocument(Tokenizer):
             self.T_HEAD4: nwHeaders.H_SIZES.get(4, 1.0) * fPt,
         }
 
-        self._mText = (mScale * self._marginText[0], mScale * self._marginText[1])
-        self._mMeta = (mScale * self._marginMeta[0], mScale * self._marginMeta[1])
-        self._mSep  = (mScale * self._marginSep[0], mScale * self._marginSep[1])
+        self._mText = (mPx * self._marginText[0], mPx * self._marginText[1])
+        self._mMeta = (mPx * self._marginMeta[0], mPx * self._marginMeta[1])
+        self._mSep  = (mPx * self._marginSep[0], mPx * self._marginSep[1])
 
-        self._mIndent = mScale * 2.0
+        self._mIndent = mPx * 2.0
+        self._tIndent = mPx * self._firstWidth
 
         # Block Format
         # ============
@@ -133,6 +136,9 @@ class ToQTextDocument(Tokenizer):
         self._blockFmt.setTopMargin(self._mText[0])
         self._blockFmt.setBottomMargin(self._mText[1])
         self._blockFmt.setAlignment(QtAlignJustify if self._doJustify else QtAlignAbsolute)
+        self._blockFmt.setLineHeight(
+            100*self._lineHeight, QTextBlockFormat.LineHeightTypes.ProportionalHeight
+        )
 
         # Character Formats
         # =================
@@ -224,6 +230,8 @@ class ToQTextDocument(Tokenizer):
                     bFmt.setLeftMargin(self._mIndent)
                 if tStyle & self.A_IND_R:
                     bFmt.setRightMargin(self._mIndent)
+                if tStyle & self.A_IND_T:
+                    bFmt.setTextIndent(self._tIndent)
 
             if tType == self.T_TEXT:
                 newBlock(cursor, bFmt)
@@ -337,6 +345,14 @@ class ToQTextDocument(Tokenizer):
                 cFmt.setVerticalAlignment(QtVAlignSub)
             elif fmt == self.FMT_SUB_E:
                 cFmt.setVerticalAlignment(QtVAlignNormal)
+            elif fmt == self.FMT_DL_B:
+                cFmt.setForeground(self._theme.dialog)
+            elif fmt == self.FMT_DL_E:
+                cFmt.setForeground(self._theme.text)
+            elif fmt == self.FMT_ADL_B:
+                cFmt.setForeground(self._theme.altdialog)
+            elif fmt == self.FMT_ADL_E:
+                cFmt.setForeground(self._theme.text)
             elif fmt == self.FMT_FNOTE:
                 xFmt = QTextCharFormat(self._cCode)
                 xFmt.setVerticalAlignment(QtVAlignSuper)