novelWriter 2.6b1__py3-none-any.whl → 2.6b2__py3-none-any.whl

novelwriter/formats/toodt.py

@@ -43,7 +43,7 @@ from novelwriter.constants import nwHeadFmt, nwStyles
 from novelwriter.core.project import NWProject
 from novelwriter.formats.shared import BlockFmt, BlockTyp, TextFmt, stripEscape
 from novelwriter.formats.tokenizer import Tokenizer
-from novelwriter.types import FONT_STYLE, FONT_WEIGHTS, QtHexRgb
+from novelwriter.types import FONT_STYLE, QtHexRgb
 
 logger = logging.getLogger(__name__)
 
@@ -173,44 +173,10 @@ class ToOdt(Tokenizer):
         self._fontStyle    = "normal"
         self._fontPitch    = "variable"
         self._fontBold     = "bold"
-        self._fSizeTitle   = "30pt"
-        self._fSizeHead1   = "24pt"
-        self._fSizeHead2   = "20pt"
-        self._fSizeHead3   = "16pt"
-        self._fSizeHead4   = "14pt"
-        self._fSizeHead    = "14pt"
-        self._fSizeText    = "12pt"
-        self._fSizeFoot    = "10pt"
-        self._fLineHeight  = "115%"
         self._fBlockIndent = "1.693cm"
-        self._fTextIndent  = "0.499cm"
         self._dLanguage    = "en"
         self._dCountry     = "GB"
 
-        # Text Margins
-        self._mTopTitle = "0.423cm"
-        self._mTopHead1 = "0.423cm"
-        self._mTopHead2 = "0.353cm"
-        self._mTopHead3 = "0.247cm"
-        self._mTopHead4 = "0.247cm"
-        self._mTopHead  = "0.423cm"
-        self._mTopText  = "0.000cm"
-        self._mTopMeta  = "0.000cm"
-        self._mTopSep   = "0.247cm"
-
-        self._mBotTitle = "0.212cm"
-        self._mBotHead1 = "0.212cm"
-        self._mBotHead2 = "0.212cm"
-        self._mBotHead3 = "0.212cm"
-        self._mBotHead4 = "0.212cm"
-        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"
         self._mDocHeight = "29.7cm"
@@ -254,60 +220,16 @@ class ToOdt(Tokenizer):
         # Initialise Variables
         # ====================
 
-        intWeight = FONT_WEIGHTS.get(self._textFont.weight(), 400)
-        fontWeight = str(intWeight)
-        fontBold = str(min(intWeight + 300, 900))
-
         lang, _, country = self._dLocale.name().partition("_")
         self._dLanguage = lang or self._dLanguage
         self._dCountry = country or self._dCountry
 
-        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._headWeight = self._fontBold if self._boldHeads else None
-
-        hScale = self._scaleHeads
-        self._fSizeTitle = self._emToPt(nwStyles.H_SIZES[0] if hScale else 1.0)  # Was 2.50
-        self._fSizeHead1 = self._emToPt(nwStyles.H_SIZES[1] if hScale else 1.0)  # Was 2.00
-        self._fSizeHead2 = self._emToPt(nwStyles.H_SIZES[2] if hScale else 1.0)  # Was 1.60
-        self._fSizeHead3 = self._emToPt(nwStyles.H_SIZES[3] if hScale else 1.0)  # Was 1.30
-        self._fSizeHead4 = self._emToPt(nwStyles.H_SIZES[4] if hScale else 1.0)  # Was 1.15
-        self._fSizeHead  = self._emToPt(nwStyles.H_SIZES[4] if hScale else 1.0)  # Was 1.15
-        self._fSizeText  = self._emToPt(1.0)
-        self._fSizeFoot  = self._emToPt(0.8)
-
-        mScale = self._lineHeight/1.15
-
-        self._mTopTitle = self._emToCm(mScale * self._marginTitle[0])
-        self._mTopHead1 = self._emToCm(mScale * self._marginHead1[0])
-        self._mTopHead2 = self._emToCm(mScale * self._marginHead2[0])
-        self._mTopHead3 = self._emToCm(mScale * self._marginHead3[0])
-        self._mTopHead4 = self._emToCm(mScale * self._marginHead4[0])
-        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])
-        self._mBotHead2 = self._emToCm(mScale * self._marginHead2[1])
-        self._mBotHead3 = self._emToCm(mScale * self._marginHead3[1])
-        self._mBotHead4 = self._emToCm(mScale * self._marginHead4[1])
-        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])
-
-        self._fLineHeight  = f"{round(100 * self._lineHeight):d}%"
+        self._fontFamily   = self._textFont.family()
+        self._fontSize     = self._textFont.pointSize()
+        self._fontStyle    = FONT_STYLE.get(self._textFont.style(), "normal")
+        self._fontPitch    = "fixed" if self._textFont.fixedPitch() else "variable"
+        self._headWeight   = self._fontBold if self._boldHeads else None
         self._fBlockIndent = self._emToCm(self._blockIndent)
