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

novelwriter/core/projectdata.py

@@ -34,7 +34,7 @@ from novelwriter.common import (
 )
 from novelwriter.core.status import NWStatus
 
-if TYPE_CHECKING:  # pragma: no cover
+if TYPE_CHECKING:
     from novelwriter.core.project import NWProject
 
 logger = logging.getLogger(__name__)
@@ -66,13 +66,13 @@ class NWProjectData:
         self._spellLang = None
 
         # Project Dictionaries
-        self._initCounts = [0, 0]
-        self._currCounts = [0, 0]
+        self._initCounts = [0, 0, 0, 0]
+        self._currCounts = [0, 0, 0, 0]
         self._lastHandle: dict[str, str | None] = {
-            "editor":    None,
-            "viewer":    None,
-            "novelTree": None,
-            "outline":   None,
+            "editor":  None,
+            "viewer":  None,
+            "novel":   None,
+            "outline": None,
         }
         self._autoReplace: dict[str, str] = {}
         self._titleFormat: dict[str, str] = {
@@ -148,18 +148,18 @@ class NWProjectData:
         return self._spellLang
 
     @property
-    def initCounts(self) -> tuple[int, int]:
-        """Return the initial count of words for novel and note
-        documents.
+    def initCounts(self) -> tuple[int, int, int, int]:
+        """Return the initial count of words and characters for novel
+        and note documents.
         """
-        return self._initCounts[0], self._initCounts[1]
+        return self._initCounts[0], self._initCounts[1], self._initCounts[2], self._initCounts[3]
 
     @property
-    def currCounts(self) -> tuple[int, int]:
-        """Return the current count of words for novel and note
-        documents.
+    def currCounts(self) -> tuple[int, int, int, int]:
+        """Return the current count of words and characters for novel
+        and note documents.
         """
-        return self._currCounts[0], self._currCounts[1]
+        return self._currCounts[0], self._currCounts[1], self._currCounts[2], self._currCounts[3]
 
     @property
     def lastHandle(self) -> dict[str, str | None]:
@@ -301,22 +301,40 @@ class NWProjectData:
             self._project.setProjectChanged(True)
         return
 
-    def setInitCounts(self, novel: Any = None, notes: Any = None) -> None:
-        """Set the word count totals for novel and note files."""
-        if novel is not None:
-            self._initCounts[0] = checkInt(novel, 0)
-            self._currCounts[0] = checkInt(novel, 0)
-        if notes is not None:
-            self._initCounts[1] = checkInt(notes, 0)
-            self._currCounts[1] = checkInt(notes, 0)
+    def setInitCounts(
+        self, wNovel: Any = None, wNotes: Any = None, cNovel: Any = None, cNotes: Any = None
+    ) -> None:
+        """Set the count totals for novel and note files."""
+        if wNovel is not None:
+            count = checkInt(wNovel, 0)
+            self._initCounts[0] = count
+            self._currCounts[0] = count
+        if wNotes is not None:
+            count = checkInt(wNotes, 0)
+            self._initCounts[1] = count
+            self._currCounts[1] = count
+        if cNovel is not None:
+            count = checkInt(cNovel, 0)
+            self._initCounts[2] = count
+            self._currCounts[2] = count
+        if cNotes is not None:
+            count = checkInt(cNotes, 0)
+            self._initCounts[3] = count
+            self._currCounts[3] = count
         return
 
-    def setCurrCounts(self, novel: Any = None, notes: Any = None) -> None:
-        """Set the word count totals for novel and note files."""
-        if novel is not None:
-            self._currCounts[0] = checkInt(novel, 0)
-        if notes is not None:
-            self._currCounts[1] = checkInt(notes, 0)
+    def setCurrCounts(
+        self, wNovel: Any = None, wNotes: Any = None, cNovel: Any = None, cNotes: Any = None
+    ) -> None:
+        """Set the count totals for novel and note files."""
+        if wNovel is not None:
+            self._currCounts[0] = checkInt(wNovel, 0)
+        if wNotes is not None:
+            self._currCounts[1] = checkInt(wNotes, 0)
+        if cNovel is not None:
+            self._currCounts[2] = checkInt(cNovel, 0)
+        if cNotes is not None:
+            self._currCounts[3] = checkInt(cNotes, 0)
         return
 
     def setAutoReplace(self, value: dict) -> None:

novelwriter/core/projectxml.py

@@ -39,14 +39,14 @@ from novelwriter.common import (
     hexToInt, simplified, xmlIndent, yesNo
 )
 
-if TYPE_CHECKING:  # pragma: no cover
+if TYPE_CHECKING:
     from novelwriter.core.projectdata import NWProjectData
     from novelwriter.core.status import NWStatus
 
 logger = logging.getLogger(__name__)
 
 FILE_VERSION = "1.5"  # The current project file format version
-FILE_REVISION = "4"   # The current project file format revision
+FILE_REVISION = "5"   # The current project file format revision
 HEX_VERSION = 0x0105
 
 NUM_VERSION = {
@@ -109,6 +109,8 @@ class ProjectXMLReader:
         Rev 3: Added TEMPLATE class. 2.3.
         Rev 4: Added shape attribute to status and importance entry
                nodes. 2.5.
+        Rev 5: Added novelChars and notesChars attributes to content
+               node. 2.7 RC 1.
     """
 
     def __init__(self, path: str | Path) -> None:
@@ -286,9 +288,9 @@ class ProjectXMLReader:
                 elif xItem.tag == "spellLang":  # Changed to spellChecking in 1.5
                     data.setSpellLang(xItem.text)
                 elif xItem.tag == "novelWordCount":  # Moved to content attribute in 1.5
-                    data.setInitCounts(novel=xItem.text)
+                    data.setInitCounts(wNovel=xItem.text)
                 elif xItem.tag == "notesWordCount":  # Moved to content attribute in 1.5
-                    data.setInitCounts(notes=xItem.text)
+                    data.setInitCounts(wNotes=xItem.text)
 
         return
 
@@ -298,8 +300,13 @@ class ProjectXMLReader:
         """Parse the content section of the XML file."""
         logger.debug("Parsing <content> section")
 
-        data.setInitCounts(novel=xSection.attrib.get("novelWords", None))  # Moved in 1.5
-        data.setInitCounts(notes=xSection.attrib.get("notesWords", None))  # Moved in 1.5
+        # Moved in 1.5
+        data.setInitCounts(
+            wNovel=xSection.attrib.get("novelWords", None),
+            wNotes=xSection.attrib.get("notesWords", None),
+            cNovel=xSection.attrib.get("novelChars", None),
+            cNotes=xSection.attrib.get("notesChars", None),
+        )
 
         for xItem in xSection:
             if xItem.tag != "item":
@@ -527,10 +534,13 @@ class ProjectXMLWriter:
             self._packSingleValue(xImport, "entry", label, attrib=attrib)
 
         # Save Tree Content
+        counts = data.currCounts
         contAttr = {
             "items": str(len(content)),
-            "novelWords": str(data.currCounts[0]),
-            "notesWords": str(data.currCounts[1]),
+            "novelWords": str(counts[0]),
+            "notesWords": str(counts[1]),
+            "novelChars": str(counts[2]),
+            "notesChars": str(counts[3]),
         }
 
         xContent = ET.SubElement(xRoot, "content", attrib=contAttr)

novelwriter/core/sessions.py

@@ -26,7 +26,6 @@ from __future__ import annotations
 import json
 import logging
 
-from collections.abc import Iterable
 from pathlib import Path
 from time import time
 from typing import TYPE_CHECKING
@@ -35,7 +34,9 @@ from novelwriter.common import formatTimeStamp
 from novelwriter.constants import nwFiles
 from novelwriter.error import logException
 
-if TYPE_CHECKING:  # pragma: no cover
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
     from novelwriter.core.project import NWProject
 
 logger = logging.getLogger(__name__)
@@ -78,29 +79,36 @@ class NWSessionLog:
             return False
 
         now = time()
-        iNovel, iNotes = self._project.data.initCounts
-        cNovel, cNotes = self._project.data.currCounts
-        iTotal = iNovel + iNotes
-        wDiff = cNovel + cNotes - iTotal
+        iWNovel, iWNotes, iCNovel, iCNotes = self._project.data.initCounts
+        cWNovel, cWNotes, cCNovel, cCNotes = self._project.data.currCounts
+        iWTotal = iWNovel + iWNotes
+        iCTotal = iCNovel + iCNotes
+        wDiff = cWNovel + cWNotes - iWTotal
+        cDiff = cCNovel + cCNotes - iCTotal
         sTime = now - self._start
 
-        logger.info("The session lasted %d sec and added %d words", int(sTime), wDiff)
-        if sTime < 300 and wDiff == 0:
+        logger.info(
+            "The session lasted %d sec and added %d words abd %d characters",
+            int(sTime), wDiff, cDiff
+        )
+        if sTime < 300 and (wDiff == 0 or cDiff == 0):
             logger.info("Session too short, skipping log entry")
             return False
 
         try:
             if not sessFile.exists():
                 with open(sessFile, mode="w", encoding="utf-8") as fObj:
-                    fObj.write(self.createInitial(iTotal))
+                    fObj.write(self.createInitial(iWTotal))
 
             with open(sessFile, mode="a+", encoding="utf-8") as fObj:
                 fObj.write(self.createRecord(
                     start=formatTimeStamp(self._start),
                     end=formatTimeStamp(now),
-                    novel=cNovel,
-                    notes=cNotes,
-                    idle=round(idleTime)
+                    novel=cWNovel,
+                    notes=cWNotes,
+                    idle=round(idleTime),
+                    cnovel=cCNovel,
+                    cnotes=cCNotes,
                 ))
 
         except Exception:
@@ -128,10 +136,19 @@ class NWSessionLog:
         data = json.dumps({"type": "initial", "offset": total})
         return f"{data}\n"
 
-    def createRecord(self, start: str, end: str, novel: int, notes: int, idle: int) -> str:
+    def createRecord(
+        self, start: str, end: str, novel: int, notes: int, idle: int,
+        cnovel: int = 0, cnotes: int = 0,
+    ) -> str:
         """Low level function to create a log record."""
         data = json.dumps({
-            "type": "record", "start": start, "end": end,
-            "novel": novel, "notes": notes, "idle": idle,
+            "type": "record",
+            "start": start,
+            "end": end,
+            "novel": novel,
+            "notes": notes,
+            "cnovel": cnovel,
+            "cnotes": cnotes,
+            "idle": idle,
         })
         return f"{data}\n"

novelwriter/core/spellcheck.py

@@ -27,16 +27,17 @@ from __future__ import annotations
 import json
 import logging
 
-from collections.abc import Iterator
 from pathlib import Path
 from typing import TYPE_CHECKING
 
-from PyQt5.QtCore import QLocale
+from PyQt6.QtCore import QLocale
 
 from novelwriter.constants import nwFiles
 from novelwriter.error import logException
 
-if TYPE_CHECKING:  # pragma: no cover
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
     from novelwriter.core.project import NWProject
 
 logger = logging.getLogger(__name__)

novelwriter/core/status.py

@@ -28,19 +28,18 @@ import dataclasses
 import logging
 import random
 
-from collections.abc import Iterable
-from typing import TYPE_CHECKING, Literal
+from typing import TYPE_CHECKING, Literal, TypeGuard
 
-from PyQt5.QtCore import QPointF, Qt
-from PyQt5.QtGui import QColor, QIcon, QPainter, QPainterPath, QPixmap, QPolygonF
+from PyQt6.QtCore import QPointF, Qt
+from PyQt6.QtGui import QColor, QIcon, QPainter, QPainterPath, QPixmap, QPolygonF
 
 from novelwriter import SHARED
 from novelwriter.common import simplified
 from novelwriter.enum import nwStatusShape
 from novelwriter.types import QtPaintAntiAlias, QtTransparent
 
-if TYPE_CHECKING:  # pragma: no cover
-    from typing import TypeGuard  # Requires Python 3.10
+if TYPE_CHECKING:
+    from collections.abc import Iterable
 
 logger = logging.getLogger(__name__)
 
@@ -57,18 +56,16 @@ class StatusEntry:
     @classmethod
     def duplicate(cls, source: StatusEntry) -> StatusEntry:
         """Create a deep copy of the source object."""
-        cls = dataclasses.replace(source)
-        cls.color = QColor(source.color)
-        cls.icon = QIcon(source.icon)
-        return cls
+        status = dataclasses.replace(source)
+        status.color = QColor(source.color)
+        status.icon = QIcon(source.icon)
+        return status
 
 
 NO_ENTRY = StatusEntry("", QColor(0, 0, 0), nwStatusShape.SQUARE, QIcon(), 0)
 
-if TYPE_CHECKING:  # pragma: no cover
-    # Requires Python 3.10
-    T_UpdateEntry = list[tuple[str | None, StatusEntry]]
-    T_StatusKind = Literal["s", "i"]
+T_UpdateEntry = list[tuple[str | None, StatusEntry]]
+T_StatusKind = Literal["s", "i"]
 
 
 class NWStatus:
@@ -76,7 +73,7 @@ class NWStatus:
     STATUS = "s"
     IMPORT = "i"
 
-    __slots__ = ("_store", "_default", "_prefix", "_height")
+    __slots__ = ("_default", "_height", "_prefix", "_store")
 
     def __init__(self, prefix: T_StatusKind) -> None:
         self._store: dict[str, StatusEntry] = {}

novelwriter/core/storage.py

@@ -40,7 +40,7 @@ from novelwriter.core.projectxml import ProjectXMLReader, ProjectXMLWriter
 from novelwriter.core.spellcheck import UserDictionary
 from novelwriter.error import logException
 
-if TYPE_CHECKING:  # pragma: no cover
+if TYPE_CHECKING:
     from novelwriter.core.project import NWProject
 
 logger = logging.getLogger(__name__)

novelwriter/core/tree.py

@@ -27,20 +27,21 @@ from __future__ import annotations
 import logging
 import random
 
-from collections.abc import Iterable, Iterator
 from pathlib import Path
 from typing import TYPE_CHECKING, Literal, overload
 
-from PyQt5.QtCore import QModelIndex
+from PyQt6.QtCore import QModelIndex
 
 from novelwriter import SHARED
-from novelwriter.constants import nwFiles, nwLabels, trConst
+from novelwriter.constants import nwFiles, nwLabels, nwStyles, trConst
 from novelwriter.core.item import NWItem
 from novelwriter.core.itemmodel import ProjectModel, ProjectNode
 from novelwriter.enum import nwChange, nwItemClass, nwItemLayout, nwItemType
 from novelwriter.error import logException
 
-if TYPE_CHECKING:  # pragma: no cover
+if TYPE_CHECKING:
+    from collections.abc import Iterable, Iterator
+
     from novelwriter.core.project import NWProject
 
 logger = logging.getLogger(__name__)
@@ -60,7 +61,7 @@ class NWTree:
     also used for file names.
     """
 
-    __slots__ = ("_project", "_model", "_items", "_nodes", "_trash")
+    __slots__ = ("_items", "_model", "_nodes", "_project", "_ready", "_trash")
 
     def __init__(self, project: NWProject) -> None:
         self._project = project
@@ -68,6 +69,7 @@ class NWTree:
         self._items: dict[str, NWItem] = {}
         self._nodes: dict[str, ProjectNode] = {}
         self._trash = None
+        self._ready = False
         logger.debug("Ready: NWTree")
         return
 
@@ -106,6 +108,11 @@ class NWTree:
     #  Properties
     ##
 
+    @property
+    def project(self) -> NWProject:
+        """Return the parent project."""
+        return self._project
+
     @property
     def trash(self) -> ProjectNode | None:
         """Return trash node, if it exists."""
@@ -249,11 +256,37 @@ class NWTree:
             logger.error("Not all items could be added to project tree")
 
         self._trash = self._getTrashNode()
+        self._ready = True
         self._model.endInsertRows()
         self._model.layoutChanged.emit()
 
         return
 
+    def pickParent(self, sNode: ProjectNode, hLevel: int, isNote: bool) -> tuple[str | None, int]:
+        """Pick an appropriate parent handle for adding a new item."""
+        if sNode.item.isFolderType() or sNode.item.isRootType():
+            # Always add as a direct child of folders
+            return sNode.item.itemHandle, sNode.childCount()
+
+        pNode = sNode.parent()
+        pLevel = nwStyles.H_LEVEL.get(pNode.item.mainHeading, 0) if pNode else 0
+
+        # Notes are treated as H0, and scenes and sections both as H3
+        sLevel = min(0 if isNote else nwStyles.H_LEVEL.get(sNode.item.mainHeading, 0), 3)
+
+        if pNode and pNode.item.isFileType() and pLevel >= hLevel and sLevel > hLevel:
+            # If the selected item is a smaller heading and the parent heading
+            # is equal or larger, we make it a sibling of the parent (See #2260)
+            return pNode.item.itemParent, pNode.row() + 1
+
+        if sNode.childCount() > 0 and (0 < sLevel < hLevel or isNote):
+            # If the selected item already has child nodes and has a larger
+            # heading or is a note, we make the new item a child
+            return sNode.item.itemHandle, sNode.childCount()
+
+        # The default behaviour is to make the new item a sibling
+        return sNode.item.itemParent, sNode.row() + 1
+
     def refreshItems(self, items: list[str]) -> None:
         """Refresh these items on the GUI. If they are an ordered range,
         also set the isRange flag to True.
@@ -278,6 +311,12 @@ class NWTree:
         self._model.layoutChanged.emit()
         return
 
+    def novelStructureChanged(self, tHandle: str) -> None:
+        """Emit a novel structure change signal."""
+        if self._ready:
+            SHARED.novelStructureChanged.emit(tHandle)
+        return
+
     def checkConsistency(self, prefix: str) -> tuple[int, int]:
         """Check the project tree consistency. Also check the content
         folder and add back files that were discovered but were not
@@ -371,16 +410,20 @@ class NWTree:
 
         return True
 
-    def sumWords(self) -> tuple[int, int]:
-        """Loop over all entries and add up the word counts."""
-        noteWords = 0
+    def sumCounts(self) -> tuple[int, int, int, int]:
+        """Loop over all entries and add up the word and char counts."""
         novelWords = 0
+        notesWords = 0
+        novelChars = 0
+        notesChars = 0
         for item in self._items.values():
             if item.itemLayout == nwItemLayout.NOTE:
-                noteWords += item.wordCount
+                notesWords += item.wordCount
+                notesChars += item.charCount
             elif item.itemLayout == nwItemLayout.DOCUMENT:
                 novelWords += item.wordCount
-        return novelWords, noteWords
+                novelChars += item.charCount
+        return novelWords, notesWords, novelChars, notesChars
 
     ##
     #  Tree Item Methods
@@ -388,7 +431,7 @@ class NWTree:
 
     def checkType(self, tHandle: str, itemType: nwItemType) -> bool:
         """Check if item exists and is of the specified item type."""
-        if tItem := self.__getitem__(tHandle):
+        if tItem := self[tHandle]:
             return tItem.itemType == itemType
         return False
 
@@ -406,8 +449,7 @@ class NWTree:
                     node = parent
                 else:
                     return path
-            else:
-                logger.error("Max project tree depth reached")
+            logger.error("Max project tree depth reached")
         return path
 
     def subTree(self, tHandle: str) -> list[str]:

novelwriter/dialogs/about.py

@@ -25,17 +25,21 @@ from __future__ import annotations
 
 import logging
 
-from PyQt5.QtGui import QCloseEvent, QColor
-from PyQt5.QtWidgets import (
+from typing import TYPE_CHECKING
+
+from PyQt6.QtWidgets import (
     QDialogButtonBox, QHBoxLayout, QLabel, QTextBrowser, QVBoxLayout, QWidget
 )
 
 from novelwriter import CONFIG, SHARED
-from novelwriter.common import cssCol, readTextFile
-from novelwriter.extensions.configlayout import NColourLabel
+from novelwriter.common import readTextFile
+from novelwriter.extensions.configlayout import NColorLabel
 from novelwriter.extensions.modified import NDialog
 from novelwriter.extensions.versioninfo import VersionInfoWidget
-from novelwriter.types import QtAlignRightTop, QtDialogClose
+from novelwriter.types import QtAlignRightTop, QtDialogClose, QtHexArgb
+
+if TYPE_CHECKING:
+    from PyQt6.QtGui import QCloseEvent
 
 logger = logging.getLogger(__name__)
 
@@ -49,19 +53,13 @@ class GuiAbout(NDialog):
         self.setObjectName("GuiAbout")
 
         self.setWindowTitle(self.tr("About novelWriter"))
-        self.resize(CONFIG.pxInt(700), CONFIG.pxInt(500))
-
-        hA = CONFIG.pxInt(8)
-        hB = CONFIG.pxInt(16)
-        nwH = CONFIG.pxInt(36)
-        nwPx = CONFIG.pxInt(128)
+        self.resize(700, 500)
 
         # Logo and Banner
-        self.nwImage = SHARED.theme.loadDecoration("nw-text", h=nwH)
-        self.bgColor = QColor(255, 255, 255) if SHARED.theme.isLightTheme else QColor(54, 54, 54)
+        self.nwImage = SHARED.theme.getDecoration("nw-text", h=36)
 
         self.nwLogo = QLabel(self)
-        self.nwLogo.setPixmap(SHARED.theme.getPixmap("novelwriter", (nwPx, nwPx)))
+        self.nwLogo.setPixmap(SHARED.theme.getPixmap("novelwriter", (128, 128)))
 
         self.nwLabel = QLabel(self)
         self.nwLabel.setPixmap(self.nwImage)
@@ -74,14 +72,13 @@ class GuiAbout(NDialog):
         self.nwLicence.setOpenExternalLinks(True)
 
         # Credits
-        self.lblCredits = NColourLabel(
+        self.lblCredits = NColorLabel(
             self.tr("Credits"), self, scale=1.6, bold=True
         )
 
         self.txtCredits = QTextBrowser(self)
         self.txtCredits.setOpenExternalLinks(True)
-        self.txtCredits.document().setDocumentMargin(0)
-        self.txtCredits.setViewportMargins(0, hA, hA, 0)
+        self.txtCredits.setViewportMargins(0, 8, 8, 0)
 
         # Buttons
         self.btnBox = QDialogButtonBox(QtDialogClose, self)
@@ -89,15 +86,15 @@ class GuiAbout(NDialog):
 
         # Assemble
         self.innerBox = QVBoxLayout()
-        self.innerBox.addSpacing(hB)
+        self.innerBox.addSpacing(16)
         self.innerBox.addWidget(self.nwLabel)
         self.innerBox.addWidget(self.nwInfo)
-        self.innerBox.addSpacing(hA)
+        self.innerBox.addSpacing(8)
         self.innerBox.addWidget(self.nwLicence)
-        self.innerBox.addSpacing(hA)
+        self.innerBox.addSpacing(8)
         self.innerBox.addWidget(self.lblCredits)
         self.innerBox.addWidget(self.txtCredits)
-        self.innerBox.addSpacing(hB)
+        self.innerBox.addSpacing(16)
         self.innerBox.addWidget(self.btnBox)
 
         self.outerBox = QHBoxLayout()
@@ -142,7 +139,7 @@ class GuiAbout(NDialog):
 
     def _setStyleSheet(self) -> None:
         """Set stylesheet text document."""
-        baseCol = cssCol(self.palette().window().color())
+        baseCol = self.palette().window().color().name(QtHexArgb)
         self.txtCredits.setStyleSheet(
             f"QTextBrowser {{border: none; background: {baseCol};}} "
         )