novelWriter 2.6.3__py3-none-any.whl → 2.7b1__py3-none-any.whl

novelwriter/extensions/versioninfo.py

@@ -31,9 +31,9 @@ from time import sleep
 from urllib.error import HTTPError
 from urllib.request import Request, urlopen
 
-from PyQt5.QtCore import QObject, QRunnable, QUrl, pyqtSignal, pyqtSlot
-from PyQt5.QtGui import QDesktopServices
-from PyQt5.QtWidgets import QLabel, QVBoxLayout, QWidget
+from PyQt6.QtCore import QObject, QRunnable, QUrl, pyqtSignal, pyqtSlot
+from PyQt6.QtGui import QDesktopServices
+from PyQt6.QtWidgets import QLabel, QVBoxLayout, QWidget
 
 from novelwriter import CONFIG, SHARED, __date__, __domain__, __version__
 from novelwriter.common import formatVersion
@@ -70,7 +70,7 @@ class VersionInfoWidget(QWidget):
         self._layout = QVBoxLayout()
         self._layout.addWidget(self._lblInfo)
         self._layout.addWidget(self._lblRelease)
-        self._layout.setSpacing(CONFIG.pxInt(2))
+        self._layout.setSpacing(2)
         self._layout.setContentsMargins(0, 0, 0, 0)
 
         self.setLayout(self._layout)

novelwriter/formats/shared.py

@@ -27,7 +27,7 @@ import re
 
 from enum import Flag, IntEnum
 
-from PyQt5.QtGui import QColor
+from PyQt6.QtGui import QColor
 
 ESCAPES = {r"\*": "*", r"\~": "~", r"\_": "_", r"\[": "[", r"\]": "]", r"\ ": ""}
 RX_ESC = re.compile("|".join([re.escape(k) for k in ESCAPES.keys()]), flags=re.DOTALL)

novelwriter/formats/todocx.py

@@ -29,21 +29,25 @@ import re
 import xml.etree.ElementTree as ET
 
 from datetime import datetime
-from pathlib import Path
-from typing import NamedTuple
+from typing import TYPE_CHECKING, NamedTuple
 from zipfile import ZIP_DEFLATED, ZipFile
 
-from PyQt5.QtCore import QMargins, QSize
-from PyQt5.QtGui import QColor
+from PyQt6.QtCore import QMargins, QSize
 
 from novelwriter import __version__
 from novelwriter.common import firstFloat, xmlElement, xmlSubElem
 from novelwriter.constants import nwHeadFmt, nwStyles
-from novelwriter.core.project import NWProject
 from novelwriter.formats.shared import BlockFmt, BlockTyp, T_Formats, TextFmt
 from novelwriter.formats.tokenizer import Tokenizer
 from novelwriter.types import QtHexRgb
 
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from PyQt6.QtGui import QColor
+
+    from novelwriter.core.project import NWProject
+
 logger = logging.getLogger(__name__)
 
 # RegEx
@@ -212,9 +216,9 @@ class ToDocX(Tokenizer):
         self._pageMargins = QMargins(_mmToSz(left), _mmToSz(top), _mmToSz(right), _mmToSz(bottom))
         return
 
-    def setHeaderFormat(self, format: str, offset: int) -> None:
+    def setHeaderFormat(self, value: str, offset: int) -> None:
         """Set the document header format."""
-        self._headerFormat = format.strip()
+        self._headerFormat = value.strip()
         self._pageOffset = offset
         return
 
@@ -1052,9 +1056,9 @@ class ToDocX(Tokenizer):
 class DocXParagraph:
 
     __slots__ = (
-        "_content", "_style", "_textAlign",
-        "_topMargin", "_bottomMargin", "_leftMargin", "_rightMargin",
-        "_indentFirst", "_breakBefore", "_breakAfter", "_footnoteRef",
+        "_bottomMargin", "_breakAfter", "_breakBefore", "_content",
+        "_footnoteRef", "_indentFirst", "_leftMargin", "_rightMargin",
+        "_style", "_textAlign", "_topMargin",
     )
 
     def __init__(self) -> None:

novelwriter/formats/tohtml.py

@@ -26,16 +26,20 @@ from __future__ import annotations
 import json
 import logging
 
-from pathlib import Path
 from time import time
+from typing import TYPE_CHECKING
 
 from novelwriter.common import formatTimeStamp
 from novelwriter.constants import nwHtmlUnicode, nwStyles
-from novelwriter.core.project import NWProject
 from novelwriter.formats.shared import BlockFmt, BlockTyp, T_Formats, TextFmt, stripEscape
 from novelwriter.formats.tokenizer import Tokenizer
 from novelwriter.types import FONT_STYLE, FONT_WEIGHTS, QtHexRgb
 
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from novelwriter.core.project import NWProject
+
 logger = logging.getLogger(__name__)
 
 # Each opener tag, with the id of its corresponding closer and tag format
@@ -311,10 +315,8 @@ class ToHtml(Tokenizer):
 
     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))
+        pages = [aLine.replace("\t", tabSpace) for aLine in self._pages]
         self._pages = pages
         return
 

novelwriter/formats/tokenizer.py

@@ -28,11 +28,10 @@ import logging
 import re
 
 from abc import ABC, abstractmethod
-from pathlib import Path
-from typing import NamedTuple
+from typing import TYPE_CHECKING, NamedTuple
 
-from PyQt5.QtCore import QLocale
-from PyQt5.QtGui import QColor, QFont
+from PyQt6.QtCore import QLocale
+from PyQt6.QtGui import QColor, QFont
 
 from novelwriter import CONFIG
 from novelwriter.common import checkInt, fontMatcher, numberToRoman
@@ -40,14 +39,18 @@ from novelwriter.constants import (
     nwHeadFmt, nwKeyWords, nwLabels, nwShortcode, nwStats, nwStyles, nwUnicode,
     trConst
 )
-from novelwriter.core.index import processComment
-from novelwriter.core.project import NWProject
 from novelwriter.enum import nwComment, nwItemLayout
 from novelwriter.formats.shared import (
     BlockFmt, BlockTyp, T_Block, T_Formats, T_Note, TextDocumentTheme, TextFmt
 )
+from novelwriter.text.comments import processComment
 from novelwriter.text.patterns import REGEX_PATTERNS, DialogParser
 
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from novelwriter.core.project import NWProject
+
 logger = logging.getLogger(__name__)
 
 
@@ -61,18 +64,18 @@ class ComStyle(NamedTuple):
 COMMENT_STYLE = {
     nwComment.PLAIN:    ComStyle("Comment", "comment", "comment"),
     nwComment.IGNORE:   ComStyle(),
-    nwComment.SYNOPSIS: ComStyle("Synopsis", "modifier", "synopsis"),
-    nwComment.SHORT:    ComStyle("Short Description", "modifier", "synopsis"),
+    nwComment.SYNOPSIS: ComStyle("Synopsis", "modifier", "note"),
+    nwComment.SHORT:    ComStyle("Short Description", "modifier", "note"),
     nwComment.NOTE:     ComStyle("Note", "modifier", "note"),
     nwComment.FOOTNOTE: ComStyle("", "modifier", "note"),
     nwComment.COMMENT:  ComStyle(),
-    nwComment.STORY:    ComStyle("", "modifier", "note"),
+    nwComment.STORY:    ComStyle("Story Structure", "modifier", "note"),
 }
 HEADINGS = [
     BlockTyp.TITLE, BlockTyp.PART, BlockTyp.HEAD1,
     BlockTyp.HEAD2, BlockTyp.HEAD3, BlockTyp.HEAD4,
 ]
-SKIP_INDENT = HEADINGS + [BlockTyp.SEP, BlockTyp.SKIP]
+SKIP_INDENT = [*HEADINGS, BlockTyp.SEP, BlockTyp.SKIP]
 B_EMPTY: T_Block = (BlockTyp.EMPTY, "", "", [], BlockFmt.NONE)
 
 
@@ -118,14 +121,16 @@ class Tokenizer(ABC):
         self._indentFirst  = False   # Indent first paragraph
         self._doJustify    = False   # Justify text
         self._doBodyText   = True    # Include body text
-        self._doSynopsis   = False   # Also process synopsis comments
-        self._doComments   = False   # Also process comments
+        self._doComments   = set()   # Comment styles to allow
         self._doKeywords   = False   # Also process keywords like tags and references
         self._keepBreaks   = True    # Keep line breaks in paragraphs
         self._defaultAlign = "left"  # The default text alignment
 
         self._skipKeywords: set[str] = set()  # Keywords to ignore
 
+        # Defaults
+        self._doComments.add(nwComment.FOOTNOTE)
+
         # Other Setting
         self._theme = TextDocumentTheme()
         self._classes: dict[str, QColor] = {}
@@ -393,14 +398,12 @@ class Tokenizer(ABC):
         self._doBodyText = state
         return
 
-    def setSynopsis(self, state: bool) -> None:
-        """Include synopsis comments in build."""
-        self._doSynopsis = state
-        return
-
-    def setComments(self, state: bool) -> None:
-        """Include comments in build."""
-        self._doComments = state
+    def setCommentType(self, comment: nwComment, state: bool) -> None:
+        """Toggle the inclusion og certain comment types."""
+        if state:
+            self._doComments.add(comment)
+        else:
+            self._doComments.discard(comment)
         return
 
     def setKeywords(self, state: bool) -> None:
@@ -437,7 +440,7 @@ class Tokenizer(ABC):
     def initDocument(self) -> None:
         """Initialise data after settings."""
         self._classes["modifier"] = self._theme.modifier
-        self._classes["synopsis"] = self._theme.note
+        self._classes["note"] = self._theme.note
         self._classes["comment"] = self._theme.comment
         self._classes["dialog"] = self._theme.dialog
         self._classes["altdialog"] = self._theme.altdialog
@@ -604,15 +607,15 @@ class Tokenizer(ABC):
                     continue
 
                 cStyle, cKey, cText, _, _ = processComment(aLine)
-                if cStyle in (nwComment.SYNOPSIS, nwComment.SHORT) and not self._doSynopsis:
-                    continue
-                if cStyle == nwComment.PLAIN and not self._doComments:
+                if cStyle not in self._doComments:
                     continue
 
                 if doJustify and not tStyle & BlockFmt.ALIGNED:
                     tStyle |= BlockFmt.JUSTIFY
 
