novelWriter 2.4.3__py3-none-any.whl → 2.5__py3-none-any.whl

novelwriter/core/spellcheck.py

@@ -27,14 +27,14 @@ from __future__ import annotations
 import json
 import logging
 
-from typing import TYPE_CHECKING
-from pathlib import Path
 from collections.abc import Iterator
+from pathlib import Path
+from typing import TYPE_CHECKING
 
 from PyQt5.QtCore import QLocale
 
-from novelwriter.error import logException
 from novelwriter.constants import nwFiles
+from novelwriter.error import logException
 
 if TYPE_CHECKING:  # pragma: no cover
     from novelwriter.core.project import NWProject
@@ -164,11 +164,10 @@ class NWSpellEnchant:
             name = ""
         return tag, name
 
-# END Class NWSpellEnchant
-
 
 class FakeEnchant:
     """Fallback for when Enchant is selected, but not installed."""
+
     def __init__(self) -> None:
 
         class FakeProvider:
@@ -188,8 +187,6 @@ class FakeEnchant:
     def add_to_session(self, word: str) -> None:
         return
 
-# END Class FakeEnchant
-
 
 class UserDictionary:
 
@@ -240,5 +237,3 @@ class UserDictionary:
                 logger.error("Failed to save user dictionary")
                 logException()
         return
-
-# END Class UserDictionary

novelwriter/core/status.py

