novelWriter 2.7.4__py3-none-any.whl → 2.8b1__py3-none-any.whl

novelwriter/gui/theme.py

@@ -21,28 +21,34 @@ 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/>.
-"""
+"""  # noqa
 from __future__ import annotations
 
 import logging
 
+from configparser import ConfigParser
+from dataclasses import dataclass
 from math import ceil
 from typing import TYPE_CHECKING, Final
 
-from PyQt6.QtCore import QSize, Qt
+from PyQt6.QtCore import QT_TRANSLATE_NOOP, QCoreApplication, QSize, Qt
 from PyQt6.QtGui import (
-    QColor, QFont, QFontDatabase, QFontMetrics, QIcon, QPainter, QPainterPath,
-    QPalette, QPixmap
+    QColor, QFont, QFontDatabase, QFontMetrics, QGuiApplication, QIcon,
+    QPainter, QPainterPath, QPalette, QPixmap
 )
-from PyQt6.QtWidgets import QApplication
+from PyQt6.QtWidgets import QApplication, QWidget
 
 from novelwriter import CONFIG
-from novelwriter.common import NWConfigParser, minmax
-from novelwriter.config import DEF_GUI, DEF_ICONS, DEF_SYNTAX
+from novelwriter.common import checkInt, minmax
+from novelwriter.config import DEF_GUI_DARK, DEF_GUI_LIGHT, DEF_ICONS, DEF_TREECOL
 from novelwriter.constants import nwLabels
-from novelwriter.enum import nwItemClass, nwItemLayout, nwItemType
+from novelwriter.enum import nwItemClass, nwItemLayout, nwItemType, nwStandardButton, nwTheme
 from novelwriter.error import logException
-from novelwriter.types import QtBlack, QtHexArgb, QtPaintAntiAlias, QtTransparent
+from novelwriter.extensions.modified import NPushButton
+from novelwriter.types import (
+    QtBlack, QtColActive, QtColDisabled, QtColInactive, QtHexArgb,
+    QtPaintAntiAlias, QtTransparent
+)
 
 if TYPE_CHECKING:
     from pathlib import Path
@@ -53,26 +59,65 @@ STYLES_FLAT_TABS = "flatTabWidget"
 STYLES_MIN_TOOLBUTTON = "minimalToolButton"
 STYLES_BIG_TOOLBUTTON = "bigToolButton"
 
+STANDARD_BUTTONS = {
+    nwStandardButton.OK:      (QT_TRANSLATE_NOOP("Button", "OK"), "btn_ok", "action"),
+    nwStandardButton.CANCEL:  (QT_TRANSLATE_NOOP("Button", "Cancel"), "btn_cancel", "reject"),
+    nwStandardButton.YES:     (QT_TRANSLATE_NOOP("Button", "&Yes"), "btn_yes", "accept"),
+    nwStandardButton.NO:      (QT_TRANSLATE_NOOP("Button", "&No"), "btn_no", "reject"),
+    nwStandardButton.OPEN:    (QT_TRANSLATE_NOOP("Button", "Open"), "btn_open", "action"),
+    nwStandardButton.CLOSE:   (QT_TRANSLATE_NOOP("Button", "Close"), "btn_close", "destroy"),
+    nwStandardButton.SAVE:    (QT_TRANSLATE_NOOP("Button", "Save"), "btn_save", "action"),
+    nwStandardButton.BROWSE:  (QT_TRANSLATE_NOOP("Button", "Browse"), "btn_browse", "systemio"),
+    nwStandardButton.LIST:    (QT_TRANSLATE_NOOP("Button", "List"), "btn_list", "action"),
+    nwStandardButton.NEW:     (QT_TRANSLATE_NOOP("Button", "New"), "btn_new", "apply"),
+    nwStandardButton.CREATE:  (QT_TRANSLATE_NOOP("Button", "Create"), "btn_create", "create"),
+    nwStandardButton.RESET:   (QT_TRANSLATE_NOOP("Button", "Reset"), "btn_reset", "reset"),
+    nwStandardButton.INSERT:  (QT_TRANSLATE_NOOP("Button", "Insert"), "btn_insert", "action"),
+    nwStandardButton.APPLY:   (QT_TRANSLATE_NOOP("Button", "Apply"), "btn_apply", "apply"),
+    nwStandardButton.BUILD:   (QT_TRANSLATE_NOOP("Button", "Build"), "btn_build", "action"),
+    nwStandardButton.PRINT:   (QT_TRANSLATE_NOOP("Button", "Print"), "btn_print", "action"),
+    nwStandardButton.PREVIEW: (QT_TRANSLATE_NOOP("Button", "Preview"), "btn_preview", "action"),
+}
+
+
+@dataclass
+class ThemeEntry:
+    """Theme data."""
+
+    name: str
+    dark: bool
+    path: Path
+
 
 class ThemeMeta:
+    """Theme meta data."""
+
+    name:   str = ""
+    mode:   str = ""
+    author: str = ""
+    credit: str = ""
+    url:    str = ""
 
-    name:        str = ""
-    description: str = ""
-    author:      str = ""
-    credit:      str = ""
-    url:         str = ""
-    license:     str = ""
-    licenseUrl:  str = ""
+
+class IconsMeta:
+    """Icon theme meta data."""
+
+    name:    str = ""
+    author:  str = ""
+    license: str = ""
 
 
 class SyntaxColors:
+    """Colours for the syntax highlighter."""
 
     back:   QColor = QColor(255, 255, 255)
     text:   QColor = QColor(0, 0, 0)
+    line:   QColor = QColor(0, 0, 0)
     link:   QColor = QColor(0, 0, 0)
     head:   QColor = QColor(0, 0, 0)
     headH:  QColor = QColor(0, 0, 0)
     emph:   QColor = QColor(0, 0, 0)
+    space:  QColor = QColor(0, 0, 0)
     dialN:  QColor = QColor(0, 0, 0)
     dialA:  QColor = QColor(0, 0, 0)
     hidden: QColor = QColor(0, 0, 0)
@@ -90,57 +135,60 @@ class SyntaxColors:
 
 
 class GuiTheme:
-    """Gui Theme Class
+    """Gui Theme Class.
 
     Handles the look and feel of novelWriter.
     """
 
     __slots__ = (
-        "_availSyntax", "_availThemes", "_guiPalette", "_styleSheets", "_syntaxList", "_themeList",
-        "baseButtonHeight", "baseIconHeight", "baseIconSize", "buttonIconSize", "errorText",
-        "fadedText", "fontPixelSize", "fontPointSize", "getDecoration", "getHeaderDecoration",
-        "getHeaderDecorationNarrow", "getIcon", "getIconColor", "getItemIcon", "getPixmap",
-        "getToggleIcon", "guiFont", "guiFontB", "guiFontBU", "guiFontFixed", "guiFontSmall",
-        "helpText", "iconCache", "isDarkTheme", "syntaxMeta", "syntaxTheme", "textNHeight",
-        "textNWidth", "themeMeta",
+        "_allThemes", "_currentTheme", "_darkThemes", "_guiPalette", "_lightThemes", "_meta",
+        "_qColors", "_styleSheets", "_svgColors", "_syntaxList", "accentCol", "baseButtonHeight",
+        "baseIconHeight", "baseIconSize", "errorText", "fadedText", "fontPixelSize",
+        "fontPointSize", "getDecoration", "getHeaderDecoration", "getHeaderDecorationNarrow",
+        "getIcon", "getItemIcon", "getPixmap", "getStandardButton", "getToggleIcon", "guiFont",
+        "guiFontB", "guiFontBU", "guiFontFixed", "guiFontSmall", "helpText", "iconCache",
+        "isDarkTheme", "pushButtonIconSize", "sidebarIconSize", "syntaxTheme", "textNHeight",
+        "textNWidth", "toolButtonIconSize",
     )
 
     def __init__(self) -> None:
 
-        self.iconCache = GuiIcons(self)
-
-        # GUI Theme
-        self.themeMeta   = ThemeMeta()
+        # Theme Objects
+        self.iconCache   = GuiIcons(self)
+        self.syntaxTheme = SyntaxColors()
         self.isDarkTheme = False
 
-        # Special Text Colours
+        # Special Colours
         self.helpText  = QColor(0, 0, 0)
         self.fadedText = QColor(0, 0, 0)
         self.errorText = QColor(255, 0, 0)
+        self.accentCol = QColor(255, 0, 255)  # Needed until we move to Qt 6.6
 
-        # Syntax Theme
-        self.syntaxMeta = ThemeMeta()
-        self.syntaxTheme = SyntaxColors()
-
-        # Load Themes
+        # Theme Data
+        self._meta = ThemeMeta()
+        self._currentTheme = ""
         self._guiPalette = QPalette()
-        self._themeList: list[tuple[str, str]] = []
-        self._syntaxList: list[tuple[str, str]] = []
-        self._availThemes: dict[str, Path] = {}
-        self._availSyntax: dict[str, Path] = {}
+        self._allThemes: dict[str, ThemeEntry] = {}
         self._styleSheets: dict[str, str] = {}
+        self._svgColors: dict[str, bytes] = {}
+        self._qColors: dict[str, QColor] = {}
 
         # Icon Functions
         self.getIcon = self.iconCache.getIcon
         self.getPixmap = self.iconCache.getPixmap
         self.getItemIcon = self.iconCache.getItemIcon
-        self.getIconColor = self.iconCache.getIconColor
         self.getToggleIcon = self.iconCache.getToggleIcon
         self.getDecoration = self.iconCache.getDecoration
+        self.getStandardButton = self.iconCache.getStandardButton
         self.getHeaderDecoration = self.iconCache.getHeaderDecoration
         self.getHeaderDecorationNarrow = self.iconCache.getHeaderDecorationNarrow
 
         # Fonts
+        sSmaller = 10.0/11.0
+        sLarger = 12.0/11.0
+        sLarge = 15.0/11.0
+        sXLarge = 19.0/11.0
+
         self.guiFont = QApplication.font()
         self.guiFontB = QApplication.font()
         self.guiFontB.setBold(True)
@@ -148,53 +196,58 @@ class GuiTheme:
         self.guiFontBU.setBold(True)
         self.guiFontBU.setUnderline(True)
         self.guiFontSmall = QApplication.font()
-        self.guiFontSmall.setPointSizeF(0.9*self.guiFont.pointSizeF())
+        self.guiFontSmall.setPointSizeF(sSmaller*self.guiFont.pointSizeF())
 
         qMetric = QFontMetrics(self.guiFont)
         fHeight = qMetric.height()
         fAscent = qMetric.ascent()
+
         self.fontPointSize = self.guiFont.pointSizeF()
-        self.fontPixelSize = round(fHeight)
-        self.baseIconHeight = round(fAscent)
-        self.baseButtonHeight = round(1.35*fAscent)
+        self.fontPixelSize = fHeight
+        self.baseIconHeight = fAscent
+        self.baseButtonHeight = round(sLarge*fAscent)
+
+        self.baseIconSize = QSize(fAscent, fAscent)
+        self.sidebarIconSize = QSize(round(sXLarge*fAscent), round(sXLarge*fAscent))
+        self.toolButtonIconSize = QSize(round(sSmaller*fAscent), round(sSmaller*fAscent))
+        self.pushButtonIconSize = QSize(round(sLarger*fAscent), round(sLarger*fAscent))
+
         self.textNHeight = qMetric.boundingRect("N").height()
         self.textNWidth = qMetric.boundingRect("N").width()
 
-        self.baseIconSize = QSize(self.baseIconHeight, self.baseIconHeight)
-        self.buttonIconSize = QSize(int(0.9*self.baseIconHeight), int(0.9*self.baseIconHeight))
-
         # Monospace Font
         self.guiFontFixed = QFont()
-        self.guiFontFixed.setPointSizeF(0.95*self.fontPointSize)
+        self.guiFontFixed.setPointSizeF(sSmaller*self.fontPointSize)
         self.guiFontFixed.setFamily(
             QFontDatabase.systemFont(QFontDatabase.SystemFont.FixedFont).family()
         )
 
         logger.debug("GUI Font Family: %s", self.guiFont.family())
-        logger.debug("GUI Font Point Size: %.2f", self.fontPointSize)
-        logger.debug("GUI Font Pixel Size: %d", self.fontPixelSize)
-        logger.debug("GUI Base Icon Height: %d", self.baseIconHeight)
-        logger.debug("GUI Base Button Height: %d", self.baseButtonHeight)
-        logger.debug("Text 'N' Height: %d", self.textNHeight)
-        logger.debug("Text 'N' Width: %d", self.textNWidth)
-
-        # Process Themes
-        _listConf(self._availSyntax, CONFIG.assetPath("syntax"), ".conf")
-        _listConf(self._availThemes, CONFIG.assetPath("themes"), ".conf")
-        _listConf(self._availSyntax, CONFIG.dataPath("syntax"), ".conf")
-        _listConf(self._availThemes, CONFIG.dataPath("themes"), ".conf")
+        logger.debug("GUI Font Point Size: %.2f pt", self.fontPointSize)
+        logger.debug("GUI Font Pixel Size: %d px", self.fontPixelSize)
+        logger.debug("GUI Base Icon Height: %d px", self.baseIconHeight)
+        logger.debug("GUI Base Button Height: %d px", self.baseButtonHeight)
+        logger.debug("GUI Sidebar Icon Height: %s px", self.sidebarIconSize.height())
+        logger.debug("GUI ToolButton Icon Height: %s px", self.toolButtonIconSize.height())
+        logger.debug("GUI PushButton Icon Height: %s px", self.pushButtonIconSize.height())
+        logger.debug("Text 'N' Height: %d px", self.textNHeight)
+        logger.debug("Text 'N' Width: %d px", self.textNWidth)
 
-        self.loadTheme()
-        self.loadSyntax()
+    ##
+    #  Properties
+    ##
 
-        return
+    @property
+    def colourThemes(self) -> dict[str, ThemeEntry]:
+        """Return a dictionary of all themes."""
+        return self._allThemes
 
     ##
-    #  Methods
+    #  Getters
     ##
 
     def getTextWidth(self, text: str, font: QFont | None = None) -> int:
-        """Returns the width needed to contain a given piece of text in
+        """Return the width needed to contain a given piece of text in
         pixels.
         """
         if isinstance(font, QFont):
@@ -203,30 +256,80 @@ class GuiTheme:
             qMetrics = QFontMetrics(self.guiFont)
         return ceil(qMetrics.boundingRect(text).width())
 
+    def getBaseColor(self, name: str) -> QColor:
+        """Return a base color."""
+        return QColor(self._qColors.get(name) or QtBlack)
+
+    def getRawBaseColor(self, name: str) -> bytes:
+        """Return a base color."""
+        if color := self._svgColors.get(name):
+            return color
+        logger.warning("No colour named '%s'", name)
+        return self._svgColors.get("default", b"#000000")
+
     ##
     #  Theme Methods
     ##
 
-    def loadTheme(self) -> bool:
-        """Load the currently specified GUI theme."""
-        theme = CONFIG.guiTheme
-        if theme not in self._availThemes:
-            logger.error("Could not find GUI theme '%s'", theme)
-            theme = DEF_GUI
-            CONFIG.guiTheme = theme
+    def initThemes(self) -> None:
+        """Initialise themes."""
+        CONFIG.splashMessage("Scanning for colour themes ...")
+        themes: list[Path] = []
+        _listContent(themes, CONFIG.assetPath("themes"), ".conf")
+        _listContent(themes, CONFIG.dataPath("themes"), ".conf")
+        self._scanThemes(themes)
+
+        self.iconCache.initIcons()
+        self.loadTheme()
+
+    def isDesktopDarkMode(self) -> bool:
+        """Check if the desktop is in dark mode."""
+        if CONFIG.verQtValue >= 0x060500 and (hint := QGuiApplication.styleHints()):
+            return hint.colorScheme() == Qt.ColorScheme.Dark
+
+        palette = QPalette()
+        text = palette.windowText().color()
+        window = palette.window().color()
+        return text.lightnessF() > window.lightnessF()
+
+    def loadTheme(self, force: bool = False) -> bool:
+        """Load the currently specified GUI theme. The boolean return
+        can be used to determine if the GUI needs refreshing.
+        """
+        match CONFIG.themeMode:
+            case nwTheme.LIGHT:
+                darkMode = False
+            case nwTheme.DARK:
+                darkMode = True
+            case _:
+                darkMode = self.isDesktopDarkMode()
+
+        theme = CONFIG.darkTheme if darkMode else CONFIG.lightTheme
+        if theme not in self._allThemes:
+            logger.error("Could not find theme '%s'", theme)
+            if darkMode:
+                theme = DEF_GUI_DARK
+                CONFIG.darkTheme = DEF_GUI_DARK
+            else:
+                theme = DEF_GUI_LIGHT
+                CONFIG.lightTheme = DEF_GUI_LIGHT
+
+        if theme == self._currentTheme and not force:
+            logger.info("Theme '%s' is already loaded", theme)
+            return False
 
-        if not (file := self._availThemes.get(theme)):
+        entry = self._allThemes.get(theme)
+        if not entry:
             logger.error("Could not load GUI theme")
             return False
 
-        CONFIG.splashMessage("Loading GUI theme ...")
+        CONFIG.splashMessage(f"Loading colour theme: {entry.name}")
         logger.info("Loading GUI theme '%s'", theme)
-        parser = NWConfigParser()
+        parser = ConfigParser()
         try:
-            with open(file, mode="r", encoding="utf-8") as fo:
-                parser.read_file(fo)
+            parser.read(entry.path, encoding="utf-8")
         except Exception:
-            logger.error("Could not read file: %s", file)
+            logger.error("Could not read file: %s", entry.path)
             logException()
             return False
 
@@ -237,39 +340,64 @@ class GuiTheme:
         sec = "Main"
         meta = ThemeMeta()
         if parser.has_section(sec):
-            meta.name        = parser.rdStr(sec, "name", "")
-            meta.description = parser.rdStr(sec, "description", "N/A")
-            meta.author      = parser.rdStr(sec, "author", "N/A")
-            meta.credit      = parser.rdStr(sec, "credit", "N/A")
-            meta.url         = parser.rdStr(sec, "url", "")
-            meta.license     = parser.rdStr(sec, "license", "N/A")
-            meta.licenseUrl  = parser.rdStr(sec, "licenseurl", "")
-
-        self.themeMeta = meta
-
-        # Icons
-        sec = "Icons"
+            meta.name   = parser.get(sec, "name", fallback="")
+            meta.mode   = parser.get(sec, "mode", fallback="light")
+            meta.author = parser.get(sec, "author", fallback="")
+            meta.credit = parser.get(sec, "credit", fallback="")
+            meta.url    = parser.get(sec, "url", fallback="")
+
+        self._meta = meta
+
+        # Base
+        sec = "Base"
         if parser.has_section(sec):
-            self.iconCache.setIconColor("default", self._parseColor(parser, sec, "default"))
-            self.iconCache.setIconColor("faded",   self._parseColor(parser, sec, "faded"))
-            self.iconCache.setIconColor("red",     self._parseColor(parser, sec, "red"))
-            self.iconCache.setIconColor("orange",  self._parseColor(parser, sec, "orange"))
-            self.iconCache.setIconColor("yellow",  self._parseColor(parser, sec, "yellow"))
-            self.iconCache.setIconColor("green",   self._parseColor(parser, sec, "green"))
-            self.iconCache.setIconColor("aqua",    self._parseColor(parser, sec, "aqua"))
-            self.iconCache.setIconColor("blue",    self._parseColor(parser, sec, "blue"))
-            self.iconCache.setIconColor("purple",  self._parseColor(parser, sec, "purple"))
+            self._setBaseColor("base",    self._readColor(parser, sec, "base"))
+            self._setBaseColor("default", self._readColor(parser, sec, "default"))
+            self._setBaseColor("faded",   self._readColor(parser, sec, "faded"))
+            self._setBaseColor("red",     self._readColor(parser, sec, "red"))
+            self._setBaseColor("orange",  self._readColor(parser, sec, "orange"))
+            self._setBaseColor("yellow",  self._readColor(parser, sec, "yellow"))
+            self._setBaseColor("green",   self._readColor(parser, sec, "green"))
+            self._setBaseColor("cyan",    self._readColor(parser, sec, "cyan"))
+            self._setBaseColor("blue",    self._readColor(parser, sec, "blue"))
+            self._setBaseColor("purple",  self._readColor(parser, sec, "purple"))
 
         # Project
         sec = "Project"
         if parser.has_section(sec):
