novelWriter 2.6.2__py3-none-any.whl → 2.7b1__py3-none-any.whl

novelwriter/core/novelmodel.py

@@ -0,0 +1,223 @@
+"""
+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_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*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
@@ -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:

novelwriter/core/projectdata.py

@@ -34,7 +34,7 @@ from novelwriter.common import (
 )
 from novelwriter.core.status import NWStatus
 
-if TYPE_CHECKING:  # pragma: no cover
+if TYPE_CHECKING:
     from novelwriter.core.project import NWProject
 
 logger = logging.getLogger(__name__)
@@ -69,10 +69,10 @@ class NWProjectData:
         self._initCounts = [0, 0]
         self._currCounts = [0, 0]
         self._lastHandle: dict[str, str | None] = {
-            "editor":    None,
-            "viewer":    None,
-            "novelTree": None,
-            "outline":   None,
+            "editor":  None,
+            "viewer":  None,
+            "novel":   None,
+            "outline": None,
         }
         self._autoReplace: dict[str, str] = {}
         self._titleFormat: dict[str, str] = {

novelwriter/core/projectxml.py

@@ -39,7 +39,7 @@ from novelwriter.common import (
     hexToInt, simplified, xmlIndent, yesNo
 )
 
-if TYPE_CHECKING:  # pragma: no cover
+if TYPE_CHECKING:
     from novelwriter.core.projectdata import NWProjectData
     from novelwriter.core.status import NWStatus
 

novelwriter/core/sessions.py

@@ -26,7 +26,6 @@ from __future__ import annotations
 import json
 import logging
 
-from collections.abc import Iterable
 from pathlib import Path
 from time import time
 from typing import TYPE_CHECKING
@@ -35,7 +34,9 @@ from novelwriter.common import formatTimeStamp
 from novelwriter.constants import nwFiles
 from novelwriter.error import logException
 
-if TYPE_CHECKING:  # pragma: no cover
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
     from novelwriter.core.project import NWProject
 
 logger = logging.getLogger(__name__)

novelwriter/core/spellcheck.py

@@ -27,16 +27,17 @@ from __future__ import annotations
 import json
 import logging
 
-from collections.abc import Iterator
 from pathlib import Path
 from typing import TYPE_CHECKING
 
-from PyQt5.QtCore import QLocale
+from PyQt6.QtCore import QLocale
 
 from novelwriter.constants import nwFiles
 from novelwriter.error import logException
 
-if TYPE_CHECKING:  # pragma: no cover
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
     from novelwriter.core.project import NWProject
 
 logger = logging.getLogger(__name__)

novelwriter/core/status.py

@@ -28,19 +28,18 @@ import dataclasses
 import logging
 import random
 
-from collections.abc import Iterable
-from typing import TYPE_CHECKING, Literal
+from typing import TYPE_CHECKING, Literal, TypeGuard
 
-from PyQt5.QtCore import QPointF, Qt
-from PyQt5.QtGui import QColor, QIcon, QPainter, QPainterPath, QPixmap, QPolygonF
+from PyQt6.QtCore import QPointF, Qt
+from PyQt6.QtGui import QColor, QIcon, QPainter, QPainterPath, QPixmap, QPolygonF
 
 from novelwriter import SHARED
 from novelwriter.common import simplified
 from novelwriter.enum import nwStatusShape
 from novelwriter.types import QtPaintAntiAlias, QtTransparent
 
-if TYPE_CHECKING:  # pragma: no cover
-    from typing import TypeGuard  # Requires Python 3.10
+if TYPE_CHECKING:
+    from collections.abc import Iterable
 
 logger = logging.getLogger(__name__)
 
@@ -57,18 +56,16 @@ class StatusEntry:
     @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
+        status = dataclasses.replace(source)
+        status.color = QColor(source.color)
+        status.icon = QIcon(source.icon)
+        return status
 
 
 NO_ENTRY = StatusEntry("", QColor(0, 0, 0), nwStatusShape.SQUARE, QIcon(), 0)
 
-if TYPE_CHECKING:  # pragma: no cover
-    # Requires Python 3.10
-    T_UpdateEntry = list[tuple[str | None, StatusEntry]]
-    T_StatusKind = Literal["s", "i"]
+T_UpdateEntry = list[tuple[str | None, StatusEntry]]
+T_StatusKind = Literal["s", "i"]
 
 
 class NWStatus:
@@ -76,7 +73,7 @@ class NWStatus:
     STATUS = "s"
     IMPORT = "i"
 
-    __slots__ = ("_store", "_default", "_prefix", "_height")
+    __slots__ = ("_default", "_height", "_prefix", "_store")
 
     def __init__(self, prefix: T_StatusKind) -> None:
         self._store: dict[str, StatusEntry] = {}

novelwriter/core/storage.py

@@ -40,7 +40,7 @@ from novelwriter.core.projectxml import ProjectXMLReader, ProjectXMLWriter
 from novelwriter.core.spellcheck import UserDictionary
 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/tree.py

@@ -27,20 +27,21 @@ from __future__ import annotations
 import logging
 import random
 
-from collections.abc import Iterable, Iterator
 from pathlib import Path
 from typing import TYPE_CHECKING, Literal, overload
 
-from PyQt5.QtCore import QModelIndex
+from PyQt6.QtCore import QModelIndex
 
 from novelwriter import SHARED
-from novelwriter.constants import nwFiles, nwLabels, trConst
+from novelwriter.constants import nwFiles, nwLabels, nwStyles, trConst
 from novelwriter.core.item import NWItem
 from novelwriter.core.itemmodel import ProjectModel, ProjectNode
 from novelwriter.enum import nwChange, nwItemClass, nwItemLayout, nwItemType
 from novelwriter.error import logException
 
-if TYPE_CHECKING:  # pragma: no cover
+if TYPE_CHECKING:
+    from collections.abc import Iterable, Iterator
+
     from novelwriter.core.project import NWProject
 
 logger = logging.getLogger(__name__)
@@ -60,7 +61,7 @@ class NWTree:
     also used for file names.
     """
 
