novelWriter 2.7b1__py3-none-any.whl → 2.7rc1__py3-none-any.whl

novelwriter/core/coretools.py

@@ -383,10 +383,12 @@ class ProjectBuilder:
         """Build or copy a project from a data dictionary."""
         if isinstance(data, dict):
             path = data.get("path", None) or None
+            if author := data.get("author"):
+                CONFIG.setLastAuthor(author)
             if isinstance(path, str | Path):
                 self._path = Path(path).resolve()
                 if data.get("sample"):
-                    return self._extractSampleProject(self._path)
+                    return self._extractSampleProject(self._path, data)
                 elif data.get("template"):
                     return self._copyProject(self._path, data)
                 else:
@@ -416,20 +418,21 @@ class ProjectBuilder:
 
         self._path = project.storage.storagePath
 
-        lblNewProject = self.tr("New Project")
-        lblTitlePage  = self.tr("Title Page")
+        trName = self.tr("New Project")
+        trAuthor = self.tr("Author Name")
+        trTitlePage = self.tr("Title Page")
 
         # Settings
         project.data.setUuid(None)
-        project.data.setName(data.get("name", lblNewProject))
-        project.data.setAuthor(data.get("author", ""))
+        project.data.setName(data.get("name", trName))
+        project.data.setAuthor(data.get("author", trAuthor))
         project.data.setLanguage(CONFIG.guiLocale)
         project.setDefaultStatusImport()
         project.session.startSession()
 
         # Add Root Folders
         hNovelRoot = project.newRoot(nwItemClass.NOVEL)
-        hTitlePage = project.newFile(lblTitlePage, hNovelRoot)
+        hTitlePage = project.newFile(trTitlePage, hNovelRoot)
 
         # Generate Title Page
         aDoc = project.storage.getDocument(hTitlePage)
@@ -446,25 +449,21 @@ class ProjectBuilder:
             "\n"
             ">> {count}: [field:{field}] <<\n"
         ).format(
-            author=project.data.author or "None",
-            address=self.tr("Address"),
-            title=project.data.name or "None",
+            author=project.data.author or trAuthor,
+            address=self.tr("Address Line"),
+            title=project.data.name or trName,
             by=self.tr("By"),
             count=self.tr("Word Count"),
             field=nwStats.WORDS_TEXT,
         ))
 
-        # Create a project structure based on selected root folders
-        # and a number of chapters and scenes selected in the
-        # wizard's custom page.
-
         # Create chapters and scenes
         numChapters = data.get("chapters", 0)
         numScenes = data.get("scenes", 0)
 
-        chSynop = self.tr("Summary of the chapter.")
-        scSynop = self.tr("Summary of the scene.")
-        bfNote = self.tr("A short description.")
+        trChSynop = self.tr("Summary of the chapter.")
+        trScSynop = self.tr("Summary of the scene.")
+        trNoteDesc = self.tr("A short description.")
 
         # Create chapters
         if numChapters > 0:
@@ -472,7 +471,7 @@ class ProjectBuilder:
                 chTitle = self.tr("Chapter {0}").format(f"{ch+1:d}")
                 cHandle = project.newFile(chTitle, hNovelRoot)
                 aDoc = project.storage.getDocument(cHandle)
-                aDoc.writeDocument(f"## {chTitle}\n\n%Synopsis: {chSynop}\n\n")
+                aDoc.writeDocument(f"## {chTitle}\n\n%Synopsis: {trChSynop}\n\n")
 
                 # Create chapter scenes
                 if numScenes > 0 and cHandle:
@@ -480,7 +479,7 @@ class ProjectBuilder:
                         scTitle = self.tr("Scene {0}").format(f"{ch+1:d}.{sc+1:d}")
                         sHandle = project.newFile(scTitle, cHandle)
                         aDoc = project.storage.getDocument(sHandle)
-                        aDoc.writeDocument(f"### {scTitle}\n\n%Synopsis: {scSynop}\n\n")
+                        aDoc.writeDocument(f"### {scTitle}\n\n%Synopsis: {trScSynop}\n\n")
 
         # Create scenes (no chapters)
         elif numScenes > 0:
@@ -488,7 +487,7 @@ class ProjectBuilder:
                 scTitle = self.tr("Scene {0}").format(f"{sc+1:d}")
                 sHandle = project.newFile(scTitle, hNovelRoot)
                 aDoc = project.storage.getDocument(sHandle)
