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

novelwriter/core/tohtml.py

@@ -26,17 +26,46 @@ from __future__ import annotations
 import json
 import logging
 
-from time import time
 from pathlib import Path
+from time import time
 
-from novelwriter import CONFIG
 from novelwriter.common import formatTimeStamp
-from novelwriter.constants import nwHeadFmt, nwKeyWords, nwLabels, nwHtmlUnicode
+from novelwriter.constants import nwHeadFmt, nwHtmlUnicode, 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__)
 
+# 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
@@ -45,19 +74,15 @@ class ToHtml(Tokenizer):
     also used by the Document Viewer, and Manuscript Build Preview.
     """
 
-    M_PREVIEW = 0  # Tweak output for the DocViewer
-    M_EXPORT  = 1  # Tweak output for saving to HTML or printing
-    M_EBOOK   = 2  # Tweak output for converting to epub
-
     def __init__(self, project: NWProject) -> None:
         super().__init__(project)
 
-        self._genMode = self.M_EXPORT
         self._cssStyles = True
         self._fullHTML: list[str] = []
 
         # Internals
         self._trMap = {}
+        self._usedNotes: dict[str, int] = {}
         self.setReplaceUnicode(False)
 
         return
@@ -74,11 +99,6 @@ class ToHtml(Tokenizer):
     #  Setters
     ##
 
-    def setPreview(self, state: bool) -> None:
-        """Set to preview generator mode."""
-        self._genMode = self.M_PREVIEW if state else self.M_EXPORT
-        return
-
     def setStyles(self, cssStyles: bool) -> None:
         """Enable or disable CSS styling. Some elements may still have
         class tags.
@@ -117,39 +137,9 @@ class ToHtml(Tokenizer):
 
     def doConvert(self) -> None:
         """Convert the list of text tokens into an HTML document."""
-        if self._genMode == self.M_PREVIEW:
-            htmlTags = {  # HTML4 + CSS2 (for Qt)
-                self.FMT_B_B: "<b>",
-                self.FMT_B_E: "</b>",
-                self.FMT_I_B: "<i>",
-                self.FMT_I_E: "</i>",
-                self.FMT_D_B: "<span style='text-decoration: line-through;'>",
-                self.FMT_D_E: "</span>",
-                self.FMT_U_B: "<u>",
-                self.FMT_U_E: "</u>",
-                self.FMT_M_B: "<mark>",
-                self.FMT_M_E: "</mark>",
-            }
-        else:
-            htmlTags = {  # HTML5 (for export)
-                self.FMT_B_B: "<strong>",
-                self.FMT_B_E: "</strong>",
-                self.FMT_I_B: "<em>",
-                self.FMT_I_E: "</em>",
-                self.FMT_D_B: "<del>",
-                self.FMT_D_E: "</del>",
-                self.FMT_U_B: "<span style='text-decoration: underline;'>",
-                self.FMT_U_E: "</span>",
-                self.FMT_M_B: "<mark>",
-                self.FMT_M_E: "</mark>",
-            }
-
-        htmlTags[self.FMT_SUP_B] = "<sup>"
-        htmlTags[self.FMT_SUP_E] = "</sup>"
-        htmlTags[self.FMT_SUB_B] = "<sub>"
-        htmlTags[self.FMT_SUB_E] = "</sub>"
+        self._result = ""
 
-        if self._isNovel and self._genMode != self.M_PREVIEW:
+        if self._isNovel:
             # For story files, we bump the titles one level up
             h1Cl = " class='title'"
             h1 = "h1"
@@ -163,12 +153,7 @@ class ToHtml(Tokenizer):
             h3 = "h3"
             h4 = "h4"
 
-        self._result = ""
-
-        para = []
-        pStyle = None
         lines = []
-
         tHandle = self._handle
 
         for tType, nHead, tText, tFormat, tStyle in self._tokens:
@@ -181,11 +166,11 @@ class ToHtml(Tokenizer):
                 for c in tText:
                     if c == "<":
                         cText.append("&lt;")
-                        tFormat = [[p + 3 if p > i else p, f] for p, f in tFormat]
+                        tFormat = [(p + 3 if p > i else p, f, k) for p, f, k in tFormat]
                         i += 4
                     elif c == ">":
                         cText.append("&gt;")