-    __slots__ = ("_project", "_model", "_items", "_nodes", "_trash")
+    __slots__ = ("_items", "_model", "_nodes", "_project", "_ready", "_trash")
 
     def __init__(self, project: NWProject) -> None:
         self._project = project
@@ -68,6 +69,7 @@ class NWTree:
         self._items: dict[str, NWItem] = {}
         self._nodes: dict[str, ProjectNode] = {}
         self._trash = None
+        self._ready = False
         logger.debug("Ready: NWTree")
         return
 
@@ -106,6 +108,11 @@ class NWTree:
     #  Properties
     ##
 
+    @property
+    def project(self) -> NWProject:
+        """Return the parent project."""
+        return self._project
+
     @property
     def trash(self) -> ProjectNode | None:
         """Return trash node, if it exists."""
@@ -249,11 +256,37 @@ class NWTree:
             logger.error("Not all items could be added to project tree")
 
         self._trash = self._getTrashNode()
+        self._ready = True
         self._model.endInsertRows()
         self._model.layoutChanged.emit()
 
         return
 
+    def pickParent(self, sNode: ProjectNode, hLevel: int, isNote: bool) -> tuple[str | None, int]:
+        """Pick an appropriate parent handle for adding a new item."""
+        if sNode.item.isFolderType() or sNode.item.isRootType():
+            # Always add as a direct child of folders
+            return sNode.item.itemHandle, sNode.childCount()
+
+        pNode = sNode.parent()
+        pLevel = nwStyles.H_LEVEL.get(pNode.item.mainHeading, 0) if pNode else 0
+
+        # Notes are treated as H0, and scenes and sections both as H3
+        sLevel = min(0 if isNote else nwStyles.H_LEVEL.get(sNode.item.mainHeading, 0), 3)
+
+        if pNode and pNode.item.isFileType() and pLevel >= hLevel and sLevel > hLevel:
+            # If the selected item is a smaller heading and the parent heading
+            # is equal or larger, we make it a sibling of the parent (See #2260)
+            return pNode.item.itemParent, pNode.row() + 1
+
+        if sNode.childCount() > 0 and (0 < sLevel < hLevel or isNote):
+            # If the selected item already has child nodes and has a larger
+            # heading or is a note, we make the new item a child
+            return sNode.item.itemHandle, sNode.childCount()
+
+        # The default behaviour is to make the new item a sibling
+        return sNode.item.itemParent, sNode.row() + 1
+
     def refreshItems(self, items: list[str]) -> None:
         """Refresh these items on the GUI. If they are an ordered range,
         also set the isRange flag to True.
@@ -278,6 +311,12 @@ class NWTree:
         self._model.layoutChanged.emit()
         return
 
+    def novelStructureChanged(self, tHandle: str) -> None:
+        """Emit a novel structure change signal."""
+        if self._ready:
+            SHARED.novelStructureChanged.emit(tHandle)
+        return
+
     def checkConsistency(self, prefix: str) -> tuple[int, int]:
         """Check the project tree consistency. Also check the content
         folder and add back files that were discovered but were not
@@ -388,7 +427,7 @@ class NWTree:
 
     def checkType(self, tHandle: str, itemType: nwItemType) -> bool:
         """Check if item exists and is of the specified item type."""
-        if tItem := self.__getitem__(tHandle):
+        if tItem := self[tHandle]:
             return tItem.itemType == itemType
         return False
 
