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

novelwriter/constants.py

@@ -50,6 +50,9 @@ class nwConst:
     URL_HELP    = "https://github.com/vkbo/novelWriter/discussions"
     URL_RELEASE = "https://github.com/vkbo/novelWriter/releases/latest"
 
+    # Requests
+    USER_AGENT = "Mozilla/5.0 (compatible; novelWriter (Python))"
+
     # Gui Settings
     STATUS_MSG_TIMEOUT = 15000  # milliseconds
 
@@ -153,6 +156,21 @@ class nwKeyWords:
 # END Class nwKeyWords
 
 
+class nwLists:
+
+    USER_CLASSES = [
+        nwItemClass.CHARACTER,
+        nwItemClass.PLOT,
+        nwItemClass.WORLD,
+        nwItemClass.TIMELINE,
+        nwItemClass.OBJECT,
+        nwItemClass.ENTITY,
+        nwItemClass.CUSTOM,
+    ]
+
+# END Class nwLists
+
+
 class nwLabels:
 
     CLASS_NAME = {
@@ -221,8 +239,8 @@ class nwLabels:
         nwOutline.FOCUS:  QT_TRANSLATE_NOOP("Constant", "Focus"),
         nwOutline.CHAR:   KEY_NAME[nwKeyWords.CHAR_KEY],
         nwOutline.PLOT:   KEY_NAME[nwKeyWords.PLOT_KEY],
-        nwOutline.TIME:   KEY_NAME[nwKeyWords.TIME_KEY],
         nwOutline.WORLD:  KEY_NAME[nwKeyWords.WORLD_KEY],
+        nwOutline.TIME:   KEY_NAME[nwKeyWords.TIME_KEY],
         nwOutline.OBJECT: KEY_NAME[nwKeyWords.OBJECT_KEY],
         nwOutline.ENTITY: KEY_NAME[nwKeyWords.ENTITY_KEY],
         nwOutline.CUSTOM: KEY_NAME[nwKeyWords.CUSTOM_KEY],
@@ -327,8 +345,7 @@ class nwQuotes:
 
 
 class nwUnicode:
-    """Supported unicode character constants and their HTML equivalents.
-    """
+    """Supported unicode character constants and their HTML equivalents."""
     # Unicode Constants
     # =================
 

novelwriter/core/buildsettings.py

@@ -349,7 +349,7 @@ class BuildSettings:
     def buildItemFilter(
         self, project: NWProject, withRoots: bool = False
     ) -> dict[str, tuple[bool, FilterMode]]:
-        """Return a dictionary of item handles with filter decissions
+        """Return a dictionary of item handles with filter decisions
         applied.
         """
         result: dict[str, tuple[bool, FilterMode]] = {}

novelwriter/core/coretools.py

@@ -406,6 +406,7 @@ class ProjectBuilder:
 
             chSynop = self.tr("Summary of the chapter.")
             scSynop = self.tr("Summary of the scene.")
+            bfNote = self.tr("A short description.")
 
             # Create chapters
             if numChapters > 0:
@@ -446,7 +447,11 @@ class ProjectBuilder:
                         aHandle = project.newFile(noteTitles[newRoot], rHandle)
                         ntTag = simplified(noteTitles[newRoot]).replace(" ", "")
                         aDoc = project.storage.getDocument(aHandle)
-                        aDoc.writeDocument(f"# {noteTitles[newRoot]}\n\n@tag: {ntTag}\n\n")
+                        aDoc.writeDocument(
+                            f"# {noteTitles[newRoot]}\n\n"
+                            f"@tag: {ntTag}\n\n"
+                            f"% Short: {bfNote}\n\n"
+                        )
 
             # Also add the archive and trash folders
             project.newRoot(nwItemClass.ARCHIVE)

novelwriter/core/index.py

@@ -35,7 +35,8 @@ from time import time
 from typing import TYPE_CHECKING, ItemsView, Iterable, Iterator
 from pathlib import Path
 
-from novelwriter.enum import nwItemClass, nwItemType, nwItemLayout
+from novelwriter import SHARED
+from novelwriter.enum import nwComment, nwItemClass, nwItemType, nwItemLayout
 from novelwriter.error import logException
 from novelwriter.common import checkInt, isHandle, isItemClass, isTitleTag, jsonEncode
 from novelwriter.constants import nwFiles, nwKeyWords, nwRegEx, nwUnicode, nwHeaders
@@ -112,6 +113,7 @@ class NWIndex:
         self._itemIndex.clear()
         self._indexChange = 0.0
         self._rootChange = {}
+        SHARED.indexSignalProxy({"event": "clearIndex"})
         return
 
     def rebuildIndex(self) -> None:
@@ -121,16 +123,22 @@ class NWIndex:
             if nwItem.isFileType():
                 tHandle = nwItem.itemHandle
                 theDoc = self._project.storage.getDocument(tHandle)
-                self.scanText(tHandle, theDoc.readDocument() or "")
+                self.scanText(tHandle, theDoc.readDocument() or "", blockSignal=True)
         self._indexBroken = False
+        SHARED.indexSignalProxy({"event": "buildIndex"})
         return
 
     def deleteHandle(self, tHandle: str) -> None:
         """Delete all entries of a given document handle."""
         logger.debug("Removing item '%s' from the index", tHandle)
-        for tTag in self._itemIndex.allItemTags(tHandle):
+        delTags = self._itemIndex.allItemTags(tHandle)
+        for tTag in delTags:
             del self._tagsIndex[tTag]
         del self._itemIndex[tHandle]
+        SHARED.indexSignalProxy({
+            "event": "updateTags",
+            "deleted": delTags,
+        })
         return
 
     def reIndexHandle(self, tHandle: str | None) -> bool:
@@ -138,14 +146,12 @@ class NWIndex:
         moved from the archive or trash folders back into the active
         project.
         """
-        if tHandle is None or not self._project.tree.checkType(tHandle, nwItemType.FILE):
-            return False
-
-        logger.debug("Re-indexing item '%s'", tHandle)
-        theDoc = self._project.storage.getDocument(tHandle)
-        self.scanText(tHandle, theDoc.readDocument() or "")
-
-        return True
+        if tHandle and self._project.tree.checkType(tHandle, nwItemType.FILE):
+            logger.debug("Re-indexing item '%s'", tHandle)
+            theDoc = self._project.storage.getDocument(tHandle)
+            self.scanText(tHandle, theDoc.readDocument() or "")
+            return True
+        return False
 
     def indexChangedSince(self, checkTime: int | float) -> bool:
         """Check if the index has changed since a given time."""
@@ -200,6 +206,7 @@ class NWIndex:
                 self.reIndexHandle(fHandle)
 
         self._indexChange = time()
+        SHARED.indexSignalProxy({"event": "buildIndex"})
 
         logger.debug("Index loaded in %.3f ms", (time() - tStart)*1000)
 
@@ -238,7 +245,7 @@ class NWIndex:
     #  Index Building
     ##
 
-    def scanText(self, tHandle: str, text: str) -> bool:
+    def scanText(self, tHandle: str, text: str, blockSignal: bool = False) -> bool:
         """Scan a piece of text associated with a handle. This will
         update the indices accordingly. This function takes the handle
         and text as separate inputs as we want to primarily scan the
@@ -282,6 +289,11 @@ class NWIndex:
         nowTime = time()
         self._indexChange = nowTime
         self._rootChange[tItem.itemRoot] = nowTime
+        if not blockSignal:
+            SHARED.indexSignalProxy({
+                "event": "scanText",
+                "handle": tHandle,
+            })
 
         return True
 
@@ -289,7 +301,7 @@ class NWIndex:
     #  Internal Indexer Helpers
     ##
 
-    def _scanActive(self, tHandle: str, nwItem: NWItem, text: str, tags: dict) -> None:
+    def _scanActive(self, tHandle: str, nwItem: NWItem, text: str, tags: dict[str, bool]) -> None:
         """Scan an active document for meta data."""
         nTitle = 0           # Line Number of the previous title
         cTitle = TT_NONE     # Tag of the current title
@@ -326,14 +338,9 @@ class NWIndex:
 
             elif line.startswith("%"):
                 if cTitle != TT_NONE:
-                    toCheck = line[1:].lstrip()
-                    synTag = toCheck[:9].lower()
-                    tLen = len(line)
-                    cLen = len(toCheck)
-                    cOff = tLen - cLen
-                    if synTag == "synopsis:":
-                        sText = line[cOff+9:].strip()
-                        self._itemIndex.setHeadingSynopsis(tHandle, cTitle, sText)
+                    cStyle, cText, _ = processComment(line)
+                    if cStyle in (nwComment.SYNOPSIS, nwComment.SHORT):
+                        self._itemIndex.setHeadingSynopsis(tHandle, cTitle, cText)
 
         # Count words for remaining text after last heading
         if pTitle != TT_NONE:
@@ -346,9 +353,21 @@ class NWIndex:
 
         # Prune no longer used tags
         for tTag, isActive in tags.items():
-            if not isActive:
-                logger.debug("Deleting removed tag '%s'", tTag)
+            updated = []
+            deleted = []
+            if isActive:
+                logger.debug("Added/updated tag '%s'", tTag)
+                updated.append(tTag)
+            else:
+                logger.debug("Removed tag '%s'", tTag)
                 del self._tagsIndex[tTag]
+                deleted.append(tTag)
+            if updated or deleted:
+                SHARED.indexSignalProxy({
+                    "event": "updateTags",
+                    "updated": updated,
+                    "deleted": deleted,
+                })
 
         return
 
@@ -385,7 +404,7 @@ class NWIndex:
         return
 
     def _indexKeyword(self, tHandle: str, line: str, sTitle: str,
-                      itemClass: nwItemClass, tags: dict) -> None:
+                      itemClass: nwItemClass, tags: dict[str, bool]) -> None:
         """Validate and save the information about a reference to a tag
         in another file, or the setting of a tag in the file. A record
         of active tags is updated so that no longer used tags can be
@@ -596,10 +615,8 @@ class NWIndex:
 
         return tRefs
 
-    def getBackReferenceList(self, tHandle: str) -> dict[str, str]:
-        """Build a list of files referring back to our file, specified
-        by tHandle.
-        """
+    def getBackReferenceList(self, tHandle: str) -> dict[str, tuple[str, IndexHeading]]:
+        """Build a dict of files referring back to our file."""
         if tHandle is None or tHandle not in self._itemIndex:
             return {}
 
@@ -611,20 +628,43 @@ class NWIndex:
         for aHandle, sTitle, hItem in self._itemIndex.iterAllHeaders():
             for aTag in hItem.references:
                 if aTag in tTags and aHandle not in tRefs:
-                    tRefs[aHandle] = sTitle
+                    tRefs[aHandle] = (sTitle, hItem)
 
         return tRefs
 
-    def getTagSource(self, tagKey: str) -> tuple[str, str]:
+    def getTagSource(self, tagKey: str) -> tuple[str | None, str]:
         """Return the source location of a given tag."""
         tHandle = self._tagsIndex.tagHandle(tagKey)
         sTitle = self._tagsIndex.tagHeading(tagKey)
         return tHandle, sTitle
 
-    def getTags(self, itemClass: nwItemClass) -> list[str]:
+    def getDocumentTags(self, tHandle: str | None) -> list[str]:
+        """Return all tags used by a specific document."""
+        return self._itemIndex.allItemTags(tHandle) if tHandle else []
+
+    def getClassTags(self, itemClass: nwItemClass) -> list[str]:
         """Return all tags based on itemClass."""
         return self._tagsIndex.filterTagNames(itemClass.name)
 
+    def getTagsData(self) -> Iterator[tuple[str, str, str, IndexItem | None, IndexHeading | None]]:
+        """Return all known tags."""
+        for tag, data in self._tagsIndex.items():
+            iItem = self._itemIndex[data.get("handle")]
+            hItem = None if iItem is None else iItem[data.get("heading")]
+            yield tag, data.get("name", ""), data.get("class", ""), iItem, hItem
+        return
+
+    def getSingleTag(self, tagKey: str) -> tuple[str, str, IndexItem | None, IndexHeading | None]:
+        """Return tag data for a specific tag."""
+        tName = self._tagsIndex.tagName(tagKey)
+        tClass = self._tagsIndex.tagClass(tagKey)
+        tHandle = self._tagsIndex.tagHandle(tagKey)
+        tHeading = self._tagsIndex.tagHeading(tagKey)
+        if tName and tClass and tHandle and tHeading:
+            iItem = self._itemIndex[tHandle]
+            return tName, tClass, iItem, None if iItem is None else iItem[tHeading]
+        return "", "", None, None
+
 # END Class NWIndex
 
 
@@ -643,7 +683,7 @@ class TagsIndex:
     __slots__ = ("_tags")
 
     def __init__(self) -> None:
-        self._tags: dict[str, dict] = {}
+        self._tags: dict[str, dict[str, str]] = {}
         return
 
     def __contains__(self, tagKey: str) -> bool:
@@ -665,6 +705,10 @@ class TagsIndex:
         self._tags = {}
         return
 
+    def items(self) -> ItemsView:
+        """Return a dictionary view of all tags."""
+        return self._tags.items()
+
     def add(self, tagKey: str, tHandle: str, sTitle: str, itemClass: nwItemClass) -> None:
         """Add a key to the index and set all values."""
         self._tags[tagKey.lower()] = {
@@ -676,7 +720,7 @@ class TagsIndex:
         """Get the display name of a given tag."""
         return self._tags.get(tagKey.lower(), {}).get("name", "")
 
-    def tagHandle(self, tagKey: str) -> str:
+    def tagHandle(self, tagKey: str) -> str | None:
         """Get the handle of a given tag."""
         return self._tags.get(tagKey.lower(), {}).get("handle", None)
 
@@ -937,6 +981,11 @@ class IndexItem:
     # Properties
     ##
 
+    @property
+    def handle(self) -> str:
+        """Return the item handle of the index item."""
+        return self._handle
+
     @property
     def item(self) -> NWItem:
         """Return the project item of the index item."""
@@ -1215,9 +1264,26 @@ class IndexHeading:
 
 
 # =============================================================================================== #
-#  Simple Word Counter
+#  Text Processing Functions
 # =============================================================================================== #
 
+CLASSIFIERS = {
+    "short": nwComment.SHORT,
+    "synopsis": nwComment.SYNOPSIS,
+}
+
+
+def processComment(text: str) -> tuple[nwComment, str, int]:
+    """Extract comment style and text. Should only be called on text
+    starting with a %.
+    """
+    check = text[1:].lstrip()
+    classifier, _, content = check.partition(":")
+    if content and (clean := classifier.strip().lower()) in CLASSIFIERS:
+        return CLASSIFIERS[clean], content.strip(), text.find(":") + 1
+    return nwComment.PLAIN, check, 0
+
+
 def countWords(text: str) -> tuple[int, int, int]:
     """Count words in a piece of text, skipping special syntax and
     comments.

novelwriter/core/options.py

@@ -69,6 +69,9 @@ VALID_MAP = {
     "GuiManuscriptBuild": {
         "winWidth", "winHeight", "fmtWidth", "sumWidth",
     },
+    "GuiDocViewerPanel": {
+        "colWidths",
+    }
 }
 
 

novelwriter/core/project.py

@@ -45,7 +45,7 @@ from novelwriter.core.sessions import NWSessionLog
 from novelwriter.core.projectxml import ProjectXMLReader, ProjectXMLWriter, XMLReadState
 from novelwriter.core.projectdata import NWProjectData
 from novelwriter.common import (
-    checkStringNone, formatInt, formatTimeStamp, hexToInt, makeFileNameSafe, minmax
+    checkStringNone, formatInt, formatTimeStamp, getFileSize, hexToInt, makeFileNameSafe, minmax
 )
 
 if TYPE_CHECKING:  # pragma: no cover
@@ -420,7 +420,7 @@ class NWProject:
         timeStamp = formatTimeStamp(time(), fileSafe=True)
         archName = baseDir / f"{cleanName} {timeStamp}.zip"
         if self._storage.zipIt(archName, compression=2):
-            size = formatInt(archName.stat().st_size)
+            size = formatInt(getFileSize(archName))
             if doNotify:
                 SHARED.info(
                     self.tr("Created a backup of your project of size {0}B.").format(size),

novelwriter/core/projectdata.py

@@ -170,7 +170,7 @@ class NWProjectData:
 
     @property
     def autoReplace(self) -> dict[str, str]:
-        """Return the autoreplace dictionary."""
+        """Return the auto-replace dictionary."""
         return self._autoReplace
 
     @property

novelwriter/core/tohtml.py

@@ -287,7 +287,10 @@ class ToHtml(Tokenizer):
                 para.append(stripEscape(tTemp.rstrip()))
 
             elif tType == self.T_SYNOPSIS and self._doSynopsis:
-                lines.append(self._formatSynopsis(tText))
+                lines.append(self._formatSynopsis(tText, True))
+
+            elif tType == self.T_SHORT and self._doSynopsis:
+                lines.append(self._formatSynopsis(tText, False))
 
             elif tType == self.T_COMMENT and self._doComments:
                 lines.append(self._formatComments(tText))
@@ -454,9 +457,12 @@ class ToHtml(Tokenizer):
     #  Internal Functions
     ##
 
-    def _formatSynopsis(self, text: str) -> str:
+    def _formatSynopsis(self, text: str, synopsis: bool) -> str:
         """Apply HTML formatting to synopsis."""
-        sSynop = self._localLookup("Synopsis")
+        if synopsis:
+            sSynop = self._localLookup("Synopsis")
+        else:
+            sSynop = self._localLookup("Short Description")
         if self._genMode == self.M_PREVIEW:
             return f"<p class='comment'><span class='synopsis'>{sSynop}:</span> {text}</p>\n"
         else:

novelwriter/core/tokenizer.py

@@ -34,8 +34,9 @@ from pathlib import Path
 from functools import partial
 
 from PyQt5.QtCore import QCoreApplication, QRegularExpression
+from novelwriter.core.index import processComment
 
-from novelwriter.enum import nwItemLayout
+from novelwriter.enum import nwComment, nwItemLayout
 from novelwriter.common import formatTimeStamp, numberToRoman, checkInt
 from novelwriter.constants import nwHeadFmt, nwRegEx, nwShortcode, nwUnicode
 from novelwriter.core.project import NWProject
@@ -79,17 +80,18 @@ class Tokenizer(ABC):
     # Block Type
     T_EMPTY    = 1   # Empty line (new paragraph)
     T_SYNOPSIS = 2   # Synopsis comment
-    T_COMMENT  = 3   # Comment line
-    T_KEYWORD  = 4   # Command line
-    T_TITLE    = 5   # Title
-    T_UNNUM    = 6   # Unnumbered
-    T_HEAD1    = 7   # Header 1
-    T_HEAD2    = 8   # Header 2
-    T_HEAD3    = 9   # Header 3
-    T_HEAD4    = 10  # Header 4
-    T_TEXT     = 11  # Text line
-    T_SEP      = 12  # Scene separator
-    T_SKIP     = 13  # Paragraph break
+    T_SHORT    = 3   # Short description comment
+    T_COMMENT  = 4   # Comment line
+    T_KEYWORD  = 5   # Command line
+    T_TITLE    = 6   # Title
+    T_UNNUM    = 7   # Unnumbered
+    T_HEAD1    = 8   # Header 1
+    T_HEAD2    = 9   # Header 2
+    T_HEAD3    = 10   # Header 3
+    T_HEAD4    = 11  # Header 4
+    T_TEXT     = 12  # Text line
+    T_SEP      = 13  # Scene separator
+    T_SKIP     = 14  # Paragraph break
 
     # Block Style
     A_NONE     = 0x0000  # No special style
@@ -216,7 +218,7 @@ class Tokenizer(ABC):
         return
 
     def setChapterFormat(self, hFormat: str) -> None:
-        """Set the chapert format pattern."""
+        """Set the chapter format pattern."""
         self._fmtChapter = hFormat.strip()
         return
 
@@ -435,8 +437,8 @@ class Tokenizer(ABC):
             if aLine[0] == "[":
                 # Parse special formatting line
                 # This must be a separate if statement, as it may not
-                # reach a continue statement and must thefore proceed to
-                # check other formats.
+                # reach a continue statement and must therefore proceed
+                # to check other formats.
 
                 if sLine in ("[newpage]", "[new page]"):
                     breakNext = True
@@ -461,17 +463,22 @@ class Tokenizer(ABC):
                     continue
 
             if aLine[0] == "%":
-                cLine = aLine[1:].lstrip()
-                synTag = cLine[:9].lower()
-                if synTag == "synopsis:":
+                cStyle, cText, _ = processComment(aLine)
+                if cStyle == nwComment.SYNOPSIS:
                     self._tokens.append((
-                        self.T_SYNOPSIS, nHead, cLine[9:].strip(), None, sAlign
+                        self.T_SYNOPSIS, nHead, cText, None, sAlign
+                    ))
+                    if self._doSynopsis and self._keepMarkdown:
+                        tmpMarkdown.append("%s\n" % aLine)
+                elif cStyle == nwComment.SHORT:
+                    self._tokens.append((
+                        self.T_SHORT, nHead, cText, None, sAlign
                     ))
                     if self._doSynopsis and self._keepMarkdown:
                         tmpMarkdown.append("%s\n" % aLine)
                 else:
                     self._tokens.append((
-                        self.T_COMMENT, nHead, aLine[1:].strip(), None, sAlign
+                        self.T_COMMENT, nHead, cText, None, sAlign
                     ))
                     if self._doComments and self._keepMarkdown:
                         tmpMarkdown.append("%s\n" % aLine)

novelwriter/core/tomd.py

@@ -170,6 +170,10 @@ class ToMarkdown(Tokenizer):
                 label = self._localLookup("Synopsis")
                 lines.append(f"**{label}:** {tText}\n\n")
 
+            elif tType == self.T_SHORT and self._doSynopsis:
+                label = self._localLookup("Short Description")
+                lines.append(f"**{label}:** {tText}\n\n")
+
             elif tType == self.T_COMMENT and self._doComments:
                 label = self._localLookup("Comment")
                 lines.append(f"**{label}:** {tText}\n\n")

novelwriter/core/toodt.py

@@ -195,7 +195,7 @@ class ToOdt(Tokenizer):
     #  Setters
     ##
 
-    def setLanguage(self, language: str) -> None:
+    def setLanguage(self, language: str | None) -> None:
         """Set language for the document."""
         if language:
             langBits = language.split("_")
@@ -481,7 +481,11 @@ class ToOdt(Tokenizer):
                 pFmt.append(tFormat)
 
             elif tType == self.T_SYNOPSIS and self._doSynopsis:
-                tTemp, fTemp = self._formatSynopsis(tText)
+                tTemp, fTemp = self._formatSynopsis(tText, True)
+                self._addTextPar("Text_20_Meta", oStyle, tTemp, tFmt=fTemp)
+
+            elif tType == self.T_SHORT and self._doSynopsis:
+                tTemp, fTemp = self._formatSynopsis(tText, False)
                 self._addTextPar("Text_20_Meta", oStyle, tTemp, tFmt=fTemp)
 
             elif tType == self.T_COMMENT and self._doComments:
@@ -552,9 +556,12 @@ class ToOdt(Tokenizer):
     #  Internal Functions
     ##
 
-    def _formatSynopsis(self, text: str) -> tuple[str, list[tuple[int, int]]]:
+    def _formatSynopsis(self, text: str, synopsis: bool) -> tuple[str, list[tuple[int, int]]]:
         """Apply formatting to synopsis lines."""
-        name = self._localLookup("Synopsis")
+        if synopsis:
+            name = self._localLookup("Synopsis")
+        else:
+            name = self._localLookup("Short Description")
         rTxt = f"{name}: {text}"
         rFmt = [(0, self.FMT_B_B), (len(name) + 1, self.FMT_B_E)]
         return rTxt, rFmt