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

novelwriter/gui/search.py

@@ -0,0 +1,316 @@
+"""
+novelWriter – GUI Project Search
+================================
+
+File History:
+Created: 2024-03-21 [2.4b1]  GuiProjectSearch
+
+This file is a part of novelWriter
+Copyright 2018–2024, Veronica Berglyd Olsen
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.
+"""
+from __future__ import annotations
+
+import logging
+
+from time import time
+
+from PyQt5.QtCore import QSize, Qt, pyqtSignal, pyqtSlot
+from PyQt5.QtGui import QCursor, QKeyEvent, QPalette
+from PyQt5.QtWidgets import (
+    QHBoxLayout, QHeaderView, QLabel, QLineEdit, QToolBar, QTreeWidget,
+    QTreeWidgetItem, QVBoxLayout, QWidget, qApp
+)
+
+from novelwriter import CONFIG, SHARED
+from novelwriter.common import checkInt
+from novelwriter.core.coretools import DocSearch
+from novelwriter.core.item import NWItem
+
+logger = logging.getLogger(__name__)
+
+CACHE_TIMEOUT = 120.0  # 2 minutes
+
+
+class GuiProjectSearch(QWidget):
+
+    C_NAME   = 0
+    C_RESULT = 0
+    C_COUNT  = 1
+
+    D_HANDLE = Qt.ItemDataRole.UserRole
+    D_RESULT = Qt.ItemDataRole.UserRole + 1
+
+    selectedItemChanged = pyqtSignal(str)
+    openDocumentSelectRequest = pyqtSignal(str, int, int, bool)
+
+    def __init__(self, parent: QWidget) -> None:
+        super().__init__(parent=parent)
+
+        logger.debug("Create: GuiProjectSearch")
+
+        iPx = SHARED.theme.baseIconSize
+        mPx = CONFIG.pxInt(2)
+
+        self._time = time()
+        self._search = DocSearch()
+        self._blocked = False
+
+        # Header
+        self.viewLabel = QLabel(self.tr("Project Search"))
+        self.viewLabel.setFont(SHARED.theme.guiFontB)
+        self.viewLabel.setContentsMargins(mPx, mPx, 0, mPx)
+
+        # Options
+        self.searchOpt = QToolBar(self)
+        self.searchOpt.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonIconOnly)
+        self.searchOpt.setIconSize(QSize(iPx, iPx))
+        self.searchOpt.setContentsMargins(0, 0, 0, 0)
+
+        self.toggleCase = self.searchOpt.addAction(self.tr("Case Sensitive"))
+        self.toggleCase.setCheckable(True)
+        self.toggleCase.setChecked(CONFIG.searchProjCase)
+        self.toggleCase.toggled.connect(self._toggleCase)
+
+        self.toggleWord = self.searchOpt.addAction(self.tr("Whole Words Only"))
+        self.toggleWord.setCheckable(True)
+        self.toggleWord.setChecked(CONFIG.searchProjWord)
+        self.toggleWord.toggled.connect(self._toggleWord)
+
+        self.toggleRegEx = self.searchOpt.addAction(self.tr("RegEx Mode"))
+        self.toggleRegEx.setCheckable(True)
+        self.toggleRegEx.setChecked(CONFIG.searchProjRegEx)
+        self.toggleRegEx.toggled.connect(self._toggleRegEx)
+
+        # Search Box
+        self.searchText = QLineEdit(self)
+        self.searchText.setPlaceholderText(self.tr("Search text ..."))
+        self.searchText.setClearButtonEnabled(True)
+
+        self.searchAction = self.searchText.addAction(
+            SHARED.theme.getIcon("search"), QLineEdit.ActionPosition.TrailingPosition
+        )
+        self.searchAction.triggered.connect(self._processSearch)
+
+        # Search Result
+        self.searchResult = QTreeWidget(self)
+        self.searchResult.setHeaderHidden(True)
+        self.searchResult.setColumnCount(2)
+        self.searchResult.setIconSize(QSize(iPx, iPx))
+        self.searchResult.setIndentation(iPx)
+        self.searchResult.itemDoubleClicked.connect(self._searchResultDoubleClicked)
+        self.searchResult.itemSelectionChanged.connect(self._searchResultSelected)
+
+        treeHeader = self.searchResult.header()
+        treeHeader.setStretchLastSection(False)
+        treeHeader.setSectionResizeMode(self.C_NAME, QHeaderView.ResizeMode.Stretch)
+        treeHeader.setSectionResizeMode(self.C_COUNT, QHeaderView.ResizeMode.ResizeToContents)
+
+        # Assemble
+        self.headerBox = QHBoxLayout()
+        self.headerBox.addWidget(self.viewLabel, 1)
+        self.headerBox.addWidget(self.searchOpt, 0)
+        self.headerBox.setContentsMargins(0, 0, 0, 0)
+
+        self.outerBox = QVBoxLayout()
+        self.outerBox.addLayout(self.headerBox, 0)
+        self.outerBox.addWidget(self.searchText, 0)
+        self.outerBox.addWidget(self.searchResult, 1)
+        self.outerBox.setContentsMargins(0, 0, 0, 0)
+        self.outerBox.setSpacing(mPx)
+
+        self.setLayout(self.outerBox)
+        self.updateTheme()
+
+        logger.debug("Ready: GuiProjectSearch")
+
+        return
+
+    ##
+    #  Methods
+    ##
+
+    def updateTheme(self) -> None:
+        """Update theme elements."""
+        qPalette = self.palette()
+        qPalette.setBrush(QPalette.ColorRole.Window, qPalette.base())
+        self.setPalette(qPalette)
+
+        self.searchAction.setIcon(SHARED.theme.getIcon("search"))
+        self.toggleCase.setIcon(SHARED.theme.getIcon("search_case"))
+        self.toggleWord.setIcon(SHARED.theme.getIcon("search_word"))
+        self.toggleRegEx.setIcon(SHARED.theme.getIcon("search_regex"))
+
+        return
+
+    def processReturn(self) -> None:
+        """Process a return keypress forwarded from the main GUI."""
+        if self.searchText.hasFocus():
+            self._processSearch()
+        elif (
+            self.searchResult.hasFocus()
+            and (items := self.searchResult.selectedItems())
+            and (data := items[0].data(0, self.D_RESULT))
+            and len(data) == 3
+        ):
+            self.openDocumentSelectRequest.emit(
+                str(data[0]), checkInt(data[1], -1), checkInt(data[2], -1), False
+            )
+        return
+
+    def beginSearch(self) -> None:
+        """Focus the search box and select its text, if any."""
+        self.searchText.setFocus()
+        self.searchText.selectAll()
+        return
+
+    def closeProjectTasks(self) -> None:
+        """Run close project tasks."""
+        self.searchText.clear()
+        self.searchResult.clear()
+        return
+
+    ##
+    #  Events
+    ##
+
+    def keyPressEvent(self, event: QKeyEvent) -> None:
+        """Process key press events. This handles up and down arrow key
+        presses to jump between search text box and result tree.
+        """
+        if (
+            event.key() == Qt.Key.Key_Down
+            and self.searchText.hasFocus()
+            and (first := self.searchResult.topLevelItem(0))
+        ):
+            first.setSelected(True)
+            self.searchResult.setFocus()
+        elif (
+            event.key() == Qt.Key.Key_Up
+            and self.searchResult.hasFocus()
+            and (first := self.searchResult.topLevelItem(0))
+            and first.isSelected()
+        ):
+            first.setSelected(False)
+            self.searchText.setFocus()
+        else:
+            super().keyPressEvent(event)
+        return
+
+    ##
+    #  Private Slots
+    ##
+
+    @pyqtSlot()
+    def _processSearch(self) -> None:
+        """Perform a search."""
+        if not self._blocked:
+            qApp.setOverrideCursor(QCursor(Qt.CursorShape.WaitCursor))
+            start = time()
+            self._blocked = True
+            self.searchResult.clear()
+            if text := self.searchText.text():
+                self._search.setUserRegEx(self.toggleRegEx.isChecked())
+                self._search.setCaseSensitive(self.toggleCase.isChecked())
+                self._search.setWholeWords(self.toggleWord.isChecked())
+                for item, results, capped in self._search.iterSearch(SHARED.project, text):
+                    self._appendResultSet(item, results, capped)
+            logger.debug("Search took %.3f ms", 1000*(time() - start))
+            self._time = time()
+            qApp.restoreOverrideCursor()
+        self._blocked = False
+        return
+
+    @pyqtSlot()
+    def _searchResultSelected(self) -> None:
+        """Process search result selection."""
+        if items := self.searchResult.selectedItems():
+            if (data := items[0].data(0, self.D_RESULT)) and len(data) == 3:
+                self.selectedItemChanged.emit(str(data[0]))
+            elif data := items[0].data(0, self.D_HANDLE):
+                self.selectedItemChanged.emit(str(data))
+        return
+
+    @pyqtSlot("QTreeWidgetItem*", int)
+    def _searchResultDoubleClicked(self, item: QTreeWidgetItem, column: int) -> None:
+        """Process search result double click."""
+        if (data := item.data(0, self.D_RESULT)) and len(data) == 3:
+            self.openDocumentSelectRequest.emit(
+                str(data[0]), checkInt(data[1], -1), checkInt(data[2], -1), True
+            )
+        return
+
+    @pyqtSlot(bool)
+    def _toggleCase(self, state: bool) -> None:
+        """Enable/disable case sensitive mode."""
+        CONFIG.searchProjCase = state
+        return
+
+    @pyqtSlot(bool)
+    def _toggleWord(self, state: bool) -> None:
+        """Enable/disable whole word search mode."""
+        CONFIG.searchProjWord = state
+        return
+
+    @pyqtSlot(bool)
+    def _toggleRegEx(self, state: bool) -> None:
+        """Enable/disable regular expression search mode."""
+        CONFIG.searchProjRegEx = state
+        return
+
+    ##
+    #  Internal Functions
+    ##
+
+    def _appendResultSet(
+        self, nwItem: NWItem, results: list[tuple[int, int, str]], capped: bool
+    ) -> None:
+        """Populate the result tree."""
+        if results:
+            tHandle = nwItem.itemHandle
+            docIcon = SHARED.theme.getItemIcon(
+                nwItem.itemType, nwItem.itemClass,
+                nwItem.itemLayout, nwItem.mainHeading
+            )
+            ext = "+" if capped else ""
+
+            tItem = QTreeWidgetItem()
+            tItem.setText(self.C_NAME, nwItem.itemName)
+            tItem.setIcon(self.C_NAME, docIcon)
+            tItem.setData(self.C_NAME, self.D_HANDLE, tHandle)
+            tItem.setText(self.C_COUNT, f"({len(results):n}{ext})")
+            tItem.setTextAlignment(self.C_COUNT, Qt.AlignmentFlag.AlignRight)
+            tItem.setForeground(self.C_COUNT, self.palette().highlight())
+            self.searchResult.addTopLevelItem(tItem)
+
+            rItems = []
+            for start, length, context in results:
+                rItem = QTreeWidgetItem()
+                rItem.setText(0, context)
+                rItem.setData(0, self.D_RESULT, (tHandle, start, length))
+                rItems.append(rItem)
+
+            tItem.addChildren(rItems)
+            tItem.setExpanded(True)
+
+            parent = self.searchResult.indexFromItem(tItem)
+            for i in range(tItem.childCount()):
+                self.searchResult.setFirstColumnSpanned(i, parent, True)
+
+            qApp.processEvents()
+
+        return
+
+# END Class GuiProjectSearch

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, 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)
@@ -53,46 +55,41 @@ class GuiSideBar(QWidget):
         self.mainGui = mainGui
 
         iPx = CONFIG.pxInt(24)
-        iconSize = QSize(iPx, iPx)
         self.setContentsMargins(0, 0, 0, 0)
         self.installEventFilter(StatusTipFilter(mainGui))
 
         # Buttons
-        self.tbProject = QToolButton(self)
+        self.tbProject = NIconToolButton(self, iPx)
         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, iPx)
         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.tbOutline = QToolButton(self)
+        self.tbSearch = NIconToolButton(self, iPx)
+        self.tbSearch.setToolTip("{0} [Ctrl+Shift+F]".format(self.tr("Search Project")))
+        self.tbSearch.clicked.connect(lambda: self.requestViewChange.emit(nwView.SEARCH))
+
+        self.tbOutline = NIconToolButton(self, iPx)
         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, iPx)
         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, iPx)
         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, iPx)
         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, iPx)
         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 +98,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)
@@ -129,12 +126,7 @@ class GuiSideBar(QWidget):
         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;}}"
+        buttonStyle = SHARED.theme.getStyleSheet(STYLES_BIG_TOOLBUTTON)
 
         self.tbProject.setIcon(SHARED.theme.getIcon("view_editor"))
         self.tbProject.setStyleSheet(buttonStyle)
@@ -142,6 +134,9 @@ class GuiSideBar(QWidget):
         self.tbNovel.setIcon(SHARED.theme.getIcon("view_novel"))
         self.tbNovel.setStyleSheet(buttonStyle)
 