-        self._fTextIndent  = self._emToCm(self._firstWidth)
 
         # Clear Errors
         self._errData = []
@@ -744,7 +666,7 @@ class ToOdt(Tokenizer):
 
     def _emToCm(self, value: float) -> str:
         """Converts an em value to centimetres."""
-        return f"{value*2.54/72*self._fontSize:.3f}cm"
+        return f"{value*self._fontSize*2.54/72.0:.3f}cm"
 
     def _emToPt(self, scale: float) -> str:
         """Compute relative font size in points."""
@@ -772,16 +694,19 @@ class ToOdt(Tokenizer):
 
         xHead = ET.SubElement(xPage, _mkTag("style", "header-style"))
         ET.SubElement(xHead, _mkTag("style", "header-footer-properties"), attrib={
-            _mkTag("fo", "min-height"): "0.600cm",
+            _mkTag("fo", "min-height"): self._emToCm(1.5),
             _mkTag("fo", "margin-left"): "0.000cm",
             _mkTag("fo", "margin-right"): "0.000cm",
-            _mkTag("fo", "margin-bottom"): "0.500cm",
+            _mkTag("fo", "margin-bottom"): self._emToCm(0.5),
         })
 
         return
 
     def _defaultStyles(self) -> None:
         """Set the default styles."""
+        hScale = self._scaleHeads
+        textSize = self._emToPt(nwStyles.T_NORMAL)
+
         # Add Paragraph Family Style
         xStyl = ET.SubElement(self._xStyl, _mkTag("style", "default-style"), attrib={
             _mkTag("style", "family"): "paragraph",
@@ -796,7 +721,7 @@ class ToOdt(Tokenizer):
             _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", "font-size"): textSize,
             _mkTag("fo", "language"): self._dLanguage,
             _mkTag("fo", "country"): self._dCountry,
         })
@@ -812,7 +737,7 @@ class ToOdt(Tokenizer):
             _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", "font-size"): textSize,
         })
 
         # Add Default Heading Style
@@ -824,8 +749,8 @@ class ToOdt(Tokenizer):
             _mkTag("style", "class"): "text",
         })
         ET.SubElement(xStyl, _mkTag("style", "paragraph-properties"), attrib={
-            _mkTag("fo", "margin-top"): self._mTopHead,
-            _mkTag("fo", "margin-bottom"): self._mBotHead,
+            _mkTag("fo", "margin-top"): self._emToCm(self._marginHead4[0]),
+            _mkTag("fo", "margin-bottom"): self._emToCm(self._marginHead4[1]),
             _mkTag("fo", "keep-with-next"): "always",
         })
         ET.SubElement(xStyl, _mkTag("style", "text-properties"), attrib={
@@ -833,7 +758,7 @@ class ToOdt(Tokenizer):
             _mkTag("fo", "font-family"): self._fontFamily,
             _mkTag("fo", "font-weight"): self._fontWeight,
             _mkTag("fo", "font-style"): self._fontStyle,
-            _mkTag("fo", "font-size"): self._fSizeHead,
+            _mkTag("fo", "font-size"): self._emToPt(nwStyles.H_SIZES[4] if hScale else 1.0),
         })
 
         # Add Header and Footer Styles
@@ -857,20 +782,24 @@ class ToOdt(Tokenizer):
 
     def _useableStyles(self) -> None:
         """Set the usable styles."""
+        hScale = self._scaleHeads
         hColor = self._theme.head if self._colorHeads else None
 
+        textSize = self._emToPt(nwStyles.T_NORMAL)
+        lineHeight = f"{round(100 * self._lineHeight):d}%"
+
         # Add Text Body Style
         style = ODTParagraphStyle(S_TEXT)
         style.setDisplayName("Text body")
         style.setParentStyleName("Standard")
         style.setClass("text")
-        style.setMarginTop(self._mTopText)
-        style.setMarginBottom(self._mBotText)
-        style.setLineHeight(self._fLineHeight)
+        style.setMarginTop(self._emToCm(self._marginText[0]))
+        style.setMarginBottom(self._emToCm(self._marginText[1]))
+        style.setLineHeight(lineHeight)
         style.setTextAlign(self._defaultAlign)
         style.setFontName(self._fontFamily)
         style.setFontFamily(self._fontFamily)
-        style.setFontSize(self._fSizeText)
+        style.setFontSize(textSize)
         style.setFontWeight(self._fontWeight)
         style.packXML(self._xStyl)
         self._mainPara[style.name] = style
@@ -880,7 +809,7 @@ class ToOdt(Tokenizer):
         style.setDisplayName("First line indent")
         style.setParentStyleName(S_TEXT)
         style.setClass("text")
-        style.setTextIndent(self._fTextIndent)
+        style.setTextIndent(self._emToCm(self._firstWidth))
         style.packXML(self._xStyl)
         self._mainPara[style.name] = style
 
@@ -889,12 +818,12 @@ class ToOdt(Tokenizer):
         style.setDisplayName("Text Meta")
         style.setParentStyleName("Standard")
         style.setClass("text")
-        style.setMarginTop(self._mTopMeta)
-        style.setMarginBottom(self._mBotMeta)
-        style.setLineHeight(self._fLineHeight)
+        style.setMarginTop(self._emToCm(self._marginMeta[0]))
+        style.setMarginBottom(self._emToCm(self._marginMeta[1]))
+        style.setLineHeight(lineHeight)
         style.setFontName(self._fontFamily)
         style.setFontFamily(self._fontFamily)
-        style.setFontSize(self._fSizeText)
+        style.setFontSize(textSize)
         style.setFontWeight(self._fontWeight)
         style.packXML(self._xStyl)
         self._mainPara[style.name] = style
@@ -905,12 +834,12 @@ class ToOdt(Tokenizer):
         style.setParentStyleName("Heading")
         style.setNextStyleName(S_TEXT)
         style.setClass("chapter")
-        style.setMarginTop(self._mTopTitle)
-        style.setMarginBottom(self._mBotTitle)
+        style.setMarginTop(self._emToCm(self._marginTitle[0]))
+        style.setMarginBottom(self._emToCm(self._marginTitle[1]))
         style.setTextAlign("center")
         style.setFontName(self._fontFamily)
         style.setFontFamily(self._fontFamily)
-        style.setFontSize(self._fSizeTitle)
+        style.setFontSize(self._emToPt(nwStyles.H_SIZES[0] if hScale else 1.0))
         style.setFontWeight(self._headWeight)
         style.packXML(self._xStyl)
         self._mainPara[style.name] = style
@@ -921,13 +850,13 @@ class ToOdt(Tokenizer):
         style.setParentStyleName("Standard")
         style.setNextStyleName(S_TEXT)
         style.setClass("text")
-        style.setMarginTop(self._mTopSep)
-        style.setMarginBottom(self._mBotSep)
-        style.setLineHeight(self._fLineHeight)
+        style.setMarginTop(self._emToCm(self._marginSep[0]))
+        style.setMarginBottom(self._emToCm(self._marginSep[1]))
+        style.setLineHeight(lineHeight)
         style.setTextAlign("center")
         style.setFontName(self._fontFamily)
         style.setFontFamily(self._fontFamily)
