novelWriter 2.2.1__py3-none-any.whl → 2.3b1__py3-none-any.whl

novelwriter/gui/dochighlight.py

@@ -35,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__)
 
@@ -48,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
@@ -58,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")
@@ -93,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:
@@ -262,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
 
     ##
@@ -281,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
 
@@ -303,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
@@ -402,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
@@ -431,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

@@ -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 (
@@ -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")
@@ -461,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});"
@@ -480,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"
@@ -490,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)
 
@@ -744,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)
@@ -763,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
@@ -937,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)
@@ -956,9 +954,9 @@ 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)
         return
 

novelwriter/gui/docviewerpanel.py

@@ -29,8 +29,8 @@ from enum import Enum
 
 from PyQt5.QtCore import QModelIndex, QSize, Qt, pyqtSignal, pyqtSlot
 from PyQt5.QtWidgets import (
-    QAbstractItemView, QFrame, QHeaderView, QTabWidget, QTreeWidget,
-    QTreeWidgetItem, QVBoxLayout, QWidget
+    QAbstractItemView, QFrame, QHeaderView, QMenu, QTabWidget, QToolButton,
+    QTreeWidget, QTreeWidgetItem, QVBoxLayout, QWidget
 )
 
 from novelwriter import CONFIG, SHARED
@@ -54,10 +54,24 @@ class GuiDocViewerPanel(QWidget):
 
         self._lastHandle = None
 
+        iPx = int(1.0*SHARED.theme.baseIconSize)
+
         self.tabBackRefs = _ViewPanelBackRefs(self)
 
+        self.optsMenu = QMenu(self)
+
+        self.aInactive = self.optsMenu.addAction(self.tr("Hide Inactive Tags"))
+        self.aInactive.setCheckable(True)
+        self.aInactive.toggled.connect(self._toggleHideInactive)
+
+        self.optsButton = QToolButton(self)
+        self.optsButton.setIconSize(QSize(iPx, iPx))
+        self.optsButton.setMenu(self.optsMenu)
+        self.optsButton.setPopupMode(QToolButton.ToolButtonPopupMode.InstantPopup)
+
         self.mainTabs = QTabWidget(self)
         self.mainTabs.addTab(self.tabBackRefs, self.tr("References"))
+        self.mainTabs.setCornerWidget(self.optsButton, Qt.Corner.TopLeftCorner)
 
         self.kwTabs: dict[str, _ViewPanelKeyWords] = {}
         self.idTabs: dict[str, int] = {}
@@ -85,20 +99,27 @@ class GuiDocViewerPanel(QWidget):
 
     def updateTheme(self, updateTabs: bool = True) -> None:
         """Update theme elements."""
+        qPalette = self.palette()
+        mPx = CONFIG.pxInt(2)
         vPx = CONFIG.pxInt(4)
-        lPx = CONFIG.pxInt(2)
-        rPx = CONFIG.pxInt(14)
-        hCol = self.palette().highlight().color()
+        hPx = CONFIG.pxInt(8)
+        hCol = qPalette.highlight().color()
+        fCol = qPalette.text().color()
+
+        buttonStyle = (
+            "QToolButton {{padding: {0}px; margin: 0 0 {1}px 0; border: none; "
+            "background: transparent;}} "
+            "QToolButton:hover {{border: none; background: rgba({2}, {3}, {4}, 0.2);}} "
+            "QToolButton::menu-indicator {{image: none;}} "
+        ).format(mPx, mPx, fCol.red(), fCol.green(), fCol.blue())
+        self.optsButton.setIcon(SHARED.theme.getIcon("menu"))
+        self.optsButton.setStyleSheet(buttonStyle)
 
         styleSheet = (
-            "QTabWidget::pane {border: 0;} "
-            "QTabWidget QTabBar::tab {"
-            f"border: 0; padding: {vPx}px {rPx}px {vPx}px {lPx}px;"
-            "} "
-            "QTabWidget QTabBar::tab:selected {"
-            f"color: rgb({hCol.red()}, {hCol.green()}, {hCol.blue()});"
-            "} "
-        )
+            "QTabWidget::pane {{border: 0;}} "
+            "QTabWidget QTabBar::tab {{border: 0; padding: {0}px {1}px;}} "
+            "QTabWidget QTabBar::tab:selected {{color: rgb({2}, {3}, {4});}} "
+        ).format(vPx, hPx, hCol.red(), hCol.green(), hCol.blue())
         self.mainTabs.setStyleSheet(styleSheet)
         self.updateHandle(self._lastHandle)
 
@@ -111,20 +132,22 @@ class GuiDocViewerPanel(QWidget):
 
     def openProjectTasks(self) -> None:
         """Run open project tasks."""
-        widths = SHARED.project.options.getValue("GuiDocViewerPanel", "colWidths", {})
-        if isinstance(widths, dict):
-            for key, value in widths.items():
+        colWidths = SHARED.project.options.getValue("GuiDocViewerPanel", "colWidths", {})
+        hideInactive = SHARED.project.options.getBool("GuiDocViewerPanel", "hideInactive", False)
+        self.aInactive.setChecked(hideInactive)
+        if isinstance(colWidths, dict):
+            for key, value in colWidths.items():
                 if key in self.kwTabs and isinstance(value, list):
                     self.kwTabs[key].setColumnWidths(value)
         return
 
     def closeProjectTasks(self) -> None:
         """Run close project tasks."""
-        widths = {}
-        for key, tab in self.kwTabs.items():
-            widths[key] = tab.getColumnWidths()
         logger.debug("Saving State: GuiDocViewerPanel")
-        SHARED.project.options.setValue("GuiDocViewerPanel", "colWidths", widths)
+        colWidths = {k: t.getColumnWidths() for k, t in self.kwTabs.items()}
+        hideInactive = self.aInactive.isChecked()
+        SHARED.project.options.setValue("GuiDocViewerPanel", "colWidths", colWidths)
+        SHARED.project.options.setValue("GuiDocViewerPanel", "hideInactive", hideInactive)
         return
 
     ##
@@ -142,9 +165,7 @@ class GuiDocViewerPanel(QWidget):
     @pyqtSlot()
     def indexHasAppeared(self) -> None:
         """Handle event when the index has appeared."""
-        for key, name, tClass, iItem, hItem in SHARED.project.index.getTagsData():
-            if tClass in self.kwTabs and iItem and hItem:
-                self.kwTabs[tClass].addUpdateEntry(key, name, iItem, hItem)
+        self._loadAllTags()
         self._updateTabVisibility()
         self.updateHandle(self._lastHandle)
         return
@@ -153,10 +174,15 @@ class GuiDocViewerPanel(QWidget):
     def projectItemChanged(self, tHandle: str) -> None:
         """Update meta data for project item."""
         self.tabBackRefs.refreshDocument(tHandle)
+        activeOnly = self.aInactive.isChecked()
         for key in SHARED.project.index.getDocumentTags(tHandle):
             name, tClass, iItem, hItem = SHARED.project.index.getSingleTag(key)
             if tClass in self.kwTabs and iItem and hItem:
-                self.kwTabs[tClass].addUpdateEntry(key, name, iItem, hItem)
+                if not activeOnly or (iItem and iItem.item.isActive):
+                    self.kwTabs[tClass].addUpdateEntry(key, name, iItem, hItem)
+                else:
+                    self.kwTabs[tClass].removeEntry(key)
+        self._updateTabVisibility()
         return
 
     @pyqtSlot(str)
@@ -182,6 +208,20 @@ class GuiDocViewerPanel(QWidget):
         self._updateTabVisibility()
         return
 
+    ##
+    #  Private Slots
+    ##
+
+    @pyqtSlot(bool)
+    def _toggleHideInactive(self, state: bool) -> None:
+        """Process toggling of active/inactive visibility."""
+        logger.debug("Setting inactive items to %s", "hidden" if state else "visible")
+        for cTab in self.kwTabs.values():
+            cTab.clearContent()
+        self._loadAllTags()
+        self._updateTabVisibility()
+        return
+
     ##
     #  Internal Functions
     ##
@@ -193,6 +233,14 @@ class GuiDocViewerPanel(QWidget):
                 self.mainTabs.setTabVisible(self.idTabs[tClass], cTab.countEntries() > 0)
         return
 
+    def _loadAllTags(self) -> None:
+        """Load all tags into the tabs."""
+        data = SHARED.project.index.getTagsData(activeOnly=self.aInactive.isChecked())
+        for key, name, tClass, iItem, hItem in data:
+            if tClass in self.kwTabs and iItem and hItem:
+                self.kwTabs[tClass].addUpdateEntry(key, name, iItem, hItem)
+        return
+
 # END Class GuiDocViewerPanel
 
 

novelwriter/gui/itemdetails.py

@@ -239,9 +239,9 @@ class GuiItemDetails(QWidget):
         # Label
         # =====
 
-        theLabel = nwItem.itemName
-        if len(theLabel) > 100:
-            theLabel = theLabel[:96].rstrip()+" ..."
+        label = nwItem.itemName
+        if len(label) > 100:
+            label = label[:96].rstrip()+" ..."
 
         if nwItem.isFileType():
             if nwItem.isActive:
@@ -251,14 +251,14 @@ class GuiItemDetails(QWidget):
         else:
             self.labelIcon.setPixmap(SHARED.theme.getPixmap("noncheckable", (iPx, iPx)))
 
-        self.labelData.setText(theLabel)
+        self.labelData.setText(label)
 
         # Status
         # ======
 
-        theStatus, theIcon = nwItem.getImportStatus(incIcon=True)
-        self.statusIcon.setPixmap(theIcon.pixmap(iPx, iPx))
-        self.statusData.setText(theStatus)
+        status, icon = nwItem.getImportStatus(incIcon=True)
+        self.statusIcon.setPixmap(icon.pixmap(iPx, iPx))
+        self.statusData.setText(status)
 
         # Class
         # =====