@@ -406,8 +445,7 @@ class NWTree:
                     node = parent
                 else:
                     return path
-            else:
-                logger.error("Max project tree depth reached")
+            logger.error("Max project tree depth reached")
         return path
 
     def subTree(self, tHandle: str) -> list[str]:

novelwriter/dialogs/about.py

@@ -25,17 +25,21 @@ from __future__ import annotations
 
 import logging
 
-from PyQt5.QtGui import QCloseEvent, QColor
-from PyQt5.QtWidgets import (
+from typing import TYPE_CHECKING
+
+from PyQt6.QtWidgets import (
     QDialogButtonBox, QHBoxLayout, QLabel, QTextBrowser, QVBoxLayout, QWidget
 )
 
 from novelwriter import CONFIG, SHARED
-from novelwriter.common import cssCol, readTextFile
-from novelwriter.extensions.configlayout import NColourLabel
+from novelwriter.common import readTextFile
+from novelwriter.extensions.configlayout import NColorLabel
 from novelwriter.extensions.modified import NDialog
 from novelwriter.extensions.versioninfo import VersionInfoWidget
-from novelwriter.types import QtAlignRightTop, QtDialogClose
+from novelwriter.types import QtAlignRightTop, QtDialogClose, QtHexArgb
+
+if TYPE_CHECKING:
+    from PyQt6.QtGui import QCloseEvent
 
 logger = logging.getLogger(__name__)
 
@@ -49,19 +53,13 @@ class GuiAbout(NDialog):
         self.setObjectName("GuiAbout")
 
         self.setWindowTitle(self.tr("About novelWriter"))
-        self.resize(CONFIG.pxInt(700), CONFIG.pxInt(500))
-
-        hA = CONFIG.pxInt(8)
-        hB = CONFIG.pxInt(16)
-        nwH = CONFIG.pxInt(36)
-        nwPx = CONFIG.pxInt(128)
+        self.resize(700, 500)
 
         # Logo and Banner
-        self.nwImage = SHARED.theme.loadDecoration("nw-text", h=nwH)
-        self.bgColor = QColor(255, 255, 255) if SHARED.theme.isLightTheme else QColor(54, 54, 54)
+        self.nwImage = SHARED.theme.getDecoration("nw-text", h=36)
 
         self.nwLogo = QLabel(self)
-        self.nwLogo.setPixmap(SHARED.theme.getPixmap("novelwriter", (nwPx, nwPx)))
+        self.nwLogo.setPixmap(SHARED.theme.getPixmap("novelwriter", (128, 128)))
 
         self.nwLabel = QLabel(self)
         self.nwLabel.setPixmap(self.nwImage)
@@ -74,14 +72,13 @@ class GuiAbout(NDialog):
         self.nwLicence.setOpenExternalLinks(True)
 
         # Credits
-        self.lblCredits = NColourLabel(
+        self.lblCredits = NColorLabel(
             self.tr("Credits"), self, scale=1.6, bold=True
         )
 
         self.txtCredits = QTextBrowser(self)
         self.txtCredits.setOpenExternalLinks(True)
-        self.txtCredits.document().setDocumentMargin(0)
-        self.txtCredits.setViewportMargins(0, hA, hA, 0)
+        self.txtCredits.setViewportMargins(0, 8, 8, 0)
 
         # Buttons
         self.btnBox = QDialogButtonBox(QtDialogClose, self)
@@ -89,15 +86,15 @@ class GuiAbout(NDialog):
 
         # Assemble
         self.innerBox = QVBoxLayout()
-        self.innerBox.addSpacing(hB)
+        self.innerBox.addSpacing(16)
         self.innerBox.addWidget(self.nwLabel)
         self.innerBox.addWidget(self.nwInfo)
-        self.innerBox.addSpacing(hA)
+        self.innerBox.addSpacing(8)
         self.innerBox.addWidget(self.nwLicence)
-        self.innerBox.addSpacing(hA)
+        self.innerBox.addSpacing(8)
         self.innerBox.addWidget(self.lblCredits)
         self.innerBox.addWidget(self.txtCredits)
-        self.innerBox.addSpacing(hB)
+        self.innerBox.addSpacing(16)
         self.innerBox.addWidget(self.btnBox)
 
         self.outerBox = QHBoxLayout()
@@ -142,7 +139,7 @@ class GuiAbout(NDialog):
 
     def _setStyleSheet(self) -> None:
         """Set stylesheet text document."""
-        baseCol = cssCol(self.palette().window().color())
+        baseCol = self.palette().window().color().name(QtHexArgb)
         self.txtCredits.setStyleSheet(
             f"QTextBrowser {{border: none; background: {baseCol};}} "
         )