novelWriter 2.3rc1__py3-none-any.whl → 2.4__py3-none-any.whl

novelwriter/gui/docviewer.py

@@ -29,27 +29,29 @@ from __future__ import annotations
 import logging
 
 from enum import Enum
-from typing import TYPE_CHECKING
 
-from PyQt5.QtCore import pyqtSignal, pyqtSlot, QPoint, QSize, Qt, QUrl
+from PyQt5.QtCore import pyqtSignal, pyqtSlot, QPoint, Qt, QUrl
 from PyQt5.QtGui import (
     QCursor, QFont, QMouseEvent, QPalette, QResizeEvent, QTextCursor,
     QTextOption
 )
 from PyQt5.QtWidgets import (
-    QAction, QFrame, QHBoxLayout, QLabel, QMenu, QTextBrowser, QToolButton,
-    QWidget, qApp
+    QAction, QApplication, QFrame, QHBoxLayout, QLabel, QMenu, QTextBrowser,
+    QToolButton, QWidget
 )
 
 from novelwriter import CONFIG, SHARED
+from novelwriter.common import cssCol
+from novelwriter.constants import nwHeaders, nwUnicode
+from novelwriter.core.tohtml import ToHtml
 from novelwriter.enum import nwItemType, nwDocAction, nwDocMode
 from novelwriter.error import logException
-from novelwriter.constants import nwUnicode
-from novelwriter.core.tohtml import ToHtml
 from novelwriter.extensions.eventfilters import WheelEventFilter
-
-if TYPE_CHECKING:  # pragma: no cover
-    from novelwriter.guimain import GuiMain
+from novelwriter.extensions.modified import NIconToolButton
+from novelwriter.gui.theme import STYLES_MIN_TOOLBUTTON
+from novelwriter.types import (
+    QtAlignCenterTop, QtAlignJustify, QtKeepAnchor, QtMouseLeft, QtMoveAnchor
+)
 
 logger = logging.getLogger(__name__)
 
@@ -58,17 +60,16 @@ class GuiDocViewer(QTextBrowser):
 
     documentLoaded = pyqtSignal(str)
     loadDocumentTagRequest = pyqtSignal(str, Enum)
+    closeDocumentRequest = pyqtSignal()
+    reloadDocumentRequest = pyqtSignal()
     togglePanelVisibility = pyqtSignal()
     requestProjectItemSelected = pyqtSignal(str, bool)
 
-    def __init__(self, mainGui: GuiMain) -> None:
-        super().__init__(parent=mainGui)
+    def __init__(self, parent: QWidget) -> None:
+        super().__init__(parent=parent)
 
         logger.debug("Create: GuiDocViewer")
 
-        # Class Variables
-        self.mainGui = mainGui
-
         # Internal Variables
         self._docHandle = None
 
@@ -128,7 +129,7 @@ class GuiDocViewer(QTextBrowser):
         self.clear()
         self.setSearchPaths([""])
         self._docHandle = None
-        self.docHeader.setTitleFromHandle(self._docHandle)
+        self.docHeader.clearHeader()
         return
 
     def updateTheme(self) -> None:
@@ -166,7 +167,7 @@ class GuiDocViewer(QTextBrowser):
         self.document().setDocumentMargin(0)
         options = QTextOption()
         if CONFIG.doJustify:
-            options.setAlignment(Qt.AlignmentFlag.AlignJustify)
+            options.setAlignment(QtAlignJustify)
         self.document().setDefaultTextOption(options)
 
         # Scroll bars
@@ -184,8 +185,7 @@ class GuiDocViewer(QTextBrowser):
         self.setTabStopDistance(CONFIG.getTabWidth())
 
         # If we have a document open, we should reload it in case the font changed
-        if self._docHandle is not None:
-            self.reloadText()
+        self.reloadText()
 
         return
 
@@ -197,12 +197,15 @@ class GuiDocViewer(QTextBrowser):
             return False
 
         logger.debug("Generating preview for item '%s'", tHandle)
-        qApp.setOverrideCursor(QCursor(Qt.CursorShape.WaitCursor))
+        QApplication.setOverrideCursor(QCursor(Qt.CursorShape.WaitCursor))
 
         sPos = self.verticalScrollBar().value()
         aDoc = ToHtml(SHARED.project)
-        aDoc.setPreview(CONFIG.viewComments, CONFIG.viewSynopsis)
-        aDoc.setLinkHeaders(True)
+        aDoc.setPreview(True)
+        aDoc.setKeywords(True)
+        aDoc.setComments(CONFIG.viewComments)
+        aDoc.setSynopsis(CONFIG.viewSynopsis)
+        aDoc.setLinkHeadings(True)
 
         # Be extra careful here to prevent crashes when first opening a
         # project as a crash here leaves no way of recovering.
@@ -216,7 +219,7 @@ class GuiDocViewer(QTextBrowser):
             logger.error("Failed to generate preview for document with handle '%s'", tHandle)
             logException()
             self.setText(self.tr("An error occurred while generating the preview."))
-            qApp.restoreOverrideCursor()
+            QApplication.restoreOverrideCursor()
             return False
 
         # Refresh the tab stops
@@ -239,13 +242,17 @@ class GuiDocViewer(QTextBrowser):
 
         self._docHandle = tHandle
         SHARED.project.data.setLastHandle(tHandle, "viewer")
-        self.docHeader.setTitleFromHandle(self._docHandle)
+        self.docHeader.setHandle(tHandle)
+        self.docHeader.setOutline({
+            sTitle: (hItem.title, nwHeaders.H_LEVEL.get(hItem.level, 0))
+            for sTitle, hItem in SHARED.project.index.iterItemHeadings(tHandle)
+        })
         self.updateDocMargins()
 
         # Since we change the content while it may still be rendering, we mark
         # the document dirty again to make sure it's re-rendered properly.
         self.redrawText()
-        qApp.restoreOverrideCursor()
+        QApplication.restoreOverrideCursor()
         self.documentLoaded.emit(tHandle)
 
         return True
@@ -281,13 +288,6 @@ class GuiDocViewer(QTextBrowser):
             return False
         return True
 
-    def navigateTo(self, tAnchor: str) -> None:
-        """Go to a specific #link in the document."""
-        if isinstance(tAnchor, str) and tAnchor.startswith("#"):
-            logger.debug("Moving to anchor '%s'", tAnchor)
-            self.setSource(QUrl(tAnchor))
-        return
-
     def clearNavHistory(self) -> None:
         """Clear the navigation history."""
         self.docHistory.clear()
@@ -340,11 +340,19 @@ class GuiDocViewer(QTextBrowser):
     @pyqtSlot(str)
     def updateDocInfo(self, tHandle: str) -> None:
         """Update the header title bar if needed."""
-        if tHandle == self._docHandle:
-            self.docHeader.setTitleFromHandle(self._docHandle)
+        if tHandle and tHandle == self._docHandle:
+            self.docHeader.setHandle(tHandle)
             self.updateDocMargins()
         return
 
+    @pyqtSlot(str)
+    def navigateTo(self, anchor: str) -> None:
+        """Go to a specific #link in the document."""
+        if isinstance(anchor, str) and anchor.startswith("#"):
+            logger.debug("Moving to anchor '%s'", anchor)
+            self.setSource(QUrl(anchor))
+        return
+
     ##
     #  Private Slots
     ##
@@ -404,7 +412,7 @@ class GuiDocViewer(QTextBrowser):
         ctxMenu.addAction(mnuSelPara)
 
         # Open the context menu
-        ctxMenu.exec_(self.viewport().mapToGlobal(point))
+        ctxMenu.exec(self.viewport().mapToGlobal(point))
         ctxMenu.deleteLater()
 
         return
@@ -446,8 +454,8 @@ class GuiDocViewer(QTextBrowser):
             posE = cursor.selectionEnd()
             selTxt = cursor.selectedText()
             if selTxt.startswith(nwUnicode.U_PSEP):
-                cursor.setPosition(posS+1, QTextCursor.MoveMode.MoveAnchor)
-                cursor.setPosition(posE, QTextCursor.MoveMode.KeepAnchor)
+                cursor.setPosition(posS+1, QtMoveAnchor)
+                cursor.setPosition(posE, QtKeepAnchor)
 
         self.setTextCursor(cursor)
 
@@ -463,53 +471,25 @@ class GuiDocViewer(QTextBrowser):
         """Generate an appropriate style sheet for the document viewer,
         based on the current syntax highlighter theme.
         """
-        colText = SHARED.theme.colText
-        colHead = SHARED.theme.colHead
-        colVals = SHARED.theme.colVal
-        colEmph = SHARED.theme.colEmph
-        colKeys = SHARED.theme.colKey
-        colHide = SHARED.theme.colHidden
-        colMods = SHARED.theme.colMod
-        colOpts = SHARED.theme.colOpt
-        styleSheet = (
-            "body {{"
-            "  color: rgb({tColR}, {tColG}, {tColB});"
-            "}}\n"
-            "h1, h2, h3, h4 {{"
-            "  color: rgb({hColR}, {hColG}, {hColB});"
-            "}}\n"
-            "a {{"
-            "  color: rgb({aColR}, {aColG}, {aColB});"
-            "}}\n"
-            "mark {{"
-            "  color: rgb({eColR}, {eColG}, {eColB});"
-            "}}\n"
-            ".tags {{"
-            "  color: rgb({kColR}, {kColG}, {kColB});"
-            "}}\n"
-            ".optional {{"
-            "  color: rgb({oColR}, {oColG}, {oColB});"
-            "}}\n"
-            ".comment {{"
-            "  color: rgb({cColR}, {cColG}, {cColB});"
-            "}}\n"
-            ".synopsis {{"
-            "  color: rgb({mColR}, {mColG}, {mColB});"
-            "}}\n"
-            ".title {{"
-            "  text-align: center;"
-            "}}\n"
-        ).format(
-            tColR=colText.red(), tColG=colText.green(), tColB=colText.blue(),
-            hColR=colHead.red(), hColG=colHead.green(), hColB=colHead.blue(),
-            aColR=colVals.red(), aColG=colVals.green(), aColB=colVals.blue(),
-            eColR=colEmph.red(), eColG=colEmph.green(), eColB=colEmph.blue(),
-            kColR=colKeys.red(), kColG=colKeys.green(), kColB=colKeys.blue(),
-            cColR=colHide.red(), cColG=colHide.green(), cColB=colHide.blue(),
-            mColR=colMods.red(), mColG=colMods.green(), mColB=colMods.blue(),
-            oColR=colOpts.red(), oColG=colOpts.green(), oColB=colOpts.blue(),
+        colText = cssCol(SHARED.theme.colText)
+        colHead = cssCol(SHARED.theme.colHead)
+        colVals = cssCol(SHARED.theme.colVal)
+        colMark = cssCol(SHARED.theme.colMark)
+        colKeys = cssCol(SHARED.theme.colKey)
+        colOpts = cssCol(SHARED.theme.colOpt)
+        colHide = cssCol(SHARED.theme.colHidden)
+        colMods = cssCol(SHARED.theme.colMod)
+        self.document().setDefaultStyleSheet(
+            f"body {{color: {colText};}}\n"
+            f"h1, h2, h3, h4 {{color: {colHead};}}\n"
+            f"a {{color: {colVals};}}\n"
+            f"mark {{background-color: {colMark};}}\n"
+            f".tags {{color: {colKeys};}}\n"
+            f".optional {{color: {colOpts};}}\n"
+            f".comment {{color: {colHide};}}\n"
+            f".synopsis {{color: {colMods};}}\n"
+            ".title {text-align: center;}\n"
         )
-        self.document().setDefaultStyleSheet(styleSheet)
 
         return
 
@@ -644,84 +624,81 @@ class GuiDocViewHeader(QWidget):
         logger.debug("Create: GuiDocViewHeader")
 
         self.docViewer = docViewer
-        self.mainGui   = docViewer.mainGui
 
         # Internal Variables
         self._docHandle = None
+        self._docOutline: dict[str, tuple[str, int]] = {}
 
-        fPx = int(0.9*SHARED.theme.fontPixelSize)
-        hSp = CONFIG.pxInt(6)
+        iPx = SHARED.theme.baseIconHeight
+        iSz = SHARED.theme.baseIconSize
+        mPx = CONFIG.pxInt(4)
 
         # Main Widget Settings
         self.setAutoFillBackground(True)
 
         # Title Label
-        self.docTitle = QLabel()
-        self.docTitle.setText("")
-        self.docTitle.setIndent(0)
-        self.docTitle.setMargin(0)
-        self.docTitle.setContentsMargins(0, 0, 0, 0)
-        self.docTitle.setAutoFillBackground(True)
-        self.docTitle.setAlignment(Qt.AlignmentFlag.AlignHCenter | Qt.AlignmentFlag.AlignTop)
-        self.docTitle.setFixedHeight(fPx)
-
-        lblFont = self.docTitle.font()
+        self.itemTitle = QLabel(self)
+        self.itemTitle.setText("")
+        self.itemTitle.setIndent(0)
+        self.itemTitle.setMargin(0)
+        self.itemTitle.setContentsMargins(0, 0, 0, 0)
+        self.itemTitle.setAutoFillBackground(True)
+        self.itemTitle.setAlignment(QtAlignCenterTop)
+        self.itemTitle.setFixedHeight(iPx)
+
+        lblFont = self.itemTitle.font()
         lblFont.setPointSizeF(0.9*SHARED.theme.fontPointSize)
-        self.docTitle.setFont(lblFont)
+        self.itemTitle.setFont(lblFont)
+
+        # Other Widgets
+        self.outlineMenu = QMenu(self)
 
         # Buttons
-        self.backButton = QToolButton(self)
-        self.backButton.setContentsMargins(0, 0, 0, 0)
-        self.backButton.setIconSize(QSize(fPx, fPx))
-        self.backButton.setFixedSize(fPx, fPx)
-        self.backButton.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonIconOnly)
+        self.outlineButton = NIconToolButton(self, iSz)
+        self.outlineButton.setVisible(False)
+        self.outlineButton.setToolTip(self.tr("Outline"))
+        self.outlineButton.setMenu(self.outlineMenu)
+
+        self.backButton = NIconToolButton(self, iSz)
         self.backButton.setVisible(False)
         self.backButton.setToolTip(self.tr("Go Backward"))
         self.backButton.clicked.connect(self.docViewer.navBackward)
 
-        self.forwardButton = QToolButton(self)
-        self.forwardButton.setContentsMargins(0, 0, 0, 0)
-        self.forwardButton.setIconSize(QSize(fPx, fPx))
-        self.forwardButton.setFixedSize(fPx, fPx)
-        self.forwardButton.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonIconOnly)
+        self.forwardButton = NIconToolButton(self, iSz)
         self.forwardButton.setVisible(False)
         self.forwardButton.setToolTip(self.tr("Go Forward"))
         self.forwardButton.clicked.connect(self.docViewer.navForward)
 
-        self.refreshButton = QToolButton(self)
-        self.refreshButton.setContentsMargins(0, 0, 0, 0)
-        self.refreshButton.setIconSize(QSize(fPx, fPx))
-        self.refreshButton.setFixedSize(fPx, fPx)
-        self.refreshButton.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonIconOnly)
+        self.refreshButton = NIconToolButton(self, iSz)
         self.refreshButton.setVisible(False)
         self.refreshButton.setToolTip(self.tr("Reload"))
         self.refreshButton.clicked.connect(self._refreshDocument)
 
-        self.closeButton = QToolButton(self)
-        self.closeButton.setContentsMargins(0, 0, 0, 0)
-        self.closeButton.setIconSize(QSize(fPx, fPx))
-        self.closeButton.setFixedSize(fPx, fPx)
-        self.closeButton.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonIconOnly)
+        self.closeButton = NIconToolButton(self, iSz)
         self.closeButton.setVisible(False)
         self.closeButton.setToolTip(self.tr("Close"))
         self.closeButton.clicked.connect(self._closeDocument)
 
         # Assemble Layout
         self.outerBox = QHBoxLayout()
-        self.outerBox.setSpacing(hSp)
+        self.outerBox.addWidget(self.outlineButton, 0)
         self.outerBox.addWidget(self.backButton, 0)
         self.outerBox.addWidget(self.forwardButton, 0)
-        self.outerBox.addWidget(self.docTitle, 1)
+        self.outerBox.addSpacing(mPx)
+        self.outerBox.addWidget(self.itemTitle, 1)
+        self.outerBox.addSpacing(mPx)
+        self.outerBox.addSpacing(iPx)
         self.outerBox.addWidget(self.refreshButton, 0)
         self.outerBox.addWidget(self.closeButton, 0)
+        self.outerBox.setSpacing(0)
+
         self.setLayout(self.outerBox)
 
         # Fix Margins and Size
         # This is needed for high DPI systems. See issue #499.
-        cM = CONFIG.pxInt(8)
         self.setContentsMargins(0, 0, 0, 0)
-        self.outerBox.setContentsMargins(cM, cM, cM, cM)
-        self.setMinimumHeight(fPx + 2*cM)
+        self.outerBox.setContentsMargins(mPx, mPx, mPx, mPx)
+        self.setMinimumHeight(iPx + 2*mPx)
 
         # Fix the Colours
         self.updateTheme()
@@ -734,19 +711,50 @@ class GuiDocViewHeader(QWidget):
     #  Methods
     ##
 
-    def updateTheme(self) -> None:
-        """Update theme elements."""
-        self.backButton.setIcon(SHARED.theme.getIcon("backward"))
-        self.forwardButton.setIcon(SHARED.theme.getIcon("forward"))
-        self.refreshButton.setIcon(SHARED.theme.getIcon("refresh"))
-        self.closeButton.setIcon(SHARED.theme.getIcon("close"))
+    def clearHeader(self) -> None:
+        """Clear the header."""
+        self._docHandle = None
+        self._docOutline = {}
 
-        colText = SHARED.theme.colText
-        buttonStyle = (
-            "QToolButton {{border: none; background: transparent;}} "
-            "QToolButton:hover {{border: none; background: rgba({0}, {1}, {2}, 0.2);}}"
-        ).format(colText.red(), colText.green(), colText.blue())
+        self.itemTitle.setText("")
+        self.outlineMenu.clear()
+        self.outlineButton.setVisible(False)
+        self.backButton.setVisible(False)
+        self.forwardButton.setVisible(False)
+        self.closeButton.setVisible(False)
+        self.refreshButton.setVisible(False)
+        return
 
+    def setOutline(self, data: dict[str, tuple[str, int]]) -> None:
+        """Set the document outline dataset."""
+        tHandle = self._docHandle
+        if data != self._docOutline and tHandle:
+            self.outlineMenu.clear()
+            entries = []
+            minLevel = 5
+            for title, (text, level) in data.items():
+                if title != "T0000":
+                    entries.append((title, text, level))
+                    minLevel = min(minLevel, level)
+            for title, text, level in entries[:30]:
+                indent = "    "*(level - minLevel)
+                action = self.outlineMenu.addAction(f"{indent}{text}")
+                action.triggered.connect(
+                    lambda _, title=title: self.docViewer.navigateTo(f"#{tHandle}:{title}")
+                )
+            self._docOutline = data
+        return
+
+    def updateTheme(self) -> None:
+        """Update theme elements."""
+        self.outlineButton.setThemeIcon("list")
+        self.backButton.setThemeIcon("backward")
+        self.forwardButton.setThemeIcon("forward")
+        self.refreshButton.setThemeIcon("refresh")
+        self.closeButton.setThemeIcon("close")
+
+        buttonStyle = SHARED.theme.getStyleSheet(STYLES_MIN_TOOLBUTTON)
+        self.outlineButton.setStyleSheet(buttonStyle)
         self.backButton.setStyleSheet(buttonStyle)
         self.forwardButton.setStyleSheet(buttonStyle)
         self.refreshButton.setStyleSheet(buttonStyle)
@@ -765,38 +773,25 @@ class GuiDocViewHeader(QWidget):
         palette.setColor(QPalette.ColorRole.WindowText, SHARED.theme.colText)
         palette.setColor(QPalette.ColorRole.Text, SHARED.theme.colText)
         self.setPalette(palette)
-        self.docTitle.setPalette(palette)
+        self.itemTitle.setPalette(palette)
         return
 
-    def setTitleFromHandle(self, tHandle: str | None) -> None:
+    def setHandle(self, tHandle: str) -> None:
         """Sets the document title from the handle, or alternatively,
         set the whole document path.
         """
         self._docHandle = tHandle
-        if tHandle is None:
-            self.docTitle.setText("")
-            self.backButton.setVisible(False)
-            self.forwardButton.setVisible(False)
-            self.closeButton.setVisible(False)
-            self.refreshButton.setVisible(False)
-            return
-
-        pTree = SHARED.project.tree
+
         if CONFIG.showFullPath:
-            tTitle = []
-            tTree = pTree.getItemPath(tHandle)
-            for aHandle in reversed(tTree):
-                nwItem = pTree[aHandle]
-                if nwItem is not None:
-                    tTitle.append(nwItem.itemName)
-            sSep = "  %s  " % nwUnicode.U_RSAQUO
-            self.docTitle.setText(sSep.join(tTitle))
+            self.itemTitle.setText(f"  {nwUnicode.U_RSAQUO}  ".join(reversed(
+                [name for name in SHARED.project.tree.getItemPath(tHandle, asName=True)]
+            )))
         else:
-            if nwItem := pTree[tHandle]:
-                self.docTitle.setText(nwItem.itemName)
+            self.itemTitle.setText(i.itemName if (i := SHARED.project.tree[tHandle]) else "")
 
         self.backButton.setVisible(True)
         self.forwardButton.setVisible(True)
+        self.outlineButton.setVisible(True)
         self.closeButton.setVisible(True)
         self.refreshButton.setVisible(True)
 
@@ -815,15 +810,14 @@ class GuiDocViewHeader(QWidget):
     @pyqtSlot()
     def _closeDocument(self) -> None:
         """Trigger the close editor/viewer on the main window."""
-        self.mainGui.closeDocViewer()
+        self.clearHeader()
+        self.docViewer.closeDocumentRequest.emit()
         return
 
     @pyqtSlot()
     def _refreshDocument(self) -> None:
         """Reload the content of the document."""
-        if self.docViewer.docHandle == self.mainGui.docEditor.docHandle:
-            self.mainGui.saveDocument()
-        self.docViewer.reloadText()
+        self.docViewer.reloadDocumentRequest.emit()
         return
 
     ##
@@ -834,7 +828,7 @@ class GuiDocViewHeader(QWidget):
         """Capture a click on the title and ensure that the item is
         selected in the project tree.
         """
-        if event.button() == Qt.MouseButton.LeftButton:
+        if event.button() == QtMouseLeft:
             self.docViewer.requestProjectItemSelected.emit(self._docHandle, True)
         return
 
@@ -854,22 +848,21 @@ class GuiDocViewFooter(QWidget):
         logger.debug("Create: GuiDocViewFooter")
 
         self.docViewer = docViewer
-        self.mainGui   = docViewer.mainGui
 
         # Internal Variables
         self._docHandle = None
 
-        fPx = int(0.9*SHARED.theme.fontPixelSize)
+        iPx = SHARED.theme.baseIconHeight
+        iSz = SHARED.theme.baseIconSize
         hSp = CONFIG.pxInt(4)
+        mPx = CONFIG.pxInt(4)
 
         # Main Widget Settings
         self.setContentsMargins(0, 0, 0, 0)
         self.setAutoFillBackground(True)
 
         # Show/Hide Details
-        self.showHide = QToolButton(self)
-        self.showHide.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonIconOnly)
-        self.showHide.setIconSize(QSize(fPx, fPx))
+        self.showHide = NIconToolButton(self, iSz)
         self.showHide.clicked.connect(lambda: self.docViewer.togglePanelVisibility.emit())
         self.showHide.setToolTip(self.tr("Show/Hide Viewer Panel"))
 
@@ -879,7 +872,7 @@ class GuiDocViewFooter(QWidget):
         self.showComments.setCheckable(True)
         self.showComments.setChecked(CONFIG.viewComments)
         self.showComments.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonTextBesideIcon)
-        self.showComments.setIconSize(QSize(fPx, fPx))
+        self.showComments.setIconSize(iSz)
         self.showComments.toggled.connect(self._doToggleComments)
         self.showComments.setToolTip(self.tr("Show Comments"))
 
@@ -889,7 +882,7 @@ class GuiDocViewFooter(QWidget):
         self.showSynopsis.setCheckable(True)
         self.showSynopsis.setChecked(CONFIG.viewSynopsis)
         self.showSynopsis.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonTextBesideIcon)
-        self.showSynopsis.setIconSize(QSize(fPx, fPx))
+        self.showSynopsis.setIconSize(iSz)
         self.showSynopsis.toggled.connect(self._doToggleSynopsis)
         self.showSynopsis.setToolTip(self.tr("Show Synopsis Comments"))
 
@@ -909,10 +902,9 @@ class GuiDocViewFooter(QWidget):
 
         # Fix Margins and Size
         # This is needed for high DPI systems. See issue #499.
-        cM = CONFIG.pxInt(8)
         self.setContentsMargins(0, 0, 0, 0)
-        self.outerBox.setContentsMargins(cM, cM, cM, cM)
-        self.setMinimumHeight(fPx + 2*cM)
+        self.outerBox.setContentsMargins(mPx, mPx, mPx, mPx)
+        self.setMinimumHeight(iPx + 2*mPx)
 
         # Fix the Colours
         self.updateTheme()
@@ -931,16 +923,11 @@ class GuiDocViewFooter(QWidget):
         fPx = int(0.9*SHARED.theme.fontPixelSize)
         bulletIcon = SHARED.theme.getToggleIcon("bullet", (fPx, fPx))
 
-        self.showHide.setIcon(SHARED.theme.getIcon("panel"))
+        self.showHide.setThemeIcon("panel")
         self.showComments.setIcon(bulletIcon)
         self.showSynopsis.setIcon(bulletIcon)
 
-        colText = SHARED.theme.colText
-        buttonStyle = (
-            "QToolButton {{border: none; background: transparent;}} "
-            "QToolButton:hover {{border: none; background: rgba({0}, {1}, {2}, 0.2);}}"
-        ).format(colText.red(), colText.green(), colText.blue())
-
+        buttonStyle = SHARED.theme.getStyleSheet(STYLES_MIN_TOOLBUTTON)
         self.showHide.setStyleSheet(buttonStyle)
         self.showComments.setStyleSheet(buttonStyle)
         self.showSynopsis.setStyleSheet(buttonStyle)