+        self.tbSearch.setIcon(SHARED.theme.getIcon("view_search"))
+        self.tbSearch.setStyleSheet(buttonStyle)
+
         self.tbOutline.setIcon(SHARED.theme.getIcon("view_outline"))
         self.tbOutline.setStyleSheet(buttonStyle)
 
@@ -155,7 +150,7 @@ class GuiSideBar(QWidget):
         self.tbStats.setStyleSheet(buttonStyle)
 
         self.tbSettings.setIcon(SHARED.theme.getIcon("settings"))
-        self.tbSettings.setStyleSheet(buttonStyleMenu)
+        self.tbSettings.setStyleSheet(buttonStyle)
 
         return
 

novelwriter/gui/theme.py

@@ -43,6 +43,10 @@ from novelwriter.constants import nwLabels
 
 logger = logging.getLogger(__name__)
 
+STYLES_FLAT_TABS = "flatTabWidget"
+STYLES_MIN_TOOLBUTTON = "minimalToolButton"
+STYLES_BIG_TOOLBUTTON = "bigToolButton"
+
 
 # =============================================================================================== #
 #  Gui Theme Class
@@ -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"))
@@ -146,6 +152,8 @@ class GuiTheme:
 
         # Fonts
         self.guiFont = qApp.font()
+        self.guiFontB = qApp.font()
+        self.guiFontB.setBold(True)
 
         qMetric = QFontMetrics(self.guiFont)
         self.fontPointSize = self.guiFont.pointSizeF()
@@ -271,6 +279,9 @@ class GuiTheme:
         # Apply Styles
         qApp.setPalette(self._guiPalette)
 
+        # Reset stylesheets so that they are regenerated
+        self._buildStyleSheets(self._guiPalette)
+
         return True
 
     def loadSyntax(self) -> bool:
@@ -329,6 +340,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,6 +376,10 @@ class GuiTheme:
 
         return self._syntaxList
 
+    def getStyleSheet(self, name: str) -> str:
+        """Load a standard style sheet."""
+        return self._styleSheets.get(name, "")
+
     ##
     #  Internal Functions
     ##
@@ -410,6 +426,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;}} "
+            "QTabWidget QTabBar::tab {{border: 0; padding: {0}px {1}px;}} "
+            "QTabWidget QTabBar::tab:selected {{color: rgb({2}, {3}, {4});}} "
+        ).format(bPx, dPx, hCol.red(), hCol.green(), hCol.blue())
+
+        # Minimal Tool Button
+        self._styleSheets[STYLES_MIN_TOOLBUTTON] = (
+            "QToolButton {{padding: {0}px; margin: 0; border: none; background: transparent;}} "
+            "QToolButton:hover {{border: none; background: rgba({1}, {2}, {3}, 0.2);}} "
+            "QToolButton::menu-indicator {{image: none;}} "
+        ).format(aPx, tCol.red(), tCol.green(), tCol.blue())
+
+        # Big Tool Button
+        self._styleSheets[STYLES_BIG_TOOLBUTTON] = (
+            "QToolButton {{padding: {0}px; margin: 0; border: none; background: transparent;}} "
+            "QToolButton:hover {{border: none; background: rgba({1}, {2}, {3}, 0.2);}} "
+            "QToolButton::menu-indicator {{image: none;}} "
+        ).format(cPx, tCol.red(), tCol.green(), tCol.blue())
+
+        return
+
 # End Class GuiTheme
 
 
@@ -437,7 +488,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 +499,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 +511,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 +522,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]] = {
@@ -638,7 +691,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:
@@ -664,7 +717,7 @@ class GuiIcons:
         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
             self._headerDec = [
@@ -677,7 +730,7 @@ 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
             self._headerDecNarrow = [