-                        tFormat = [[p + 3 if p > i else p, f] for p, f in tFormat]
+                        tFormat = [(p + 3 if p > i else p, f, k) for p, f, k in tFormat]
                         i += 4
                     else:
                         cText.append(c)
@@ -209,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;")
 
@@ -219,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:
@@ -235,37 +221,27 @@ class ToHtml(Tokenizer):
                 aNm = ""
 
             # Process Text Type
-            if tType == self.T_EMPTY:
-                if pStyle is None:
-                    pStyle = ""
-                if len(para) > 1 and self._cssStyles:
-                    pClass = " class='break'"
-                else:
-                    pClass = ""
-                if len(para) > 0:
-                    tTemp = "<br/>".join(para)
-                    lines.append(f"<p{pClass+pStyle}>{tTemp.rstrip()}</p>\n")
-                para = []
-                pStyle = None
+            if tType == self.T_TEXT:
+                lines.append(f"<p{hStyle}>{self._formatText(tText, tFormat)}</p>\n")
 
             elif tType == self.T_TITLE:
-                tHead = tText.replace(nwHeadFmt.BR, "<br/>")
+                tHead = tText.replace(nwHeadFmt.BR, "<br>")
                 lines.append(f"<h1 class='title'{hStyle}>{aNm}{tHead}</h1>\n")
 
             elif tType == self.T_HEAD1:
-                tHead = tText.replace(nwHeadFmt.BR, "<br/>")
+                tHead = tText.replace(nwHeadFmt.BR, "<br>")
                 lines.append(f"<{h1}{h1Cl}{hStyle}>{aNm}{tHead}</{h1}>\n")
 
             elif tType == self.T_HEAD2:
-                tHead = tText.replace(nwHeadFmt.BR, "<br/>")
+                tHead = tText.replace(nwHeadFmt.BR, "<br>")
                 lines.append(f"<{h2}{hStyle}>{aNm}{tHead}</{h2}>\n")
 
             elif tType == self.T_HEAD3:
-                tHead = tText.replace(nwHeadFmt.BR, "<br/>")
+                tHead = tText.replace(nwHeadFmt.BR, "<br>")
                 lines.append(f"<{h3}{hStyle}>{aNm}{tHead}</{h3}>\n")
 
             elif tType == self.T_HEAD4:
-                tHead = tText.replace(nwHeadFmt.BR, "<br/>")
+                tHead = tText.replace(nwHeadFmt.BR, "<br>")
                 lines.append(f"<{h4}{hStyle}>{aNm}{tHead}</{h4}>\n")
 
             elif tType == self.T_SEP:
@@ -274,22 +250,14 @@ class ToHtml(Tokenizer):
             elif tType == self.T_SKIP:
                 lines.append(f"<p class='skip'{hStyle}>&nbsp;</p>\n")
 
-            elif tType == self.T_TEXT:
-                tTemp = tText
-                if pStyle is None:
-                    pStyle = hStyle
-                for pos, fmt in reversed(tFormat):
-                    tTemp = f"{tTemp[:pos]}{htmlTags[fmt]}{tTemp[pos:]}"
-                para.append(stripEscape(tTemp.rstrip()))
-
             elif tType == self.T_SYNOPSIS and self._doSynopsis:
-                lines.append(self._formatSynopsis(tText, True))
+                lines.append(self._formatSynopsis(self._formatText(tText, tFormat), True))
 
             elif tType == self.T_SHORT and self._doSynopsis:
-                lines.append(self._formatSynopsis(tText, False))
+                lines.append(self._formatSynopsis(self._formatText(tText, tFormat), False))
 
             elif tType == self.T_COMMENT and self._doComments:
-                lines.append(self._formatComments(tText))
+                lines.append(self._formatComments(self._formatText(tText, tFormat)))
 
             elif tType == self.T_KEYWORD and self._doKeywords:
                 tag, text = self._formatKeywords(tText)
@@ -302,6 +270,26 @@ class ToHtml(Tokenizer):
 
         return
 
+    def appendFootnotes(self) -> None:
+        """Append the footnotes in the buffer."""
+        if self._usedNotes:
+            footnotes = self._localLookup("Footnotes")
+
+            lines = []
+            lines.append(f"<h3>{footnotes}</h3>\n")
+            lines.append("<ol>\n")
+            for key, index in self._usedNotes.items():
+                if content := self._footnotes.get(key):
+                    text = self._formatText(*content)
+                    lines.append(f"<li id='footnote_{index}'><p>{text}</p></li>\n")
+            lines.append("</ol>\n")
+
+            result = "".join(lines)
+            self._result += result
+            self._fullHTML.append(result)
+
+        return
+
     def saveHtml5(self, path: str | Path) -> None:
         """Save the data to an HTML file."""
         with open(path, mode="w", encoding="utf-8") as fObj:
@@ -367,8 +355,16 @@ class ToHtml(Tokenizer):
         mScale = self._lineHeight/1.15
 
         styles = []
-        styles.append("body {{font-family: '{0:s}'; font-size: {1:d}pt;}}".format(
-            self._textFont, self._textSize
+        font = self._textFont
+        styles.append((
+            "body {{"
+            "font-family: '{0:s}'; font-size: {1:d}pt; "
+            "font-weight: {2:d}; font-style: {3:s};"
+            "}}"
+        ).format(
+            font.family(), font.pointSize(),
+            FONT_WEIGHTS.get(font.weight(), 400),
+            FONT_STYLE.get(font.style(), "normal"),
         ))
         styles.append((
             "p {{"
@@ -442,10 +438,12 @@ class ToHtml(Tokenizer):
 
         styles.append("a {color: rgb(66, 113, 174);}")
         styles.append("mark {background: rgb(255, 255, 166);}")
-        styles.append(".tags {color: rgb(245, 135, 31); font-weight: bold;}")
+        styles.append(".keyword {color: rgb(245, 135, 31); font-weight: bold;}")
         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
 
@@ -453,24 +451,63 @@ class ToHtml(Tokenizer):
     #  Internal Functions
     ##
 
+    def _formatText(self, text: str, tFmt: T_Formats) -> str:
+        """Apply formatting tags to text."""
+        temp = text
+
+        # 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
+                    tags.append((pos, f"<sup><a href='#footnote_{index}'>{index}</a></sup>"))
+                else:
+                    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:
         """Apply HTML formatting to synopsis."""
         if synopsis:
             sSynop = self._localLookup("Synopsis")
         else:
             sSynop = self._localLookup("Short Description")
-        if self._genMode == self.M_PREVIEW:
-            return f"<p class='comment'><span class='synopsis'>{sSynop}:</span> {text}</p>\n"
-        else:
-            return f"<p class='synopsis'><strong>{sSynop}:</strong> {text}</p>\n"
+        return f"<p class='synopsis'><strong>{sSynop}:</strong> {text}</p>\n"
 
     def _formatComments(self, text: str) -> str:
         """Apply HTML formatting to comments."""
-        if self._genMode == self.M_PREVIEW:
-            return f"<p class='comment'>{text}</p>\n"
-        else:
-            sComm = self._localLookup("Comment")
-            return f"<p class='comment'><strong>{sComm}:</strong> {text}</p>\n"
+        sComm = self._localLookup("Comment")
+        return f"<p class='comment'><strong>{sComm}:</strong> {text}</p>\n"
 
     def _formatKeywords(self, text: str) -> tuple[str, str]:
         """Apply HTML formatting to keywords."""
@@ -478,19 +515,16 @@ class ToHtml(Tokenizer):
         if not valid or not bits or bits[0] not in nwLabels.KEY_NAME:
             return "", ""
 
-        result = f"<span class='tags'>{self._localLookup(nwLabels.KEY_NAME[bits[0]])}:</span> "
+        result = f"<span class='keyword'>{self._localLookup(nwLabels.KEY_NAME[bits[0]])}:</span> "
         if len(bits) > 1:
             if bits[0] == nwKeyWords.TAG_KEY:
                 one, two = self._project.index.parseValue(bits[1])
-                result += f"<a name='tag_{one}'>{one}</a>"
+                result += f"<a class='tag' name='tag_{one}'>{one}</a>"
                 if two:
                     result += f" | <span class='optional'>{two}</a>"
             else:
-                if self._genMode == self.M_PREVIEW:
-                    result += ", ".join(f"<a href='#{bits[0][1:]}={t}'>{t}</a>" for t in bits[1:])
-                else:
-                    result += ", ".join(f"<a href='#tag_{t}'>{t}</a>" for t in bits[1:])
+                result += ", ".join(
+                    f"<a class='tag' href='#tag_{t}'>{t}</a>" for t in bits[1:]
+                )
 
         return bits[0][1:], result
-
-# END Class ToHtml