-                aDoc.writeDocument(f"### {scTitle}\n\n%Synopsis: {scSynop}\n\n")
+                aDoc.writeDocument(f"### {scTitle}\n\n%Synopsis: {trScSynop}\n\n")
 
         # Create notes folders
         noteTitles = {
@@ -508,7 +507,7 @@ class ProjectBuilder:
                     aDoc.writeDocument(
                         f"# {noteTitles[newRoot]}\n\n"
                         f"@tag: {ntTag}\n\n"
-                        f"%Short: {bfNote}\n\n"
+                        f"%Short: {trNoteDesc}\n\n"
                     )
 
         # Also add the archive and trash folders
@@ -563,23 +562,11 @@ class ProjectBuilder:
             return False
 
         # Open the copied project and update settings
-        project = NWProject()
-        project.openProject(dstPath)
-        project.data.setUuid("")  # Creates a fresh uuid
-        project.data.setName(data.get("name", "None"))
-        project.data.setAuthor(data.get("author", ""))
-        project.data.setSpellCheck(True)
-        project.data.setSpellLang(None)
-        project.data.setDoBackup(True)
-        project.data.setSaveCount(0)
-        project.data.setAutoCount(0)
-        project.data.setEditTime(0)
-        project.saveProject()
-        project.closeProject()
+        self._resetProject(dstPath, data)
 
         return True
 
-    def _extractSampleProject(self, path: Path) -> bool:
+    def _extractSampleProject(self, path: Path, data: dict) -> bool:
         """Make a copy of the sample project by extracting the
         sample.zip file to the new path.
         """
@@ -593,6 +580,7 @@ class ProjectBuilder:
         if (sample := CONFIG.assetPath("sample.zip")).is_file():
             try:
                 shutil.unpack_archive(sample, path)
+                self._resetProject(path, data)
             except Exception as exc:
                 SHARED.error(self.tr("Failed to create a new example project."), exc=exc)
                 return False
@@ -605,3 +593,22 @@ class ProjectBuilder:
             return False
 
         return True
+
+    def _resetProject(self, path: Path, data: dict) -> None:
+        """Open a project and reset/update its settings."""
+        project = NWProject()
+        project.openProject(path)
+        project.data.setUuid("")  # Creates a fresh uuid
+        if name := data.get("name", ""):
+            project.data.setName(name)
+        if author := data.get("author", ""):
+            project.data.setAuthor(author)
+        project.data.setSpellCheck(True)
+        project.data.setSpellLang(None)
+        project.data.setDoBackup(True)
+        project.data.setSaveCount(0)
+        project.data.setAutoCount(0)
+        project.data.setEditTime(0)
+        project.saveProject()
+        project.closeProject()
+        return

novelwriter/core/docbuild.py

@@ -317,6 +317,7 @@ class NWBuildDocument:
         bldObj.setCommentType(nwComment.SYNOPSIS, self._build.getBool("text.includeSynopsis"))
         bldObj.setCommentType(nwComment.SHORT, self._build.getBool("text.includeSynopsis"))
         bldObj.setCommentType(nwComment.STORY, self._build.getBool("text.includeStory"))
+        bldObj.setCommentType(nwComment.NOTE, self._build.getBool("text.includeNotes"))
 
         if isinstance(bldObj, ToHtml):
             bldObj.setStyles(self._build.getBool("html.addStyles"))

novelwriter/core/index.py

@@ -131,6 +131,12 @@ class Index:
         self._novelExtra = extra
         return
 
+    def setItemClass(self, tHandle: str, itemClass: nwItemClass) -> None:
+        """Update the class for all tags of a handle."""
+        logger.info("Updating class for '%s'", tHandle)
+        self._tagsIndex.updateClass(tHandle, itemClass.name)
+        return
+
     ##
     #  Public Methods
     ##
@@ -612,6 +618,10 @@ class Index:
         """Return all story structure keys."""
         return self._itemIndex.allStoryKeys()
 
+    def getNoteKeys(self) -> set[str]:
+        """Return all note comment keys."""
+        return self._itemIndex.allNoteKeys()
+
     def novelStructure(
         self, rootHandle: str | None = None, activeOnly: bool = True
     ) -> Iterable[tuple[str, str, str, IndexHeading]]:
@@ -854,6 +864,15 @@ class TagsIndex:
                 x.get("name", "") for x in self._tags.values() if x.get("class", "") == className
             ]
 
+    def updateClass(self, tHandle: str, className: str) -> None:
+        """Update the class name of an item. This must be called when a
+        document moves to another class.
+        """
+        for entry in self._tags.values():
+            if entry.get("handle") == tHandle:
+                entry["class"] = className
+        return
+
     ##
     #  Pack/Unpack
     ##