-        style.setFontSize(self._fSizeText)
+        style.setFontSize(textSize)
         style.setFontWeight(self._fontWeight)
         style.packXML(self._xStyl)
         self._mainPara[style.name] = style
@@ -939,11 +868,11 @@ class ToOdt(Tokenizer):
         style.setNextStyleName(S_TEXT)
         style.setOutlineLevel("1")
         style.setClass("text")
-        style.setMarginTop(self._mTopHead1)
-        style.setMarginBottom(self._mBotHead1)
+        style.setMarginTop(self._emToCm(self._marginHead1[0]))
+        style.setMarginBottom(self._emToCm(self._marginHead1[1]))
         style.setFontName(self._fontFamily)
         style.setFontFamily(self._fontFamily)
-        style.setFontSize(self._fSizeHead1)
+        style.setFontSize(self._emToPt(nwStyles.H_SIZES[1] if hScale else 1.0))
         style.setFontWeight(self._headWeight)
         style.setColor(hColor)
         style.packXML(self._xStyl)
@@ -956,11 +885,11 @@ class ToOdt(Tokenizer):
         style.setNextStyleName(S_TEXT)
         style.setOutlineLevel("2")
         style.setClass("text")
-        style.setMarginTop(self._mTopHead2)
-        style.setMarginBottom(self._mBotHead2)
+        style.setMarginTop(self._emToCm(self._marginHead2[0]))
+        style.setMarginBottom(self._emToCm(self._marginHead2[1]))
         style.setFontName(self._fontFamily)
         style.setFontFamily(self._fontFamily)
-        style.setFontSize(self._fSizeHead2)
+        style.setFontSize(self._emToPt(nwStyles.H_SIZES[2] if hScale else 1.0))
         style.setFontWeight(self._headWeight)
         style.setColor(hColor)
         style.packXML(self._xStyl)
@@ -973,11 +902,11 @@ class ToOdt(Tokenizer):
         style.setNextStyleName(S_TEXT)
         style.setOutlineLevel("3")
         style.setClass("text")
-        style.setMarginTop(self._mTopHead3)
-        style.setMarginBottom(self._mBotHead3)
+        style.setMarginTop(self._emToCm(self._marginHead3[0]))
+        style.setMarginBottom(self._emToCm(self._marginHead3[1]))
         style.setFontName(self._fontFamily)
         style.setFontFamily(self._fontFamily)
-        style.setFontSize(self._fSizeHead3)
+        style.setFontSize(self._emToPt(nwStyles.H_SIZES[3] if hScale else 1.0))
         style.setFontWeight(self._headWeight)
         style.setColor(hColor)
         style.packXML(self._xStyl)
@@ -990,11 +919,11 @@ class ToOdt(Tokenizer):
         style.setNextStyleName(S_TEXT)
         style.setOutlineLevel("4")
         style.setClass("text")
-        style.setMarginTop(self._mTopHead4)
-        style.setMarginBottom(self._mBotHead4)
+        style.setMarginTop(self._emToCm(self._marginHead4[0]))
+        style.setMarginBottom(self._emToCm(self._marginHead4[1]))
         style.setFontName(self._fontFamily)
         style.setFontFamily(self._fontFamily)
-        style.setFontSize(self._fSizeHead4)
+        style.setFontSize(self._emToPt(nwStyles.H_SIZES[4] if hScale else 1.0))
         style.setFontWeight(self._headWeight)
         style.setColor(hColor)
         style.packXML(self._xStyl)
@@ -1013,10 +942,10 @@ class ToOdt(Tokenizer):
         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.setMarginLeft(self._emToCm(self._marginFoot[0]))
+        style.setMarginBottom(self._emToCm(self._marginFoot[1]))
+        style.setTextIndent("-"+self._emToCm(self._marginFoot[0]))
+        style.setFontSize(self._emToPt(nwStyles.T_SMALL))
         style.packXML(self._xStyl)
         self._mainPara[style.name] = style
 

novelwriter/formats/toqdoc.py

@@ -29,11 +29,12 @@ from pathlib import Path
 
 from PyQt5.QtCore import QMarginsF, QSizeF
 from PyQt5.QtGui import (
-    QColor, QFont, QFontMetricsF, QPageSize, QTextBlockFormat, QTextCharFormat,
-    QTextCursor, QTextDocument
+    QColor, QFont, QFontDatabase, QPageSize, QTextBlockFormat, QTextCharFormat,
+    QTextCursor, QTextDocument, QTextFrameFormat
 )
 from PyQt5.QtPrintSupport import QPrinter
 
+from novelwriter import __version__
 from novelwriter.constants import nwStyles, nwUnicode
 from novelwriter.core.project import NWProject
 from novelwriter.formats.shared import BlockFmt, BlockTyp, T_Formats, TextFmt
@@ -67,16 +68,22 @@ class ToQTextDocument(Tokenizer):
         super().__init__(project)
         self._document = QTextDocument()
         self._document.setUndoRedoEnabled(False)
-        self._document.setDocumentMargin(0)
+        self._document.setDocumentMargin(0.0)
 
         self._usedNotes: dict[str, int] = {}
         self._usedFields: list[tuple[int, str]] = []
 
         self._init = False
-        self._bold = QFont.Weight.Bold
-        self._normal = QFont.Weight.Normal
         self._newPage = False
+        self._anchors = True
 
+        self._hWeight = QFont.Weight.Bold
+        self._dWeight = QFont.Weight.Normal
+        self._dItalic = False
+        self._dStrike = False
+        self._dUnderline = False
+
+        self._dpi = 96
         self._pageSize = QPageSize(QPageSize.PageSizeId.A4)
         self._pageMargins = QMarginsF(20.0, 20.0, 20.0, 20.0)
 
@@ -108,32 +115,52 @@ class ToQTextDocument(Tokenizer):
         self._newPage = state
         return
 
+    def disableAnchors(self) -> None:
+        """Disable anchors for when writing to file."""
+        self._anchors = False
+        return
+
     ##
     #  Class Methods
     ##
 
-    def initDocument(self) -> None:
+    def initDocument(self, pdf: bool = False) -> None:
         """Initialise all computed values of the document."""
         super().initDocument()
 
+        if pdf:
+            fontDB = QFontDatabase()
+            family = self._textFont.family()
+            style = self._textFont.styleName()
+            self._dpi = 1200 if fontDB.isScalable(family, style) else 72
+
         self._document.setUndoRedoEnabled(False)
         self._document.blockSignals(True)
         self._document.clear()
         self._document.setDefaultFont(self._textFont)
 
-        qMetric = QFontMetricsF(self._textFont)
-        mPx = qMetric.ascent()  # 1 em in pixels
-        fPt = self._textFont.pointSizeF()
+        # Default Styles
+        self._dWeight = self._textFont.weight()
+        self._dItalic = self._textFont.italic()
+        self._dStrike = self._textFont.strikeOut()
+        self._dUnderline = self._textFont.underline()
+
+        # Header Weight
+        self._hWeight = QFont.Weight.Bold if self._boldHeads else self._dWeight
 
         # Scaled Sizes
         # ============
 
+        fPt = self._textFont.pointSizeF()
+        fPx = fPt*96.0/72.0  # 1 em in pixels
+        mPx = fPx * self._dpi/96.0
+
         self._mHead = {
-            BlockTyp.TITLE: (mPx * self._marginTitle[0], mPx * self._marginTitle[1]),
-            BlockTyp.HEAD1: (mPx * self._marginHead1[0], mPx * self._marginHead1[1]),
-            BlockTyp.HEAD2: (mPx * self._marginHead2[0], mPx * self._marginHead2[1]),
-            BlockTyp.HEAD3: (mPx * self._marginHead3[0], mPx * self._marginHead3[1]),
-            BlockTyp.HEAD4: (mPx * self._marginHead4[0], mPx * self._marginHead4[1]),
+            BlockTyp.TITLE: (fPx * self._marginTitle[0], fPx * self._marginTitle[1]),
+            BlockTyp.HEAD1: (fPx * self._marginHead1[0], fPx * self._marginHead1[1]),
+            BlockTyp.HEAD2: (fPx * self._marginHead2[0], fPx * self._marginHead2[1]),
+            BlockTyp.HEAD3: (fPx * self._marginHead3[0], fPx * self._marginHead3[1]),
+            BlockTyp.HEAD4: (fPx * self._marginHead4[0], fPx * self._marginHead4[1]),
         }
 
         hScale = self._scaleHeads
@@ -145,9 +172,9 @@ class ToQTextDocument(Tokenizer):
             BlockTyp.HEAD4: (nwStyles.H_SIZES.get(4, 1.0) * fPt) if hScale else fPt,
         }
 
-        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._mText = (fPx * self._marginText[0], fPx * self._marginText[1])
+        self._mMeta = (fPx * self._marginMeta[0], fPx * self._marginMeta[1])
+        self._mSep  = (fPx * self._marginSep[0], fPx * self._marginSep[1])
 
         self._mIndent = mPx * 2.0
         self._tIndent = mPx * self._firstWidth
@@ -242,14 +269,19 @@ class ToQTextDocument(Tokenizer):
     def saveDocument(self, path: Path) -> None:
         """Save the document as a PDF file."""
         m = self._pageMargins
+        logger.info("Writing PDF at %d DPI", self._dpi)
 
-        printer = QPrinter(QPrinter.PrinterMode.PrinterResolution)
+        printer = QPrinter(QPrinter.PrinterMode.HighResolution)
+        printer.setDocName(self._project.data.name)
+        printer.setCreator(f"novelWriter/{__version__}")
+        printer.setResolution(self._dpi)
         printer.setOutputFormat(QPrinter.OutputFormat.PdfFormat)
         printer.setPageSize(self._pageSize)
         printer.setPageMargins(m.left(), m.top(), m.right(), m.bottom(), QPrinter.Unit.Millimeter)
         printer.setOutputFileName(str(path))
 
-        self._document.setPageSize(self._pageSize.size(QPageSize.Unit.Point))
+        self._document.documentLayout().setPaintDevice(printer)
+        self._document.setPageSize(QSizeF(printer.pageRect().size()))
         self._document.print(printer)
 
         return
@@ -309,21 +341,21 @@ class ToQTextDocument(Tokenizer):
 
             # Construct next format
             if fmt == TextFmt.B_B:
-                cFmt.setFontWeight(self._bold)
+                cFmt.setFontWeight(QFont.Weight.Bold)
             elif fmt == TextFmt.B_E:
-                cFmt.setFontWeight(self._normal)
+                cFmt.setFontWeight(self._dWeight)
             elif fmt == TextFmt.I_B:
                 cFmt.setFontItalic(True)
             elif fmt == TextFmt.I_E:
-                cFmt.setFontItalic(False)
+                cFmt.setFontItalic(self._dItalic)
             elif fmt == TextFmt.D_B:
                 cFmt.setFontStrikeOut(True)
             elif fmt == TextFmt.D_E:
-                cFmt.setFontStrikeOut(False)
+                cFmt.setFontStrikeOut(self._dStrike)
             elif fmt == TextFmt.U_B:
                 cFmt.setFontUnderline(True)
             elif fmt == TextFmt.U_E:
-                cFmt.setFontUnderline(False)
+                cFmt.setFontUnderline(self._dUnderline)
             elif fmt == TextFmt.M_B:
                 cFmt.setBackground(self._theme.highlight)
             elif fmt == TextFmt.M_E:
@@ -344,18 +376,22 @@ class ToQTextDocument(Tokenizer):
                 cFmt.setForeground(self._theme.text)
                 primary = None
             elif fmt == TextFmt.ANM_B:
-                cFmt.setAnchor(True)
-                cFmt.setAnchorNames([data])
+                if self._anchors:
+                    cFmt.setAnchor(True)
+                    cFmt.setAnchorNames([data])
             elif fmt == TextFmt.ANM_E:
-                cFmt.setAnchor(False)
+                if self._anchors:
+                    cFmt.setAnchor(False)
             elif fmt == TextFmt.ARF_B:
-                cFmt.setFontUnderline(True)
-                cFmt.setAnchor(True)
-                cFmt.setAnchorHref(data)
+                if self._anchors:
+                    cFmt.setFontUnderline(True)
+                    cFmt.setAnchor(True)
+                    cFmt.setAnchorHref(data)
             elif fmt == TextFmt.ARF_E:
-                cFmt.setFontUnderline(False)
-                cFmt.setAnchor(False)
-                cFmt.setAnchorHref("")
+                if self._anchors:
+                    cFmt.setFontUnderline(False)
+                    cFmt.setAnchor(False)
+                    cFmt.setAnchorHref("")
             elif fmt == TextFmt.HRF_B:
                 cFmt.setForeground(self._theme.link)
                 cFmt.setFontUnderline(True)
@@ -363,7 +399,7 @@ class ToQTextDocument(Tokenizer):
                 cFmt.setAnchorHref(data)
             elif fmt == TextFmt.HRF_E:
                 cFmt.setForeground(primary or self._theme.text)
-                cFmt.setFontUnderline(False)
+                cFmt.setFontUnderline(self._dUnderline)
                 cFmt.setAnchor(False)
                 cFmt.setAnchorHref("")
             elif fmt == TextFmt.FNOTE:
@@ -396,24 +432,36 @@ class ToQTextDocument(Tokenizer):
     def _insertNewPageMarker(self, cursor: QTextCursor) -> None:
         """Insert a new page marker."""
         if self._newPage:
-            cursor.insertHtml("<hr width='100%'>")
+            bgCol = QColor(self._theme.text)
+            bgCol.setAlphaF(0.1)
+            fgCol = QColor(self._theme.text)
+            fgCol.setAlphaF(0.8)
 
-            hFmt = cursor.blockFormat()
-            hFmt.setBottomMargin(0.0)
-            hFmt.setLineHeight(75.0, QtPropLineHeight)
-            cursor.setBlockFormat(hFmt)
+            fFmt = QTextFrameFormat()
+            fFmt.setBorderStyle(QTextFrameFormat.BorderStyle.BorderStyle_None)
+            fFmt.setBackground(bgCol)
+            fFmt.setTopMargin(self._mSep[0])
+            fFmt.setBottomMargin(self._mSep[1])
 
             bFmt = QTextBlockFormat(self._blockFmt)
             bFmt.setAlignment(QtAlignCenter)
             bFmt.setTopMargin(0.0)
-            bFmt.setLineHeight(75.0, QtPropLineHeight)
+            bFmt.setBottomMargin(0.0)
+            bFmt.setLineHeight(100.0, QtPropLineHeight)
 
             cFmt = QTextCharFormat(self._charFmt)
+            cFmt.setFontItalic(False)
+            cFmt.setFontUnderline(False)
+            cFmt.setFontStrikeOut(False)
+            cFmt.setFontWeight(QFont.Weight.Normal)
             cFmt.setFontPointSize(0.75*self._textFont.pointSizeF())
-            cFmt.setForeground(self._theme.comment)
+            cFmt.setForeground(fgCol)
 
-            newBlock(cursor, bFmt)
+            cursor.insertFrame(fFmt)
+            cursor.setBlockFormat(bFmt)
             cursor.insertText(self._project.localLookup("New Page"), cFmt)
+            cursor.swap(self._document.rootFrame().lastCursorPosition())
+
         return
 
     def _genHeadStyle(self, hType: BlockTyp, hKey: str, rFmt: QTextBlockFormat) -> T_TextStyle:
@@ -427,9 +475,9 @@ class ToQTextDocument(Tokenizer):
         hCol = self._colorHeads and hType != BlockTyp.TITLE
         cFmt = QTextCharFormat(self._charFmt)
         cFmt.setForeground(self._theme.head if hCol else self._theme.text)
-        cFmt.setFontWeight(self._bold if self._boldHeads else self._normal)
+        cFmt.setFontWeight(self._hWeight)
         cFmt.setFontPointSize(self._sHead.get(hType, 1.0))
-        if hKey:
+        if hKey and self._anchors:
             cFmt.setAnchorNames([hKey])
             cFmt.setAnchor(True)