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

novelwriter/gui/noveltree.py

@@ -8,7 +8,7 @@ Created: 2022-06-12 [2.0rc1] GuiNovelView
 Created: 2022-06-12 [2.0rc1] GuiNovelToolBar
 
 This file is a part of novelWriter
-Copyright 2018–2020, 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
@@ -145,6 +145,7 @@ class GuiNovelView(QWidget):
         """Run closing project tasks."""
         lastColType = self.novelTree.lastColType
         lastColSize = self.novelTree.lastColSize
+        logger.debug("Saving State: GuiNovelView")
         pOptions = SHARED.project.options
         pOptions.setValue("GuiNovelView", "lastCol", lastColType)
         pOptions.setValue("GuiNovelView", "lastColSize", lastColSize)
@@ -205,18 +206,19 @@ class GuiNovelToolBar(QWidget):
 
         # Novel Selector
         selFont = self.font()
-        selFont.setWeight(QFont.Bold)
-        self.novelPrefix = self.tr("Outline of {0}")
+        selFont.setWeight(QFont.Weight.Bold)
+
         self.novelValue = NovelSelector(self)
         self.novelValue.setFont(selFont)
+        self.novelValue.setListFormat(self.tr("Outline of {0}"))
         self.novelValue.setMinimumWidth(CONFIG.pxInt(150))
-        self.novelValue.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
+        self.novelValue.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
         self.novelValue.novelSelectionChanged.connect(self.setCurrentRoot)
 
         self.tbNovel = QToolButton(self)
         self.tbNovel.setToolTip(self.tr("Novel Root"))
         self.tbNovel.setIconSize(QSize(iPx, iPx))
-        self.tbNovel.clicked.connect(self._openNovelSelector)
+        self.tbNovel.clicked.connect(self.novelValue.showPopup)
 
         # Refresh Button
         self.tbRefresh = QToolButton(self)
@@ -243,7 +245,7 @@ class GuiNovelToolBar(QWidget):
         self.tbMore.setToolTip(self.tr("More Options"))
         self.tbMore.setIconSize(QSize(iPx, iPx))
         self.tbMore.setMenu(self.mMore)
-        self.tbMore.setPopupMode(QToolButton.InstantPopup)
+        self.tbMore.setPopupMode(QToolButton.ToolButtonPopupMode.InstantPopup)
 
         # Assemble
         self.outerBox = QHBoxLayout()
@@ -274,7 +276,7 @@ class GuiNovelToolBar(QWidget):
         self.tbMore.setIcon(SHARED.theme.getIcon("menu"))
 
         qPalette = self.palette()
-        qPalette.setBrush(QPalette.Window, qPalette.base())
+        qPalette.setBrush(QPalette.ColorRole.Window, qPalette.base())
         self.setPalette(qPalette)
 
         # StyleSheets
@@ -293,7 +295,7 @@ class GuiNovelToolBar(QWidget):
             "QComboBox {border-style: none; padding-left: 0;} "
             "QComboBox::drop-down {border-style: none}"
         )
-        self.novelValue.updateList(prefix=self.novelPrefix)
+        self.novelValue.refreshNovelList()
         self.tbNovel.setVisible(self.novelValue.count() > 1)
 
         return
@@ -306,7 +308,7 @@ class GuiNovelToolBar(QWidget):
 
     def buildNovelRootMenu(self) -> None:
         """Build the novel root menu."""
-        self.novelValue.updateList(prefix=self.novelPrefix)
+        self.novelValue.refreshNovelList()
         self.tbNovel.setVisible(self.novelValue.count() > 1)
         return
 
@@ -326,12 +328,6 @@ class GuiNovelToolBar(QWidget):
     #  Private Slots
     ##
 
-    @pyqtSlot()
-    def _openNovelSelector(self) -> None:
-        """Trigger the dropdown list of the novel selector."""
-        self.novelValue.showPopup()
-        return
-
     @pyqtSlot()
     def _refreshNovelTree(self) -> None:
         """Rebuild the current tree."""
@@ -407,14 +403,14 @@ class GuiNovelTree(QTreeWidget):
         cMg = CONFIG.pxInt(6)
 
         self.setIconSize(QSize(iPx, iPx))
-        self.setFrameStyle(QFrame.NoFrame)
+        self.setFrameStyle(QFrame.Shape.NoFrame)
         self.setUniformRowHeights(True)
         self.setAllColumnsShowFocus(True)
         self.setHeaderHidden(True)
         self.setIndentation(0)
         self.setColumnCount(4)
-        self.setSelectionBehavior(QAbstractItemView.SelectRows)
-        self.setSelectionMode(QAbstractItemView.SingleSelection)
+        self.setSelectionBehavior(QAbstractItemView.SelectionBehavior.SelectRows)
+        self.setSelectionMode(QAbstractItemView.SelectionMode.SingleSelection)
         self.setExpandsOnDoubleClick(False)
         self.setDragEnabled(False)
 
@@ -422,10 +418,10 @@ class GuiNovelTree(QTreeWidget):
         treeHeader = self.header()
         treeHeader.setStretchLastSection(False)
         treeHeader.setMinimumSectionSize(iPx + cMg)
-        treeHeader.setSectionResizeMode(self.C_TITLE, QHeaderView.Stretch)
-        treeHeader.setSectionResizeMode(self.C_WORDS, QHeaderView.ResizeToContents)
-        treeHeader.setSectionResizeMode(self.C_EXTRA, QHeaderView.ResizeToContents)
-        treeHeader.setSectionResizeMode(self.C_MORE, QHeaderView.ResizeToContents)
+        treeHeader.setSectionResizeMode(self.C_TITLE, QHeaderView.ResizeMode.Stretch)
+        treeHeader.setSectionResizeMode(self.C_WORDS, QHeaderView.ResizeMode.ResizeToContents)
+        treeHeader.setSectionResizeMode(self.C_EXTRA, QHeaderView.ResizeMode.ResizeToContents)
+        treeHeader.setSectionResizeMode(self.C_MORE, QHeaderView.ResizeMode.ResizeToContents)
 
         # Pre-Generate Tree Formatting
         fH1 = self.font()
@@ -454,14 +450,14 @@ class GuiNovelTree(QTreeWidget):
         """Set or update tree widget settings."""
         # Scroll bars
         if CONFIG.hideVScroll:
-            self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
+            self.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
         else:
-            self.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
+            self.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAsNeeded)
 
         if CONFIG.hideHScroll:
-            self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
+            self.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
         else:
-            self.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
+            self.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAsNeeded)
 
         return
 
@@ -521,21 +517,16 @@ class GuiNovelTree(QTreeWidget):
 
     def refreshHandle(self, tHandle: str) -> None:
         """Refresh the data for a given handle."""
-        idxData = SHARED.project.index.getItemData(tHandle)
-        if idxData is None:
-            return
-
-        logger.debug("Refreshing meta data for item '%s'", tHandle)
-        for sTitle, tHeading in idxData.items():
-            sKey = f"{tHandle}:{sTitle}"
-            trItem = self._treeMap.get(sKey, None)
-            if trItem is None:
-                logger.debug("Heading '%s' not in novel tree", sKey)
-                self.refreshTree()
-                return
-
-            self._updateTreeItemValues(trItem, tHeading, tHandle, sTitle)
-
+        if idxData := SHARED.project.index.getItemData(tHandle):
+            logger.debug("Refreshing meta data for item '%s'", tHandle)
+            for sTitle, tHeading in idxData.items():
+                sKey = f"{tHandle}:{sTitle}"
+                if trItem := self._treeMap.get(sKey, None):
+                    self._updateTreeItemValues(trItem, tHeading, tHandle, sTitle)
+                else:
+                    logger.debug("Heading '%s' not in novel tree", sKey)
+                    self.refreshTree()
+                    return
         return
 
     def getSelectedHandle(self) -> tuple[str | None, str | None]:
@@ -566,27 +557,25 @@ class GuiNovelTree(QTreeWidget):
         self._lastColSize = minmax(colSize, 15, 75)/100.0
         return
 
-    def setActiveHandle(self, tHandle: str | None) -> None:
+    def setActiveHandle(self, tHandle: str | None, doScroll: bool = False) -> None:
         """Highlight the rows associated with a given handle."""
-        tStart = time()
-
+        didScroll = False
         self._actHandle = tHandle
         for i in range(self.topLevelItemCount()):
-            tItem = self.topLevelItem(i)
-            if tItem is not None:
+            if tItem := self.topLevelItem(i):
                 if tItem.data(self.C_DATA, self.D_HANDLE) == tHandle:
                     tItem.setBackground(self.C_TITLE, self.palette().alternateBase())
                     tItem.setBackground(self.C_WORDS, self.palette().alternateBase())
                     tItem.setBackground(self.C_EXTRA, self.palette().alternateBase())
                     tItem.setBackground(self.C_MORE, self.palette().alternateBase())
+                    if doScroll and not didScroll:
+                        self.scrollToItem(tItem, QAbstractItemView.ScrollHint.PositionAtCenter)
+                        didScroll = True
                 else:
                     tItem.setBackground(self.C_TITLE, self.palette().base())
                     tItem.setBackground(self.C_WORDS, self.palette().base())
                     tItem.setBackground(self.C_EXTRA, self.palette().base())
                     tItem.setBackground(self.C_MORE, self.palette().base())
-
-        logger.debug("Highlighted Novel Tree in %.3f ms", (time() - tStart)*1000)
-
         return
 
     ##
@@ -600,12 +589,12 @@ class GuiNovelTree(QTreeWidget):
         """
         super().mousePressEvent(event)
 
-        if event.button() == Qt.LeftButton:
+        if event.button() == Qt.MouseButton.LeftButton:
             selItem = self.indexAt(event.pos())
             if not selItem.isValid():
                 self.clearSelection()
 
-        elif event.button() == Qt.MiddleButton:
+        elif event.button() == Qt.MouseButton.MiddleButton:
             selItem = self.itemAt(event.pos())
             if not isinstance(selItem, QTreeWidgetItem):
                 return
@@ -636,7 +625,10 @@ class GuiNovelTree(QTreeWidget):
                 trItem = self.topLevelItem(i)
                 if isinstance(trItem, QTreeWidgetItem):
                     lastText = trItem.data(self.C_DATA, self.D_EXTRA)
-                    trItem.setText(self.C_EXTRA, fMetric.elidedText(lastText, Qt.ElideRight, eliW))
+                    trItem.setText(
+                        self.C_EXTRA,
+                        fMetric.elidedText(lastText, Qt.TextElideMode.ElideRight, eliW)
+                    )
         return
 
     ##
@@ -683,7 +675,7 @@ class GuiNovelTree(QTreeWidget):
         tStart = time()
         logger.debug("Building novel tree for root item '%s'", rootHandle)
 
-        novStruct = SHARED.project.index.novelStructure(rootHandle=rootHandle, skipExcl=True)
+        novStruct = SHARED.project.index.novelStructure(rootHandle=rootHandle, activeOnly=True)
         for tKey, tHandle, sTitle, novIdx in novStruct:
             if novIdx.level == "H0":
                 continue
@@ -692,7 +684,7 @@ class GuiNovelTree(QTreeWidget):
             newItem.setData(self.C_DATA, self.D_HANDLE, tHandle)
             newItem.setData(self.C_DATA, self.D_TITLE, sTitle)
             newItem.setData(self.C_DATA, self.D_KEY, tKey)
-            newItem.setTextAlignment(self.C_WORDS, Qt.AlignRight)
+            newItem.setTextAlignment(self.C_WORDS, Qt.AlignmentFlag.AlignRight)
 
             self._updateTreeItemValues(newItem, novIdx, tHandle, sTitle)
             self._treeMap[tKey] = newItem
@@ -711,16 +703,16 @@ class GuiNovelTree(QTreeWidget):
         iLevel = nwHeaders.H_LEVEL.get(idxItem.level, 0)
         hDec = SHARED.theme.getHeaderDecoration(iLevel)
 
-        trItem.setData(self.C_TITLE, Qt.DecorationRole, hDec)
+        trItem.setData(self.C_TITLE, Qt.ItemDataRole.DecorationRole, hDec)
         trItem.setText(self.C_TITLE, idxItem.title)
         trItem.setFont(self.C_TITLE, self._hFonts[iLevel])
         trItem.setText(self.C_WORDS, f"{idxItem.wordCount:n}")
-        trItem.setData(self.C_MORE, Qt.DecorationRole, self._pMore)
+        trItem.setData(self.C_MORE, Qt.ItemDataRole.DecorationRole, self._pMore)
 
         # Custom column
         mW = int(self._lastColSize * self.viewport().width())
         lastText, toolTip = self._getLastColumnText(tHandle, sTitle)
-        elideText = self.fontMetrics().elidedText(lastText, Qt.ElideRight, mW)
+        elideText = self.fontMetrics().elidedText(lastText, Qt.TextElideMode.ElideRight, mW)
         trItem.setText(self.C_EXTRA, elideText)
         trItem.setData(self.C_DATA, self.D_EXTRA, lastText)
         trItem.setToolTip(self.C_EXTRA, toolTip)
@@ -734,17 +726,17 @@ class GuiNovelTree(QTreeWidget):
 
         refData = []
         refName = ""
-        theRefs = SHARED.project.index.getReferences(tHandle, sTitle)
+        refs = SHARED.project.index.getReferences(tHandle, sTitle)
         if self._lastCol == NovelTreeColumn.POV:
-            refData = theRefs[nwKeyWords.POV_KEY]
+            refData = refs[nwKeyWords.POV_KEY]
             refName = self._povLabel
 
         elif self._lastCol == NovelTreeColumn.FOCUS:
-            refData = theRefs[nwKeyWords.FOCUS_KEY]
+            refData = refs[nwKeyWords.FOCUS_KEY]
             refName = self._focLabel
 
         elif self._lastCol == NovelTreeColumn.PLOT:
-            refData = theRefs[nwKeyWords.PLOT_KEY]
+            refData = refs[nwKeyWords.PLOT_KEY]
             refName = self._pltLabel
 
         if refData:

novelwriter/gui/outline.py

@@ -10,7 +10,7 @@ Created: 2019-11-16 [0.4.1]  GuiOutlineHeaderMenu
 Created: 2020-06-02 [0.7]    GuiOutlineDetails
 
 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
@@ -27,18 +27,17 @@ along with this program. If not, see <https://www.gnu.org/licenses/>.
 """
 from __future__ import annotations
 
+import csv
 import logging
 
 from time import time
 from enum import Enum
 
-from PyQt5.QtCore import (
-    Qt, pyqtSignal, pyqtSlot, QSize, QT_TRANSLATE_NOOP
-)
+from PyQt5.QtCore import Qt, pyqtSignal, pyqtSlot, QSize, QT_TRANSLATE_NOOP
 from PyQt5.QtWidgets import (
-    QAbstractItemView, QAction, QFrame, QGridLayout, QGroupBox, QHBoxLayout,
-    QLabel, QMenu, QScrollArea, QSizePolicy, QSplitter, QToolBar, QToolButton,
-    QTreeWidget, QTreeWidgetItem, QVBoxLayout, QWidget
+    QAbstractItemView, QAction, QFileDialog, QFrame, QGridLayout, QGroupBox,
+    QHBoxLayout, QLabel, QMenu, QScrollArea, QSizePolicy, QSplitter, QToolBar,
+    QToolButton, QTreeWidget, QTreeWidgetItem, QVBoxLayout, QWidget
 )
 
 from novelwriter import CONFIG, SHARED
@@ -46,7 +45,7 @@ from novelwriter.enum import (
     nwDocMode, nwItemClass, nwItemLayout, nwItemType, nwOutline
 )
 from novelwriter.error import logException
-from novelwriter.common import checkInt
+from novelwriter.common import checkInt, formatFileFilter, makeFileNameSafe
 from novelwriter.constants import nwHeaders, trConst, nwKeyWords, nwLabels
 from novelwriter.extensions.novelselector import NovelSelector
 
@@ -88,6 +87,7 @@ class GuiOutlineView(QWidget):
         self.outlineData.itemTagClicked.connect(self._tagClicked)
         self.outlineBar.loadNovelRootRequest.connect(self._rootItemChanged)
         self.outlineBar.viewColumnToggled.connect(self.outlineTree.menuColumnToggled)
+        self.outlineBar.outlineExportRequest.connect(self.outlineTree.exportOutline)
 
         # Function Mappings
         self.getSelectedHandle = self.outlineTree.getSelectedHandle
@@ -124,7 +124,7 @@ class GuiOutlineView(QWidget):
     def openProjectTasks(self) -> None:
         """Run open project tasks."""
         lastOutline = SHARED.project.data.getLastHandle("outline")
-        if not (lastOutline is None or lastOutline in SHARED.project.tree):
+        if not lastOutline or lastOutline not in SHARED.project.tree:
             lastOutline = SHARED.project.tree.findRoot(nwItemClass.NOVEL)
 
         logger.debug("Setting outline tree to root item '%s'", lastOutline)
@@ -198,6 +198,7 @@ class GuiOutlineView(QWidget):
 class GuiOutlineToolBar(QToolBar):
 
     loadNovelRootRequest = pyqtSignal(str)
+    outlineExportRequest = pyqtSignal()
     viewColumnToggled = pyqtSignal(bool, Enum)
 
     def __init__(self, outlineView: GuiOutlineView) -> None:
@@ -220,6 +221,7 @@ class GuiOutlineToolBar(QToolBar):
         self.novelLabel.setContentsMargins(0, 0, mPx, 0)
 
         self.novelValue = NovelSelector(self)
+        self.novelValue.setIncludeAll(True)
         self.novelValue.setMinimumWidth(CONFIG.pxInt(200))
         self.novelValue.novelSelectionChanged.connect(self._novelValueChanged)
 
@@ -227,6 +229,9 @@ class GuiOutlineToolBar(QToolBar):
         self.aRefresh = QAction(self.tr("Refresh"), self)
         self.aRefresh.triggered.connect(self._refreshRequested)
 