@@ -24,17 +24,19 @@ along with this program. If not, see <https://www.gnu.org/licenses/>.
 """
 from __future__ import annotations
 
-import random
+import dataclasses
 import logging
+import random
 
+from collections.abc import Iterable
 from typing import TYPE_CHECKING, Literal
-from collections.abc import ItemsView, Iterable, Iterator, KeysView, ValuesView
 
-from PyQt5.QtGui import QIcon, QPainter, QPainterPath, QPixmap, QColor
-from PyQt5.QtCore import QRectF
+from PyQt5.QtCore import QPointF, Qt
+from PyQt5.QtGui import QColor, QIcon, QPainter, QPainterPath, QPixmap, QPolygonF
 
-from novelwriter import CONFIG
-from novelwriter.common import minmax, simplified
+from novelwriter import SHARED
+from novelwriter.common import simplified
+from novelwriter.enum import nwStatusShape
 from novelwriter.types import QtPaintAnitAlias, QtTransparent
 
 if TYPE_CHECKING:  # pragma: no cover
@@ -43,83 +45,92 @@ if TYPE_CHECKING:  # pragma: no cover
 logger = logging.getLogger(__name__)
 
 
-class NWStatus:
+@dataclasses.dataclass
+class StatusEntry:
 
-    STATUS = 1
-    IMPORT = 2
+    name: str
+    color: QColor
+    shape: nwStatusShape
+    icon: QIcon
+    count: int = 0
 
-    def __init__(self, kind: Literal[1, 2]) -> None:
+    @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
 
-        self._type = kind
-        self._store = {}
-        self._default = None
 
-        self._iPX = CONFIG.pxInt(24)
+NO_ENTRY = StatusEntry("", QColor(0, 0, 0), nwStatusShape.SQUARE, QIcon(), 0)
+
 
-        pA = CONFIG.pxInt(2)
-        pB = CONFIG.pxInt(20)
-        pR = float(CONFIG.pxInt(4))
-        self._iconPath = QPainterPath()
-        self._iconPath.addRoundedRect(QRectF(pA, pA, pB, pB), pR, pR)
+class NWStatus:
 
-        self._defaultIcon = self._createIcon(100, 100, 100)
+    STATUS = "s"
+    IMPORT = "i"
 
-        if self._type == self.STATUS:
-            self._prefix = "s"
-        elif self._type == self.IMPORT:
-            self._prefix = "i"
-        else:
-            raise Exception("This is a bug!")
+    __slots__ = ("_store", "_default", "_prefix", "_height")
 
+    def __init__(self, prefix: Literal["s", "i"]) -> None:
+        self._store: dict[str, StatusEntry] = {}
+        self._default = None
+        self._prefix = prefix[:1]
+        self._height = SHARED.theme.baseIconHeight
         return
 
-    def write(self, key: str | None, name: str, col: tuple, count: int | None = None) -> str:
+    def __len__(self) -> int:
+        return len(self._store)
+
+    def __getitem__(self, key: str | None) -> StatusEntry:
+        """Return the entry associated with a given key."""
+        if key and key in self._store:
+            return self._store[key]
+        elif self._default is not None:
+            return self._store[self._default]
+        return NO_ENTRY
+
+    ##
+    #  Methods
+    ##
+
+    def add(self, key: str | None, name: str, color: tuple[int, int, int],
+            shape: str, count: int) -> str:
         """Add or update a status entry. If the key is invalid, a new
         key is generated.
         """
-        if not self._isKey(key):
-            key = self._newKey()
-        if not isinstance(col, tuple):
-            col = (100, 100, 100)
-        if len(col) != 3:
-            col = (100, 100, 100)
-
-        cR = minmax(col[0], 0, 255)
-        cG = minmax(col[1], 0, 255)
-        cB = minmax(col[2], 0, 255)
-        name = simplified(name)
-        if count is None:
-            count = self._store.get(key, {}).get("count", 0)
+        if isinstance(color, tuple) and len(color) == 3:
+            qColor = QColor(*color)
+        else:
+            qColor = QColor(100, 100, 100)
+
+        try:
+            iShape = nwStatusShape[shape]
+        except KeyError:
+            iShape = nwStatusShape.SQUARE
 
-        self._store[key] = {
-            "name": name,
-            "icon": self._createIcon(cR, cG, cB),
-            "cols": (cR, cG, cB),
-            "count": count,
-        }
+        key = self._checkKey(key)
+        name = simplified(name)
+        icon = self.createIcon(self._height, qColor, iShape)
+        self._store[key] = StatusEntry(name, qColor, iShape, icon, count)
 
         if self._default is None:
             self._default = key
 
         return key
 
-    def remove(self, key: str) -> bool:
-        """Remove an entry in the list, except if the count > 0."""
-        if key not in self._store:
-            return False
-        if self._store[key]["count"] > 0:
-            return False
-
-        del self._store[key]
+    def update(self, update: list[tuple[str | None, StatusEntry]]) -> None:
+        """Update the list of statuses, and from removed list."""
+        self._store.clear()
+        for key, entry in update:
+            self._store[self._checkKey(key)] = entry
 
-        keys = list(self._store.keys())
-        if key == self._default:
-            if len(keys) > 0:
-                self._default = keys[0]
-            else:
-                self._default = None
+        # Check if we need a new default
+        if self._default not in self._store:
+            self._default = next(iter(self._store)) if self._store else None
 
-        return True
+        return
 
     def check(self, value: str) -> str:
         """Check the key against the stored status names."""
@@ -129,93 +140,51 @@ class NWStatus:
             return self._default
         return ""
 
-    def name(self, key: str | None) -> str:
-        """Return the name associated with a given key."""
-        if key and key in self._store:
-            return self._store[key]["name"]
-        elif self._default is not None:
-            return self._store[self._default]["name"]
-        return ""
-
-    def cols(self, key: str | None) -> tuple[int, int, int]:
-        """Return the colours associated with a given key."""
-        if key and key in self._store:
-            return self._store[key]["cols"]
-        elif self._default is not None:
-            return self._store[self._default]["cols"]
-        return 100, 100, 100
-
-    def count(self, key: str | None) -> int:
-        """Return the count associated with a given key."""
-        if key and key in self._store:
-            return self._store[key]["count"]
-        elif self._default is not None:
-            return self._store[self._default]["count"]
-        return 0
-
-    def icon(self, key: str | None) -> QIcon:
-        """Return the icon associated with a given key."""
-        if key and key in self._store:
-            return self._store[key]["icon"]
-        elif self._default is not None:
-            return self._store[self._default]["icon"]
-        return self._defaultIcon
-
-    def reorder(self, order: list[str]) -> bool:
-        """Reorder the items according to list."""
-        if len(order) != len(self._store):
-            logger.error("Length mismatch between new and old order")
-            return False
-
-        if order == list(self._store.keys()):
-            return False
-
-        store = {}
-        for key in order:
-            if key in self._store:
-                store[key] = self._store[key]
-            else:
-                logger.error("Unknown key '%s' in order", key)
-                return False
-
-        self._store = store
-
-        return True
-
     def resetCounts(self) -> None:
         """Clear the counts of references to the status entries."""
-        for key in self._store:
-            self._store[key]["count"] = 0
+        for entry in self._store.values():
+            entry.count = 0
         return
 
     def increment(self, key: str | None) -> None:
         """Increment the counter for a given entry."""
         if key and key in self._store:
-            self._store[key]["count"] += 1
+            self._store[key].count += 1
         return
 
     def pack(self) -> Iterable[tuple[str, dict]]:
         """Pack the status entries into a dictionary."""
-        for key, data in self._store.items():
-            yield (data["name"], {
+        for key, entry in self._store.items():
+            yield (entry.name, {
                 "key":   key,
-                "count": str(data["count"]),
-                "red":   str(data["cols"][0]),
-                "green": str(data["cols"][1]),
-                "blue":  str(data["cols"][2]),
+                "count": str(entry.count),
+                "red":   str(entry.color.red()),
+                "green": str(entry.color.green()),
+                "blue":  str(entry.color.blue()),
+                "shape": entry.shape.name,
             })
         return
 
-    def unpack(self, data: dict) -> None:
-        """Unpack a data dictionary and set the class values."""
-        self._store = {}
-        self._default = None
-        for key, entry in data.items():
-            label = entry.get("label", "")
-            colour = entry.get("colour", (100, 100, 100))
-            count = entry.get("count", 0)
-            self.write(key, label, colour, count)
-        return
+    def iterItems(self) -> Iterable[tuple[str, StatusEntry]]:
+        """Yield entries from the status icons."""
+        yield from self._store.items()
+
+    @staticmethod
+    def createIcon(height: int, color: QColor, shape: nwStatusShape) -> QIcon:
+        """Generate an icon for a status label."""
+        pixmap = QPixmap(48, 48)
+        pixmap.fill(QtTransparent)
+
+        painter = QPainter(pixmap)
+        painter.setRenderHint(QtPaintAnitAlias)
+        painter.fillPath(_SHAPES.getShape(shape), color)
+        painter.end()
+
+        return QIcon(pixmap.scaled(
+            height, height,
+            Qt.AspectRatioMode.IgnoreAspectRatio,
+            Qt.TransformationMode.SmoothTransformation
+        ))
 
     ##
     #  Internal Functions
@@ -246,38 +215,116 @@ class NWStatus:
                 return False
         return True
 
-    def _createIcon(self, red: int, green: int, blue: int) -> QIcon:
-        """Generate an icon for a status label."""
-        pixmap = QPixmap(self._iPX, self._iPX)
-        pixmap.fill(QtTransparent)
-
-        painter = QPainter(pixmap)
-        painter.setRenderHint(QtPaintAnitAlias)
-        painter.fillPath(self._iconPath, QColor(red, green, blue))
-        painter.end()
-
-        return QIcon(pixmap)
+    def _checkKey(self, key: str | None) -> str:
+        """Check key is valid, and if not, generate one."""
+        return key if self._isKey(key) else self._newKey()
 
-    ##
-    #  Iterator Bits
-    ##
-
-    def __len__(self) -> int:
-        return len(self._store)
 
-    def __getitem__(self, key: str) -> dict:
-        return self._store[key]
+class _ShapeCache:
 
-    def __iter__(self) -> Iterator[dict]:
-        return iter(self._store)
-
-    def keys(self) -> KeysView[str]:
-        return self._store.keys()
-
-    def items(self) -> ItemsView[str, dict]:
-        return self._store.items()
-
-    def values(self) -> ValuesView[dict]:
-        return self._store.values()
+    def __init__(self) -> None:
+        self._cache: dict[nwStatusShape, QPainterPath] = {}
+        return
 
-# END Class NWStatus
+    def getShape(self, shape: nwStatusShape) -> QPainterPath:
+        """Return a painter shape for an icon."""
+        if shape in self._cache:
+            return self._cache[shape]
+
+        path = QPainterPath()
+        if shape == nwStatusShape.SQUARE:
+            path.addRoundedRect(2.0, 2.0, 44.0, 44.0, 4.0, 4.0)
+        elif shape == nwStatusShape.TRIANGLE:
+            path.addPolygon(QPolygonF([
+                QPointF(24.00, 3.00),
+                QPointF(43.92, 37.50),
+                QPointF(4.08, 37.50),
+            ]))
+        elif shape == nwStatusShape.NABLA:
+            path.addPolygon(QPolygonF([
+                QPointF(24.00, 48.00),
+                QPointF(4.08, 14.50),
+                QPointF(43.92, 14.50),
+            ]))
+        elif shape == nwStatusShape.DIAMOND:
+            path.addPolygon(QPolygonF([
+                QPointF(24.00, 2.00),
+                QPointF(44.00, 24.00),
+                QPointF(24.00, 46.00),
+                QPointF(4.00, 24.00),
+            ]))
+        elif shape == nwStatusShape.PENTAGON:
+            path.addPolygon(QPolygonF([
+                QPointF(24.00, 1.50),
+                QPointF(45.87, 17.39),
+                QPointF(37.52, 43.11),
+                QPointF(10.48, 43.11),
+                QPointF(2.13, 17.39),
+            ]))
+        elif shape == nwStatusShape.HEXAGON:
+            path.addPolygon(QPolygonF([
+                QPointF(24.00, 1.50),
+                QPointF(43.92, 13.00),
+                QPointF(43.92, 36.00),
+                QPointF(24.00, 47.50),
+                QPointF(4.08, 36.00),
+                QPointF(4.08, 13.00),
+            ]))
+        elif shape == nwStatusShape.STAR:
+            path.addPolygon(QPolygonF([
+                QPointF(24.00, 0.50), QPointF(31.05, 14.79),
+                QPointF(46.83, 17.08), QPointF(35.41, 28.21),
+                QPointF(38.11, 43.92), QPointF(24.00, 36.50),
+                QPointF(9.89, 43.92), QPointF(12.59, 28.21),
+                QPointF(1.17, 17.08), QPointF(15.37, 16.16),
+            ]))
+        elif shape == nwStatusShape.PACMAN:
+            path.moveTo(24.0, 24.0)
+            path.arcTo(2.0, 2.0, 44.0, 44.0, 40.0, 280.0)
+        elif shape == nwStatusShape.CIRCLE_Q:
+            path.moveTo(24.0, 24.0)
+            path.arcTo(2.0, 2.0, 44.0, 44.0, 0.0, 90.0)
+        elif shape == nwStatusShape.CIRCLE_H:
+            path.moveTo(24.0, 24.0)
+            path.arcTo(2.0, 2.0, 44.0, 44.0, -90.0, 180.0)
+        elif shape == nwStatusShape.CIRCLE_T:
+            path.moveTo(24.0, 24.0)
+            path.arcTo(2.0, 2.0, 44.0, 44.0, -180.0, 270.0)
+        elif shape == nwStatusShape.CIRCLE:
+            path.addEllipse(2.0, 2.0, 44.0, 44.0)
+        elif shape == nwStatusShape.BARS_1:
+            path.addRoundedRect(2.0, 2.0, 8.0, 44.0, 4.0, 4.0)
+        elif shape == nwStatusShape.BARS_2:
+            path.addRoundedRect(2.0, 2.0, 8.0, 44.0, 4.0, 4.0)
+            path.addRoundedRect(14.0, 2.0, 8.0, 44.0, 4.0, 4.0)
+        elif shape == nwStatusShape.BARS_3:
+            path.addRoundedRect(2.0, 2.0, 8.0, 44.0, 4.0, 4.0)
+            path.addRoundedRect(14.0, 2.0, 8.0, 44.0, 4.0, 4.0)
+            path.addRoundedRect(26.0, 2.0, 8.0, 44.0, 4.0, 4.0)
+        elif shape == nwStatusShape.BARS_4:
+            path.addRoundedRect(2.0, 2.0, 8.0, 44.0, 4.0, 4.0)
+            path.addRoundedRect(14.0, 2.0, 8.0, 44.0, 4.0, 4.0)
+            path.addRoundedRect(26.0, 2.0, 8.0, 44.0, 4.0, 4.0)
+            path.addRoundedRect(38.0, 2.0, 8.0, 44.0, 4.0, 4.0)
+        elif shape == nwStatusShape.BLOCK_1:
+            path.addRoundedRect(2.0, 2.0, 20.0, 20.0, 4.0, 4.0)
+        elif shape == nwStatusShape.BLOCK_2:
+            path.addRoundedRect(2.0, 2.0, 20.0, 20.0, 4.0, 4.0)
+            path.addRoundedRect(24.0, 2.0, 20.0, 20.0, 4.0, 4.0)
+        elif shape == nwStatusShape.BLOCK_3:
+            path.addRoundedRect(2.0, 2.0, 20.0, 20.0, 4.0, 4.0)
+            path.addRoundedRect(2.0, 24.0, 20.0, 20.0, 4.0, 4.0)
+            path.addRoundedRect(24.0, 2.0, 20.0, 20.0, 4.0, 4.0)
+        elif shape == nwStatusShape.BLOCK_4:
+            path.addRoundedRect(2.0, 2.0, 20.0, 20.0, 4.0, 4.0)
+            path.addRoundedRect(2.0, 24.0, 20.0, 20.0, 4.0, 4.0)
+            path.addRoundedRect(24.0, 2.0, 20.0, 20.0, 4.0, 4.0)
+            path.addRoundedRect(24.0, 24.0, 20.0, 20.0, 4.0, 4.0)
+
+        self._cache[shape] = path
+
+        return path
+
+
+# Create Singleton
+_SHAPES = _ShapeCache()

novelwriter/core/storage.py

@@ -54,8 +54,6 @@ class NWStorageOpen(Enum):
     FAILED    = 3
     READY     = 4
 
-# END Enum NWStorageOpen
-
 
 class NWStorageCreate(Enum):
 
@@ -63,8 +61,6 @@ class NWStorageCreate(Enum):
     OS_ERROR  = 1
     READY     = 2
 
-# END Enum NWStorageCreate
-
 
 class NWStorage:
     """Core: Project Storage Class
@@ -391,8 +387,6 @@ class NWStorage:
         self._lockedBy = None
         return True
 
-# END Class NWStorage
-
 
 class _LegacyStorage:
     """Core: Legacy Storage Converter Utils
@@ -590,5 +584,3 @@ class _LegacyStorage:
             logException()
 
         return
-
-# END Class _LegacyStorage