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

novelwriter/assets/text/credits_en.htm

@@ -35,6 +35,7 @@ translators for the languages currently available:</p>
   <li><b>Norwegian:</b> Veronica Berglyd Olsen (vkbo)</li>
   <li><b>Polish:</b> Anna Maria Polak (Nauthiz)</li>
   <li><b>Portuguese:</b> Bruno Meneguello (bkmeneguello)</li>
+  <li><b>Russian:</b> Konstantin Tan (k1kimosha)</li>
   <li><b>Simplified Chinese:</b> Qianzhi Long (longqzh)</li>
 </ul>
 

novelwriter/common.py

@@ -37,8 +37,8 @@ from typing import TYPE_CHECKING, Any, Literal, TypeVar
 from urllib.parse import urljoin
 from urllib.request import pathname2url
 
-from PyQt5.QtCore import QCoreApplication, QUrl
-from PyQt5.QtGui import QColor, QDesktopServices, QFont, QFontInfo
+from PyQt5.QtCore import QCoreApplication, QMimeData, QUrl
+from PyQt5.QtGui import QColor, QDesktopServices, QFont, QFontDatabase, QFontInfo
 
 from novelwriter.constants import nwConst, nwLabels, nwUnicode, trConst
 from novelwriter.enum import nwItemClass, nwItemLayout, nwItemType
@@ -434,6 +434,30 @@ def describeFont(font: QFont) -> str:
     return "Error"
 
 
+def fontMatcher(font: QFont) -> QFont:
+    """Make sure the font is the correct family, if possible. This
+    ensures that Qt doesn't re-use another font under the hood. The
+    default Qt5 font matching algorithm doesn't handle well changing
+    application fonts at runtime.
+    """
+    info = QFontInfo(font)
+    if (famRequest := font.family()) != (famActual := info.family()):
+        logger.warning("Font mismatch: Requested '%s', but got '%s'", famRequest, famActual)
+        db = QFontDatabase()
+        if famRequest in db.families():
+            styleRequest, sizeRequest = font.styleName(), font.pointSize()
+            logger.info("Lookup: %s, %s, %d pt", famRequest, styleRequest, sizeRequest)
+            temp = db.font(famRequest, styleRequest, sizeRequest)
+            temp.setPointSize(sizeRequest)  # Make sure it isn't changed
+            famFound, styleFound, sizeFound = temp.family(), temp.styleName(), temp.pointSize()
+            if famFound == famRequest:
+                logger.info("Found: %s, %s, %d pt", famFound, styleFound, sizeFound)
+                return temp
+        logger.warning("Could not find a font match in the font database")
+        logger.warning("If you just changed font, you may need to restart the application")
+    return font
+
+
 def qtLambda(func: Callable, *args: Any, **kwargs: Any) -> Callable:
     """A replacement for Python lambdas that works for Qt slots."""
     def wrapper(*a_: Any) -> None:
@@ -441,6 +465,17 @@ def qtLambda(func: Callable, *args: Any, **kwargs: Any) -> Callable:
     return wrapper
 
 
+def encodeMimeHandles(mimeData: QMimeData, handles: list[str]) -> None:
+    """Encode handles into a mime data object."""
+    mimeData.setData(nwConst.MIME_HANDLE, b"|".join(h.encode() for h in handles))
+    return
+
+
+def decodeMimeHandles(mimeData: QMimeData) -> list[str]:
+    """Decode and split a mime data object with handles."""
+    return mimeData.data(nwConst.MIME_HANDLE).data().decode().split("|")
+
+
 ##
 #  Encoder Functions
 ##

novelwriter/config.py

@@ -40,7 +40,10 @@ from PyQt5.QtCore import (
 from PyQt5.QtGui import QFont, QFontDatabase
 from PyQt5.QtWidgets import QApplication
 
-from novelwriter.common import NWConfigParser, checkInt, checkPath, describeFont, formatTimeStamp
+from novelwriter.common import (
+    NWConfigParser, checkInt, checkPath, describeFont, fontMatcher,
+    formatTimeStamp
+)
 from novelwriter.constants import nwFiles, nwUnicode
 from novelwriter.error import formatException, logException
 
@@ -369,10 +372,11 @@ class Config:
     def setGuiFont(self, value: QFont | str | None) -> None:
         """Update the GUI's font style from settings."""
         if isinstance(value, QFont):
-            self.guiFont = value
+            self.guiFont = fontMatcher(value)
         elif value and isinstance(value, str):
-            self.guiFont = QFont()
-            self.guiFont.fromString(value)
+            font = QFont()
+            font.fromString(value)
+            self.guiFont = fontMatcher(font)
         else:
             font = QFont()
             fontDB = QFontDatabase()
@@ -382,11 +386,9 @@ class Config:
                 font.setPointSize(10)
             else:
                 font = fontDB.systemFont(QFontDatabase.SystemFont.GeneralFont)
-            self.guiFont = font
+            self.guiFont = fontMatcher(font)
             logger.debug("GUI font set to: %s", describeFont(font))
-
         QApplication.setFont(self.guiFont)
-
         return
 
     def setTextFont(self, value: QFont | str | None) -> None:
@@ -394,10 +396,11 @@ class Config:
         set to default font.
         """
         if isinstance(value, QFont):
-            self.textFont = value
+            self.textFont = fontMatcher(value)
         elif value and isinstance(value, str):
-            self.textFont = QFont()
-            self.textFont.fromString(value)
+            font = QFont()
+            font.fromString(value)
+            self.textFont = fontMatcher(font)
         else:
             fontDB = QFontDatabase()
             fontFam = fontDB.families()
@@ -411,8 +414,8 @@ class Config:
                 font.setPointSize(12)
             else:
                 font = fontDB.systemFont(QFontDatabase.SystemFont.GeneralFont)
-            self.textFont = font
-            logger.debug("Text font set to: %s", describeFont(font))
+            self.textFont = fontMatcher(font)
+            logger.debug("Text font set to: %s", describeFont(self.textFont))
         return
 
     ##

novelwriter/constants.py

@@ -53,6 +53,9 @@ class nwConst:
     # Requests
     USER_AGENT = "Mozilla/5.0 (compatible; novelWriter (Python))"
 
+    # Mime Types
+    MIME_HANDLE = "text/vnd.novelwriter.handle"
+
     # Gui Settings
     STATUS_MSG_TIMEOUT = 15000  # milliseconds
     MAX_SEARCH_RESULT = 1000
@@ -105,6 +108,9 @@ class nwStyles:
     H_LEVEL = {"H0": 0, "H1": 1, "H2": 2, "H3": 3, "H4": 4}
     H_SIZES = {0: 2.50, 1: 2.00, 2: 1.75, 3: 1.50, 4: 1.25}
 
+    T_NORMAL = 1.0
+    T_SMALL  = 0.8
+
     T_LABEL = {
         "H0": QT_TRANSLATE_NOOP("Constant", "Title"),
         "H1": QT_TRANSLATE_NOOP("Constant", "Heading 1 (Partition)"),
@@ -115,15 +121,15 @@ class nwStyles:
         "SP": QT_TRANSLATE_NOOP("Constant", "Scene Separator"),
     }
     T_MARGIN = {
-        "H0": (1.42, 0.50),  # Title margins
-        "H1": (1.42, 0.50),  # Heading 1 margins
-        "H2": (1.67, 0.50),  # Heading 2 margins
-        "H3": (1.17, 0.50),  # Heading 3 margins
-        "H4": (1.17, 0.50),  # Heading 4 margins
-        "TT": (0.00, 0.58),  # Text margins
-        "SP": (1.17, 1.17),  # Separator margins
-        "MT": (0.00, 0.58),  # Meta margins
-        "FT": (1.42, 0.47),  # Footnote margins
+        "H0": (1.50, 0.60),  # Title margins (top, bottom)
+        "H1": (1.50, 0.60),  # Heading 1 margins (top, bottom)
+        "H2": (1.50, 0.60),  # Heading 2 margins (top, bottom)
+        "H3": (1.20, 0.60),  # Heading 3 margins (top, bottom)
+        "H4": (1.20, 0.60),  # Heading 4 margins (top, bottom)
+        "TT": (0.00, 0.60),  # Text margins (top, bottom)
+        "SP": (1.20, 1.20),  # Separator margins (top, bottom)
+        "MT": (0.00, 0.60),  # Meta margins (top, bottom)
+        "FT": (1.40, 0.40),  # Footnote margins (left, bottom)
     }
 
 
@@ -268,6 +274,10 @@ class nwLabels:
         "doc_h4":   QT_TRANSLATE_NOOP("Constant", "Novel Section"),
         "note":     QT_TRANSLATE_NOOP("Constant", "Project Note"),
     }
+    ACTIVE_NAME = {
+        "checked":   QT_TRANSLATE_NOOP("Constant", "Active"),
+        "unchecked": QT_TRANSLATE_NOOP("Constant", "Inactive"),
+    }
     KEY_NAME = {
         nwKeyWords.TAG_KEY:     QT_TRANSLATE_NOOP("Constant", "Tag"),
         nwKeyWords.POV_KEY:     QT_TRANSLATE_NOOP("Constant", "Point of View"),
@@ -542,6 +552,11 @@ class nwUnicode:
     U_LTRI   = "\u25c0"  # Left-pointing triangle
     U_LTRIS  = "\u25c2"  # Left-pointing triangle, small
 
+    # Special
+    U_UNKN   = "\ufffd"  # Unknown character
+    U_NAC1   = "\ufffe"  # Not a character
+    U_NAC2   = "\uffff"  # Not a character
+
     # HTML Equivalents
     # ================
 

novelwriter/core/coretools.py

@@ -56,10 +56,17 @@ class DocMerger:
     def __init__(self, project: NWProject) -> None:
         self._project = project
         self._error = ""
-        self._targetDoc = None
-        self._targetText = []
+        self._target = None
+        self._text = []
         return
 
+    @property
+    def targetHandle(self) -> str | None:
+        """Get the handle of the target document."""
+        if self._target:
+            return self._target.itemHandle
+        return None
+
     ##
     #  Methods
     ##
@@ -72,63 +79,56 @@ class DocMerger:
         """Set the target document for the merging. Calling this
         function resets the class.
         """
-        self._targetDoc = tHandle
-        self._targetText = []
+        self._target = self._project.tree[tHandle]
+        self._text = []
         return
 
-    def newTargetDoc(self, srcHandle: str, docLabel: str) -> str | None:
+    def newTargetDoc(self, sHandle: str, label: str) -> None:
         """Create a brand new target document based on a source handle
         and a new doc label. Calling this function resets the class.
         """
-        srcItem = self._project.tree[srcHandle]
-        if srcItem is None or srcItem.itemParent is None:
-            return None
-
-        newHandle = self._project.newFile(docLabel, srcItem.itemParent)
-        newItem = self._project.tree[newHandle]
-        if isinstance(newItem, NWItem):
-            newItem.setLayout(srcItem.itemLayout)
-            newItem.setStatus(srcItem.itemStatus)
-            newItem.setImport(srcItem.itemImport)
-
-        self._targetDoc = newHandle
-        self._targetText = []
-
-        return newHandle
+        sItem = self._project.tree[sHandle]
+        if sItem and sItem.itemParent:
+            tHandle = self._project.newFile(label, sItem.itemParent)
+            if nwItem := self._project.tree[tHandle]:
+                nwItem.setLayout(sItem.itemLayout)
+                nwItem.setStatus(sItem.itemStatus)
+                nwItem.setImport(sItem.itemImport)
+                nwItem.notifyToRefresh()
+                self._target = nwItem
+                self._text = []
+        return
 
-    def appendText(self, srcHandle: str, addComment: bool, cmtPrefix: str) -> bool:
+    def appendText(self, sHandle: str, addComment: bool, cmtPrefix: str) -> None:
         """Append text from an existing document to the text buffer."""
-        srcItem = self._project.tree[srcHandle]
-        if srcItem is None:
-            return False
-
-        docText = self._project.storage.getDocumentText(srcHandle).rstrip("\n")
-        if addComment:
-            docInfo = srcItem.describeMe()
-            docSt, _ = srcItem.getImportStatus()
-            cmtLine = f"% {cmtPrefix} {docInfo}: {srcItem.itemName} [{docSt}]\n\n"
-            docText = cmtLine + docText
-
-        self._targetText.append(docText)
-
-        return True
+        if item := self._project.tree[sHandle]:
+            text = self._project.storage.getDocumentText(sHandle).rstrip("\n")
+            if addComment:
+                info = item.describeMe()
+                status, _ = item.getImportStatus()
+                text = f"% {cmtPrefix} {info}: {item.itemName} [{status}]\n\n{text}"
+            self._text.append(text)
+        return
 
     def writeTargetDoc(self) -> bool:
         """Write the accumulated text into the designated target
         document, appending any existing text.
         """
-        if self._targetDoc is None:
-            return False
+        if self._target:
+            outDoc = self._project.storage.getDocument(self._target.itemHandle)
+            if text := (outDoc.readDocument() or "").rstrip("\n"):
+                self._text.insert(0, text)
 
-        outDoc = self._project.storage.getDocument(self._targetDoc)
-        if text := (outDoc.readDocument() or "").rstrip("\n"):
-            self._targetText.insert(0, text)
+            status = outDoc.writeDocument("\n\n".join(self._text) + "\n\n")
+            if not status:
+                self._error = outDoc.getError()
 
-        status = outDoc.writeDocument("\n\n".join(self._targetText) + "\n\n")
-        if not status:
-            self._error = outDoc.getError()
+            self._project.index.reIndexHandle(self._target.itemHandle)
+            self._target.notifyToRefresh()
 
-        return status
+            return status
+
+        return False
 
 
 class DocSplitter:
@@ -172,23 +172,19 @@ class DocSplitter:
         self._inFolder = False
         return
 
-    def newParentFolder(self, pHandle: str, folderLabel: str) -> str | None:
+    def newParentFolder(self, pHandle: str, folderLabel: str) -> None:
         """Create a new folder that will be the top level parent item
         for the new documents.
         """
-        if self._srcItem is None:
-            return None
-
-        newHandle = self._project.newFolder(folderLabel, pHandle)
-        newItem = self._project.tree[newHandle]
-        if isinstance(newItem, NWItem):
-            newItem.setStatus(self._srcItem.itemStatus)
-            newItem.setImport(self._srcItem.itemImport)
-
-        self._parHandle = newHandle
-        self._inFolder = True
-
-        return newHandle
+        if self._srcItem:
+            nHandle = self._project.newFolder(folderLabel, pHandle)
+            if nwItem := self._project.tree[nHandle]:
+                nwItem.setStatus(self._srcItem.itemStatus)
+                nwItem.setImport(self._srcItem.itemImport)
+                nwItem.notifyToRefresh()
+            self._parHandle = nHandle
+            self._inFolder = True
+        return
 
     def splitDocument(self, splitData: list, splitText: list[str]) -> None:
         """Loop through the split data record and perform the split job
@@ -202,58 +198,50 @@ class DocSplitter:
             self._rawData.insert(0, (chunk, hLevel, hLabel))
         return
 
-    def writeDocuments(self, docHierarchy: bool) -> Iterable[tuple[bool, str | None, str | None]]:
+    def writeDocuments(self, docHierarchy: bool) -> Iterable[bool]:
         """An iterator that will write each document in the buffer, and
         return its new handle, parent handle, and sibling handle.
         """
-        if self._srcHandle is None or self._srcItem is None or self._parHandle is None:
-            return
-
-        pHandle = self._parHandle
-        nHandle = self._parHandle if self._inFolder else self._srcHandle
-        hHandle = [self._parHandle, None, None, None, None]
-
-        pLevel = 0
-        for docText, hLevel, docLabel in self._rawData:
-
-            hLevel = minmax(hLevel, 1, 4)
-            if pLevel == 0:
-                pLevel = hLevel
-
-            if docHierarchy:
-                if hLevel == 1:
-                    pHandle = self._parHandle
-                elif hLevel == 2:
-                    pHandle = hHandle[1] or hHandle[0]
-                elif hLevel == 3:
-                    pHandle = hHandle[2] or hHandle[1] or hHandle[0]
-                elif hLevel == 4:
-                    pHandle = hHandle[3] or hHandle[2] or hHandle[1] or hHandle[0]
-
-                if hLevel < pLevel:
-                    nHandle = hHandle[hLevel] or hHandle[0]
-                elif hLevel > pLevel:
-                    nHandle = pHandle
-
-            dHandle = self._project.newFile(docLabel, pHandle)
-            hHandle[hLevel] = dHandle
-
-            newItem = self._project.tree[dHandle]
-            if isinstance(newItem, NWItem):
-                newItem.setStatus(self._srcItem.itemStatus)
-                newItem.setImport(self._srcItem.itemImport)
-
-            outDoc = self._project.storage.getDocument(dHandle)
-            status = outDoc.writeDocument("\n".join(docText))
-            if not status:
-                self._error = outDoc.getError()
-
-            yield status, dHandle, nHandle
-
-            hHandle[hLevel] = dHandle
-            nHandle = dHandle
-            pLevel = hLevel
-
+        if self._srcHandle and self._srcItem and self._parHandle:
+            pHandle = self._parHandle
+            hHandle = [self._parHandle, None, None, None, None]
+            pLevel = 0
+            for docText, hLevel, docLabel in self._rawData:
+
+                hLevel = minmax(hLevel, 1, 4)
+                if pLevel == 0:
+                    pLevel = hLevel
+
+                if docHierarchy:
+                    if hLevel == 1:
+                        pHandle = self._parHandle
+                    elif hLevel == 2:
+                        pHandle = hHandle[1] or hHandle[0]
+                    elif hLevel == 3:
+                        pHandle = hHandle[2] or hHandle[1] or hHandle[0]
+                    elif hLevel == 4:
+                        pHandle = hHandle[3] or hHandle[2] or hHandle[1] or hHandle[0]
+
+                if (
+                    (dHandle := self._project.newFile(docLabel, pHandle))
+                    and (nwItem := self._project.tree[dHandle])
+                ):
+                    hHandle[hLevel] = dHandle
+                    nwItem.setStatus(self._srcItem.itemStatus)
+                    nwItem.setImport(self._srcItem.itemImport)
+
+                    outDoc = self._project.storage.getDocument(dHandle)
+                    status = outDoc.writeDocument("\n".join(docText))
+                    if not status:
+                        self._error = outDoc.getError()
+
+                    self._project.index.reIndexHandle(dHandle)
+                    nwItem.notifyToRefresh()
+
+                    yield status
+
+                    hHandle[hLevel] = dHandle
+                    pLevel = hLevel
         return
 
 
@@ -270,29 +258,27 @@ class DocDuplicator:
     #  Methods
     ##
 
-    def duplicate(self, items: list[str]) -> Iterable[tuple[str, str | None]]:
+    def duplicate(self, items: list[str]) -> list[str]:
         """Run through a list of items, duplicate them, and copy the
         text content if they are documents.
         """
+        result = []
+        after = True
         if items:
-            nHandle = items[0]
             hMap: dict[str, str | None] = {t: None for t in items}
             for tHandle in items:
-                newItem = self._project.tree.duplicate(tHandle)
-                if newItem is None:
-                    return
-                hMap[tHandle] = newItem.itemHandle
-                if newItem.itemParent in hMap:
-                    newItem.setParent(hMap[newItem.itemParent])
-                    self._project.tree.updateItemData(newItem.itemHandle)
-                if newItem.isFileType():
-                    newDoc = self._project.storage.getDocument(newItem.itemHandle)
-                    if newDoc.fileExists():
-                        return
-                    newDoc.writeDocument(self._project.storage.getDocumentText(tHandle))
-                yield newItem.itemHandle, nHandle
-                nHandle = None
-        return
+                if oldItem := self._project.tree[tHandle]:
+                    pHandle = hMap.get(oldItem.itemParent or "") or oldItem.itemParent
+                    if newItem := self._project.tree.duplicate(tHandle, pHandle, after):
+                        hMap[tHandle] = newItem.itemHandle
+                        if newItem.isFileType():
+                            self._project.copyFileContent(newItem.itemHandle, tHandle)
+                        newItem.notifyToRefresh()
+                        result.append(newItem.itemHandle)
+                    after = False
+                else:
+                    break
+        return result
 
 
 class DocSearch:
@@ -523,7 +509,7 @@ class ProjectBuilder:
 
         # Also add the archive and trash folders
         project.newRoot(nwItemClass.ARCHIVE)
-        project.trashFolder()
+        project.tree.trash  # Triggers the creation of Trash
 
         project.saveProject()
         project.closeProject()

novelwriter/core/docbuild.py

@@ -176,8 +176,9 @@ class NWBuildDocument:
 
         elif bFormat == nwBuildFmt.PDF:
             makeObj = ToQTextDocument(self._project)
+            makeObj.disableAnchors()
             filtered = self._setupBuild(makeObj)
-            makeObj.initDocument()
+            makeObj.initDocument(pdf=True)
             yield from self._iterBuild(makeObj, filtered)
             makeObj.closeDocument()
 
@@ -217,7 +218,7 @@ class NWBuildDocument:
         textFont = QFont(CONFIG.textFont)
         textFont.fromString(self._build.getStr("format.textFont"))
 
-        bldObj.setFont(textFont)
+        bldObj.setTextFont(textFont)
         bldObj.setLanguage(self._project.data.language)
 
         bldObj.setPartitionFormat(

novelwriter/core/index.py

@@ -116,24 +116,24 @@ class NWIndex:
     #  Public Methods
     ##
 
-    def clearIndex(self) -> None:
+    def clear(self) -> None:
         """Clear the index dictionaries and time stamps."""
         self._tagsIndex.clear()
         self._itemIndex.clear()
         self._indexChange = 0.0
         self._rootChange = {}
-        SHARED.indexSignalProxy({"event": "clearIndex"})
+        SHARED.emitIndexCleared(self._project)
         return
 
-    def rebuildIndex(self) -> None:
+    def rebuild(self) -> None:
         """Rebuild the entire index from scratch."""
-        self.clearIndex()
+        self.clear()
         for nwItem in self._project.tree:
             if nwItem.isFileType():
                 text = self._project.storage.getDocumentText(nwItem.itemHandle)
                 self.scanText(nwItem.itemHandle, text, blockSignal=True)
         self._indexBroken = False
-        SHARED.indexSignalProxy({"event": "buildIndex"})
+        SHARED.emitIndexAvailable(self._project)
         return
 
     def deleteHandle(self, tHandle: str) -> None:
@@ -143,10 +143,7 @@ class NWIndex:
         for tTag in delTags:
             del self._tagsIndex[tTag]
         del self._itemIndex[tHandle]
-        SHARED.indexSignalProxy({
-            "event": "updateTags",
-            "deleted": delTags,
-        })
+        SHARED.emitIndexChangedTags(self._project, [], delTags)
         return
 
     def reIndexHandle(self, tHandle: str | None) -> None:
@@ -212,7 +209,7 @@ class NWIndex:
                 self.reIndexHandle(fHandle)
 
         self._indexChange = time()
-        SHARED.indexSignalProxy({"event": "buildIndex"})
+        SHARED.emitIndexAvailable(self._project)
 
         logger.debug("Index loaded in %.3f ms", (time() - tStart)*1000)
 
@@ -296,10 +293,7 @@ class NWIndex:
         self._indexChange = nowTime
         self._rootChange[tItem.itemRoot] = nowTime
         if not blockSignal:
-            SHARED.indexSignalProxy({
-                "event": "scanText",
-                "handle": tHandle,
-            })
+            tItem.notifyToRefresh()
 
         return True
 
@@ -370,11 +364,7 @@ class NWIndex:
                 del self._tagsIndex[tTag]
                 deleted.append(tTag)
             if updated or deleted:
-                SHARED.indexSignalProxy({
-                    "event": "updateTags",
-                    "updated": updated,
-                    "deleted": deleted,
-                })
+                SHARED.emitIndexChangedTags(self._project, updated, deleted)
 
         return