novelWriter 2.3.1__py3-none-any.whl → 2.4__py3-none-any.whl

novelwriter/gui/sidebar.py

@@ -28,12 +28,14 @@ import logging
 from typing import TYPE_CHECKING
 
 from PyQt5.QtGui import QPalette
-from PyQt5.QtCore import QEvent, QPoint, Qt, QSize, pyqtSignal
-from PyQt5.QtWidgets import QMenu, QToolButton, QVBoxLayout, QWidget
+from PyQt5.QtCore import QEvent, QPoint, QSize, pyqtSignal
+from PyQt5.QtWidgets import QMenu, QVBoxLayout, QWidget
 
 from novelwriter import CONFIG, SHARED
 from novelwriter.enum import nwView
 from novelwriter.extensions.eventfilters import StatusTipFilter
+from novelwriter.extensions.modified import NIconToolButton
+from novelwriter.gui.theme import STYLES_BIG_TOOLBUTTON
 
 if TYPE_CHECKING:  # pragma: no cover
     from novelwriter.guimain import GuiMain
@@ -43,7 +45,7 @@ logger = logging.getLogger(__name__)
 
 class GuiSideBar(QWidget):
 
-    viewChangeRequested = pyqtSignal(nwView)
+    requestViewChange = pyqtSignal(nwView)
 
     def __init__(self, mainGui: GuiMain) -> None:
         super().__init__(parent=mainGui)
@@ -52,47 +54,44 @@ class GuiSideBar(QWidget):
 
         self.mainGui = mainGui
 
-        iPx = CONFIG.pxInt(24)
-        iconSize = QSize(iPx, iPx)
+        iPx = int(1.2*SHARED.theme.baseButtonHeight)
+        iSz = QSize(iPx, iPx)
+
         self.setContentsMargins(0, 0, 0, 0)
         self.installEventFilter(StatusTipFilter(mainGui))
 
         # Buttons
-        self.tbProject = QToolButton(self)
+        self.tbProject = NIconToolButton(self, iSz)
         self.tbProject.setToolTip("{0} [Ctrl+T]".format(self.tr("Project Tree View")))
-        self.tbProject.setIconSize(iconSize)
-        self.tbProject.clicked.connect(lambda: self.viewChangeRequested.emit(nwView.PROJECT))
+        self.tbProject.clicked.connect(lambda: self.requestViewChange.emit(nwView.PROJECT))
 
-        self.tbNovel = QToolButton(self)
+        self.tbNovel = NIconToolButton(self, iSz)
         self.tbNovel.setToolTip("{0} [Ctrl+T]".format(self.tr("Novel Tree View")))
-        self.tbNovel.setIconSize(iconSize)
-        self.tbNovel.clicked.connect(lambda: self.viewChangeRequested.emit(nwView.NOVEL))
+        self.tbNovel.clicked.connect(lambda: self.requestViewChange.emit(nwView.NOVEL))
+
+        self.tbSearch = NIconToolButton(self, iSz)
+        self.tbSearch.setToolTip("{0} [Ctrl+Shift+F]".format(self.tr("Project Search")))
+        self.tbSearch.clicked.connect(lambda: self.requestViewChange.emit(nwView.SEARCH))
 
-        self.tbOutline = QToolButton(self)
+        self.tbOutline = NIconToolButton(self, iSz)
         self.tbOutline.setToolTip("{0} [Ctrl+Shift+T]".format(self.tr("Novel Outline View")))
-        self.tbOutline.setIconSize(iconSize)
-        self.tbOutline.clicked.connect(lambda: self.viewChangeRequested.emit(nwView.OUTLINE))
+        self.tbOutline.clicked.connect(lambda: self.requestViewChange.emit(nwView.OUTLINE))
 
-        self.tbBuild = QToolButton(self)
+        self.tbBuild = NIconToolButton(self, iSz)
         self.tbBuild.setToolTip("{0} [F5]".format(self.tr("Build Manuscript")))
-        self.tbBuild.setIconSize(iconSize)
         self.tbBuild.clicked.connect(self.mainGui.showBuildManuscriptDialog)
 
-        self.tbDetails = QToolButton(self)
+        self.tbDetails = NIconToolButton(self, iSz)
         self.tbDetails.setToolTip("{0} [Shift+F6]".format(self.tr("Novel Details")))
-        self.tbDetails.setIconSize(iconSize)
         self.tbDetails.clicked.connect(self.mainGui.showNovelDetailsDialog)
 
-        self.tbStats = QToolButton(self)
+        self.tbStats = NIconToolButton(self, iSz)
         self.tbStats.setToolTip("{0} [F6]".format(self.tr("Writing Statistics")))
-        self.tbStats.setIconSize(iconSize)
         self.tbStats.clicked.connect(self.mainGui.showWritingStatsDialog)
 
         # Settings Menu
-        self.tbSettings = QToolButton(self)
+        self.tbSettings = NIconToolButton(self, iSz)
         self.tbSettings.setToolTip(self.tr("Settings"))
-        self.tbSettings.setIconSize(iconSize)
-        self.tbSettings.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonIconOnly)
 
         self.mSettings = _PopRightMenu(self.tbSettings)
         self.mSettings.addAction(self.mainGui.mainMenu.aEditWordList)
@@ -101,12 +100,12 @@ class GuiSideBar(QWidget):
         self.mSettings.addAction(self.mainGui.mainMenu.aPreferences)
 
         self.tbSettings.setMenu(self.mSettings)
-        self.tbSettings.setPopupMode(QToolButton.InstantPopup)
 
         # Assemble
         self.outerBox = QVBoxLayout()
         self.outerBox.addWidget(self.tbProject)
         self.outerBox.addWidget(self.tbNovel)
+        self.outerBox.addWidget(self.tbSearch)
         self.outerBox.addWidget(self.tbOutline)
         self.outerBox.addWidget(self.tbBuild)
         self.outerBox.addStretch(1)
@@ -126,36 +125,28 @@ class GuiSideBar(QWidget):
     def updateTheme(self) -> None:
         """Initialise GUI elements that depend on specific settings."""
         qPalette = self.palette()
-        qPalette.setBrush(QPalette.Window, qPalette.base())
+        qPalette.setBrush(QPalette.ColorRole.Window, qPalette.base())
         self.setPalette(qPalette)
 
-        fadeCol = qPalette.text().color()
-        buttonStyle = (
-            "QToolButton {{padding: {0}px; border: none; background: transparent;}} "
-            "QToolButton:hover {{border: none; background: rgba({1},{2},{3},0.2);}}"
-        ).format(CONFIG.pxInt(6), fadeCol.red(), fadeCol.green(), fadeCol.blue())
-        buttonStyleMenu = f"{buttonStyle} QToolButton::menu-indicator {{image: none;}}"
+        buttonStyle = SHARED.theme.getStyleSheet(STYLES_BIG_TOOLBUTTON)
 
-        self.tbProject.setIcon(SHARED.theme.getIcon("view_editor"))
         self.tbProject.setStyleSheet(buttonStyle)
-
-        self.tbNovel.setIcon(SHARED.theme.getIcon("view_novel"))
         self.tbNovel.setStyleSheet(buttonStyle)
-
-        self.tbOutline.setIcon(SHARED.theme.getIcon("view_outline"))
+        self.tbSearch.setStyleSheet(buttonStyle)
         self.tbOutline.setStyleSheet(buttonStyle)
-
-        self.tbBuild.setIcon(SHARED.theme.getIcon("view_build"))
         self.tbBuild.setStyleSheet(buttonStyle)
-
-        self.tbDetails.setIcon(SHARED.theme.getIcon("proj_details"))
         self.tbDetails.setStyleSheet(buttonStyle)
-
-        self.tbStats.setIcon(SHARED.theme.getIcon("proj_stats"))
         self.tbStats.setStyleSheet(buttonStyle)
+        self.tbSettings.setStyleSheet(buttonStyle)
 
-        self.tbSettings.setIcon(SHARED.theme.getIcon("settings"))
-        self.tbSettings.setStyleSheet(buttonStyleMenu)
+        self.tbProject.setThemeIcon("view_editor")
+        self.tbNovel.setThemeIcon("view_novel")
+        self.tbSearch.setThemeIcon("view_search")
+        self.tbOutline.setThemeIcon("view_outline")
+        self.tbBuild.setThemeIcon("view_build")
+        self.tbDetails.setThemeIcon("proj_details")
+        self.tbStats.setThemeIcon("proj_stats")
+        self.tbSettings.setThemeIcon("settings")
 
         return
 
@@ -166,7 +157,7 @@ class _PopRightMenu(QMenu):
 
     def event(self, event: QEvent) -> bool:
         """Overload the show event and move the menu popup location."""
-        if event.type() == QEvent.Show:
+        if event.type() == QEvent.Type.Show:
             if isinstance(parent := self.parent(), QWidget):
                 offset = QPoint(parent.width(), parent.height() - self.height())
                 self.move(parent.mapToGlobal(offset))

novelwriter/gui/statusbar.py

@@ -25,12 +25,12 @@ from __future__ import annotations
 
 import logging
 
+from datetime import datetime
 from time import time
 from typing import TYPE_CHECKING, Literal
-from datetime import datetime
 
 from PyQt5.QtCore import pyqtSlot, QLocale
-from PyQt5.QtWidgets import qApp, QStatusBar, QLabel
+from PyQt5.QtWidgets import QApplication, QStatusBar, QLabel
 
 from novelwriter import CONFIG, SHARED
 from novelwriter.common import formatTime
@@ -58,7 +58,7 @@ class GuiMainStatus(QStatusBar):
         colSaved = SHARED.theme.statSaved
         colUnsaved = SHARED.theme.statUnsaved
 
-        iPx = SHARED.theme.baseIconSize
+        iPx = SHARED.theme.baseIconHeight
 
         # Permanent Widgets
         # =================
@@ -66,8 +66,8 @@ class GuiMainStatus(QStatusBar):
         xM = CONFIG.pxInt(8)
 
         # The Spell Checker Language
-        self.langIcon = QLabel("")
-        self.langText = QLabel(self.tr("None"))
+        self.langIcon = QLabel("", self)
+        self.langText = QLabel(self.tr("None"), self)
         self.langIcon.setContentsMargins(0, 0, 0, 0)
         self.langText.setContentsMargins(0, 0, xM, 0)
         self.addPermanentWidget(self.langIcon)
@@ -75,7 +75,7 @@ class GuiMainStatus(QStatusBar):
 
         # The Editor Status
         self.docIcon = StatusLED(colNone, colSaved, colUnsaved, iPx, iPx, self)
-        self.docText = QLabel(self.tr("Editor"))
+        self.docText = QLabel(self.tr("Editor"), self)
         self.docIcon.setContentsMargins(0, 0, 0, 0)
         self.docText.setContentsMargins(0, 0, xM, 0)
         self.addPermanentWidget(self.docIcon)
@@ -83,15 +83,15 @@ class GuiMainStatus(QStatusBar):
 
         # The Project Status
         self.projIcon = StatusLED(colNone, colSaved, colUnsaved, iPx, iPx, self)
-        self.projText = QLabel(self.tr("Project"))
+        self.projText = QLabel(self.tr("Project"), self)
         self.projIcon.setContentsMargins(0, 0, 0, 0)
         self.projText.setContentsMargins(0, 0, xM, 0)
         self.addPermanentWidget(self.projIcon)
         self.addPermanentWidget(self.projText)
 
         # The Project and Session Stats
-        self.statsIcon = QLabel()
-        self.statsText = QLabel("")
+        self.statsIcon = QLabel(self)
+        self.statsText = QLabel("", self)
         self.statsIcon.setContentsMargins(0, 0, 0, 0)
         self.statsText.setContentsMargins(0, 0, xM, 0)
         self.addPermanentWidget(self.statsIcon)
@@ -99,8 +99,8 @@ class GuiMainStatus(QStatusBar):
 
         # The Session Clock
         # Set the minimum width so the label doesn't rescale every second
-        self.timeIcon = QLabel()
-        self.timeText = QLabel("")
+        self.timeIcon = QLabel(self)
+        self.timeText = QLabel("", self)
         self.timeText.setToolTip(self.tr("Session Time"))
         self.timeText.setMinimumWidth(SHARED.theme.getTextWidth("00:00:00:"))
         self.timeIcon.setContentsMargins(0, 0, 0, 0)
@@ -130,7 +130,7 @@ class GuiMainStatus(QStatusBar):
 
     def updateTheme(self) -> None:
         """Update theme elements."""
-        iPx = SHARED.theme.baseIconSize
+        iPx = SHARED.theme.baseIconHeight
         self.langIcon.setPixmap(SHARED.theme.getPixmap("status_lang", (iPx, iPx)))
         self.statsIcon.setPixmap(SHARED.theme.getPixmap("status_stats", (iPx, iPx)))
         self.timePixmap = SHARED.theme.getPixmap("status_time", (iPx, iPx))
@@ -198,7 +198,7 @@ class GuiMainStatus(QStatusBar):
     def setStatusMessage(self, message: str) -> None:
         """Set the status bar message to display."""
         self.showMessage(message, nwConst.STATUS_MSG_TIMEOUT)
-        qApp.processEvents()
+        QApplication.processEvents()
         return
 
     @pyqtSlot(str, str)
@@ -240,7 +240,7 @@ class GuiMainStatus(QStatusBar):
         import tracemalloc
         from collections import Counter
 
-        widgets = qApp.allWidgets()
+        widgets = QApplication.allWidgets()
         if not self._debugInfo:
             if tracemalloc.is_tracing():
                 self._traceMallocRef = "Total"

novelwriter/gui/theme.py

@@ -29,20 +29,24 @@ import logging
 from math import ceil
 from pathlib import Path
 
-from PyQt5.QtCore import Qt
-from PyQt5.QtWidgets import qApp
+from PyQt5.QtCore import QSize, Qt
 from PyQt5.QtGui import (
     QPalette, QColor, QIcon, QFont, QFontMetrics, QFontDatabase, QPixmap
 )
+from PyQt5.QtWidgets import QApplication
 
 from novelwriter import CONFIG
+from novelwriter.common import NWConfigParser, cssCol, minmax
+from novelwriter.constants import nwLabels
 from novelwriter.enum import nwItemClass, nwItemLayout, nwItemType
 from novelwriter.error import logException
-from novelwriter.common import NWConfigParser, minmax
-from novelwriter.constants import nwLabels
 
 logger = logging.getLogger(__name__)
 
+STYLES_FLAT_TABS = "flatTabWidget"
+STYLES_MIN_TOOLBUTTON = "minimalToolButton"
+STYLES_BIG_TOOLBUTTON = "bigToolButton"
+
 
 # =============================================================================================== #
 #  Gui Theme Class
@@ -70,9 +74,9 @@ class GuiTheme:
         self.isLightTheme     = True
 
         # GUI
-        self.statNone    = QColor(120, 120, 120)
-        self.statUnsaved = QColor(200, 15, 39)
-        self.statSaved   = QColor(2, 133, 37)
+        self.statNone    = QColor(0, 0, 0)
+        self.statUnsaved = QColor(0, 0, 0)
+        self.statSaved   = QColor(0, 0, 0)
         self.helpText    = QColor(0, 0, 0)
 
         # Loaded Syntax Settings
@@ -106,6 +110,7 @@ class GuiTheme:
         self.colError  = QColor(0, 0, 0)
         self.colRepTag = QColor(0, 0, 0)
         self.colMod    = QColor(0, 0, 0)
+        self.colMark   = QColor(255, 255, 255, 128)
 
         # Class Setup
         # ===========
@@ -119,6 +124,7 @@ class GuiTheme:
         self._syntaxList: list[tuple[str, str]] = []
         self._availThemes: dict[str, Path] = {}
         self._availSyntax: dict[str, Path] = {}
+        self._styleSheets: dict[str, str] = {}
 
         self._listConf(self._availSyntax, CONFIG.assetPath("syntax"))
         self._listConf(self._availThemes, CONFIG.assetPath("themes"))
@@ -138,31 +144,42 @@ class GuiTheme:
         self.getHeaderDecorationNarrow = self.iconCache.getHeaderDecorationNarrow
 
         # Extract Other Info
-        self.guiDPI = qApp.primaryScreen().logicalDotsPerInchX()
-        self.guiScale = qApp.primaryScreen().logicalDotsPerInchX()/96.0
+        self.guiDPI = QApplication.primaryScreen().logicalDotsPerInchX()
+        self.guiScale = QApplication.primaryScreen().logicalDotsPerInchX()/96.0
         CONFIG.guiScale = self.guiScale
         logger.debug("GUI DPI: %.1f", self.guiDPI)
         logger.debug("GUI Scale: %.2f", self.guiScale)
 
         # Fonts
-        self.guiFont = qApp.font()
+        self.guiFont = QApplication.font()
+        self.guiFontB = QApplication.font()
+        self.guiFontB.setBold(True)
 
         qMetric = QFontMetrics(self.guiFont)
+        fHeight = qMetric.height()
+        fAscent = qMetric.ascent()
         self.fontPointSize = self.guiFont.pointSizeF()
-        self.fontPixelSize = int(round(qMetric.height()))
-        self.baseIconSize = int(round(qMetric.ascent()))
+        self.fontPixelSize = int(round(fHeight))
+        self.baseIconHeight = int(round(fAscent))
+        self.baseButtonHeight = int(round(1.35*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.setFamily(QFontDatabase.systemFont(QFontDatabase.FixedFont).family())
+        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 Size: %d", self.baseIconSize)
+        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)
 
@@ -210,6 +227,10 @@ class GuiTheme:
             logException()
             return False
 
+        # Reset Palette
+        self._guiPalette = QApplication.style().standardPalette()
+        self._resetGuiColors()
+
         # Main
         sec = "Main"
         if parser.has_section(sec):
@@ -239,8 +260,6 @@ 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)
-        else:
-            self._guiPalette = qApp.style().standardPalette()
 
         # GUI
         sec = "GUI"
@@ -269,7 +288,10 @@ class GuiTheme:
         self.iconCache.loadTheme(self.themeIcons or defaultIcons)
 
         # Apply Styles
-        qApp.setPalette(self._guiPalette)
+        QApplication.setPalette(self._guiPalette)
+
+        # Reset stylesheets so that they are regenerated
+        self._buildStyleSheets(self._guiPalette)
 
         return True
 
@@ -329,6 +351,7 @@ class GuiTheme:
             self.colError  = self._parseColour(confParser, cnfSec, "errorline")
             self.colRepTag = self._parseColour(confParser, cnfSec, "replacetag")
             self.colMod    = self._parseColour(confParser, cnfSec, "modifier")
+            self.colMark   = self._parseColour(confParser, cnfSec, "texthighlight")
 
         return True
 
@@ -364,10 +387,22 @@ class GuiTheme:
 
         return self._syntaxList
 
+    def getStyleSheet(self, name: str) -> str:
+        """Load a standard style sheet."""
+        return self._styleSheets.get(name, "")
+
     ##
     #  Internal Functions
     ##
 
+    def _resetGuiColors(self) -> None:
+        """Reset GUI colours to default values."""
+        self.statNone    = QColor(120, 120, 120)
+        self.statUnsaved = QColor(200, 15, 39)
+        self.statSaved   = QColor(2, 133, 37)
+        self.helpText    = QColor(0, 0, 0)
+        return
+
     def _setGuiFont(self) -> None:
         """Update the GUI's font style from settings."""
         font = QFont()
@@ -378,14 +413,14 @@ class GuiTheme:
                 font.setFamily("Arial")
                 font.setPointSize(10)
             else:
-                font = fontDB.systemFont(QFontDatabase.GeneralFont)
+                font = fontDB.systemFont(QFontDatabase.SystemFont.GeneralFont)
             CONFIG.guiFont = font.family()
             CONFIG.guiFontSize = font.pointSize()
         else:
             font.setFamily(CONFIG.guiFont)
             font.setPointSize(CONFIG.guiFontSize)
 
-        qApp.setFont(font)
+        QApplication.setFont(font)
 
         return
 
@@ -410,6 +445,41 @@ class GuiTheme:
         self._guiPalette.setColor(value, self._parseColour(parser, section, name))
         return
 
+    def _buildStyleSheets(self, palette: QPalette) -> None:
+        """Build default style sheets."""
+        self._styleSheets = {}
+
+        aPx = CONFIG.pxInt(2)
+        bPx = CONFIG.pxInt(4)
+        cPx = CONFIG.pxInt(6)
+        dPx = CONFIG.pxInt(8)
+
+        tCol = palette.text().color()
+        hCol = palette.highlight().color()
+
+        # Flat Tab Widget and Tab Bar:
+        self._styleSheets[STYLES_FLAT_TABS] = (
+            "QTabWidget::pane {border: 0;} "
+            f"QTabWidget QTabBar::tab {{border: 0; padding: {bPx}px {dPx}px;}} "
+            f"QTabWidget QTabBar::tab:selected {{color: {cssCol(hCol)};}} "
+        )
+
+        # Minimal Tool Button
+        self._styleSheets[STYLES_MIN_TOOLBUTTON] = (
+            f"QToolButton {{padding: {aPx}px; margin: 0; border: none; background: transparent;}} "
+            f"QToolButton:hover {{border: none; background: {cssCol(tCol, 48)};}} "
+            "QToolButton::menu-indicator {image: none;} "
+        )
+
+        # Big Tool Button
+        self._styleSheets[STYLES_BIG_TOOLBUTTON] = (
+            f"QToolButton {{padding: {cPx}px; margin: 0; border: none; background: transparent;}} "
+            f"QToolButton:hover {{border: none; background: {cssCol(tCol, 48)};}} "
+            "QToolButton::menu-indicator {image: none;} "
+        )
+
+        return
+
 # End Class GuiTheme
 
 
@@ -437,7 +507,7 @@ class GuiIcons:
         "build_excluded", "build_filtered", "build_included", "proj_chapter", "proj_details",
         "proj_document", "proj_folder", "proj_note", "proj_nwx", "proj_section", "proj_scene",
         "proj_stats", "proj_title", "status_idle", "status_lang", "status_lines", "status_stats",
-        "status_time", "view_build", "view_editor", "view_novel", "view_outline",
+        "status_time", "view_build", "view_editor", "view_novel", "view_outline", "view_search",
 
         # Class Icons
         "cls_archive", "cls_character", "cls_custom", "cls_entity", "cls_none", "cls_novel",
@@ -448,8 +518,8 @@ class GuiIcons:
         "search_regex", "search_word",
 
         # Format Icons
-        "fmt_bold", "fmt_bold-md", "fmt_italic", "fmt_italic-md", "fmt_strike", "fmt_strike-md",
-        "fmt_subscript", "fmt_superscript", "fmt_underline",
+        "fmt_bold", "fmt_bold-md", "fmt_italic", "fmt_italic-md", "fmt_mark", "fmt_strike",
+        "fmt_strike-md", "fmt_subscript", "fmt_superscript", "fmt_underline",
 
         # General Button Icons
         "add", "add_document", "backward", "bookmark", "browse", "checked", "close", "cross",
@@ -460,6 +530,7 @@ class GuiIcons:
         # Switches
         "sticky-on", "sticky-off",
         "bullet-on", "bullet-off",
+        "unfold-show", "unfold-hide",
 
         # Decorations
         "deco_doc_h0", "deco_doc_h1", "deco_doc_h2", "deco_doc_h3", "deco_doc_h4", "deco_doc_more",
@@ -470,6 +541,7 @@ class GuiIcons:
     TOGGLE_ICON_KEYS: dict[str, tuple[str, str]] = {
         "sticky": ("sticky-on", "sticky-off"),
         "bullet": ("bullet-on", "bullet-off"),
+        "unfold": ("unfold-show", "unfold-hide"),
     }
 
     IMAGE_MAP: dict[str, tuple[str, str]] = {
@@ -491,6 +563,9 @@ class GuiIcons:
         self._confName = "icons.conf"
         self._iconPath = CONFIG.assetPath("icons")
 
+        # None Icon
+        self._noIcon = QIcon(str(self._iconPath / "none.svg"))
+
         # Icon Theme Meta
         self.themeName        = ""
         self.themeDescription = ""
@@ -621,13 +696,13 @@ class GuiIcons:
     def getToggleIcon(self, name: str, size: tuple[int, int]) -> 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)
+            pOne = self.getPixmap(self.TOGGLE_ICON_KEYS[name][0], size)
             pTwo = self.getPixmap(self.TOGGLE_ICON_KEYS[name][1], size)
             icon = QIcon()
             icon.addPixmap(pOne, QIcon.Mode.Normal, QIcon.State.On)
             icon.addPixmap(pTwo, QIcon.Mode.Normal, QIcon.State.Off)
             return icon
-        return QIcon()
+        return self._noIcon
 
     def getPixmap(self, name: str, size: tuple[int, int]) -> QPixmap:
         """Return an icon from the icon buffer as a QPixmap. If it
@@ -638,7 +713,7 @@ class GuiIcons:
     def getItemIcon(self, tType: nwItemType, tClass: nwItemClass,
                     tLayout: nwItemLayout, hLevel: str = "H0") -> QIcon:
         """Get the correct icon for a project item based on type, class
-        and header level
+        and heading level
         """
         iconName = None
         if tType == nwItemType.ROOT:
@@ -659,14 +734,14 @@ class GuiIcons:
             elif tLayout == nwItemLayout.NOTE:
                 iconName = "proj_note"
         if iconName is None:
-            return QIcon()
+            return self._noIcon
 
         return self.getIcon(iconName)
 
     def getHeaderDecoration(self, hLevel: int) -> QPixmap:
-        """Get the decoration for a specific header level."""
+        """Get the decoration for a specific heading level."""
         if not self._headerDec:
-            iPx = self.mainTheme.baseIconSize
+            iPx = self.mainTheme.baseIconHeight
             self._headerDec = [
                 self.loadDecoration("deco_doc_h0", h=iPx),
                 self.loadDecoration("deco_doc_h1", h=iPx),
@@ -677,9 +752,9 @@ class GuiIcons:
         return self._headerDec[minmax(hLevel, 0, 4)]
 
     def getHeaderDecorationNarrow(self, hLevel: int) -> QPixmap:
-        """Get the narrow decoration for a specific header level."""
+        """Get the narrow decoration for a specific heading level."""
         if not self._headerDecNarrow:
-            iPx = self.mainTheme.baseIconSize
+            iPx = self.mainTheme.baseIconHeight
             self._headerDecNarrow = [
                 self.loadDecoration("deco_doc_h0_n", h=iPx),
                 self.loadDecoration("deco_doc_h1_n", h=iPx),
@@ -700,7 +775,7 @@ class GuiIcons:
         """
         if name not in self.ICON_KEYS:
             logger.error("Requested unknown icon name '%s'", name)
-            return QIcon()
+            return self._noIcon
 
         # If we just want the app icons, return right away
         if name == "novelwriter":
@@ -716,7 +791,7 @@ class GuiIcons:
         # If we didn't find one, give up and return an empty icon
         logger.warning("Did not load an icon for '%s'", name)
 
-        return QIcon()
+        return self._noIcon
 
 # END Class GuiIcons