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

novelwriter/core/itemmodel.py

@@ -28,8 +28,8 @@ import logging
 
 from typing import TYPE_CHECKING
 
-from PyQt5.QtCore import QAbstractItemModel, QMimeData, QModelIndex, Qt
-from PyQt5.QtGui import QFont, QIcon
+from PyQt6.QtCore import QAbstractItemModel, QMimeData, QModelIndex, Qt
+from PyQt6.QtGui import QFont, QIcon
 
 from novelwriter.common import decodeMimeHandles, encodeMimeHandles, minmax
 from novelwriter.constants import nwConst
@@ -37,7 +37,7 @@ from novelwriter.core.item import NWItem
 from novelwriter.enum import nwItemClass
 from novelwriter.types import QtAlignRight
 
-if TYPE_CHECKING:  # pragma: no cover
+if TYPE_CHECKING:
     from novelwriter.core.tree import NWTree
 
 logger = logging.getLogger(__name__)
@@ -45,24 +45,24 @@ 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
 NODE_FLAGS |= Qt.ItemFlag.ItemIsDropEnabled
 
-if TYPE_CHECKING:  # pragma: no cover
-    # Requires Python 3.10
-    T_NodeData = str | QIcon | QFont | Qt.AlignmentFlag | None
+T_NodeData = str | QIcon | QFont | Qt.AlignmentFlag | None
 
 
 class ProjectNode:
@@ -91,7 +91,7 @@ class ProjectNode:
     C_ACTIVE = 2
     C_STATUS = 3
 
-    __slots__ = ("_item", "_children", "_parent", "_row", "_cache", "_flags", "_count")
+    __slots__ = ("_cache", "_children", "_count", "_flags", "_item", "_parent", "_row")
 
     def __init__(self, item: NWItem) -> None:
         self._item = item
@@ -152,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)
+        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()
@@ -195,7 +197,7 @@ class ProjectNode:
         return self._parent
 
     def child(self, row: int) -> ProjectNode | None:
-        """Return a child ofg the node."""
+        """Return a child of the node."""
         if 0 <= row < len(self._children):
             return self._children[row]
         return None
@@ -220,6 +222,7 @@ class ProjectNode:
             child._row = len(self._children)
             self._children.append(child)
         self._refreshChildrenPos()
+        self._item.notifyNovelStructureChange()
         return
 
     def takeChild(self, pos: int) -> ProjectNode | None:
@@ -228,6 +231,7 @@ class ProjectNode:
             node = self._children.pop(pos)
             self._refreshChildrenPos()
             self.updateCount()
+            self._item.notifyNovelStructureChange()
             return node
         return None
 
@@ -238,6 +242,7 @@ class ProjectNode:
             node = self._children.pop(source)
             self._children.insert(target, node)
             self._refreshChildrenPos()
+            self._item.notifyNovelStructureChange()
         return
 
     def setExpanded(self, state: bool) -> None:
@@ -256,13 +261,13 @@ class ProjectNode:
         """Recursively add all nodes to a list."""
         for node in self._children:
             children.append(node)
-            node._recursiveAppendChildren(children)
+            node._recursiveAppendChildren(children)  # noqa: SLF001
         return
 
     def _refreshChildrenPos(self) -> None:
         """Update the row value on all children."""
         for n, child in enumerate(self._children):
-            child._row = n
+            child._row = n  # noqa: SLF001
             child.item.setOrder(n)
         return
 