@@ -905,11 +924,12 @@ class IndexCache:
     which provides lookup capabilities and caching for shared data.
     """
 
-    __slots__ = ("story", "tags")
+    __slots__ = ("note", "story", "tags")
 
     def __init__(self, tagsIndex: TagsIndex) -> None:
         self.tags: TagsIndex = tagsIndex
         self.story: set[str] = set()
+        self.note: set[str] = set()
         return
 
 
@@ -964,6 +984,10 @@ class ItemIndex:
         """Return all story structure keys."""
         return self._cache.story.copy()
 
+    def allNoteKeys(self) -> set[str]:
+        """Return all note comment keys."""
+        return self._cache.note.copy()
+
     def allItemTags(self, tHandle: str) -> list[str]:
         """Get all tags set for headings of an item."""
         if tHandle in self._items:

novelwriter/core/indexdata.py

@@ -316,6 +316,9 @@ class IndexHeading:
             case "story" if key:
                 self._cache.story.add(key)
                 self._comments[f"story.{key}"] = str(text)
+            case "note" if key:
+                self._cache.note.add(key)
+                self._comments[f"note.{key}"] = str(text)
         return
 
     def setTag(self, tag: str) -> None:
@@ -395,7 +398,7 @@ class IndexHeading:
                             self.addReference(tag, keyword)
                         else:
                             raise ValueError("Heading reference contains an invalid keyword")
-            elif key == "summary" or key.startswith("story"):
+            elif key == "summary" or key.startswith(("story", "note")):
                 comment, _, kind = str(key).partition(".")
                 self.setComment(comment, compact(kind), str(entry))
             else:

novelwriter/core/item.py

@@ -53,10 +53,10 @@ class NWItem:
     """
 
     __slots__ = (
-        "_active", "_charCount", "_class", "_cursorPos", "_expanded",
-        "_handle", "_heading", "_import", "_initCount", "_layout", "_name",
+        "_active", "_charCount", "_charInit", "_class", "_cursorPos",
+        "_expanded", "_handle", "_heading", "_import", "_layout", "_name",
         "_order", "_paraCount", "_parent", "_project", "_root", "_status",
-        "_type", "_wordCount",
+        "_type", "_wordCount", "_wordInit",
     )
 
     def __init__(self, project: NWProject, handle: str) -> None:
@@ -81,7 +81,8 @@ class NWItem:
         self._wordCount = 0     # Current word count
         self._paraCount = 0     # Current paragraph count
         self._cursorPos = 0     # Last cursor position
-        self._initCount = 0     # Initial word count
+        self._wordInit  = 0     # Initial character count
+        self._charInit  = 0     # Initial word count
 
         return
 
@@ -164,9 +165,13 @@ class NWItem:
     def paraCount(self) -> int:
         return self._paraCount
 
+    @property
+    def mainCount(self) -> int:
+        return self._charCount if CONFIG.useCharCount else self._wordCount
+
     @property
     def initCount(self) -> int:
-        return self._initCount
+        return self._wordInit if CONFIG.useCharCount else self._charInit
 
     @property
     def cursorPos(self) -> int:
@@ -257,7 +262,8 @@ class NWItem:
             self._paraCount = 0
             self._cursorPos = 0
 
-        self._initCount = self._wordCount
+        self._wordInit = self._charCount
+        self._charInit = self._wordCount
 
         return True
 
@@ -265,23 +271,24 @@ class NWItem:
     def duplicate(cls, source: NWItem, handle: str) -> NWItem:
         """Make a copy of an item."""
         new = cls(source._project, handle)
-        new._name      = source._name
-        new._parent    = source._parent
-        new._root      = source._root
-        new._order     = source._order
-        new._type      = source._type
-        new._class     = source._class
-        new._layout    = source._layout
-        new._status    = source._status
-        new._import    = source._import
-        new._active    = source._active
-        new._expanded  = source._expanded
-        new._heading   = source._heading
-        new._charCount = source._charCount
-        new._wordCount = source._wordCount
-        new._paraCount = source._paraCount
-        new._cursorPos = source._cursorPos
-        new._initCount = source._initCount
+        new._name       = source._name
+        new._parent     = source._parent
+        new._root       = source._root
+        new._order      = source._order
+        new._type       = source._type
+        new._class      = source._class
+        new._layout     = source._layout
+        new._status     = source._status
+        new._import     = source._import
+        new._active     = source._active
+        new._expanded   = source._expanded
+        new._heading    = source._heading
+        new._charCount  = source._charCount
+        new._wordCount  = source._wordCount
+        new._paraCount  = source._paraCount
+        new._cursorPos  = source._cursorPos
+        new._wordInit = source._wordInit
+        new._charInit = source._charInit
         return new
 
     ##
@@ -428,7 +435,11 @@ class NWItem:
         """
         if self._parent is not None:
             # Only update for child items
-            self.setClass(itemClass)
+            if itemClass != self._class:
+                self.setClass(itemClass)
+                if self._type == nwItemType.FILE:
+                    # Notify the index of the class change
+                    self._project.index.setItemClass(self._handle, itemClass)
 
         if self._layout == nwItemLayout.NO_LAYOUT:
             # If no layout is set, pick one

novelwriter/core/itemmodel.py

@@ -45,16 +45,18 @@ logger = logging.getLogger(__name__)
 INV_ROOT = "invisibleRoot"
 C_FACTOR = 0x0100
 
-C_LABEL_TEXT  = 0x0000 | Qt.ItemDataRole.DisplayRole
-C_LABEL_ICON  = 0x0000 | Qt.ItemDataRole.DecorationRole
-C_LABEL_FONT  = 0x0000 | Qt.ItemDataRole.FontRole
-C_COUNT_TEXT  = 0x0100 | Qt.ItemDataRole.DisplayRole
-C_COUNT_ICON  = 0x0100 | Qt.ItemDataRole.DecorationRole
-C_COUNT_ALIGN = 0x0100 | Qt.ItemDataRole.TextAlignmentRole
-C_ACTIVE_ICON = 0x0200 | Qt.ItemDataRole.DecorationRole
-C_ACTIVE_TIP  = 0x0200 | Qt.ItemDataRole.ToolTipRole
-C_STATUS_ICON = 0x0300 | Qt.ItemDataRole.DecorationRole
-C_STATUS_TIP  = 0x0300 | Qt.ItemDataRole.ToolTipRole
+C_LABEL_TEXT    = 0x0000 | Qt.ItemDataRole.DisplayRole
+C_LABEL_ICON    = 0x0000 | Qt.ItemDataRole.DecorationRole
+C_LABEL_FONT    = 0x0000 | Qt.ItemDataRole.FontRole
+C_COUNT_TEXT    = 0x0100 | Qt.ItemDataRole.DisplayRole
+C_COUNT_ICON    = 0x0100 | Qt.ItemDataRole.DecorationRole
+C_COUNT_ALIGN   = 0x0100 | Qt.ItemDataRole.TextAlignmentRole
+C_ACTIVE_ICON   = 0x0200 | Qt.ItemDataRole.DecorationRole
+C_ACTIVE_TIP    = 0x0200 | Qt.ItemDataRole.ToolTipRole
+C_ACTIVE_ACCESS = 0x0200 | Qt.ItemDataRole.AccessibleTextRole
+C_STATUS_ICON   = 0x0300 | Qt.ItemDataRole.DecorationRole
+C_STATUS_TIP    = 0x0300 | Qt.ItemDataRole.ToolTipRole
+C_STATUS_ACCESS = 0x0300 | Qt.ItemDataRole.AccessibleTextRole
 
 NODE_FLAGS = Qt.ItemFlag.ItemIsEnabled
 NODE_FLAGS |= Qt.ItemFlag.ItemIsSelectable
@@ -150,19 +152,21 @@ class ProjectNode:
 
         # Active
         aText, aIcon = self._item.getActiveStatus()
-        self._cache[C_ACTIVE_TIP] = aText
         self._cache[C_ACTIVE_ICON] = aIcon
+        self._cache[C_ACTIVE_TIP] = aText
+        self._cache[C_ACTIVE_ACCESS] = aText
 
         # Status
         sText, sIcon = self._item.getImportStatus()
-        self._cache[C_STATUS_TIP] = sText
         self._cache[C_STATUS_ICON] = sIcon
+        self._cache[C_STATUS_TIP] = sText
+        self._cache[C_STATUS_ACCESS] = sText
 
         return
 
     def updateCount(self, propagate: bool = True) -> None:
         """Update counts, and propagate upwards in the tree."""
-        self._count = self._item.wordCount + sum(c._count for c in self._children)  # noqa: SLF001
+        self._count = self._item.mainCount + sum(c._count for c in self._children)  # noqa: SLF001
         self._cache[C_COUNT_TEXT] = f"{self._count:n}"
         if propagate and (parent := self._parent):
             parent.updateCount()

novelwriter/core/novelmodel.py

@@ -46,6 +46,7 @@ R_TEXT   = Qt.ItemDataRole.DisplayRole
 R_ICON   = Qt.ItemDataRole.DecorationRole
 R_ALIGN  = Qt.ItemDataRole.TextAlignmentRole
 R_TIP    = Qt.ItemDataRole.ToolTipRole
+R_ACCESS = Qt.ItemDataRole.AccessibleTextRole
 R_HANDLE = 0xff01
 R_KEY    = 0xff02
 
@@ -217,6 +218,7 @@ class NovelModel(QAbstractTableModel):
                 text = ", ".join(refs)
                 data[C_FACTOR*2 | R_TEXT] = text
                 data[C_FACTOR*2 | R_TIP] = f"<b>{self._extraLabel}:</b> {text}"
+                data[C_FACTOR*2 | R_ACCESS] = f"{self._extraLabel}: {text}"
             data[C_FACTOR*3 | R_ICON] = self._more
         data[R_HANDLE] = handle
         data[R_KEY] = key

novelwriter/core/project.py

@@ -367,7 +367,7 @@ class NWProject:
             # Often, the index needs to be rebuilt when updating format
             self._index.rebuild()
 
-        self.updateWordCounts()
+        self.updateCounts()
         self._session.startSession()
         self.setProjectChanged(False)
         self._valid = True
@@ -397,7 +397,7 @@ class NWProject:
         else:
             self._data.incSaveCount()
 
-        self.updateWordCounts()
+        self.updateCounts()
         self.countStatus()
 
         xmlWriter = self._storage.getXmlWriter()
@@ -483,14 +483,14 @@ class NWProject:
 
     def setDefaultStatusImport(self) -> None:
         """Set the default status and importance values."""
-        self._data.itemStatus.add(None, self.tr("New"),      (100, 100, 100), "SQUARE", 0)
-        self._data.itemStatus.add(None, self.tr("Note"),     (200, 50,  0),   "SQUARE", 0)
-        self._data.itemStatus.add(None, self.tr("Draft"),    (200, 150, 0),   "SQUARE", 0)
-        self._data.itemStatus.add(None, self.tr("Finished"), (50,  200, 0),   "SQUARE", 0)
-        self._data.itemImport.add(None, self.tr("New"),      (100, 100, 100), "SQUARE", 0)
-        self._data.itemImport.add(None, self.tr("Minor"),    (200, 50,  0),   "SQUARE", 0)
-        self._data.itemImport.add(None, self.tr("Major"),    (200, 150, 0),   "SQUARE", 0)
-        self._data.itemImport.add(None, self.tr("Main"),     (50,  200, 0),   "SQUARE", 0)
+        self._data.itemStatus.add(None, self.tr("New"),      (120, 120, 120), "STAR", 0)
+        self._data.itemStatus.add(None, self.tr("Note"),     (205, 171, 143), "TRIANGLE", 0)
+        self._data.itemStatus.add(None, self.tr("Draft"),    (143, 240, 164), "CIRCLE_T", 0)
+        self._data.itemStatus.add(None, self.tr("Finished"), (249, 240, 107), "STAR", 0)
+        self._data.itemImport.add(None, self.tr("New"),      (120, 120, 120), "SQUARE", 0)
+        self._data.itemImport.add(None, self.tr("Minor"),    (220, 138, 221), "BLOCK_2", 0)
+        self._data.itemImport.add(None, self.tr("Major"),    (220, 138, 221), "BLOCK_3", 0)
+        self._data.itemImport.add(None, self.tr("Main"),     (220, 138, 221), "BLOCK_4", 0)
         return
 
     def setProjectLang(self, language: str | None) -> None:
@@ -515,10 +515,10 @@ class NWProject:
     #  Class Methods
     ##
 
-    def updateWordCounts(self) -> None:
-        """Update the total word count values."""
-        novel, notes = self._tree.sumWords()
-        self._data.setCurrCounts(novel=novel, notes=notes)
+    def updateCounts(self) -> None:
+        """Update the total word and character count values."""
+        wNovel, wNotes, cNovel, cNotes = self._tree.sumCounts()
+        self._data.setCurrCounts(wNovel=wNovel, wNotes=wNotes, cNovel=cNovel, cNotes=cNotes)
         return
 
     def countStatus(self) -> None:

novelwriter/core/projectdata.py

@@ -66,8 +66,8 @@ 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,
@@ -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

@@ -46,7 +46,7 @@ if TYPE_CHECKING:
 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)