-                if cStyle in (nwComment.SYNOPSIS, nwComment.SHORT, nwComment.PLAIN):
+                if cStyle in (
+                    nwComment.SYNOPSIS, nwComment.SHORT, nwComment.PLAIN, nwComment.STORY
+                ):
                     bStyle = COMMENT_STYLE[cStyle]
                     tLine, tFmt = self._formatComment(bStyle, cKey, cText)
                     tBlocks.append((
@@ -651,7 +654,7 @@ class Tokenizer(ABC):
                 tText = aLine[2:].strip()
                 tType = BlockTyp.HEAD1 if isPlain else BlockTyp.TITLE
                 sHide = self._hidePart if isPlain else False
-                if not (isPlain or isNovel and sHide):
+                if not (isPlain or (isNovel and sHide)):
                     tStyle |= self._titleStyle
                 if isNovel:
                     tType = BlockTyp.PART if isPlain else BlockTyp.TITLE
@@ -1034,10 +1037,12 @@ class Tokenizer(ABC):
 
     def _formatComment(self, style: ComStyle, key: str, text: str) -> tuple[str, T_Formats]:
         """Apply formatting to comments and notes."""
+        rFmt = []
         tTxt, tFmt = self._extractFormats(text)
         tFmt.insert(0, (0, TextFmt.COL_B, style.textClass))
         tFmt.append((len(tTxt), TextFmt.COL_E, ""))
-        if label := (self._localLookup(style.label) + (f" ({key})" if key else "")).strip():
+        term = f" ({key.title()})" if key else ""
+        if label := f"{self._localLookup(style.label)}{term}".strip():
             shift = len(label) + 2
             tTxt = f"{label}: {tTxt}"
             rFmt = [(0, TextFmt.B_B, ""), (shift - 1, TextFmt.B_E, "")]
@@ -1123,12 +1128,10 @@ class Tokenizer(ABC):
             temp.append((res.end(0), 0, TextFmt.HRF_E, ""))
 
         # Match Shortcodes
-        for res in REGEX_PATTERNS.shortcodePlain.finditer(text):
-            temp.append((
-                res.start(1), res.end(1),
-                self._shortCodeFmt.get(res.group(1).lower(), 0),
-                "",
-            ))
+        temp.extend(
+            (res.start(1), res.end(1), self._shortCodeFmt.get(res.group(1).lower(), 0), "")
+            for res in REGEX_PATTERNS.shortcodePlain.finditer(text)
+        )
 
         # Match Shortcode w/Values
         tHandle = self._handle or ""

novelwriter/formats/tomarkdown.py

@@ -25,13 +25,17 @@ from __future__ import annotations
 
 import logging
 
-from pathlib import Path
+from typing import TYPE_CHECKING
 
 from novelwriter.constants import nwUnicode
-from novelwriter.core.project import NWProject
 from novelwriter.formats.shared import BlockFmt, BlockTyp, T_Formats, TextFmt
 from novelwriter.formats.tokenizer import Tokenizer
 
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from novelwriter.core.project import NWProject
+
 logger = logging.getLogger(__name__)
 
 

novelwriter/formats/toodt.py

@@ -29,22 +29,26 @@ 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 typing import TYPE_CHECKING, Final
 from zipfile import ZIP_DEFLATED, ZipFile
 
-from PyQt5.QtGui import QColor, QFont
+from PyQt6.QtGui import QColor, QFont
 
 from novelwriter import __version__
 from novelwriter.common import xmlElement, xmlIndent, xmlSubElem
 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, QtHexRgb
 
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+    from pathlib import Path
+
+    from novelwriter.core.project import NWProject
+
 logger = logging.getLogger(__name__)
 
 # Main XML NameSpaces
@@ -203,9 +207,9 @@ class ToOdt(Tokenizer):
         self._mDocRight  = f"{right/10.0:.3f}cm"
         return
 
-    def setHeaderFormat(self, format: str, offset: int) -> None:
+    def setHeaderFormat(self, value: str, offset: int) -> None:
         """Set the document header format."""
-        self._headerFormat = format.strip()
+        self._headerFormat = value.strip()
         self._pageOffset = offset
         return
 
@@ -598,6 +602,7 @@ class ToOdt(Tokenizer):
     def _textStyle(self, hFmt: int, fClass: str = "") -> str:
         """Return a text style for a given style code."""
         tKey = str(hFmt)
+        color = None
         if fClass and (color := self._classes.get(fClass)):
             tKey = f"{tKey}:{fClass}"
         if tKey in self._autoText:
@@ -999,11 +1004,11 @@ class ODTParagraphStyle:
     exporter. Only the used settings are exposed here to keep the class
     minimal and fast.
     """
-    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", "extra"]
-    VALID_WEIGHT = ["normal", "bold"] + FONT_WEIGHT_NUM
+    VALID_ALIGN: Final[list[str]]  = ["start", "center", "end", "justify", "left", "right"]
+    VALID_BREAK: Final[list[str]]  = ["auto", "page", "even-page", "odd-page", "inherit"]
+    VALID_LEVEL: Final[list[str]]  = ["1", "2", "3", "4"]
+    VALID_CLASS: Final[list[str]]  = ["text", "chapter", "extra"]
+    VALID_WEIGHT: Final[list[str]] = ["normal", "bold", *FONT_WEIGHT_NUM]
 
     def __init__(self, name: str) -> None:
 
@@ -1206,9 +1211,9 @@ class ODTParagraphStyle:
     def getID(self) -> str:
         """Generate a unique ID from the settings."""
         return sha256((
-            f"Paragraph:Main:{str(self._mAttr)}:"
-            f"Paragraph:Para:{str(self._pAttr)}:"
-            f"Paragraph:Text:{str(self._tAttr)}:"
+            f"Paragraph:Main:{self._mAttr!s}:"
+            f"Paragraph:Para:{self._pAttr!s}:"
+            f"Paragraph:Text:{self._tAttr!s}:"
         ).encode()).hexdigest()
 
     def packXML(self, xParent: ET.Element) -> None:
@@ -1236,13 +1241,13 @@ class ODTTextStyle:
     Only the used settings are exposed here to keep the class minimal
     and fast.
     """
-    VALID_WEIGHT = ["normal", "bold"] + FONT_WEIGHT_NUM
-    VALID_STYLE  = ["normal", "italic", "oblique"]
-    VALID_POS    = ["super", "sub"]
-    VALID_LSTYLE = ["none", "solid"]
-    VALID_LTYPE  = ["single", "double"]
-    VALID_LWIDTH = ["auto"]
-    VALID_LCOL   = ["font-color"]
+    VALID_WEIGHT: Final[list[str]] = ["normal", "bold", *FONT_WEIGHT_NUM]
+    VALID_STYLE: Final[list[str]]  = ["normal", "italic", "oblique"]
+    VALID_POS: Final[list[str]]    = ["super", "sub"]
+    VALID_LSTYLE: Final[list[str]] = ["none", "solid"]
+    VALID_LTYPE: Final[list[str]]  = ["single", "double"]
+    VALID_LWIDTH: Final[list[str]] = ["auto"]
+    VALID_LCOL: Final[list[str]]   = ["font-color"]
 
     def __init__(self, name: str) -> None:
         self._name = name
@@ -1508,7 +1513,7 @@ class XMLParagraph:
         errMsg = ""
         nMissed = len(self._rawTxt) - self._chrPos
         if nMissed != 0:
-            errMsg = "%d char(s) were not written: '%s'" % (nMissed, self._rawTxt)
+            errMsg = f"{nMissed} char(s) were not written: '{self._rawTxt}'"
         return nMissed, errMsg
 
     ##

novelwriter/formats/toqdoc.py

@@ -25,18 +25,17 @@ from __future__ import annotations
 
 import logging
 
-from pathlib import Path
+from typing import TYPE_CHECKING
 
-from PyQt5.QtCore import QMarginsF, QSizeF
-from PyQt5.QtGui import (
-    QColor, QFont, QFontDatabase, QPageSize, QTextBlockFormat, QTextCharFormat,
-    QTextCursor, QTextDocument, QTextFrameFormat
+from PyQt6.QtCore import QMarginsF, QSizeF
+from PyQt6.QtGui import (
+    QColor, QFont, QFontDatabase, QPageLayout, QPageSize, QTextBlockFormat,
+    QTextCharFormat, QTextCursor, QTextDocument, QTextFrameFormat
 )
-from PyQt5.QtPrintSupport import QPrinter
+from PyQt6.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
 from novelwriter.formats.tokenizer import HEADINGS, Tokenizer
 from novelwriter.types import (
@@ -45,6 +44,11 @@ from novelwriter.types import (
     QtPropLineHeight, QtTransparent, QtVAlignNormal, QtVAlignSub, QtVAlignSuper
 )
 
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from novelwriter.core.project import NWProject
+
 logger = logging.getLogger(__name__)
 
 T_TextStyle = tuple[QTextBlockFormat, QTextCharFormat]
@@ -129,10 +133,9 @@ class ToQTextDocument(Tokenizer):
         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._dpi = 1200 if QFontDatabase.isScalable(family, style) else 72
 
         self._document.setUndoRedoEnabled(False)
         self._document.blockSignals(True)
@@ -270,7 +273,6 @@ 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.HighResolution)
@@ -279,11 +281,13 @@ class ToQTextDocument(Tokenizer):
         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.setPageMargins(self._pageMargins, QPageLayout.Unit.Millimeter)
         printer.setOutputFileName(str(path))
 
-        self._document.documentLayout().setPaintDevice(printer)
-        self._document.setPageSize(QSizeF(printer.pageRect().size()))
+        if layout := self._document.documentLayout():
+            layout.setPaintDevice(printer)
+
+        self._document.setPageSize(printer.pageRect(QPrinter.Unit.DevicePixel).size())
         self._document.print(printer)
 
         return
@@ -462,7 +466,8 @@ class ToQTextDocument(Tokenizer):
             cursor.insertFrame(fFmt)
             cursor.setBlockFormat(bFmt)
             cursor.insertText(self._project.localLookup("New Page"), cFmt)
-            cursor.swap(self._document.rootFrame().lastCursorPosition())
+            if root := self._document.rootFrame():
+                cursor.swap(root.lastCursorPosition())
 
         return
 

novelwriter/formats/toraw.py

@@ -26,13 +26,17 @@ from __future__ import annotations
 import json
 import logging
 
-from pathlib import Path
 from time import time
+from typing import TYPE_CHECKING
 
 from novelwriter.common import formatTimeStamp
-from novelwriter.core.project import NWProject
 from novelwriter.formats.tokenizer import Tokenizer
 
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from novelwriter.core.project import NWProject
+
 logger = logging.getLogger(__name__)