@@ -289,12 +294,12 @@ class ProjectModel(QAbstractItemModel):
     methods needed primarily by the project tree GUI component.
     """
 
-    __slots__ = ("_tree", "_root")
+    __slots__ = ("_root", "_tree")
 
     def __init__(self, tree: NWTree) -> None:
         super().__init__()
         self._tree = tree
-        self._root = ProjectNode(NWItem(tree._project, INV_ROOT))
+        self._root = ProjectNode(NWItem(tree.project, INV_ROOT))
         self._root.item.setName("Invisible Root")
         logger.debug("Ready: ProjectModel")
         return
@@ -332,8 +337,9 @@ class ProjectModel(QAbstractItemModel):
             return self.createIndex(parent.row(), 0, parent)
         return QModelIndex()
 
-    def index(self, row: int, column: int, parent: QModelIndex = QModelIndex()) -> QModelIndex:
-        """get the index of a child item of a parent."""
+    def index(self, row: int, column: int, parent: QModelIndex | None = None) -> QModelIndex:
+        """Get the index of a child item of a parent."""
+        parent = parent or QModelIndex()
         if self.hasIndex(row, column, parent):
             node: ProjectNode = parent.internalPointer() if parent.isValid() else self._root
             if child := node.child(row):
@@ -389,10 +395,10 @@ class ProjectModel(QAbstractItemModel):
     ) -> bool:
         """Process mime data drop."""
         if self.canDropMimeData(data, action, row, column, parent):
-            items = []
-            for handle in decodeMimeHandles(data):
-                if (index := self.indexFromHandle(handle)).isValid():
-                    items.append(index)
+            items = [
+                index for handle in decodeMimeHandles(data)
+                if (index := self.indexFromHandle(handle)).isValid()
+            ]
             self.multiMove(items, parent, row)
             return True
         return False
@@ -488,7 +494,7 @@ class ProjectModel(QAbstractItemModel):
                     if temp := self.removeChild(index.parent(), index.row()):
                         self.insertChild(temp, target, pos)
                         for child in reversed(node.allChildren()):
-                            node._updateRelationships(child)
+                            node._updateRelationships(child)  # noqa: SLF001
                             child.item.notifyToRefresh()
                         node.item.notifyToRefresh()
         return
@@ -499,16 +505,15 @@ class ProjectModel(QAbstractItemModel):
 
     def clear(self) -> None:
         """Clear the project model."""
-        self._root._children.clear()
+        self._root.children.clear()
         return
 
     def allExpanded(self) -> list[QModelIndex]:
         """Return a list of all expanded items."""
-        expanded = []
-        for node in self._root.allChildren():
-            if node._item.isExpanded:
-                expanded.append(self.createIndex(node.row(), 0, node))
-        return expanded
+        return [
+            self.createIndex(node.row(), 0, node) for node in self._root.allChildren()
+            if node.item.isExpanded
+        ]
 
     def trashSelection(self, indices: list[QModelIndex]) -> bool:
         """Check if a selection of indices are all in trash or not."""

novelwriter/core/novelmodel.py

@@ -0,0 +1,225 @@
+"""
+novelWriter – Novel Model
+=========================
+
+File History:
+Created: 2025-02-22 [2.7b1] NovelModel
+
+This file is a part of novelWriter
+Copyright (C) 2025 Veronica Berglyd Olsen and novelWriter contributors
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.
+"""
+from __future__ import annotations
+
+import logging
+
+from typing import TYPE_CHECKING
+
+from PyQt6.QtCore import QAbstractTableModel, QModelIndex, Qt
+from PyQt6.QtGui import QIcon, QPixmap
+
+from novelwriter import SHARED
+from novelwriter.constants import nwKeyWords, nwLabels, nwStyles, trConst
+from novelwriter.enum import nwNovelExtra
+from novelwriter.types import QtAlignRight
+
+if TYPE_CHECKING:
+    from novelwriter.core.indexdata import IndexHeading, IndexNode
+
+logger = logging.getLogger(__name__)
+
+C_FACTOR = 0x0100
+
+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
+
+T_NodeData = str | QIcon | QPixmap | Qt.AlignmentFlag | None
+
+
+class NovelModel(QAbstractTableModel):
+
+    __slots__ = ("_columns", "_extraKey", "_extraLabel", "_more", "_rows")
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._rows: list[dict[int, T_NodeData]] = []
+        self._more = SHARED.theme.getIcon("more_arrow")
+        self._columns = 3
+        self._extraKey = ""
+        self._extraLabel = ""
+        return
+
+    def __del__(self) -> None:  # pragma: no cover
+        logger.debug("Delete: NovelModel")
+        return
+
+    ##
+    #  Properties
+    ##
+
+    @property
+    def columns(self) -> int:
+        """Return the number of columns."""
+        return self._columns
+
+    ##
+    #  Setters
+    ##
+
+    def setExtraColumn(self, extra: nwNovelExtra) -> None:
+        """Set extra data column settings."""
+        match extra:
+            case nwNovelExtra.HIDDEN:
+                self._columns = 3
+                self._extraKey = ""
+                self._extraLabel = ""
+            case nwNovelExtra.POV:
+                self._columns = 4
+                self._extraKey = nwKeyWords.POV_KEY
+                self._extraLabel = trConst(nwLabels.KEY_NAME[nwKeyWords.POV_KEY])
+            case nwNovelExtra.FOCUS:
+                self._columns = 4
+                self._extraKey = nwKeyWords.FOCUS_KEY
+                self._extraLabel = trConst(nwLabels.KEY_NAME[nwKeyWords.FOCUS_KEY])
+            case nwNovelExtra.PLOT:
+                self._columns = 4
+                self._extraKey = nwKeyWords.PLOT_KEY
+                self._extraLabel = trConst(nwLabels.KEY_NAME[nwKeyWords.PLOT_KEY])
+        return
+
+    ##
+    #  Model Interface
+    ##
+
+    def rowCount(self, index: QModelIndex) -> int:
+        """Return the number of rows."""
+        return len(self._rows)
+
+    def columnCount(self, index: QModelIndex) -> int:
+        """Return the number of columns."""
+        return self._columns
+
+    def data(self, index: QModelIndex, role: Qt.ItemDataRole) -> T_NodeData:
+        """Return display data for a node."""
+        try:
+            return self._rows[index.row()].get(C_FACTOR*index.column() | role)
+        except Exception:
+            logger.error("Novel model index is inconsistent")
+        return None
+
+    def handle(self, index: QModelIndex) -> str | None:
+        """Return item handle for the row."""
+        try:
+            return self._rows[index.row()].get(R_HANDLE)  # type: ignore
+        except Exception:
+            logger.error("Novel model index is inconsistent")
+        return None
+
+    def key(self, index: QModelIndex) -> str | None:
+        """Return item handle for the row."""
+        try:
+            return self._rows[index.row()].get(R_KEY)  # type: ignore
+        except Exception:
+            logger.error("Novel model index is inconsistent")
+        return None
+
+    ##
+    #  Data Methods
+    ##
+
+    def clear(self) -> None:
+        """Clear the model."""
+        self._rows.clear()
+        return
+
+    def append(self, node: IndexNode) -> None:
+        """Append a node to the model."""
+        handle = node.handle
+        for key, head in node.items():
+            if key != "T0000":
+                self._rows.append(self._generateEntry(handle, key, head))
+        return
+
+    def refresh(self, node: IndexNode) -> bool:
+        """Refresh an index node."""
+        handle = node.handle
+        current = []
+        for i, row in enumerate(self._rows):
+            if row.get(R_HANDLE) == handle:
+                current.append(i)
+
+        if current == []:
+            logger.warning("No novel model entries for '%s'", handle)
+            return False
+
+        cols = self._columns - 1
+        first = current[0]
+        last = current[-1]
+
+        remains = []
+        for key, head in node.items():
+            if key != "T0000":
+                if current:
+                    j = current.pop(0)
+                    self._rows[j] = self._generateEntry(handle, key, head)
+                else:
+                    remains.append((key, head))
+
+        self.dataChanged.emit(self.createIndex(first, 0), self.createIndex(last, cols))
+
+        if remains:
+            # Inserting is safe for out of bounds indices
+            self.beginInsertRows(QModelIndex(), last, last + len(remains) - 1)
+            for k, (key, head) in enumerate(remains, last + 1):
+                self._rows.insert(k, self._generateEntry(handle, key, head))
+            self.endInsertRows()
+        elif current:
+            # Deleting ranges are safe for out of bounds indices
+            self.beginRemoveRows(QModelIndex(), current[0], current[-1])
+            del self._rows[current[0]:current[-1] + 1]
+            self.endRemoveRows()
+
+        return True
+
+    ##
+    #  Internal Functions
+    ##
+
+    def _generateEntry(self, handle: str, key: str, head: IndexHeading) -> dict[int, T_NodeData]:
+        """Generate a cache entry."""
+        iLevel = nwStyles.H_LEVEL.get(head.level, 0)
+        data = {}
+        data[C_FACTOR*0 | R_TIP] = head.title
+        data[C_FACTOR*0 | R_TEXT] = head.title
+        data[C_FACTOR*0 | R_ICON] = SHARED.theme.getHeaderDecoration(iLevel)
+        data[C_FACTOR*1 | R_TEXT] = f"{head.mainCount:n}"
+        data[C_FACTOR*1 | R_ALIGN] = QtAlignRight
+        if self._columns == 3:
+            data[C_FACTOR*2 | R_ICON] = self._more
+        else:
+            if self._extraKey and (refs := head.getReferencesByKeyword(self._extraKey)):
+                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
+        return data

novelwriter/core/options.py

@@ -35,7 +35,7 @@ from novelwriter.common import checkBool, checkFloat, checkInt, checkString, jso
 from novelwriter.constants import nwFiles
 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/project.py

@@ -32,7 +32,7 @@ from pathlib import Path
 from time import time
 from typing import TYPE_CHECKING
 
-from PyQt5.QtCore import QCoreApplication
+from PyQt6.QtCore import QCoreApplication
 
 from novelwriter import CONFIG, SHARED, __hexversion__, __version__
 from novelwriter.common import (
@@ -40,7 +40,7 @@ from novelwriter.common import (
     makeFileNameSafe, minmax
 )
 from novelwriter.constants import nwLabels, trConst
-from novelwriter.core.index import NWIndex
+from novelwriter.core.index import Index
 from novelwriter.core.options import OptionState
 from novelwriter.core.projectdata import NWProjectData
 from novelwriter.core.projectxml import ProjectXMLReader, ProjectXMLWriter, XMLReadState
@@ -50,8 +50,7 @@ from novelwriter.core.tree import NWTree
 from novelwriter.enum import nwItemClass, nwItemLayout, nwItemType
 from novelwriter.error import logException
 
-if TYPE_CHECKING:  # pragma: no cover
-    # Requires Python 3.10
+if TYPE_CHECKING:
     from novelwriter.core.status import T_StatusKind, T_UpdateEntry
 
 logger = logging.getLogger(__name__)
@@ -68,8 +67,8 @@ class NWProjectState(Enum):
 class NWProject:
 
     __slots__ = (
-        "_options", "_storage", "_data", "_tree", "_index", "_session",
-        "_langData", "_changed", "_valid", "_state", "tr",
+        "_changed", "_data", "_index", "_langData", "_options", "_session",
+        "_state", "_storage", "_tree", "_valid", "tr",
     )
 
     def __init__(self) -> None:
@@ -79,7 +78,7 @@ class NWProject:
         self._storage = NWStorage(self)      # The project storage handler
         self._data    = NWProjectData(self)  # The project settings
         self._tree    = NWTree(self)         # The project tree
-        self._index   = NWIndex(self)        # The project index
+        self._index   = Index(self)          # The project index
         self._session = NWSessionLog(self)   # The session record
 
         # Project Status
@@ -126,7 +125,7 @@ class NWProject:
         return self._tree
 
     @property
-    def index(self) -> NWIndex:
+    def index(self) -> Index:
         return self._index
 
     @property
@@ -368,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
@@ -398,7 +397,7 @@ class NWProject:
         else:
             self._data.incSaveCount()
 
-        self.updateWordCounts()
+        self.updateCounts()
         self.countStatus()
 
         xmlWriter = self._storage.getXmlWriter()
@@ -484,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:
@@ -516,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:
@@ -561,13 +560,13 @@ class NWProject:
 
     def _loadProjectLocalisation(self) -> bool:
         """Load the language data for the current project language."""
-        if self._data.language is None or CONFIG._nwLangPath is None:
+        if self._data.language is None or CONFIG.nwLangPath is None:
             self._langData = {}
             return False
 
-        langFile = Path(CONFIG._nwLangPath) / f"project_{self._data.language}.json"
+        langFile = Path(CONFIG.nwLangPath) / f"project_{self._data.language}.json"
         if not langFile.is_file():
-            langFile = Path(CONFIG._nwLangPath) / "project_en_GB.json"
+            langFile = Path(CONFIG.nwLangPath) / "project_en_GB.json"
 
         try:
             with open(langFile, mode="r", encoding="utf-8") as inFile: