novelWriter 2.1.1__py3-none-any.whl → 2.2rc1__py3-none-any.whl

novelwriter/gui/sidebar.py

@@ -25,119 +25,150 @@ from __future__ import annotations
 
 import logging
 
-from PyQt5.QtCore import Qt, QSize, pyqtSignal
-from PyQt5.QtWidgets import (
-    QToolBar, QWidget, QSizePolicy, QAction, QMenu, QToolButton
-)
+from typing import TYPE_CHECKING
+
+from PyQt5.QtCore import QEvent, QPoint, Qt, QSize, pyqtSignal
+from PyQt5.QtGui import QPalette
+from PyQt5.QtWidgets import QMenu, QToolButton, QVBoxLayout, QWidget
 
 from novelwriter import CONFIG, SHARED
 from novelwriter.enum import nwView
 
+if TYPE_CHECKING:  # pragma: no cover
+    from novelwriter.guimain import GuiMain
+
 logger = logging.getLogger(__name__)
 
 
-class GuiSideBar(QToolBar):
+class GuiSideBar(QWidget):
 
     viewChangeRequested = pyqtSignal(nwView)
 
-    def __init__(self, mainGui):
+    def __init__(self, mainGui: GuiMain) -> None:
         super().__init__(parent=mainGui)
 
         logger.debug("Create: GuiSideBar")
 
         self.mainGui = mainGui
 
-        # Style
-        iPx = CONFIG.pxInt(22)
-        mPx = CONFIG.pxInt(60)
-
-        lblFont = SHARED.theme.guiFont
-        lblFont.setPointSizeF(0.65*SHARED.theme.fontPointSize)
-
-        self.setMovable(False)
-        self.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
-        self.setIconSize(QSize(iPx, iPx))
-        self.setMaximumWidth(mPx)
+        iPx = CONFIG.pxInt(24)
+        iconSize = QSize(iPx, iPx)
         self.setContentsMargins(0, 0, 0, 0)
 
-        stretch = QWidget(self)
-        stretch.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
-
-        # Actions
-        self.aProject = QAction(self.tr("Project"), self)
-        self.aProject.setFont(lblFont)
-        self.aProject.setToolTip(self.tr("Project Tree View"))
-        self.aProject.triggered.connect(lambda: self.viewChangeRequested.emit(nwView.PROJECT))
-
-        self.aNovel = QAction(self.tr("Novel"), self)
-        self.aNovel.setFont(lblFont)
-        self.aNovel.setToolTip(self.tr("Novel Tree View"))
-        self.aNovel.triggered.connect(lambda: self.viewChangeRequested.emit(nwView.NOVEL))
-
-        self.aOutline = QAction(self.tr("Outline"), self)
-        self.aOutline.setFont(lblFont)
-        self.aOutline.setToolTip(self.tr("Novel Outline View"))
-        self.aOutline.triggered.connect(lambda: self.viewChangeRequested.emit(nwView.OUTLINE))
-
-        self.aBuild = QAction(self.tr("Build"), self)
-        self.aBuild.setFont(lblFont)
-        self.aBuild.setToolTip(self.tr("Build Manuscript"))
-        self.aBuild.triggered.connect(lambda: self.mainGui.showBuildManuscriptDialog())
-
-        self.aDetails = QAction(self.tr("Details"), self)
-        self.aDetails.setFont(lblFont)
-        self.aDetails.setToolTip(self.tr("Project Details"))
-        self.aDetails.triggered.connect(lambda: self.mainGui.showProjectDetailsDialog())
-
-        self.aStats = QAction(self.tr("Stats"), self)
-        self.aStats.setFont(lblFont)
-        self.aStats.setToolTip(self.tr("Writing Statistics"))
-        self.aStats.triggered.connect(lambda: self.mainGui.showWritingStatsDialog())
+        # Buttons
+        self.tbProject = QToolButton(self)
+        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.tbNovel = QToolButton(self)
+        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.tbOutline = QToolButton(self)
+        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.tbBuild = QToolButton(self)
+        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.setToolTip("{0} [Shift+F6]".format(self.tr("Project Details")))
+        self.tbDetails.setIconSize(iconSize)
+        self.tbDetails.clicked.connect(self.mainGui.showProjectDetailsDialog)
+
+        self.tbStats = QToolButton(self)
+        self.tbStats.setToolTip("{0} [F6]".format(self.tr("Writing Statistics")))
+        self.tbStats.setIconSize(iconSize)
+        self.tbStats.clicked.connect(self.mainGui.showWritingStatsDialog)
 
         # Settings Menu
-        self.mSettings = QMenu(self)
+        self.tbSettings = QToolButton(self)
+        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)
         self.mSettings.addAction(self.mainGui.mainMenu.aProjectSettings)
         self.mSettings.addSeparator()
         self.mSettings.addAction(self.mainGui.mainMenu.aPreferences)
 
-        self.tbSettings = QToolButton(self)
-        self.tbSettings.setFont(lblFont)
-        self.tbSettings.setText(self.tr("Settings"))
         self.tbSettings.setMenu(self.mSettings)
-        self.tbSettings.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
         self.tbSettings.setPopupMode(QToolButton.InstantPopup)
 
         # Assemble
-        self.addAction(self.aProject)
-        self.addAction(self.aNovel)
-        self.addAction(self.aOutline)
-        self.addAction(self.aBuild)
-        self.addWidget(stretch)
-        self.addAction(self.aDetails)
-        self.addAction(self.aStats)
-        self.addWidget(self.tbSettings)
-
+        self.outerBox = QVBoxLayout()
+        self.outerBox.addWidget(self.tbProject)
+        self.outerBox.addWidget(self.tbNovel)
+        self.outerBox.addWidget(self.tbOutline)
+        self.outerBox.addWidget(self.tbBuild)
+        self.outerBox.addStretch(1)
+        self.outerBox.addWidget(self.tbDetails)
+        self.outerBox.addWidget(self.tbStats)
+        self.outerBox.addWidget(self.tbSettings)
+        self.outerBox.setContentsMargins(0, 0, 0, 0)
+        self.outerBox.setSpacing(CONFIG.pxInt(4))
+
+        self.setLayout(self.outerBox)
         self.updateTheme()
 
         logger.debug("Ready: GuiSideBar")
 
         return
 
-    def updateTheme(self):
-        """Initialise GUI elements that depend on specific settings.
-        """
-        self.setStyleSheet("QToolBar {border: 0px;}")
-
-        self.aProject.setIcon(SHARED.theme.getIcon("view_editor"))
-        self.aNovel.setIcon(SHARED.theme.getIcon("view_novel"))
-        self.aOutline.setIcon(SHARED.theme.getIcon("view_outline"))
-        self.aBuild.setIcon(SHARED.theme.getIcon("view_build"))
-        self.aDetails.setIcon(SHARED.theme.getIcon("proj_details"))
-        self.aStats.setIcon(SHARED.theme.getIcon("proj_stats"))
+    def updateTheme(self) -> None:
+        """Initialise GUI elements that depend on specific settings."""
+        qPalette = self.palette()
+        qPalette.setBrush(QPalette.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;}}"
+
+        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.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.setIcon(SHARED.theme.getIcon("settings"))
+        self.tbSettings.setStyleSheet(buttonStyleMenu)
 
         return
 
 # END Class GuiSideBar
+
+
+class _PopRightMenu(QMenu):
+
+    def event(self, event: QEvent):
+        """Overload the show event and move the menu popup location."""
+        if event.type() == QEvent.Show:
+            parent = self.parent()
+            if isinstance(parent, QWidget):
+                offset = QPoint(parent.width(), parent.height() - self.height())
+                self.move(parent.mapToGlobal(offset))
+        return super(_PopRightMenu, self).event(event)
+
+# END Class _PopRightMenu

novelwriter/gui/statusbar.py

@@ -97,7 +97,7 @@ class GuiMainStatus(QStatusBar):
         self.addPermanentWidget(self.statsText)
 
         # The Session Clock
-        # Set the mimimum width so the label doesn't rescale every second
+        # Set the minimum width so the label doesn't rescale every second
         self.timeIcon = QLabel()
         self.timeText = QLabel("")
         self.timeText.setToolTip(self.tr("Session Time"))

novelwriter/gui/theme.py

@@ -36,7 +36,7 @@ from PyQt5.QtGui import (
 )
 
 from novelwriter import CONFIG
-from novelwriter.enum import nwItemLayout, nwItemType
+from novelwriter.enum import nwItemClass, nwItemLayout, nwItemType
 from novelwriter.error import logException
 from novelwriter.common import NWConfigParser, minmax
 from novelwriter.constants import nwLabels
@@ -51,7 +51,7 @@ logger = logging.getLogger(__name__)
 
 class GuiTheme:
 
-    def __init__(self):
+    def __init__(self) -> None:
 
         self.iconCache = GuiIcons(self)
 
@@ -97,6 +97,7 @@ class GuiTheme:
         self.colDialD  = [0, 0, 0]
         self.colDialS  = [0, 0, 0]
         self.colHidden = [0, 0, 0]
+        self.colCode   = [0, 0, 0]
         self.colKey    = [0, 0, 0]
         self.colVal    = [0, 0, 0]
         self.colSpell  = [0, 0, 0]
@@ -129,8 +130,10 @@ class GuiTheme:
         self.getIcon = self.iconCache.getIcon
         self.getPixmap = self.iconCache.getPixmap
         self.getItemIcon = self.iconCache.getItemIcon
+        self.getToggleIcon = self.iconCache.getToggleIcon
         self.loadDecoration = self.iconCache.loadDecoration
         self.getHeaderDecoration = self.iconCache.getHeaderDecoration
+        self.getHeaderDecorationNarrow = self.iconCache.getHeaderDecorationNarrow
 
         # Extract Other Info
         self.guiDPI = qApp.primaryScreen().logicalDotsPerInchX()
@@ -181,7 +184,7 @@ class GuiTheme:
     #  Theme Methods
     ##
 
-    def loadTheme(self):
+    def loadTheme(self) -> bool:
         """Load the currently specified GUI theme."""
         guiTheme = CONFIG.guiTheme
         if guiTheme not in self._availThemes:
@@ -268,7 +271,7 @@ class GuiTheme:
 
         return True
 
-    def loadSyntax(self):
+    def loadSyntax(self) -> bool:
         """Load the currently specified syntax highlighter theme."""
         guiSyntax = CONFIG.guiSyntax
         if guiSyntax not in self._availSyntax:
@@ -316,6 +319,7 @@ class GuiTheme:
             self.colDialD  = self._parseColour(confParser, cnfSec, "doublequotes")
             self.colDialS  = self._parseColour(confParser, cnfSec, "singlequotes")
             self.colHidden = self._parseColour(confParser, cnfSec, "hidden")
+            self.colCode   = self._parseColour(confParser, cnfSec, "shortcode")
             self.colKey    = self._parseColour(confParser, cnfSec, "keyword")
             self.colVal    = self._parseColour(confParser, cnfSec, "value")
             self.colSpell  = self._parseColour(confParser, cnfSec, "spellcheckline")
@@ -361,7 +365,7 @@ class GuiTheme:
     #  Internal Functions
     ##
 
-    def _setGuiFont(self):
+    def _setGuiFont(self) -> None:
         """Update the GUI's font style from settings."""
         theFont = QFont()
         fontDB = QFontDatabase()
@@ -393,9 +397,7 @@ class GuiTheme:
 
         return True
 
-    def _parseColour(
-        self, parser: NWConfigParser, section: str, name: str
-    ) -> list[int]:
+    def _parseColour(self, parser: NWConfigParser, section: str, name: str) -> list[int]:
         """Parse a colour value from a config string."""
         if parser.has_option(section, name):
             values = parser.get(section, name).split(",")
@@ -412,9 +414,8 @@ class GuiTheme:
             result = [0, 0, 0]
         return result
 
-    def _setPalette(
-        self, parser: NWConfigParser, section: str, name: str, value: QPalette.ColorRole
-    ):
+    def _setPalette(self, parser: NWConfigParser, section: str,
+                    name: str, value: QPalette.ColorRole) -> None:
         """Set a palette colour value from a config string."""
         self._guiPalette.setColor(
             value, QColor(*self._parseColour(parser, section, name))
@@ -445,19 +446,27 @@ class GuiIcons:
     ICON_KEYS = {
         # Project and GUI Icons
         "novelwriter", "alert_error", "alert_info", "alert_question", "alert_warn",
-        "build_excluded", "build_filtered", "build_included", "cls_archive", "cls_character",
-        "cls_custom", "cls_entity", "cls_none", "cls_novel", "cls_object", "cls_plot",
-        "cls_timeline", "cls_trash", "cls_world", "proj_chapter", "proj_details", "proj_document",
-        "proj_folder", "proj_note", "proj_nwx", "proj_section", "proj_scene", "proj_stats",
-        "proj_title", "search_cancel", "search_case", "search_loop", "search_preserve",
-        "search_project", "search_regex", "search_word", "status_idle", "status_lang",
-        "status_lines", "status_stats", "status_time", "view_build", "view_editor", "view_novel",
-        "view_outline",
+        "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",
+
+        # Class Icons
+        "cls_archive", "cls_character", "cls_custom", "cls_entity", "cls_none", "cls_novel",
+        "cls_object", "cls_plot", "cls_timeline", "cls_trash", "cls_world",
+
+        # Search Icons
+        "search_cancel", "search_case", "search_loop", "search_preserve", "search_project",
+        "search_regex", "search_word",
+
+        # Format Icons
+        "fmt_bold", "fmt_italic", "fmt_mode-md", "fmt_mode-sc", "fmt_strike", "fmt_subscript",
+        "fmt_superscript", "fmt_underline",
 
         # General Button Icons
         "add", "backward", "bookmark", "browse", "checked", "close", "cross", "down", "edit",
-        "export", "forward", "maximise", "menu", "minimise", "noncheckable", "reference",
-        "refresh", "remove", "revert", "search_replace", "search", "settings", "unchecked", "up",
+        "export", "forward", "maximise", "menu", "minimise", "noncheckable", "panel", "refresh",
+        "remove", "revert", "search_replace", "search", "settings", "unchecked", "up", "view",
 
         # Switches
         "sticky-on", "sticky-off",
@@ -465,23 +474,32 @@ class GuiIcons:
 
         # Decorations
         "deco_doc_h0", "deco_doc_h1", "deco_doc_h2", "deco_doc_h3", "deco_doc_h4", "deco_doc_more",
+        "deco_doc_h0_n", "deco_doc_h1_n", "deco_doc_h2_n", "deco_doc_h3_n", "deco_doc_h4_n",
+        "deco_doc_nt_n",
+    }
+
+    TOGGLE_ICON_KEYS = {
+        "sticky":   ("sticky-on", "sticky-off"),
+        "bullet":   ("bullet-on", "bullet-off"),
+        "fmt_mode": ("fmt_mode-sc", "fmt_mode-md"),
     }
 
     IMAGE_MAP = {
         "wiz-back": "wizard-back.jpg",
     }
 
-    def __init__(self, mainTheme):
+    def __init__(self, mainTheme: GuiTheme) -> None:
 
         self.mainTheme = mainTheme
 
         # Storage
-        self._qIcons    = {}
-        self._themeMap  = {}
-        self._headerDec = []
-        self._confName  = "icons.conf"
+        self._qIcons: dict[str, QIcon] = {}
+        self._themeMap: dict[str, Path] = {}
+        self._headerDec: list[QPixmap] = []
+        self._headerDecNarrow: list[QPixmap] = []
 
         # Icon Theme Path
+        self._confName = "icons.conf"
         self._iconPath = CONFIG.assetPath("icons")
 
         # Icon Theme Meta
@@ -499,7 +517,7 @@ class GuiIcons:
     #  Actions
     ##
 
-    def loadTheme(self, iconTheme):
+    def loadTheme(self, iconTheme: str) -> bool:
         """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.
@@ -566,6 +584,7 @@ class GuiIcons:
             self._qIcons[iconKey] = qIcon
 
         self._headerDec = []
+        self._headerDecNarrow = []
 
         return True
 
@@ -573,52 +592,60 @@ class GuiIcons:
     #  Access Functions
     ##
 
-    def loadDecoration(self, decoKey, pxW=None, pxH=None):
+    def loadDecoration(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 decoKey in self._themeMap:
-            imgPath = self._themeMap[decoKey]
-        elif decoKey in self.IMAGE_MAP:
-            imgPath = CONFIG.assetPath("images") / self.IMAGE_MAP[decoKey]
+        if name in self._themeMap:
+            imgPath = self._themeMap[name]
+        elif name in self.IMAGE_MAP:
+            imgPath = CONFIG.assetPath("images") / self.IMAGE_MAP[name]
         else:
-            logger.error("Decoration with name '%s' does not exist", decoKey)
+            logger.error("Decoration with name '%s' does not exist", name)
             return QPixmap()
 
         if not imgPath.is_file():
             logger.error("Asset not found: %s", imgPath)
             return QPixmap()
 
-        theDeco = QPixmap(str(imgPath))
-        if pxW is not None and pxH is not None:
-            return theDeco.scaled(pxW, pxH, Qt.IgnoreAspectRatio, Qt.SmoothTransformation)
-        elif pxW is None and pxH is not None:
-            return theDeco.scaledToHeight(pxH, Qt.SmoothTransformation)
-        elif pxW is not None and pxH is None:
-            return theDeco.scaledToWidth(pxW, Qt.SmoothTransformation)
+        pixmap = QPixmap(str(imgPath))
+        if w is not None and h is not None:
+            return pixmap.scaled(w, h, Qt.IgnoreAspectRatio, Qt.SmoothTransformation)
+        elif w is None and h is not None:
+            return pixmap.scaledToHeight(h, Qt.SmoothTransformation)
+        elif w is not None and h is None:
+            return pixmap.scaledToWidth(w, Qt.SmoothTransformation)
 
-        return theDeco
+        return pixmap
 
-    def getIcon(self, iconKey):
-        """Return an icon from the icon buffer. If it doesn't exist,
-        return, load it, and if it still doesn't exist, return an empty
-        icon.
-        """
-        if iconKey in self._qIcons:
-            return self._qIcons[iconKey]
+    def getIcon(self, name: str) -> QIcon:
+        """Return an icon from the icon buffer, or load it."""
+        if name in self._qIcons:
+            return self._qIcons[name]
         else:
-            qIcon = self._loadIcon(iconKey)
-            self._qIcons[iconKey] = qIcon
-            return qIcon
+            icon = self._loadIcon(name)
+            self._qIcons[name] = icon
+            return icon
+
+    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)
+            pTwo = self.getPixmap(self.TOGGLE_ICON_KEYS[name][1], size)
+            icon = QIcon()
+            icon.addPixmap(pOne, QIcon.Normal, QIcon.On)
+            icon.addPixmap(pTwo, QIcon.Normal, QIcon.Off)
+            return icon
+        return QIcon()
 
-    def getPixmap(self, iconKey, iconSize):
+    def getPixmap(self, name: str, size: tuple[int, int]) -> QPixmap:
         """Return an icon from the icon buffer as a QPixmap. If it
         doesn't exist, return an empty QPixmap.
         """
-        qIcon = self.getIcon(iconKey)
-        return qIcon.pixmap(iconSize[0], iconSize[1], QIcon.Normal)
+        return self.getIcon(name).pixmap(size[0], size[1], QIcon.Normal)
 
-    def getItemIcon(self, tType, tClass, tLayout, hLevel="H0"):
+    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
         """
@@ -645,45 +672,58 @@ class GuiIcons:
 
         return self.getIcon(iconName)
 
-    def getHeaderDecoration(self, hLevel):
-        """Get the decoration for a specific header level.
-        """
+    def getHeaderDecoration(self, hLevel: int) -> QPixmap:
+        """Get the decoration for a specific header level."""
         if not self._headerDec:
             iPx = self.mainTheme.baseIconSize
             self._headerDec = [
-                self.loadDecoration("deco_doc_h0", pxH=iPx),
-                self.loadDecoration("deco_doc_h1", pxH=iPx),
-                self.loadDecoration("deco_doc_h2", pxH=iPx),
-                self.loadDecoration("deco_doc_h3", pxH=iPx),
-                self.loadDecoration("deco_doc_h4", pxH=iPx),
+                self.loadDecoration("deco_doc_h0", h=iPx),
+                self.loadDecoration("deco_doc_h1", h=iPx),
+                self.loadDecoration("deco_doc_h2", h=iPx),
+                self.loadDecoration("deco_doc_h3", h=iPx),
+                self.loadDecoration("deco_doc_h4", h=iPx),
             ]
         return self._headerDec[minmax(hLevel, 0, 4)]
 
+    def getHeaderDecorationNarrow(self, hLevel: int) -> QPixmap:
+        """Get the narrow decoration for a specific header level."""
+        if not self._headerDecNarrow:
+            iPx = self.mainTheme.baseIconSize
+            self._headerDecNarrow = [
+                self.loadDecoration("deco_doc_h0_n", h=iPx),
+                self.loadDecoration("deco_doc_h1_n", h=iPx),
+                self.loadDecoration("deco_doc_h2_n", h=iPx),
+                self.loadDecoration("deco_doc_h3_n", h=iPx),
+                self.loadDecoration("deco_doc_h4_n", h=iPx),
+                self.loadDecoration("deco_doc_nt_n", h=iPx),
+            ]
+        return self._headerDecNarrow[minmax(hLevel, 0, 5)]
+
     ##
     #  Internal Functions
     ##
 
-    def _loadIcon(self, iconKey):
+    def _loadIcon(self, name: str) -> QIcon:
         """Load an icon from the assets themes folder. Is guaranteed to
         return a QIcon.
         """
-        if iconKey not in self.ICON_KEYS:
-            logger.error("Requested unknown icon name '%s'", iconKey)
+        if name not in self.ICON_KEYS:
+            logger.error("Requested unknown icon name '%s'", name)
             return QIcon()
 
         # If we just want the app icons, return right away
-        if iconKey == "novelwriter":
+        if name == "novelwriter":
             return QIcon(str(self._iconPath / "novelwriter.svg"))
-        elif iconKey == "proj_nwx":
+        elif name == "proj_nwx":
             return QIcon(str(self._iconPath / "x-novelwriter-project.svg"))
 
         # Otherwise, we load from the theme folder
-        if iconKey in self._themeMap:
-            logger.debug("Loading: %s", self._themeMap[iconKey].name)
-            return QIcon(str(self._themeMap[iconKey]))
+        if name in self._themeMap:
+            logger.debug("Loading: %s", self._themeMap[name].name)
+            return QIcon(str(self._themeMap[name]))
 
         # If we didn't find one, give up and return an empty icon
-        logger.warning("Did not load an icon for '%s'", iconKey)
+        logger.warning("Did not load an icon for '%s'", name)
 
         return QIcon()
 
@@ -694,9 +734,8 @@ class GuiIcons:
 #  Module Functions
 # =============================================================================================== #
 
-def _loadInternalName(confParser, confFile):
-    """Open a conf file and read the 'name' setting.
-    """
+def _loadInternalName(confParser: NWConfigParser, confFile: str | Path) -> str:
+    """Open a conf file and read the 'name' setting."""
     try:
         with open(confFile, mode="r", encoding="utf-8") as inFile:
             confParser.read_file(inFile)