Veronica Berglyd Olsen
353 lines
11 KiB
Python
353 lines
11 KiB
Python
"""
|
||
novelWriter – Project Item Status Class
|
||
=======================================
|
||
|
||
File History:
|
||
Created: 2019-05-19 [0.1.3] NWStatus
|
||
Rewritten: 2022-04-05 [2.0b1] NWStatus
|
||
|
||
This file is a part of novelWriter
|
||
Copyright 2018–2024, Veronica Berglyd Olsen
|
||
|
||
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
|
||
import random
|
||
|
||
from collections.abc import Iterable
|
||
from dataclasses import dataclass
|
||
from math import cos, pi, sin
|
||
from typing import TYPE_CHECKING, Literal
|
||
|
||
from PyQt5.QtCore import QPointF, Qt
|
||
from PyQt5.QtGui import QIcon, QPainter, QPainterPath, QPixmap, QColor, QPolygonF
|
||
|
||
from novelwriter import CONFIG
|
||
from novelwriter.common import simplified
|
||
from novelwriter.enum import nwStatusShape
|
||
from novelwriter.types import QtPaintAnitAlias, QtTransparent
|
||
|
||
if TYPE_CHECKING: # pragma: no cover
|
||
from typing import TypeGuard # Requires Python 3.10
|
||
|
||
logger = logging.getLogger(__name__)
|
||
|
||
|
||
@dataclass
|
||
class StatusEntry:
|
||
|
||
name: str
|
||
colour: QColor
|
||
shape: nwStatusShape
|
||
icon: QIcon
|
||
count: int = 0
|
||
|
||
# END Class StatusEntry
|
||
|
||
|
||
class NWStatus:
|
||
|
||
STATUS = 1
|
||
IMPORT = 2
|
||
|
||
def __init__(self, kind: Literal[1, 2]) -> None:
|
||
|
||
self._type = kind
|
||
self._store: dict[str, StatusEntry] = {}
|
||
self._default = None
|
||
|
||
self._iPX = CONFIG.pxInt(24)
|
||
self._defaultIcon = self.createIcon(
|
||
self._iPX, QColor(100, 100, 100), nwStatusShape.SQUARE
|
||
)
|
||
|
||
if self._type == self.STATUS:
|
||
self._prefix = "s"
|
||
elif self._type == self.IMPORT:
|
||
self._prefix = "i"
|
||
else:
|
||
raise Exception("This is a bug!")
|
||
|
||
return
|
||
|
||
def __len__(self) -> int:
|
||
return len(self._store)
|
||
|
||
def __getitem__(self, key: str) -> StatusEntry:
|
||
return self._store[key]
|
||
|
||
##
|
||
# Methods
|
||
##
|
||
|
||
def write(self, key: str | None, name: str, col: tuple[int, int, int],
|
||
shape: nwStatusShape | str, count: int | None = None) -> 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)
|
||
|
||
name = simplified(name)
|
||
colour = QColor(*col)
|
||
if not isinstance(shape, nwStatusShape):
|
||
if shape in nwStatusShape.__members__:
|
||
shape = nwStatusShape[shape]
|
||
else:
|
||
shape = nwStatusShape.SQUARE
|
||
|
||
icon = self.createIcon(self._iPX, colour, shape)
|
||
|
||
if key and key in self._store:
|
||
entry = self._store[key]
|
||
entry.name = name
|
||
entry.colour = colour
|
||
entry.shape = shape
|
||
entry.icon = icon
|
||
entry.count = count or 0
|
||
else:
|
||
self._store[key] = StatusEntry(name, colour, shape, icon, count or 0)
|
||
|
||
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]
|
||
|
||
keys = list(self._store.keys())
|
||
if key == self._default:
|
||
if len(keys) > 0:
|
||
self._default = keys[0]
|
||
else:
|
||
self._default = None
|
||
|
||
return True
|
||
|
||
def check(self, value: str) -> str:
|
||
"""Check the key against the stored status names."""
|
||
if self._isKey(value) and value in self._store:
|
||
return value
|
||
elif self._default is not None:
|
||
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) -> QColor:
|
||
"""Return the colours associated with a given key."""
|
||
if key and key in self._store:
|
||
return self._store[key].colour
|
||
elif self._default is not None:
|
||
return self._store[self._default].colour
|
||
return QColor(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
|
||
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
|
||
return
|
||
|
||
def pack(self) -> Iterable[tuple[str, dict]]:
|
||
"""Pack the status entries into a dictionary."""
|
||
for key, entry in self._store.items():
|
||
yield (entry.name, {
|
||
"key": key,
|
||
"count": str(entry.count),
|
||
"red": str(entry.colour.red()),
|
||
"green": str(entry.colour.green()),
|
||
"blue": str(entry.colour.blue()),
|
||
"shape": entry.shape.name,
|
||
})
|
||
return
|
||
|
||
def iterItems(self) -> Iterable[tuple[str, StatusEntry]]:
|
||
"""Yield entries from the status icons."""
|
||
yield from self._store.items()
|
||
|
||
@staticmethod
|
||
def createIcon(height: int, colour: 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), colour)
|
||
painter.end()
|
||
|
||
return QIcon(pixmap.scaled(
|
||
height, height,
|
||
Qt.AspectRatioMode.IgnoreAspectRatio,
|
||
Qt.TransformationMode.SmoothTransformation
|
||
))
|
||
|
||
##
|
||
# Internal Functions
|
||
##
|
||
|
||
def _newKey(self) -> str:
|
||
"""Generate a new key for a status flag. This method is
|
||
recursive, but should only fail if there is an issue with the
|
||
random number generator or the user has added a lot of status
|
||
flags. The Python recursion limit is given the job to handle
|
||
the extreme case and will cause an app crash.
|
||
"""
|
||
key = f"{self._prefix}{random.getrandbits(24):06x}"
|
||
if key in self._store:
|
||
key = self._newKey()
|
||
return key
|
||
|
||
def _isKey(self, value: str | None) -> TypeGuard[str]:
|
||
"""Check if a value is a key or not."""
|
||
if not isinstance(value, str):
|
||
return False
|
||
if len(value) != 7:
|
||
return False
|
||
if value[0] != self._prefix:
|
||
return False
|
||
for c in value[1:]:
|
||
if c not in "0123456789abcdef":
|
||
return False
|
||
return True
|
||
|
||
# END Class NWStatus
|
||
|
||
|
||
class _ShapeCache:
|
||
|
||
def __init__(self) -> None:
|
||
self._cache: dict[nwStatusShape, QPainterPath] = {}
|
||
return
|
||
|
||
def getShape(self, shape: nwStatusShape) -> QPainterPath:
|
||
"""Return a painter shape for an icon."""
|
||
if shape in self._cache:
|
||
return self._cache[shape]
|
||
|
||
def circ(r: float, a: float, x: float, y: float) -> QPointF:
|
||
# print(round(x+r*sin(pi*a/180), 2), round(y-r*cos(pi*a/180), 2))
|
||
return QPointF(round(x+r*sin(pi*a/180), 2), round(y-r*cos(pi*a/180), 2))
|
||
|
||
path = QPainterPath()
|
||
if shape == nwStatusShape.SQUARE:
|
||
path.addRoundedRect(2.0, 2.0, 44.0, 44.0, 4.0, 4.0)
|
||
elif shape == nwStatusShape.CIRCLE:
|
||
path.addEllipse(2.0, 2.0, 44.0, 44.0)
|
||
elif shape == nwStatusShape.TRIANGLE:
|
||
path.addPolygon(QPolygonF([
|
||
circ(23.0, 0.0, 24.0, 26.0),
|
||
circ(23.0, 120.0, 24.0, 26.0),
|
||
circ(23.0, 240.0, 24.0, 26.0),
|
||
]))
|
||
elif shape == nwStatusShape.DIAMOND:
|
||
path.addPolygon(QPolygonF([
|
||
circ(22.0, 0.0, 24.0, 24.0),
|
||
circ(20.0, 90.0, 24.0, 24.0),
|
||
circ(22.0, 180.0, 24.0, 24.0),
|
||
circ(20.0, 270.0, 24.0, 24.0),
|
||
]))
|
||
elif shape == nwStatusShape.PENTAGON:
|
||
path.addPolygon(QPolygonF([
|
||
circ(23.0, 0.0, 24.0, 24.5),
|
||
circ(23.0, 72.0, 24.0, 24.5),
|
||
circ(23.0, 144.0, 24.0, 24.5),
|
||
circ(23.0, 216.0, 24.0, 24.5),
|
||
circ(23.0, 288.0, 24.0, 24.5),
|
||
]))
|
||
elif shape == nwStatusShape.STAR:
|
||
path.addPolygon(QPolygonF([
|
||
circ(24.0, 0.0, 24.0, 24.5),
|
||
circ(24.0, 144.0, 24.0, 24.5),
|
||
circ(24.0, 288.0, 24.0, 24.5),
|
||
circ(24.0, 72.0, 24.0, 24.5),
|
||
circ(24.0, 216.0, 24.0, 24.5),
|
||
]))
|
||
path.setFillRule(Qt.FillRule.WindingFill)
|
||
elif shape == nwStatusShape.PACMAN:
|
||
path.moveTo(24.0, 24.0)
|
||
path.arcTo(2.0, 2.0, 44.0, 44.0, 40.0, 280.0)
|
||
|
||
self._cache[shape] = path
|
||
|
||
return path
|
||
|
||
# END Class _ShapeCache
|
||
|
||
|
||
# Create Singleton
|
||
_SHAPES = _ShapeCache()
|