\n")
elif tType == BlockTyp.COMMENT:
lines.append(f"\n")
elif tType == BlockTyp.KEYWORD:
tClass = f"meta meta-{tMeta}"
lines.append(f"{self._formatText(tText, tFmt)}
\n")
self._pages.append("".join(lines))
return
def closeDocument(self) -> None:
"""Run close document tasks."""
# Replace fields if there are stats available
if self._usedFields and self._counts:
pages = len(self._pages)
for doc, field in self._usedFields:
if doc >= 0 and doc < pages and (value := self._counts.get(field)) is not None:
self._pages[doc] = self._pages[doc].replace(
f"{{{{{field}}}}}", self._formatInt(value)
)
# Add footnotes
if self._usedNotes:
footnotes = self._localLookup("Footnotes")
lines = []
lines.append(f"{footnotes}
\n")
lines.append("\n")
for key, index in self._usedNotes.items():
if content := self._footnotes.get(key):
text = self._formatText(*content)
lines.append(f"\n")
lines.append("
\n")
self._pages.append("".join(lines))
return
def saveDocument(self, path: Path) -> None:
"""Save the data to an HTML file."""
if path.suffix.lower() == ".json":
ts = time()
data = {
"meta": {
"projectName": self._project.data.name,
"novelAuthor": self._project.data.author,
"buildTime": int(ts),
"buildTimeStr": formatTimeStamp(ts),
},
"text": {
"css": self.getStyleSheet(),
"html": [t.replace("\t", " ").rstrip().split("\n") for t in self._pages],
}
}
with open(path, mode="w", encoding="utf-8") as fObj:
json.dump(data, fObj, indent=2)
else:
with open(path, mode="w", encoding="utf-8") as fObj:
fObj.write((
"\n"
"\n"
"\n"
"\n"
"{title:s}\n"
"\n"
"\n"
"\n"
"\n"
"{body:s}\n"
"\n"
"\n"
"\n"
).format(
title=self._project.data.name,
style="\n".join(self.getStyleSheet()),
body=("".join(self._pages)).replace("\t", " ").rstrip(),
))
logger.info("Wrote file: %s", path)
return
def replaceTabs(self, nSpaces: int = 8, spaceChar: str = " ") -> None:
"""Replace tabs with spaces in the html."""
pages = []
tabSpace = spaceChar*nSpaces
for aLine in self._pages:
pages.append(aLine.replace("\t", tabSpace))
self._pages = pages
return
def getStyleSheet(self) -> list[str]:
"""Generate a stylesheet for the current settings."""
if not self._cssStyles:
return []
tColor = self._theme.text.name(QtHexRgb)
hColor = self._theme.head.name(QtHexRgb) if self._colorHeads else tColor
lColor = self._theme.head.name(QtHexRgb)
mColor = self._theme.highlight.name(QtHexRgb)
mtH0 = self._marginTitle[0]
mbH0 = self._marginTitle[1]
mtH1 = self._marginHead1[0]
mbH1 = self._marginHead1[1]
mtH2 = self._marginHead2[0]
mbH2 = self._marginHead2[1]
mtH3 = self._marginHead3[0]
mbH3 = self._marginHead3[1]
mtH4 = self._marginHead4[0]
mbH4 = self._marginHead4[1]
mtTT = self._marginText[0]
mbTT = self._marginText[1]
mtSP = self._marginSep[0]
mbSP = self._marginSep[1]
font = self._textFont
fFam = font.family()
fSz = font.pointSize()
fW = FONT_WEIGHTS.get(font.weight(), 400)
fS = FONT_STYLE.get(font.style(), "normal")
lHeight = round(100 * self._lineHeight)
styles = []
styles.append(
f"body {{color: {tColor}; font-family: '{fFam}'; font-size: {fSz}pt; "
f"font-weight: {fW}; font-style: {fS};}}"
)
styles.append(
f"p {{text-align: {self._defaultAlign}; line-height: {lHeight}%; "
f"margin-top: {mtTT:.2f}em; margin-bottom: {mbTT:.2f}em;}}"
)
styles.append(f"a {{color: {lColor};}}")
styles.append(f"mark {{background: {mColor};}}")
styles.append(f"h1, h2, h3, h4 {{color: {hColor}; page-break-after: avoid;}}")
styles.append(f"h1 {{margin-top: {mtH1:.2f}em; margin-bottom: {mbH1:.2f}em;}}")
styles.append(f"h2 {{margin-top: {mtH2:.2f}em; margin-bottom: {mbH2:.2f}em;}}")
styles.append(f"h3 {{margin-top: {mtH3:.2f}em; margin-bottom: {mbH3:.2f}em;}}")
styles.append(f"h4 {{margin-top: {mtH4:.2f}em; margin-bottom: {mbH4:.2f}em;}}")
styles.append(
f".title {{font-size: 2.5em; margin-top: {mtH0:.2f}em; margin-bottom: {mbH0:.2f}em;}}"
)
styles.append(
f".sep {{text-align: center; margin-top: {mtSP:.2f}em; margin-bottom: {mbSP:.2f}em;}}"
)
return styles
##
# 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):
if fmt == TextFmt.COL_B and (color := self._classes.get(data)):
tags.append((pos, m[1].format(color.name(QtHexRgb))))
elif fmt in (TextFmt.ANM_B, TextFmt.ARF_B, TextFmt.HRF_B):
tags.append((pos, m[1].format(data or "#")))
else:
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 == TextFmt.FNOTE:
if data in self._footnotes:
index = len(self._usedNotes) + 1
self._usedNotes[data] = index
tags.append((pos, f"{index}"))
else:
tags.append((pos, "ERR"))
elif fmt == TextFmt.FIELD:
if field := data.partition(":")[2]:
self._usedFields.append((len(self._pages), field))
tags.append((pos, f"{{{{{field}}}}}"))
# 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", "
")
return stripEscape(temp)