-            self.iconCache.setIconColor("root",    self._parseColor(parser, sec, "root"))
-            self.iconCache.setIconColor("folder",  self._parseColor(parser, sec, "folder"))
-            self.iconCache.setIconColor("file",    self._parseColor(parser, sec, "file"))
-            self.iconCache.setIconColor("title",   self._parseColor(parser, sec, "title"))
-            self.iconCache.setIconColor("chapter", self._parseColor(parser, sec, "chapter"))
-            self.iconCache.setIconColor("scene",   self._parseColor(parser, sec, "scene"))
-            self.iconCache.setIconColor("note",    self._parseColor(parser, sec, "note"))
+            self._setBaseColor("root",     self._readColor(parser, sec, "root"))
+            self._setBaseColor("folder",   self._readColor(parser, sec, "folder"))
+            self._setBaseColor("file",     self._readColor(parser, sec, "file"))
+            self._setBaseColor("title",    self._readColor(parser, sec, "title"))
+            self._setBaseColor("chapter",  self._readColor(parser, sec, "chapter"))
+            self._setBaseColor("scene",    self._readColor(parser, sec, "scene"))
+            self._setBaseColor("note",     self._readColor(parser, sec, "note"))
+            self._setBaseColor("active",   self._readColor(parser, sec, "active"))
+            self._setBaseColor("inactive", self._readColor(parser, sec, "inactive"))
+            self._setBaseColor("disabled", self._readColor(parser, sec, "disabled"))
+
+        # Icon
+        sec = "Icon"
+        if parser.has_section(sec):
+            self._setBaseColor("tool",      self._readColor(parser, sec, "tool"))
+            self._setBaseColor("sidebar",   self._readColor(parser, sec, "sidebar"))
+            self._setBaseColor("accept",    self._readColor(parser, sec, "accept"))
+            self._setBaseColor("reject",    self._readColor(parser, sec, "reject"))
+            self._setBaseColor("action",    self._readColor(parser, sec, "action"))
+            self._setBaseColor("altaction", self._readColor(parser, sec, "altaction"))
+            self._setBaseColor("apply",     self._readColor(parser, sec, "apply"))
+            self._setBaseColor("create",    self._readColor(parser, sec, "create"))
+            self._setBaseColor("destroy",   self._readColor(parser, sec, "destroy"))
+            self._setBaseColor("reset",     self._readColor(parser, sec, "reset"))
+            self._setBaseColor("add",       self._readColor(parser, sec, "add"))
+            self._setBaseColor("change",    self._readColor(parser, sec, "change"))
+            self._setBaseColor("remove",    self._readColor(parser, sec, "remove"))
+            self._setBaseColor("shortcode", self._readColor(parser, sec, "shortcode"))
+            self._setBaseColor("markdown",  self._readColor(parser, sec, "markdown"))
+            self._setBaseColor("systemio",  self._readColor(parser, sec, "systemio"))
+            self._setBaseColor("info",      self._readColor(parser, sec, "info"))
+            self._setBaseColor("warning",   self._readColor(parser, sec, "warning"))
+            self._setBaseColor("error",     self._readColor(parser, sec, "error"))
 
         # Palette
         sec = "Palette"
@@ -288,24 +416,47 @@ class GuiTheme:
             self._setPalette(parser, sec, "highlightedtext", QPalette.ColorRole.HighlightedText)
             self._setPalette(parser, sec, "link",            QPalette.ColorRole.Link)
             self._setPalette(parser, sec, "linkvisited",     QPalette.ColorRole.LinkVisited)
+            self.accentCol = self._readColor(parser, sec, "accent")  # Special handling 'til Qt 6.6
 
         # GUI
         sec = "GUI"
         if parser.has_section(sec):
-            self.helpText  = self._parseColor(parser, sec, "helptext")
-            self.fadedText = self._parseColor(parser, sec, "fadedtext")
-            self.errorText = self._parseColor(parser, sec, "errortext")
+            self.helpText  = self._readColor(parser, sec, "helptext")
+            self.fadedText = self._readColor(parser, sec, "fadedtext")
+            self.errorText = self._readColor(parser, sec, "errortext")
+
+        # Syntax
+        sec = "Syntax"
+        self.syntaxTheme = SyntaxColors()
+        if parser.has_section(sec):
+            self.syntaxTheme.back   = self._readColor(parser, sec, "background")
+            self.syntaxTheme.text   = self._readColor(parser, sec, "text")
+            self.syntaxTheme.line   = self._readColor(parser, sec, "line")
+            self.syntaxTheme.link   = self._readColor(parser, sec, "link")
+            self.syntaxTheme.head   = self._readColor(parser, sec, "headertext")
+            self.syntaxTheme.headH  = self._readColor(parser, sec, "headertag")
+            self.syntaxTheme.emph   = self._readColor(parser, sec, "emphasis")
+            self.syntaxTheme.space  = self._readColor(parser, sec, "whitespace")
+            self.syntaxTheme.dialN  = self._readColor(parser, sec, "dialog")
+            self.syntaxTheme.dialA  = self._readColor(parser, sec, "altdialog")
+            self.syntaxTheme.hidden = self._readColor(parser, sec, "hidden")
+            self.syntaxTheme.note   = self._readColor(parser, sec, "note")
+            self.syntaxTheme.code   = self._readColor(parser, sec, "shortcode")
+            self.syntaxTheme.key    = self._readColor(parser, sec, "keyword")
+            self.syntaxTheme.tag    = self._readColor(parser, sec, "tag")
+            self.syntaxTheme.val    = self._readColor(parser, sec, "value")
+            self.syntaxTheme.opt    = self._readColor(parser, sec, "optional")
+            self.syntaxTheme.spell  = self._readColor(parser, sec, "spellcheckline")
+            self.syntaxTheme.error  = self._readColor(parser, sec, "errorline")
+            self.syntaxTheme.repTag = self._readColor(parser, sec, "replacetag")
+            self.syntaxTheme.mod    = self._readColor(parser, sec, "modifier")
+            self.syntaxTheme.mark   = self._readColor(parser, sec, "texthighlight")
 
         # Update Dependant Colours
         # Based on: https://github.com/qt/qtbase/blob/dev/src/gui/kernel/qplatformtheme.cpp
         text = self._guiPalette.text().color()
         window = self._guiPalette.window().color()
         highlight = self._guiPalette.highlight().color()
-        isDark = text.lightnessF() > window.lightnessF()
-
-        QtColActive = QPalette.ColorGroup.Active
-        QtColInactive = QPalette.ColorGroup.Inactive
-        QtColDisabled = QPalette.ColorGroup.Disabled
 
         if window.lightnessF() < 0.15:
             # If window is too dark, we need a lighter ref colour for shades
@@ -321,8 +472,8 @@ class GuiTheme:
         darkOff   = dark.darker(150)
         shadowOff = ref.darker(150)
 
-        grey   = QColor(120, 120, 120) if isDark else QColor(140, 140, 140)
-        dimmed = QColor(130, 130, 130) if isDark else QColor(190, 190, 190)
+        grey   = QColor(120, 120, 120) if darkMode else QColor(140, 140, 140)
+        dimmed = QColor(130, 130, 130) if darkMode else QColor(190, 190, 190)
 
         placeholder = QColor(text)
         placeholder.setAlpha(128)
@@ -347,145 +498,93 @@ class GuiTheme:
         self._guiPalette.setBrush(QtColDisabled, QPalette.ColorRole.Highlight, grey)
 
         if CONFIG.verQtValue >= 0x060600:
-            self._guiPalette.setBrush(QtColActive, QPalette.ColorRole.Accent, highlight)
-            self._guiPalette.setBrush(QtColInactive, QPalette.ColorRole.Accent, highlight)
+            self._guiPalette.setBrush(QtColActive, QPalette.ColorRole.Accent, self.accentCol)
+            self._guiPalette.setBrush(QtColInactive, QPalette.ColorRole.Accent, self.accentCol)
             self._guiPalette.setBrush(QtColDisabled, QPalette.ColorRole.Accent, grey)
 
+        # Set project override colours
+        if (override := CONFIG.iconColTree) != DEF_TREECOL:
+            color = self._qColors.get(override, QtBlack)
+            self._setBaseColor("root", color)
+            self._setBaseColor("folder", color)
+            if not CONFIG.iconColDocs:
+                self._setBaseColor("file", color)
+                self._setBaseColor("title", color)
+                self._setBaseColor("chapter", color)
+                self._setBaseColor("scene", color)
+                self._setBaseColor("note", color)
+
+        self.isDarkTheme = darkMode
+        self._currentTheme = theme
+
         # Load icons after the theme is parsed
         self.iconCache.loadTheme(CONFIG.iconTheme)
 
         # Finalise
-        self.isDarkTheme = isDark
         QApplication.setPalette(self._guiPalette)
         self._buildStyleSheets(self._guiPalette)
 
-        CONFIG.splashMessage(f"Loaded GUI theme: {meta.name}")
-
         return True
 
-    def loadSyntax(self) -> bool:
-        """Load the currently specified syntax highlighter theme."""
-        theme = CONFIG.guiSyntax
-        if theme not in self._availSyntax:
-            logger.error("Could not find syntax theme '%s'", theme)
-            theme = DEF_SYNTAX
-            CONFIG.guiSyntax = theme
-
-        if not (file := self._availSyntax.get(theme)):
-            logger.error("Could not load syntax theme")
-            return False
-
-        CONFIG.splashMessage("Loading syntax theme ...")
-        logger.info("Loading syntax theme '%s'", theme)
-        parser = NWConfigParser()
-        try:
-            with open(file, mode="r", encoding="utf-8") as fo:
-                parser.read_file(fo)
-        except Exception:
-            logger.error("Could not read file: %s", file)
-            logException()
-            return False
-
-        # Main
-        sec = "Main"
-        meta = ThemeMeta()
-        if parser.has_section(sec):
-            meta.name        = parser.rdStr(sec, "name", "")
-            meta.description = parser.rdStr(sec, "description", "N/A")
-            meta.author      = parser.rdStr(sec, "author", "N/A")
-            meta.credit      = parser.rdStr(sec, "credit", "N/A")
-            meta.url         = parser.rdStr(sec, "url", "")
-            meta.license     = parser.rdStr(sec, "license", "N/A")
-            meta.licenseUrl  = parser.rdStr(sec, "licenseurl", "")
-
-        # Syntax
-        sec = "Syntax"
-        syntax = SyntaxColors()
-        if parser.has_section(sec):
-            syntax.back   = self._parseColor(parser, sec, "background")
-            syntax.text   = self._parseColor(parser, sec, "text")
-            syntax.link   = self._parseColor(parser, sec, "link")
-            syntax.head   = self._parseColor(parser, sec, "headertext")
-            syntax.headH  = self._parseColor(parser, sec, "headertag")
-            syntax.emph   = self._parseColor(parser, sec, "emphasis")
-            syntax.dialN  = self._parseColor(parser, sec, "dialog")
-            syntax.dialA  = self._parseColor(parser, sec, "altdialog")
-            syntax.hidden = self._parseColor(parser, sec, "hidden")
-            syntax.note   = self._parseColor(parser, sec, "note")
-            syntax.code   = self._parseColor(parser, sec, "shortcode")
-            syntax.key    = self._parseColor(parser, sec, "keyword")
-            syntax.tag    = self._parseColor(parser, sec, "tag")
-            syntax.val    = self._parseColor(parser, sec, "value")
-            syntax.opt    = self._parseColor(parser, sec, "optional")
-            syntax.spell  = self._parseColor(parser, sec, "spellcheckline")
-            syntax.error  = self._parseColor(parser, sec, "errorline")
-            syntax.repTag = self._parseColor(parser, sec, "replacetag")
-            syntax.mod    = self._parseColor(parser, sec, "modifier")
-            syntax.mark   = self._parseColor(parser, sec, "texthighlight")
-
-        CONFIG.splashMessage(f"Loaded syntax theme: {meta.name}")
-
-        self.syntaxMeta = meta
-        self.syntaxTheme = syntax
-
-        return True
-
-    def listThemes(self) -> list[tuple[str, str]]:
-        """Scan the GUI themes folder and list all themes."""
-        if self._themeList:
-            return self._themeList
-
-        themes = []
-        parser = NWConfigParser()
-        for key, path in self._availThemes.items():
-            logger.debug("Checking theme config '%s'", key)
-            if name := _loadInternalName(parser, path):
-                themes.append((key, name))
-
-        self._themeList = sorted(themes, key=_sortTheme)
-
-        return self._themeList
-
-    def listSyntax(self) -> list[tuple[str, str]]:
-        """Scan the syntax themes folder and list all themes."""
-        if self._syntaxList:
-            return self._syntaxList
-
-        themes = []
-        parser = NWConfigParser()
-        for key, path in self._availSyntax.items():
-            logger.debug("Checking theme syntax '%s'", key)
-            if name := _loadInternalName(parser, path):
-                themes.append((key, name))
-
-        self._syntaxList = sorted(themes, key=_sortTheme)
-
-        return self._syntaxList
-
     def getStyleSheet(self, name: str) -> str:
         """Load a standard style sheet."""
         return self._styleSheets.get(name, "")
 
+    def parseColor(self, value: str, default: QColor = QtBlack) -> QColor:
+        """Parse a string as a colour value."""
+        if value in self._qColors:
+            # Named colour
+            return self._qColors[value]
+        elif value.startswith("#") and len(value) == 7:
+            # Assume #RRGGBB
+            return QColor.fromString(value)
+        elif value.startswith("#") and len(value) == 9:
+            # Assume #RRGGBBAA and convert to #AARRGGBB
+            return QColor.fromString(f"#{value[7:9]}{value[1:7]}")
+        elif ":" in value:
+            # Colour name and lighter, darker or alpha
+            name, _, adjust = value.partition(":")
+            color = QColor(self._qColors.get(name.strip(), default))
+            if adjust.startswith("L"):
+                color = color.lighter(checkInt(adjust[1:], 100))
+            elif adjust.startswith("D"):
+                color = color.darker(checkInt(adjust[1:], 100))
+            else:
+                color.setAlpha(checkInt(adjust, 255))
+            return color
+        elif "," in value:
+            # Integer red, green, blue, alpha
+            data = value.split(",")
+            result = [0, 0, 0, 255]
+            for i in range(min(len(data), 4)):
+                result[i] = checkInt(data[i].strip(), result[i])
+            return QColor(*result)
+        return default
+
     ##
     #  Internal Functions
     ##
 
+    def _setBaseColor(self, key: str, color: QColor) -> None:
+        """Set the colour for a named colour."""
+        self._qColors[key] = QColor(color)
+        self._svgColors[key] = color.name(QColor.NameFormat.HexRgb).encode("utf-8")
+
     def _resetTheme(self) -> None:
         """Reset GUI colours to default values."""
         palette = QPalette()
-
-        text = palette.color(QPalette.ColorRole.Text)
-        window = palette.color(QPalette.ColorRole.Window)
-        isDark = text.lightnessF() > window.lightnessF()
+        isDark = self.isDesktopDarkMode()
 
         # Reset GUI Palette
+        base    = palette.color(QPalette.ColorRole.Base)
+        default = palette.color(QPalette.ColorRole.Text)
         faded   = QColor(128, 128, 128)
         dimmed  = QColor(130, 130, 130) if isDark else QColor(190, 190, 190)
         red     = QColor(242, 119, 122) if isDark else QColor(240, 40, 41)
         orange  = QColor(249, 145,  57) if isDark else QColor(245, 135, 31)
         yellow  = QColor(255, 204, 102) if isDark else QColor(234, 183, 0)
         green   = QColor(153, 204, 153) if isDark else QColor(113, 140, 0)
-        aqua    = QColor(102, 204, 204) if isDark else QColor(62, 153, 159)
+        cyan    = QColor(102, 204, 204) if isDark else QColor(62, 153, 159)
         blue    = QColor(102, 153, 204) if isDark else QColor(66, 113, 174)
         purple  = QColor(204, 153, 204) if isDark else QColor(137, 89, 168)
 
@@ -496,38 +595,65 @@ class GuiTheme:
 
         self._guiPalette = palette
 
-        # Reset Icons
-        icons = self.iconCache
-        icons.clear()
-        icons.setIconColor("default", text)
-        icons.setIconColor("faded",   faded)
-        icons.setIconColor("red",     red)
-        icons.setIconColor("orange",  orange)
-        icons.setIconColor("yellow",  yellow)
-        icons.setIconColor("green",   green)
-        icons.setIconColor("aqua",    aqua)
-        icons.setIconColor("blue",    blue)
-        icons.setIconColor("purple",  purple)
-        icons.setIconColor("root",    blue)
-        icons.setIconColor("folder",  yellow)
-        icons.setIconColor("file",    text)
-        icons.setIconColor("title",   green)
-        icons.setIconColor("chapter", red)
-        icons.setIconColor("scene",   blue)
-        icons.setIconColor("note",    yellow)
+        # Reset Base Colours and Icons
+        self.iconCache.clear()
+        self._svgColors = {}
+        self._qColors = {}
 
-        return
+        # Base
+        self._setBaseColor("base",     base)
+        self._setBaseColor("default",  default)
+        self._setBaseColor("faded",    faded)
+        self._setBaseColor("red",      red)
+        self._setBaseColor("orange",   orange)
+        self._setBaseColor("yellow",   yellow)
+        self._setBaseColor("green",    green)
+        self._setBaseColor("cyan",     cyan)
+        self._setBaseColor("blue",     blue)
+        self._setBaseColor("purple",   purple)
 
-    def _parseColor(self, parser: NWConfigParser, section: str, name: str) -> QColor:
+        # Project
+        self._setBaseColor("root",     blue)
+        self._setBaseColor("folder",   yellow)
+        self._setBaseColor("file",     default)
+        self._setBaseColor("title",    green)
+        self._setBaseColor("chapter",  red)
+        self._setBaseColor("scene",    blue)
+        self._setBaseColor("note",     yellow)
+        self._setBaseColor("active",   green)
+        self._setBaseColor("inactive", red)
+        self._setBaseColor("disabled", faded)
+
+        # Icon
+        self._setBaseColor("tool",      default)
+        self._setBaseColor("sidebar",   default)
+        self._setBaseColor("accept",    green)
+        self._setBaseColor("reject",    red)
+        self._setBaseColor("action",    blue)
+        self._setBaseColor("altaction", orange)
+        self._setBaseColor("apply",     green)
+        self._setBaseColor("create",    yellow)
+        self._setBaseColor("destroy",   faded)
+        self._setBaseColor("reset",     green)
+        self._setBaseColor("add",       green)
+        self._setBaseColor("change",    green)
+        self._setBaseColor("remove",    red)
+        self._setBaseColor("shortcode", default)
+        self._setBaseColor("markdown",  orange)
+        self._setBaseColor("systemio",  yellow)
+        self._setBaseColor("info",      blue)
+        self._setBaseColor("warning",   orange)
+        self._setBaseColor("error",     red)
+
+    def _readColor(self, parser: ConfigParser, section: str, name: str) -> QColor:
         """Parse a colour value from a config string."""
-        return QColor(*parser.rdIntList(section, name, [0, 0, 0, 255]))
+        return self.parseColor(parser.get(section, name, fallback="default"))
 
     def _setPalette(
-        self, parser: NWConfigParser, section: str, name: str, value: QPalette.ColorRole
+        self, parser: ConfigParser, section: str, name: str, value: QPalette.ColorRole
     ) -> None:
         """Set a palette colour value from a config string."""
-        self._guiPalette.setBrush(value, self._parseColor(parser, section, name))
-        return
+        self._guiPalette.setBrush(value, self._readColor(parser, section, name))
 
     def _buildStyleSheets(self, palette: QPalette) -> None:
         """Build default style sheets."""
@@ -559,7 +685,32 @@ class GuiTheme:
             "QToolButton::menu-indicator {image: none;} "
         )
 
-        return
+    def _scanThemes(self, files: list[Path]) -> None:
+        """Scan the GUI themes folder and list all themes."""
+        parser = ConfigParser()
+        data: dict[str, tuple[str, str, bool, Path]] = {}
+        keys = []
+        for file in files:
+            try:
+                parser.clear()
+                parser.read(file, encoding="utf-8")
+                name = parser.get("Main", "name", fallback="")
+                mode = parser.get("Main", "mode", fallback="").lower()
+                if name and mode in ("light", "dark"):
+                    key = file.stem
+                    prefix = "*" if key.startswith("default") else ""
+                    lookup = f"{prefix}{name} {key}"
+                    keys.append(lookup)
+                    data[lookup] = (file.stem, name, mode == "dark", file)
+            except Exception:
+                logger.error("Could not read file: %s", file)
+                logException()
+
+        self._allThemes = {}
+        for lookup in sorted(keys):
+            key, name, dark, item = data[lookup]
+            logger.debug("Checking theme config '%s'", key)
+            self._allThemes[key] = ThemeEntry(name, dark, item)
 
 
 class GuiIcons:
@@ -572,9 +723,8 @@ class GuiIcons:
     """
 
     __slots__ = (
-        "_availThemes", "_headerDec", "_headerDecNarrow", "_noIcon",
-        "_qColors", "_qIcons", "_svgColors", "_svgData", "_themeList",
-        "mainTheme", "themeMeta",
+        "_allThemes", "_headerDec", "_headerDecNarrow", "_meta",
+        "_noIcon", "_qIcons", "_svgData", "_theme",
     )
 
     TOGGLE_ICON_KEYS: Final[dict[str, tuple[str, str]]] = {
@@ -582,69 +732,74 @@ class GuiIcons:
         "unfold": ("unfold-show", "unfold-hide"),
     }
     IMAGE_MAP: Final[dict[str, tuple[str, str]]] = {
-        "welcome":  ("welcome-light.jpg", "welcome-dark.jpg"),
+        "welcome":  ("welcome.webp", "welcome.webp"),
         "nw-text":  ("novelwriter-text-light.svg", "novelwriter-text-dark.svg"),
     }
 
     def __init__(self, mainTheme: GuiTheme) -> None:
 
-        self.mainTheme = mainTheme
-        self.themeMeta = ThemeMeta()
+        self._theme = mainTheme
+        self._meta = IconsMeta()
 
         # Storage
+        self._allThemes: dict[str, ThemeEntry] = {}
         self._svgData: dict[str, bytes] = {}
-        self._svgColors: dict[str, bytes] = {}
-        self._qColors: dict[str, QColor] = {}
         self._qIcons: dict[str, QIcon] = {}
         self._headerDec: list[QPixmap] = []
         self._headerDecNarrow: list[QPixmap] = []
 
-        # Icon Theme Path
-        self._availThemes: dict[str, Path] = {}
-        self._themeList: list[tuple[str, str]] = []
-
         # None Icon
         self._noIcon = QIcon(str(CONFIG.assetPath("icons") / "none.svg"))
 
-        _listConf(self._availThemes, CONFIG.assetPath("icons"), ".icons")
-        _listConf(self._availThemes, CONFIG.dataPath("icons"), ".icons")
-
-        return
-
     def clear(self) -> None:
         """Clear the icon cache."""
         self._svgData = {}
-        self._svgColors = {}
-        self._qColors = {}
         self._qIcons = {}
         self._headerDec = []
         self._headerDecNarrow = []
-        self.themeMeta = ThemeMeta()
-        return
+        self._meta = ThemeMeta()
+
+    ##
+    #  Properties
+    ##
+
+    @property
+    def iconThemes(self) -> dict[str, ThemeEntry]:
+        """Return a dictionary of all icon themes."""
+        return self._allThemes
 
     ##
     #  Actions
     ##
 
-    def loadTheme(self, theme: str) -> bool:
+    def initIcons(self) -> None:
+        """Initialise icons."""
+        CONFIG.splashMessage("Scanning for icon themes ...")
+        icons: list[Path] = []
+        _listContent(icons, CONFIG.assetPath("icons"), ".icons")
+        _listContent(icons, CONFIG.dataPath("icons"), ".icons")
+        self._scanThemes(icons)
+
+    def loadTheme(self, theme: str) -> None:
         """Update the theme map. This is more of an init, since many of
         the GUI icons cannot really be replaced without writing specific
         update functions for the classes where they're used.
         """
-        if theme not in self._availThemes:
+        if theme not in self._allThemes:
             logger.error("Could not find icon theme '%s'", theme)
             theme = DEF_ICONS
             CONFIG.iconTheme = theme
 
-        if not (file := self._availThemes.get(theme)):
+        entry = self._allThemes.get(theme)
+        if not entry:
             logger.error("Could not load icon theme")
-            return False
+            return
 
-        CONFIG.splashMessage("Loading icon theme ...")
+        CONFIG.splashMessage(f"Loading icon theme: {entry.name}")
         logger.info("Loading icon theme '%s'", theme)
         try:
-            meta = ThemeMeta()
-            with open(file, mode="r", encoding="utf-8") as icons:
+            meta = IconsMeta()
+            with open(entry.path, mode="r", encoding="utf-8") as icons:
                 for icon in icons:
                     bits = icon.partition("=")
                     key = bits[0].strip()
@@ -658,48 +813,24 @@ class GuiIcons:
                             meta.author = value
                         elif key == "meta:license":
                             meta.license = value
-            self.themeMeta = meta
+            self._meta = meta
         except Exception:
-            logger.error("Could not read file: %s", file)
+            logger.error("Could not read file: %s", entry.path)
             logException()
-            return False
-
-        CONFIG.splashMessage(f"Loaded icon theme: {meta.name}")
-        CONFIG.splashMessage("Generating additional icons ...")
-
-        # Set colour overrides for project item icons
-        if (override := CONFIG.iconColTree) != "theme":
-            color = self._svgColors.get(override, b"#000000")
-            self._svgColors["root"] = color
-            self._svgColors["folder"] = color
-            if not CONFIG.iconColDocs:
-                self._svgColors["file"] = color
-                self._svgColors["title"] = color
-                self._svgColors["chapter"] = color
-                self._svgColors["scene"] = color
-                self._svgColors["note"] = color
+            return
 
         # Populate generated icons cache
+        CONFIG.splashMessage("Generating additional icons ...")
         self.getHeaderDecoration(0)
         self.getHeaderDecorationNarrow(0)
 
-        return True
-
-    def setIconColor(self, key: str, color: QColor) -> None:
-        """Set an icon colour for a named colour."""
-        self._qColors[key] = QColor(color)
-        self._svgColors[key] = color.name(QColor.NameFormat.HexRgb).encode("utf-8")
         return
 
     ##
     #  Access Functions
     ##
 
-    def getIconColor(self, name: str) -> QColor:
-        """Return an icon color."""
-        return QColor(self._qColors.get(name) or QtBlack)
-
-    def getIcon(self, name: str, color: str | None = None, w: int = 24, h: int = 24) -> QIcon:
+    def getIcon(self, name: str, color: str, w: int = 24, h: int = 24) -> QIcon:
         """Return an icon from the icon buffer, or load it."""
         variant = f"{name}-{color}" if color else name
         if (key := f"{variant}-{w}x{h}") in self._qIcons:
@@ -710,7 +841,7 @@ class GuiIcons:
             logger.debug("Icon: %s", key)
             return icon
 
-    def getToggleIcon(self, name: str, size: tuple[int, int], color: str | None = None) -> QIcon:
+    def getToggleIcon(self, name: str, size: tuple[int, int], color: str) -> QIcon:
         """Return a toggle icon from the icon buffer, or load it."""
         if name in self.TOGGLE_ICON_KEYS:
             pOne = self.getPixmap(self.TOGGLE_ICON_KEYS[name][0], size, color)
@@ -725,7 +856,7 @@ class GuiIcons:
         self, tType: nwItemType, tClass: nwItemClass, tLayout: nwItemLayout, hLevel: str = "H0"
     ) -> QIcon:
         """Get the correct icon for a project item based on type, class
-        and heading level
+        and heading level.
         """
         name = None
         color = "default"
@@ -762,14 +893,22 @@ class GuiIcons:
         doesn't exist, return an empty QPixmap.
         """
         w, h = size
-        return self.getIcon(name, color, w, h).pixmap(w, h, QIcon.Mode.Normal)
+        return self.getIcon(name, color or "default", w, h).pixmap(w, h, QIcon.Mode.Normal)
+
+    def getStandardButton(self, button: nwStandardButton, parent: QWidget) -> NPushButton:
+        """Return a standard button with icon and text."""
+        text, icon, color = STANDARD_BUTTONS.get(button, ("", "", ""))
+        return NPushButton(
+            parent, QCoreApplication.translate("Button", text),
+            self._theme.pushButtonIconSize, icon, color
+        )
 
     def getDecoration(self, name: str, w: int | None = None, h: int | None = None) -> QPixmap:
         """Load graphical decoration element based on the decoration
         map or the icon map. This function always returns a QPixmap.
         """
         if name in self.IMAGE_MAP:
-            idx = int(self.mainTheme.isDarkTheme)
+            idx = int(self._theme.isDarkTheme)
             imgPath = CONFIG.assetPath("images") / self.IMAGE_MAP[name][idx]
         else:
             logger.error("Decoration with name '%s' does not exist", name)
@@ -793,7 +932,7 @@ class GuiIcons:
     def getHeaderDecoration(self, hLevel: int) -> QPixmap:
         """Get the decoration for a specific heading level."""
         if not self._headerDec:
-            iPx = self.mainTheme.baseIconHeight
+            iPx = self._theme.baseIconHeight
             self._headerDec = [
                 self._generateDecoration("file", iPx, 0),
                 self._generateDecoration("title", iPx, 0),
@@ -806,7 +945,7 @@ class GuiIcons:
     def getHeaderDecorationNarrow(self, hLevel: int) -> QPixmap:
         """Get the narrow decoration for a specific heading level."""
         if not self._headerDecNarrow:
-            iPx = self.mainTheme.baseIconHeight
+            iPx = self._theme.baseIconHeight
             self._headerDecNarrow = [
                 self._generateDecoration("file", iPx, 0),
                 self._generateDecoration("title", iPx, 0),
@@ -817,21 +956,6 @@ class GuiIcons:
             ]
         return self._headerDecNarrow[minmax(hLevel, 0, 5)]
 
-    def listThemes(self) -> list[tuple[str, str]]:
-        """Scan the GUI icons folder and list all themes."""
-        if self._themeList:
-            return self._themeList
-
-        themes = []
-        for key, path in self._availThemes.items():
-            logger.debug("Checking icon theme '%s'", key)
-            if name := _loadIconName(path):
-                themes.append((key, name))
-
-        self._themeList = sorted(themes, key=_sortTheme)
-
-        return self._themeList
-
     ##
     #  Internal Functions
     ##
@@ -847,7 +971,7 @@ class GuiIcons:
             return QIcon(str(CONFIG.assetPath("icons") / "x-novelwriter-project.svg"))
 
         if svg := self._svgData.get(name, b""):
-            if fill := self._svgColors.get(color or "default"):
+            if fill := self._theme.getRawBaseColor(color or "default"):
                 svg = svg.replace(b"#000000", fill)
             pixmap = QPixmap(w, h)
             pixmap.fill(QtTransparent)
@@ -869,53 +993,43 @@ class GuiIcons:
 
         painter = QPainter(pixmap)
         painter.setRenderHint(QtPaintAntiAlias)
-        if fill := self._svgColors.get(color or "default"):
+        if fill := self._theme.getRawBaseColor(color or "default"):
             painter.fillPath(path, QColor(fill.decode(encoding="utf-8")))
         painter.end()
 
         tMode = Qt.TransformationMode.SmoothTransformation
         return pixmap.scaledToHeight(height, tMode)
 
+    def _scanThemes(self, entries: list[Path]) -> None:
+        """Scan the GUI themes folder and list all themes."""
+        data: dict[str, tuple[str, str, Path]] = {}
+        keys = []
+        for entry in entries:
+            try:
+                with open(entry, mode="r", encoding="utf-8") as fo:
+                    for line in fo:
+                        key, _, value = line.partition("=")
+                        if key.strip() == "meta:name":
+                            if name := value.strip():
+                                lookup = entry.stem
+                                keys.append(lookup)
+                                data[lookup] = (lookup, name, entry)
+                            break
+            except Exception:
+                logger.error("Could not read file: %s", entry)
+                logException()
+
+        self._allThemes = {}
+        for lookup in sorted(keys):
+            key, name, item = data[lookup]
+            logger.debug("Checking icon theme '%s'", key)
+            self._allThemes[key] = ThemeEntry(name, False, item)
+
 
 # Module Functions
 # ================
 
-def _listConf(target: dict, path: Path, extension: str) -> None:
-    """Scan for theme files and populate the dictionary."""
+def _listContent(data: list[Path], path: Path, extension: str) -> None:
+    """List files of a specific type and extend the list."""
     if path.is_dir():
-        for item in path.iterdir():
-            if item.is_file() and item.name.endswith(extension):
-                target[item.stem] = item
-    return
-
-
-def _sortTheme(data: tuple[str, str]) -> str:
-    """Key function for theme sorting."""
-    key, name = data
-    return f"*{name}" if key.startswith("default_") else name
-
-
-def _loadInternalName(parser: NWConfigParser, path: str | Path) -> str:
-    """Open a conf file and read the 'name' setting."""
-    try:
-        with open(path, mode="r", encoding="utf-8") as inFile:
-            parser.read_file(inFile)
-        return parser.rdStr("Main", "name", "")
-    except Exception:
-        logger.error("Could not read file: %s", path)
-        logException()
-    return ""
-
-
-def _loadIconName(path: Path) -> str:
-    """Open an icons file and read the name setting."""
-    try:
-        with open(path, mode="r", encoding="utf-8") as icons:
-            for icon in icons:
-                key, _, value = icon.partition("=")
-                if key.strip() == "meta:name":
-                    return value.strip()
-    except Exception:
-        logger.error("Could not read file: %s", path)
-        logException()
-    return ""
+        data.extend(n for n in path.iterdir() if n.is_file() and n.suffix == extension)