+        self.aExport = QAction(self.tr("Export CSV"), self)
+        self.aExport.triggered.connect(self._exportRequested)
+
         # Column Menu
         self.mColumns = GuiOutlineHeaderMenu(self)
         self.mColumns.columnToggled.connect(
@@ -242,6 +247,7 @@ class GuiOutlineToolBar(QToolBar):
         self.addWidget(self.novelValue)
         self.addSeparator()
         self.addAction(self.aRefresh)
+        self.addAction(self.aExport)
         self.addWidget(self.tbColumns)
         self.addWidget(stretch)
 
@@ -258,15 +264,16 @@ class GuiOutlineToolBar(QToolBar):
     def updateTheme(self) -> None:
         """Update theme elements."""
         self.setStyleSheet("QToolBar {border: 0px;}")
-        self.novelValue.updateList(includeAll=True)
+        self.novelValue.refreshNovelList()
         self.aRefresh.setIcon(SHARED.theme.getIcon("refresh"))
+        self.aExport.setIcon(SHARED.theme.getIcon("export"))
         self.tbColumns.setIcon(SHARED.theme.getIcon("menu"))
         self.tbColumns.setStyleSheet("QToolButton::menu-indicator {image: none;}")
         return
 
     def populateNovelList(self) -> None:
         """Reload the content of the novel list."""
-        self.novelValue.updateList(includeAll=True)
+        self.novelValue.refreshNovelList()
         return
 
     def setCurrentRoot(self, rootHandle: str | None) -> None:
@@ -295,6 +302,12 @@ class GuiOutlineToolBar(QToolBar):
         self.loadNovelRootRequest.emit(self.novelValue.handle)
         return
 
+    @pyqtSlot()
+    def _exportRequested(self) -> None:
+        """Emit a signal that an export of the outline was requested."""
+        self.outlineExportRequest.emit()
+        return
+
 # END Class GuiOutlineToolBar
 
 
@@ -491,15 +504,48 @@ class GuiOutlineTree(QTreeWidget):
         """Get the currently selected handle. If multiple items are
         selected, return the first.
         """
-        selItem = self.selectedItems()
-        if selItem:
-            tHandle = selItem[0].data(self._colIdx[nwOutline.TITLE], self.D_HANDLE)
-            sTitle = selItem[0].data(self._colIdx[nwOutline.TITLE], self.D_TITLE)
+        if item := self.selectedItems():
+            tHandle = item[0].data(self._colIdx[nwOutline.TITLE], self.D_HANDLE)
+            sTitle = item[0].data(self._colIdx[nwOutline.TITLE], self.D_TITLE)
             return tHandle, sTitle
         return None, None
 
     ##
-    #  Slots
+    #  Public Slots
+    ##
+
+    @pyqtSlot(bool, Enum)
+    def menuColumnToggled(self, isChecked: bool, hItem: nwOutline) -> None:
+        """Receive the changes to column visibility forwarded by the
+        column selection menu.
+        """
+        if hItem in self._colIdx:
+            self.setColumnHidden(self._colIdx[hItem], not isChecked)
+            self._saveHeaderState()
+        return
+
+    @pyqtSlot()
+    def exportOutline(self) -> None:
+        """Export the outline as a CSV file."""
+        path = CONFIG.lastPath() / f"{makeFileNameSafe(SHARED.project.data.name)}.csv"
+        path, _ = QFileDialog.getSaveFileName(
+            self, self.tr("Save Outline As"), str(path), formatFileFilter(["*.csv", "*"])
+        )
+        if path:
+            CONFIG.setLastPath(path)
+            logger.info("Writing CSV file: %s", path)
+            cols = [col for col in self._treeOrder if not self._colHidden[col]]
+            order = [self._colIdx[col] for col in cols]
+            with open(path, mode="w", newline="") as csvFile:
+                writer = csv.writer(csvFile, dialect="excel", quoting=csv.QUOTE_ALL)
+                writer.writerow([trConst(nwLabels.OUTLINE_COLS[col]) for col in cols])
+                for i in range(self.topLevelItemCount()):
+                    if item := self.topLevelItem(i):
+                        writer.writerow(item.text(i) for i in order)
+        return
+
+    ##
+    #  Private Slots
     ##
 
     @pyqtSlot("QTreeWidgetItem*", int)
@@ -509,9 +555,8 @@ class GuiOutlineTree(QTreeWidget):
         document editor.
         """
         tHandle, sTitle = self.getSelectedHandle()
-        if tHandle is None:
-            return
-        self.outlineView.openDocumentRequest.emit(tHandle, nwDocMode.EDIT, sTitle or "", True)
+        if tHandle:
+            self.outlineView.openDocumentRequest.emit(tHandle, nwDocMode.EDIT, sTitle or "", True)
         return
 
     @pyqtSlot()
@@ -535,16 +580,6 @@ class GuiOutlineTree(QTreeWidget):
         self._saveHeaderState()
         return
 
-    @pyqtSlot(bool, Enum)
-    def menuColumnToggled(self, isChecked: bool, hItem: nwOutline) -> None:
-        """Receive the changes to column visibility forwarded by the
-        column selection menu.
-        """
-        if hItem in self._colIdx:
-            self.setColumnHidden(self._colIdx[hItem], not isChecked)
-            self._saveHeaderState()
-        return
-
     ##
     #  Internal Functions
     ##
@@ -606,6 +641,7 @@ class GuiOutlineTree(QTreeWidget):
                 logHidden, orgWidth if logHidden and logWidth == 0 else logWidth
             ]
 
+        logger.debug("Saving State: GuiOutline")
         pOptions = SHARED.project.options
         pOptions.setValue("GuiOutline", "columnState", colState)
         pOptions.saveSettings()
@@ -623,12 +659,12 @@ class GuiOutlineTree(QTreeWidget):
         self.clear()
 
         if self._firstView:
-            theLabels = []
+            labels = []
             for i, hItem in enumerate(self._treeOrder):
-                theLabels.append(trConst(nwLabels.OUTLINE_COLS[hItem]))
+                labels.append(trConst(nwLabels.OUTLINE_COLS[hItem]))
                 self._colIdx[hItem] = i
 
-            self.setHeaderLabels(theLabels)
+            self.setHeaderLabels(labels)
             for hItem in self._treeOrder:
                 self.setColumnWidth(self._colIdx[hItem], self._colWidth[hItem])
                 self.setColumnHidden(self._colIdx[hItem], self._colHidden[hItem])
@@ -645,7 +681,7 @@ class GuiOutlineTree(QTreeWidget):
                 headItem.setTextAlignment(
                     self._colIdx[nwOutline.PCOUNT], Qt.AlignmentFlag.AlignRight)
 
-        novStruct = SHARED.project.index.novelStructure(rootHandle=rootHandle, skipExcl=True)
+        novStruct = SHARED.project.index.novelStructure(rootHandle=rootHandle, activeOnly=True)
         for _, tHandle, sTitle, novIdx in novStruct:
 
             iLevel = nwHeaders.H_LEVEL.get(novIdx.level, 0)
@@ -841,18 +877,15 @@ class GuiOutlineDetails(QScrollArea):
         self.entKeyValue.setWordWrap(True)
         self.cstKeyValue.setWordWrap(True)
 
-        def tagClicked(link):
-            self.itemTagClicked.emit(link)
-
-        self.povKeyValue.linkActivated.connect(tagClicked)
-        self.focKeyValue.linkActivated.connect(tagClicked)
-        self.chrKeyValue.linkActivated.connect(tagClicked)
-        self.pltKeyValue.linkActivated.connect(tagClicked)
-        self.timKeyValue.linkActivated.connect(tagClicked)
-        self.wldKeyValue.linkActivated.connect(tagClicked)
-        self.objKeyValue.linkActivated.connect(tagClicked)
-        self.entKeyValue.linkActivated.connect(tagClicked)
-        self.cstKeyValue.linkActivated.connect(tagClicked)
+        self.povKeyValue.linkActivated.connect(lambda x: self.itemTagClicked.emit(x))
+        self.focKeyValue.linkActivated.connect(lambda x: self.itemTagClicked.emit(x))
+        self.chrKeyValue.linkActivated.connect(lambda x: self.itemTagClicked.emit(x))
+        self.pltKeyValue.linkActivated.connect(lambda x: self.itemTagClicked.emit(x))
+        self.timKeyValue.linkActivated.connect(lambda x: self.itemTagClicked.emit(x))
+        self.wldKeyValue.linkActivated.connect(lambda x: self.itemTagClicked.emit(x))
+        self.objKeyValue.linkActivated.connect(lambda x: self.itemTagClicked.emit(x))
+        self.entKeyValue.linkActivated.connect(lambda x: self.itemTagClicked.emit(x))
+        self.cstKeyValue.linkActivated.connect(lambda x: self.itemTagClicked.emit(x))
 
         self.povKeyLWrap.addWidget(self.povKeyValue, 1)
         self.focKeyLWrap.addWidget(self.focKeyValue, 1)
@@ -981,49 +1014,40 @@ class GuiOutlineDetails(QScrollArea):
     ##
 
     @pyqtSlot(str, str)
-    def showItem(self, tHandle: str, sTitle: str) -> bool:
+    def showItem(self, tHandle: str, sTitle: str) -> None:
         """Update the content of the tree with the given handle and line
         number pointing to a header.
         """
         pIndex = SHARED.project.index
         nwItem = SHARED.project.tree[tHandle]
         novIdx = pIndex.getItemHeader(tHandle, sTitle)
-        theRefs = pIndex.getReferences(tHandle, sTitle)
-        if nwItem is None or novIdx is None:
-            return False
-
-        if novIdx.level in self.LVL_MAP:
-            self.titleLabel.setText("<b>%s</b>" % self.tr(self.LVL_MAP[novIdx.level]))
-        else:
-            self.titleLabel.setText("<b>%s</b>" % self.tr("Title"))
-        self.titleValue.setText(novIdx.title)
+        novRefs = pIndex.getReferences(tHandle, sTitle)
+        if nwItem and novIdx:
+            self.titleLabel.setText("<b>%s</b>" % self.tr(self.LVL_MAP.get(novIdx.level, "H1")))
+            self.titleValue.setText(novIdx.title)
 
-        itemStatus, _ = nwItem.getImportStatus(incIcon=False)
+            itemStatus, _ = nwItem.getImportStatus(incIcon=False)
 
-        self.fileValue.setText(nwItem.itemName)
-        self.itemValue.setText(itemStatus)
+            self.fileValue.setText(nwItem.itemName)
+            self.itemValue.setText(itemStatus)
 
-        cC = checkInt(novIdx.charCount, 0)
-        wC = checkInt(novIdx.wordCount, 0)
-        pC = checkInt(novIdx.paraCount, 0)
+            self.cCValue.setText(f"{checkInt(novIdx.charCount, 0):n}")
+            self.wCValue.setText(f"{checkInt(novIdx.wordCount, 0):n}")
+            self.pCValue.setText(f"{checkInt(novIdx.paraCount, 0):n}")
 
-        self.cCValue.setText(f"{cC:n}")
-        self.wCValue.setText(f"{wC:n}")
-        self.pCValue.setText(f"{pC:n}")
+            self.synopValue.setText(novIdx.synopsis)
 
-        self.synopValue.setText(novIdx.synopsis)
+            self.povKeyValue.setText(self._formatTags(novRefs, nwKeyWords.POV_KEY))
+            self.focKeyValue.setText(self._formatTags(novRefs, nwKeyWords.FOCUS_KEY))
+            self.chrKeyValue.setText(self._formatTags(novRefs, nwKeyWords.CHAR_KEY))
+            self.pltKeyValue.setText(self._formatTags(novRefs, nwKeyWords.PLOT_KEY))
+            self.timKeyValue.setText(self._formatTags(novRefs, nwKeyWords.TIME_KEY))
+            self.wldKeyValue.setText(self._formatTags(novRefs, nwKeyWords.WORLD_KEY))
+            self.objKeyValue.setText(self._formatTags(novRefs, nwKeyWords.OBJECT_KEY))
+            self.entKeyValue.setText(self._formatTags(novRefs, nwKeyWords.ENTITY_KEY))
+            self.cstKeyValue.setText(self._formatTags(novRefs, nwKeyWords.CUSTOM_KEY))
 
-        self.povKeyValue.setText(self._formatTags(theRefs, nwKeyWords.POV_KEY))
-        self.focKeyValue.setText(self._formatTags(theRefs, nwKeyWords.FOCUS_KEY))
-        self.chrKeyValue.setText(self._formatTags(theRefs, nwKeyWords.CHAR_KEY))
-        self.pltKeyValue.setText(self._formatTags(theRefs, nwKeyWords.PLOT_KEY))
-        self.timKeyValue.setText(self._formatTags(theRefs, nwKeyWords.TIME_KEY))
-        self.wldKeyValue.setText(self._formatTags(theRefs, nwKeyWords.WORLD_KEY))
-        self.objKeyValue.setText(self._formatTags(theRefs, nwKeyWords.OBJECT_KEY))
-        self.entKeyValue.setText(self._formatTags(theRefs, nwKeyWords.ENTITY_KEY))
-        self.cstKeyValue.setText(self._formatTags(theRefs, nwKeyWords.CUSTOM_KEY))
-
-        return True
+        return
 
     @pyqtSlot()
     def updateClasses(self) -> None: