novelWriter 2.2rc1__py3-none-any.whl → 2.3b1__py3-none-any.whl

novelwriter/gui/dochighlight.py

@@ -3,10 +3,11 @@ novelWriter – GUI Syntax Highlighter
 ====================================
 
 File History:
-Created: 2019-04-06 [0.0.1]
+Created: 2019-04-06 [0.0.1] GuiDocHighlighter
+Created: 2023-09-10 [2.2b1] TextBlockData
 
 This file is a part of novelWriter
-Copyright 2018–2023, Veronica Berglyd Olsen
+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
@@ -34,10 +35,10 @@ from PyQt5.QtGui import (
 )
 
 from novelwriter import CONFIG, SHARED
+from novelwriter.enum import nwComment
 from novelwriter.common import checkInt
 from novelwriter.constants import nwRegEx, nwUnicode
 from novelwriter.core.index import processComment
-from novelwriter.enum import nwComment
 
 logger = logging.getLogger(__name__)
 
@@ -47,6 +48,8 @@ SPELLRX.setPatternOptions(QRegularExpression.UseUnicodePropertiesOption)
 
 class GuiDocHighlighter(QSyntaxHighlighter):
 
+    __slots__ = ("_tItem", "_tHandle", "_spellCheck", "_spellErr", "_hRules", "_hStyles")
+
     BLOCK_NONE  = 0
     BLOCK_TEXT  = 1
     BLOCK_META  = 2
@@ -57,29 +60,14 @@ class GuiDocHighlighter(QSyntaxHighlighter):
 
         logger.debug("Create: GuiDocHighlighter")
 
-        self._tItem      = None
-        self._tHandle    = None
+        self._tHandle = None
+        self._isInactive = False
         self._spellCheck = False
+        self._spellErr = QTextCharFormat()
 
         self._hRules: list[tuple[str, dict]] = []
         self._hStyles: dict[str, QTextCharFormat] = {}
 
-        self._colHead   = QColor(0, 0, 0)
-        self._colHeadH  = QColor(0, 0, 0)
-        self._colEmph   = QColor(0, 0, 0)
-        self._colDialN  = QColor(0, 0, 0)
-        self._colDialD  = QColor(0, 0, 0)
-        self._colDialS  = QColor(0, 0, 0)
-        self._colHidden = QColor(0, 0, 0)
-        self._colCode   = QColor(0, 0, 0)
-        self._colKey    = QColor(0, 0, 0)
-        self._colVal    = QColor(0, 0, 0)
-        self._colSpell  = QColor(0, 0, 0)
-        self._colError  = QColor(0, 0, 0)
-        self._colRepTag = QColor(0, 0, 0)
-        self._colMod    = QColor(0, 0, 0)
-        self._colBreak  = QColor(0, 0, 0)
-
         self.initHighlighter()
 
         logger.debug("Ready: GuiDocHighlighter")
@@ -92,54 +80,43 @@ class GuiDocHighlighter(QSyntaxHighlighter):
         """
         logger.debug("Setting up highlighting rules")
 
-        self._colHead   = QColor(*SHARED.theme.colHead)
-        self._colHeadH  = QColor(*SHARED.theme.colHeadH)
-        self._colDialN  = QColor(*SHARED.theme.colDialN)
-        self._colDialD  = QColor(*SHARED.theme.colDialD)
-        self._colDialS  = QColor(*SHARED.theme.colDialS)
-        self._colHidden = QColor(*SHARED.theme.colHidden)
-        self._colCode   = QColor(*SHARED.theme.colCode)
-        self._colKey    = QColor(*SHARED.theme.colKey)
-        self._colVal    = QColor(*SHARED.theme.colVal)
-        self._colSpell  = QColor(*SHARED.theme.colSpell)
-        self._colError  = QColor(*SHARED.theme.colError)
-        self._colRepTag = QColor(*SHARED.theme.colRepTag)
-        self._colMod    = QColor(*SHARED.theme.colMod)
-        self._colBreak  = QColor(*SHARED.theme.colEmph)
-        self._colBreak.setAlpha(64)
-
-        self._colEmph = None
-        if CONFIG.highlightEmph:
-            self._colEmph = QColor(*SHARED.theme.colEmph)
+        colEmph = SHARED.theme.colEmph if CONFIG.highlightEmph else None
+        colBreak = QColor(SHARED.theme.colEmph)
+        colBreak.setAlpha(64)
 
+        self._hRules = []
         self._hStyles = {
-            "header1":   self._makeFormat(self._colHead, "bold", 1.8),
-            "header2":   self._makeFormat(self._colHead, "bold", 1.6),
-            "header3":   self._makeFormat(self._colHead, "bold", 1.4),
-            "header4":   self._makeFormat(self._colHead, "bold", 1.2),
-            "header1h":  self._makeFormat(self._colHeadH, "bold", 1.8),
-            "header2h":  self._makeFormat(self._colHeadH, "bold", 1.6),
-            "header3h":  self._makeFormat(self._colHeadH, "bold", 1.4),
-            "header4h":  self._makeFormat(self._colHeadH, "bold", 1.2),
-            "bold":      self._makeFormat(self._colEmph, "bold"),
-            "italic":    self._makeFormat(self._colEmph, "italic"),
-            "strike":    self._makeFormat(self._colHidden, "strike"),
-            "mspaces":   self._makeFormat(self._colError, "errline"),
-            "nobreak":   self._makeFormat(self._colBreak, "background"),
-            "dialogue1": self._makeFormat(self._colDialN),
-            "dialogue2": self._makeFormat(self._colDialD),
-            "dialogue3": self._makeFormat(self._colDialS),
-            "replace":   self._makeFormat(self._colRepTag),
-            "hidden":    self._makeFormat(self._colHidden),
-            "code":      self._makeFormat(self._colCode),
-            "keyword":   self._makeFormat(self._colKey),
-            "modifier":  self._makeFormat(self._colMod),
-            "value":     self._makeFormat(self._colVal, "underline"),
-            "codevalue": self._makeFormat(self._colVal),
+            "header1":   self._makeFormat(SHARED.theme.colHead, "bold", 1.8),
+            "header2":   self._makeFormat(SHARED.theme.colHead, "bold", 1.6),
+            "header3":   self._makeFormat(SHARED.theme.colHead, "bold", 1.4),
+            "header4":   self._makeFormat(SHARED.theme.colHead, "bold", 1.2),
+            "header1h":  self._makeFormat(SHARED.theme.colHeadH, "bold", 1.8),
+            "header2h":  self._makeFormat(SHARED.theme.colHeadH, "bold", 1.6),
+            "header3h":  self._makeFormat(SHARED.theme.colHeadH, "bold", 1.4),
+            "header4h":  self._makeFormat(SHARED.theme.colHeadH, "bold", 1.2),
+            "bold":      self._makeFormat(colEmph, "bold"),
+            "italic":    self._makeFormat(colEmph, "italic"),
+            "strike":    self._makeFormat(SHARED.theme.colHidden, "strike"),
+            "mspaces":   self._makeFormat(SHARED.theme.colError, "errline"),
+            "nobreak":   self._makeFormat(colBreak, "background"),
+            "dialogue1": self._makeFormat(SHARED.theme.colDialN),
+            "dialogue2": self._makeFormat(SHARED.theme.colDialD),
+            "dialogue3": self._makeFormat(SHARED.theme.colDialS),
+            "replace":   self._makeFormat(SHARED.theme.colRepTag),
+            "hidden":    self._makeFormat(SHARED.theme.colHidden),
+            "code":      self._makeFormat(SHARED.theme.colCode),
+            "keyword":   self._makeFormat(SHARED.theme.colKey),
+            "modifier":  self._makeFormat(SHARED.theme.colMod),
+            "value":     self._makeFormat(SHARED.theme.colVal),
+            "optional":  self._makeFormat(SHARED.theme.colOpt),
+            "codevalue": self._makeFormat(SHARED.theme.colVal),
             "codeinval": self._makeFormat(None, "errline"),
         }
 
-        self._hRules = []
+        # Cache Spell Error Format
+        self._spellErr = QTextCharFormat()
+        self._spellErr.setUnderlineColor(SHARED.theme.colSpell)
+        self._spellErr.setUnderlineStyle(QTextCharFormat.SpellCheckUnderline)
 
         # Multiple or Trailing Spaces
         if CONFIG.showMultiSpaces:
@@ -261,11 +238,10 @@ class GuiDocHighlighter(QSyntaxHighlighter):
     def setHandle(self, tHandle: str) -> None:
         """Set the handle of the currently highlighted document."""
         self._tHandle = tHandle
-        self._tItem = SHARED.project.tree[tHandle]
-        logger.debug(
-            "Syntax highlighter %s for item '%s'",
-            "enabled" if self._tItem else "disabled", tHandle
+        self._isInactive = (
+            item.isInactiveClass() if (item := SHARED.project.tree[tHandle]) else False
         )
+        logger.debug("Syntax highlighter enabled for item '%s'", tHandle)
         return
 
     ##
@@ -280,9 +256,9 @@ class GuiDocHighlighter(QSyntaxHighlighter):
         nBlocks = qDoc.blockCount()
         tStart = time()
         for i in range(nBlocks):
-            theBlock = qDoc.findBlockByNumber(i)
-            if theBlock.userState() & cType > 0:
-                self.rehighlightBlock(theBlock)
+            block = qDoc.findBlockByNumber(i)
+            if block.userState() & cType > 0:
+                self.rehighlightBlock(block)
         logger.debug("Document highlighted in %.3f ms" % (1000*(time() - tStart)))
         return
 
@@ -302,24 +278,23 @@ class GuiDocHighlighter(QSyntaxHighlighter):
 
         if text.startswith("@"):  # Keywords and commands
             self.setCurrentBlockState(self.BLOCK_META)
-            if self._tItem:
-                pIndex = SHARED.project.index
-                isValid, theBits, thePos = pIndex.scanThis(text)
-                isGood = pIndex.checkThese(theBits, self._tItem)
-                if isValid:
-                    for n, theBit in enumerate(theBits):
-                        xPos = thePos[n]
-                        xLen = len(theBit)
-                        if isGood[n]:
-                            if n == 0:
-                                self.setFormat(xPos, xLen, self._hStyles["keyword"])
-                            else:
-                                self.setFormat(xPos, xLen, self._hStyles["value"])
-                        else:
-                            kwFmt = self.format(xPos)
-                            kwFmt.setUnderlineColor(self._colError)
-                            kwFmt.setUnderlineStyle(QTextCharFormat.SpellCheckUnderline)
-                            self.setFormat(xPos, xLen, kwFmt)
+            index = SHARED.project.index
+            isValid, bits, pos = index.scanThis(text)
+            isGood = index.checkThese(bits, self._tHandle)
+            if isValid:
+                for n, bit in enumerate(bits):
+                    xPos = pos[n]
+                    xLen = len(bit)
+                    if n == 0 and isGood[n]:
+                        self.setFormat(xPos, xLen, self._hStyles["keyword"])
+                    elif isGood[n] and not self._isInactive:
+                        one, two = index.parseValue(bit)
+                        self.setFormat(xPos, len(one), self._hStyles["value"])
+                        if two:
+                            yPos = xPos + len(bit) - len(two)
+                            self.setFormat(yPos, len(two), self._hStyles["optional"])
+                    elif not self._isInactive:
+                        self.setFormat(xPos, xLen, self._hStyles["codeinval"])
 
             # We never want to run the spell checker on keyword/values,
             # so we force a return here
@@ -401,8 +376,7 @@ class GuiDocHighlighter(QSyntaxHighlighter):
             for xPos, xLen in data.spellCheck(text):
                 for x in range(xPos, xPos+xLen):
                     spFmt = self.format(x)
-                    spFmt.setUnderlineColor(self._colSpell)
-                    spFmt.setUnderlineStyle(QTextCharFormat.SpellCheckUnderline)
+                    spFmt.merge(self._spellErr)
                     self.setFormat(x, 1, spFmt)
 
         return
@@ -430,10 +404,8 @@ class GuiDocHighlighter(QSyntaxHighlighter):
             if "strike" in styles:
                 charFormat.setFontStrikeOut(True)
             if "errline" in styles:
-                charFormat.setUnderlineColor(self._colError)
+                charFormat.setUnderlineColor(SHARED.theme.colError)
                 charFormat.setUnderlineStyle(QTextCharFormat.SpellCheckUnderline)
-            if "underline" in styles:
-                charFormat.setFontUnderline(True)
             if "background" in styles and color is not None:
                 charFormat.setBackground(QBrush(color, Qt.SolidPattern))
 

novelwriter/gui/docviewer.py

@@ -9,7 +9,7 @@ Created: 2020-06-09 [0.8]   GuiDocViewFooter
 Created: 2020-09-08 [1.0b1] GuiDocViewHistory
 
 This file is a part of novelWriter
-Copyright 2018–2023, Veronica Berglyd Olsen
+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
@@ -33,7 +33,7 @@ from typing import TYPE_CHECKING
 
 from PyQt5.QtCore import pyqtSignal, pyqtSlot, QPoint, QSize, Qt, QUrl
 from PyQt5.QtGui import (
-    QColor, QCursor, QFont, QMouseEvent, QPalette, QResizeEvent, QTextCursor,
+    QCursor, QFont, QMouseEvent, QPalette, QResizeEvent, QTextCursor,
     QTextOption
 )
 from PyQt5.QtWidgets import (
@@ -46,7 +46,7 @@ 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.wheeleventfilter import WheelEventFilter
+from novelwriter.extensions.eventfilters import WheelEventFilter
 
 if TYPE_CHECKING:  # pragma: no cover
     from novelwriter.guimain import GuiMain
@@ -142,21 +142,21 @@ class GuiDocViewer(QTextBrowser):
         self._makeStyleSheet()
 
         # Set Font
-        textFont = QFont()
-        textFont.setFamily(CONFIG.textFont)
-        textFont.setPointSize(CONFIG.textSize)
-        self.setFont(textFont)
+        font = QFont()
+        font.setFamily(CONFIG.textFont)
+        font.setPointSize(CONFIG.textSize)
+        self.setFont(font)
 
         # Set the widget colours to match syntax theme
         mainPalette = self.palette()
-        mainPalette.setColor(QPalette.ColorRole.Window, QColor(*SHARED.theme.colBack))
-        mainPalette.setColor(QPalette.ColorRole.Base, QColor(*SHARED.theme.colBack))
-        mainPalette.setColor(QPalette.ColorRole.Text, QColor(*SHARED.theme.colText))
+        mainPalette.setColor(QPalette.ColorRole.Window, SHARED.theme.colBack)
+        mainPalette.setColor(QPalette.ColorRole.Base, SHARED.theme.colBack)
+        mainPalette.setColor(QPalette.ColorRole.Text, SHARED.theme.colText)
         self.setPalette(mainPalette)
 
         docPalette = self.viewport().palette()
-        docPalette.setColor(QPalette.ColorRole.Base, QColor(*SHARED.theme.colBack))
-        docPalette.setColor(QPalette.ColorRole.Text, QColor(*SHARED.theme.colText))
+        docPalette.setColor(QPalette.ColorRole.Base, SHARED.theme.colBack)
+        docPalette.setColor(QPalette.ColorRole.Text, SHARED.theme.colText)
         self.viewport().setPalette(docPalette)
 
         self.docHeader.matchColours()
@@ -164,10 +164,10 @@ class GuiDocViewer(QTextBrowser):
 
         # Set default text margins
         self.document().setDocumentMargin(0)
-        theOpt = QTextOption()
+        options = QTextOption()
         if CONFIG.doJustify:
-            theOpt.setAlignment(Qt.AlignmentFlag.AlignJustify)
-        self.document().setDefaultTextOption(theOpt)
+            options.setAlignment(Qt.AlignmentFlag.AlignJustify)
+        self.document().setDefaultTextOption(options)
 
         # Scroll bars
         if CONFIG.hideVScroll:
@@ -229,7 +229,7 @@ class GuiDocViewer(QTextBrowser):
         self.setDocumentTitle(tHandle)
 
         # Replace tabs before setting the HTML, and then put them back in
-        self.setHtml(aDoc.theResult.replace("\t", "!!tab!!"))
+        self.setHtml(aDoc.result.replace("\t", "!!tab!!"))
         while self.find("!!tab!!"):
             self.textCursor().insertText("\t")
 
@@ -367,9 +367,9 @@ class GuiDocViewer(QTextBrowser):
         link = url.url()
         logger.debug("Clicked link: '%s'", link)
         if len(link) > 0:
-            theBits = link.split("=")
-            if len(theBits) == 2:
-                self.loadDocumentTagRequest.emit(theBits[1], nwDocMode.VIEW)
+            bits = link.split("=")
+            if len(bits) == 2:
+                self.loadDocumentTagRequest.emit(bits[1], nwDocMode.VIEW)
         return
 
     @pyqtSlot("QPoint")
@@ -378,33 +378,34 @@ class GuiDocViewer(QTextBrowser):
         userCursor = self.textCursor()
         userSelection = userCursor.hasSelection()
 
-        mnuContext = QMenu(self)
+        ctxMenu = QMenu(self)
 
         if userSelection:
-            mnuCopy = QAction(self.tr("Copy"), mnuContext)
+            mnuCopy = QAction(self.tr("Copy"), ctxMenu)
             mnuCopy.triggered.connect(lambda: self.docAction(nwDocAction.COPY))
-            mnuContext.addAction(mnuCopy)
+            ctxMenu.addAction(mnuCopy)
 
-            mnuContext.addSeparator()
+            ctxMenu.addSeparator()
 
-        mnuSelAll = QAction(self.tr("Select All"), mnuContext)
+        mnuSelAll = QAction(self.tr("Select All"), ctxMenu)
         mnuSelAll.triggered.connect(lambda: self.docAction(nwDocAction.SEL_ALL))
-        mnuContext.addAction(mnuSelAll)
+        ctxMenu.addAction(mnuSelAll)
 
-        mnuSelWord = QAction(self.tr("Select Word"), mnuContext)
+        mnuSelWord = QAction(self.tr("Select Word"), ctxMenu)
         mnuSelWord.triggered.connect(
             lambda: self._makePosSelection(QTextCursor.SelectionType.WordUnderCursor, point)
         )
-        mnuContext.addAction(mnuSelWord)
+        ctxMenu.addAction(mnuSelWord)
 
-        mnuSelPara = QAction(self.tr("Select Paragraph"), mnuContext)
+        mnuSelPara = QAction(self.tr("Select Paragraph"), ctxMenu)
         mnuSelPara.triggered.connect(
             lambda: self._makePosSelection(QTextCursor.SelectionType.BlockUnderCursor, point)
         )
-        mnuContext.addAction(mnuSelPara)
+        ctxMenu.addAction(mnuSelPara)
 
         # Open the context menu
-        mnuContext.exec_(self.viewport().mapToGlobal(point))
+        ctxMenu.exec_(self.viewport().mapToGlobal(point))
+        ctxMenu.deleteLater()
 
         return
 
@@ -460,9 +461,16 @@ class GuiDocViewer(QTextBrowser):
 
     def _makeStyleSheet(self) -> None:
         """Generate an appropriate style sheet for the document viewer,
-        based on the current syntax highlighter theme,
+        based on the current syntax highlighter theme.
         """
-        pTheme = SHARED.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});"
@@ -479,6 +487,9 @@ class GuiDocViewer(QTextBrowser):
             ".tags {{"
             "  color: rgb({kColR}, {kColG}, {kColB});"
             "}}\n"
+            ".optional {{"
+            "  color: rgb({oColR}, {oColG}, {oColB});"
+            "}}\n"
             ".comment {{"
             "  color: rgb({cColR}, {cColG}, {cColB});"
             "}}\n"
@@ -489,27 +500,14 @@ class GuiDocViewer(QTextBrowser):
             "  text-align: center;"
             "}}\n"
         ).format(
-            tColR=pTheme.colText[0],
-            tColG=pTheme.colText[1],
-            tColB=pTheme.colText[2],
-            hColR=pTheme.colHead[0],
-            hColG=pTheme.colHead[1],
-            hColB=pTheme.colHead[2],
-            aColR=pTheme.colVal[0],
-            aColG=pTheme.colVal[1],
-            aColB=pTheme.colVal[2],
-            eColR=pTheme.colEmph[0],
-            eColG=pTheme.colEmph[1],
-            eColB=pTheme.colEmph[2],
-            kColR=pTheme.colKey[0],
-            kColG=pTheme.colKey[1],
-            kColB=pTheme.colKey[2],
-            cColR=pTheme.colHidden[0],
-            cColG=pTheme.colHidden[1],
-            cColB=pTheme.colHidden[2],
-            mColR=pTheme.colMod[0],
-            mColG=pTheme.colMod[1],
-            mColB=pTheme.colMod[2],
+            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(),
         )
         self.document().setDefaultStyleSheet(styleSheet)
 
@@ -743,10 +741,11 @@ class GuiDocViewHeader(QWidget):
         self.refreshButton.setIcon(SHARED.theme.getIcon("refresh"))
         self.closeButton.setIcon(SHARED.theme.getIcon("close"))
 
+        colText = SHARED.theme.colText
         buttonStyle = (
             "QToolButton {{border: none; background: transparent;}} "
-            "QToolButton:hover {{border: none; background: rgba({0},{1},{2},0.2);}}"
-        ).format(*SHARED.theme.colText)
+            "QToolButton:hover {{border: none; background: rgba({0}, {1}, {2}, 0.2);}}"
+        ).format(colText.red(), colText.green(), colText.blue())
 
         self.backButton.setStyleSheet(buttonStyle)
         self.forwardButton.setStyleSheet(buttonStyle)
@@ -762,9 +761,9 @@ class GuiDocViewHeader(QWidget):
         theme rather than the main GUI.
         """
         palette = QPalette()
-        palette.setColor(QPalette.ColorRole.Window, QColor(*SHARED.theme.colBack))
-        palette.setColor(QPalette.ColorRole.WindowText, QColor(*SHARED.theme.colText))
-        palette.setColor(QPalette.ColorRole.Text, QColor(*SHARED.theme.colText))
+        palette.setColor(QPalette.ColorRole.Window, SHARED.theme.colBack)
+        palette.setColor(QPalette.ColorRole.WindowText, SHARED.theme.colText)
+        palette.setColor(QPalette.ColorRole.Text, SHARED.theme.colText)
         self.setPalette(palette)
         self.docTitle.setPalette(palette)
         return
@@ -861,8 +860,7 @@ class GuiDocViewFooter(QWidget):
         self._docHandle = None
 
         fPx = int(0.9*SHARED.theme.fontPixelSize)
-        bSp = CONFIG.pxInt(2)
-        hSp = CONFIG.pxInt(8)
+        hSp = CONFIG.pxInt(4)
 
         # Main Widget Settings
         self.setContentsMargins(0, 0, 0, 0)
@@ -872,64 +870,41 @@ class GuiDocViewFooter(QWidget):
         self.showHide = QToolButton(self)
         self.showHide.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonIconOnly)
         self.showHide.setIconSize(QSize(fPx, fPx))
-        self.showHide.setFixedSize(QSize(fPx, fPx))
         self.showHide.clicked.connect(lambda: self.docViewer.togglePanelVisibility.emit())
         self.showHide.setToolTip(self.tr("Show/Hide Viewer Panel"))
 
         # Show Comments
         self.showComments = QToolButton(self)
+        self.showComments.setText(self.tr("Comments"))
         self.showComments.setCheckable(True)
         self.showComments.setChecked(CONFIG.viewComments)
-        self.showComments.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonIconOnly)
+        self.showComments.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonTextBesideIcon)
         self.showComments.setIconSize(QSize(fPx, fPx))
-        self.showComments.setFixedSize(QSize(fPx, fPx))
         self.showComments.toggled.connect(self._doToggleComments)
         self.showComments.setToolTip(self.tr("Show Comments"))
 
         # Show Synopsis
         self.showSynopsis = QToolButton(self)
+        self.showSynopsis.setText(self.tr("Synopsis"))
         self.showSynopsis.setCheckable(True)
         self.showSynopsis.setChecked(CONFIG.viewSynopsis)
-        self.showSynopsis.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonIconOnly)
+        self.showSynopsis.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonTextBesideIcon)
         self.showSynopsis.setIconSize(QSize(fPx, fPx))
-        self.showSynopsis.setFixedSize(QSize(fPx, fPx))
         self.showSynopsis.toggled.connect(self._doToggleSynopsis)
         self.showSynopsis.setToolTip(self.tr("Show Synopsis Comments"))
 
-        # Labels
-        self.lblComments = QLabel(self.tr("Comments"))
-        self.lblComments.setBuddy(self.showComments)
-        self.lblComments.setIndent(0)
-        self.lblComments.setMargin(0)
-        self.lblComments.setContentsMargins(0, 0, 0, 0)
-        self.lblComments.setAutoFillBackground(True)
-        self.lblComments.setFixedHeight(fPx)
-        self.lblComments.setAlignment(Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignTop)
-
-        self.lblSynopsis = QLabel(self.tr("Synopsis"))
-        self.lblSynopsis.setBuddy(self.showSynopsis)
-        self.lblSynopsis.setIndent(0)
-        self.lblSynopsis.setMargin(0)
-        self.lblSynopsis.setContentsMargins(0, 0, 0, 0)
-        self.lblSynopsis.setAutoFillBackground(True)
-        self.lblSynopsis.setFixedHeight(fPx)
-        self.lblSynopsis.setAlignment(Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignTop)
-
         lblFont = self.font()
         lblFont.setPointSizeF(0.9*SHARED.theme.fontPointSize)
-        self.lblComments.setFont(lblFont)
-        self.lblSynopsis.setFont(lblFont)
+        self.showComments.setFont(lblFont)
+        self.showSynopsis.setFont(lblFont)
 
         # Assemble Layout
         self.outerBox = QHBoxLayout()
-        self.outerBox.setSpacing(bSp)
         self.outerBox.addWidget(self.showHide, 0)
         self.outerBox.addStretch(1)
         self.outerBox.addWidget(self.showComments, 0)
-        self.outerBox.addWidget(self.lblComments, 0)
-        self.outerBox.addSpacing(hSp)
         self.outerBox.addWidget(self.showSynopsis, 0)
-        self.outerBox.addWidget(self.lblSynopsis, 0)
+        self.outerBox.setSpacing(hSp)
         self.setLayout(self.outerBox)
 
         # Fix Margins and Size
@@ -960,11 +935,11 @@ class GuiDocViewFooter(QWidget):
         self.showComments.setIcon(bulletIcon)
         self.showSynopsis.setIcon(bulletIcon)
 
-        # StyleSheets
+        colText = SHARED.theme.colText
         buttonStyle = (
             "QToolButton {{border: none; background: transparent;}} "
-            "QToolButton:hover {{border: none; background: rgba({0},{1},{2},0.2);}}"
-        ).format(*SHARED.theme.colText)
+            "QToolButton:hover {{border: none; background: rgba({0}, {1}, {2}, 0.2);}}"
+        ).format(colText.red(), colText.green(), colText.blue())
 
         self.showHide.setStyleSheet(buttonStyle)
         self.showComments.setStyleSheet(buttonStyle)
@@ -979,12 +954,10 @@ class GuiDocViewFooter(QWidget):
         theme rather than the main GUI.
         """
         palette = QPalette()
-        palette.setColor(QPalette.ColorRole.Window, QColor(*SHARED.theme.colBack))
-        palette.setColor(QPalette.ColorRole.WindowText, QColor(*SHARED.theme.colText))
-        palette.setColor(QPalette.ColorRole.Text, QColor(*SHARED.theme.colText))
+        palette.setColor(QPalette.ColorRole.Window, SHARED.theme.colBack)
+        palette.setColor(QPalette.ColorRole.WindowText, SHARED.theme.colText)
+        palette.setColor(QPalette.ColorRole.Text, SHARED.theme.colText)
         self.setPalette(palette)
-        self.lblComments.setPalette(palette)
-        self.lblSynopsis.setPalette(palette)
         return
 
     ##