novelWriter 2.6.2__py3-none-any.whl → 2.7__py3-none-any.whl

novelwriter/gui/noveltree.py

@@ -3,9 +3,11 @@ novelWriter – GUI Novel Tree
 ============================
 
 File History:
-Created: 2020-12-20 [1.1rc1] GuiNovelTree
-Created: 2022-06-12 [2.0rc1] GuiNovelView
-Created: 2022-06-12 [2.0rc1] GuiNovelToolBar
+Created:   2020-12-20 [1.1rc1] GuiNovelTree
+Created:   2022-06-12 [2.0rc1] GuiNovelView
+Created:   2022-06-12 [2.0rc1] GuiNovelToolBar
+Rewritten: 2025-02-22 [2.7b1] GuiNovelView
+Rewritten: 2025-02-22 [2.7b1] GuiNovelToolBar
 
 This file is a part of novelWriter
 Copyright (C) 2020 Veronica Berglyd Olsen and novelWriter contributors
@@ -28,40 +30,30 @@ from __future__ import annotations
 import logging
 
 from enum import Enum
-from time import time
 
-from PyQt5.QtCore import QModelIndex, QPoint, Qt, pyqtSignal, pyqtSlot
-from PyQt5.QtGui import QFocusEvent, QFont, QMouseEvent, QPalette, QResizeEvent
-from PyQt5.QtWidgets import (
-    QAbstractItemView, QActionGroup, QFrame, QHBoxLayout, QInputDialog, QMenu,
-    QToolTip, QTreeWidget, QTreeWidgetItem, QVBoxLayout, QWidget
+from PyQt6.QtCore import QModelIndex, QPoint, pyqtSignal, pyqtSlot
+from PyQt6.QtGui import QActionGroup, QFont, QPainter, QPalette, QResizeEvent
+from PyQt6.QtWidgets import (
+    QAbstractItemView, QFrame, QHBoxLayout, QInputDialog, QMenu,
+    QStyleOptionViewItem, QToolTip, QVBoxLayout, QWidget
 )
 
 from novelwriter import CONFIG, SHARED
-from novelwriter.common import minmax, qtLambda
-from novelwriter.constants import nwKeyWords, nwLabels, nwStyles, trConst
-from novelwriter.core.index import IndexHeading
-from novelwriter.enum import nwChange, nwDocMode, nwItemClass, nwOutline
-from novelwriter.extensions.modified import NIconToolButton
+from novelwriter.common import minmax, qtAddAction, qtAddMenu, qtLambda
+from novelwriter.constants import nwKeyWords, nwLabels, trConst
+from novelwriter.core.novelmodel import NovelModel
+from novelwriter.enum import nwChange, nwDocMode, nwNovelExtra, nwOutline
+from novelwriter.extensions.modified import NIconToolButton, NTreeView
 from novelwriter.extensions.novelselector import NovelSelector
 from novelwriter.gui.theme import STYLES_MIN_TOOLBUTTON
 from novelwriter.types import (
-    QtAlignRight, QtDecoration, QtHeaderStretch, QtHeaderToContents,
-    QtMouseLeft, QtMouseMiddle, QtScrollAlwaysOff, QtScrollAsNeeded,
-    QtSizeExpanding, QtUserRole
+    QtHeaderStretch, QtHeaderToContents, QtScrollAlwaysOff, QtScrollAsNeeded,
+    QtSizeExpanding
 )
 
 logger = logging.getLogger(__name__)
 
 
-class NovelTreeColumn(Enum):
-
-    HIDDEN = 0
-    POV    = 1
-    FOCUS  = 2
-    PLOT   = 3
-
-
 class GuiNovelView(QWidget):
 
     # Signals for user interaction with the novel tree
@@ -86,7 +78,9 @@ class GuiNovelView(QWidget):
         self.setLayout(self.outerBox)
 
         # Function Mappings
+        self.setActive = self.novelBar.setActive
         self.getSelectedHandle = self.novelTree.getSelectedHandle
+        self.refreshCurrentTree = self.novelBar.forceRefreshNovelTree
 
         return
 
@@ -97,8 +91,6 @@ class GuiNovelView(QWidget):
     def updateTheme(self) -> None:
         """Update theme elements."""
         self.novelBar.updateTheme()
-        self.novelTree.updateTheme()
-        self.refreshTree()
         return
 
     def initSettings(self) -> None:
@@ -108,21 +100,18 @@ class GuiNovelView(QWidget):
 
     def clearNovelView(self) -> None:
         """Clear project-related GUI content."""
-        self.novelTree.clearContent()
         self.novelBar.clearContent()
         self.novelBar.setEnabled(False)
+        self.novelTree.clearContent()
         return
 
     def openProjectTasks(self) -> None:
         """Run open project tasks."""
-        lastNovel = SHARED.project.data.getLastHandle("novelTree")
-        if lastNovel and lastNovel not in SHARED.project.tree:
-            lastNovel = SHARED.project.tree.findRoot(nwItemClass.NOVEL)
-
+        lastNovel = SHARED.project.data.getLastHandle("novel")
         logger.debug("Setting novel tree to root item '%s'", lastNovel)
 
         lastCol = SHARED.project.options.getEnum(
-            "GuiNovelView", "lastCol", NovelTreeColumn, NovelTreeColumn.HIDDEN
+            "GuiNovelView", "lastCol", nwNovelExtra, nwNovelExtra.HIDDEN
         )
         lastColSize = SHARED.project.options.getInt(
             "GuiNovelView", "lastColSize", 25
@@ -140,13 +129,17 @@ class GuiNovelView(QWidget):
 
     def closeProjectTasks(self) -> None:
         """Run closing project tasks."""
+        logger.debug("Saving State: GuiNovelView")
+
         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)
+
+        options = SHARED.project.options
+        options.setValue("GuiNovelView", "lastCol", lastColType)
+        options.setValue("GuiNovelView", "lastColSize", lastColSize)
+
         self.clearNovelView()
+
         return
 
     def setTreeFocus(self) -> None:
@@ -162,32 +155,24 @@ class GuiNovelView(QWidget):
     #  Public Slots
     ##
 
+    @pyqtSlot(str)
+    def setCurrentNovel(self, rootHandle: str | None) -> None:
+        """Set the current novel to display."""
+        self.novelTree.setNovelModel(rootHandle)
+        return
+
     @pyqtSlot(str)
     def setActiveHandle(self, tHandle: str) -> None:
         """Highlight the rows associated with a given handle."""
         self.novelTree.setActiveHandle(tHandle)
         return
 
-    @pyqtSlot()
-    def refreshTree(self) -> None:
-        """Refresh the current tree."""
-        self.novelTree.refreshTree(rootHandle=SHARED.project.data.getLastHandle("novelTree"))
-        return
-
     @pyqtSlot(str, Enum)
     def updateRootItem(self, tHandle: str, change: nwChange) -> None:
         """If any root item changes, rebuild the novel root menu."""
         self.novelBar.buildNovelRootMenu()
         return
 
-    @pyqtSlot(str)
-    def updateNovelItemMeta(self, tHandle: str) -> None:
-        """The meta data of a novel item has changed, and the tree item
-        needs to be refreshed.
-        """
-        self.novelTree.refreshHandle(tHandle)
-        return
-
 
 class GuiNovelToolBar(QWidget):
 
@@ -198,10 +183,13 @@ class GuiNovelToolBar(QWidget):
 
         self.novelView = novelView
 
+        self._active = False
+        self._refresh: dict[str, bool] = {}
+
         iSz = SHARED.theme.baseIconSize
-        mPx = CONFIG.pxInt(2)
 
         self.setContentsMargins(0, 0, 0, 0)
+        self.setBackgroundRole(QPalette.ColorRole.Base)
         self.setAutoFillBackground(True)
 
         # Novel Selector
@@ -211,7 +199,7 @@ class GuiNovelToolBar(QWidget):
         self.novelValue = NovelSelector(self)
         self.novelValue.setFont(selFont)
         self.novelValue.setListFormat(self.tr("Outline of {0}"))
-        self.novelValue.setMinimumWidth(CONFIG.pxInt(150))
+        self.novelValue.setMinimumWidth(150)
         self.novelValue.setSizePolicy(QtSizeExpanding, QtSizeExpanding)
         self.novelValue.novelSelectionChanged.connect(self.setCurrentRoot)
 
@@ -222,21 +210,21 @@ class GuiNovelToolBar(QWidget):
         # Refresh Button
         self.tbRefresh = NIconToolButton(self, iSz)
         self.tbRefresh.setToolTip(self.tr("Refresh"))
-        self.tbRefresh.clicked.connect(self._refreshNovelTree)
+        self.tbRefresh.clicked.connect(self.forceRefreshNovelTree)
 
         # More Options Menu
         self.mMore = QMenu(self)
 
-        self.mLastCol = self.mMore.addMenu(self.tr("Last Column"))
+        self.mLastCol = qtAddMenu(self.mMore, self.tr("Last Column"))
         self.gLastCol = QActionGroup(self.mMore)
         self.aLastCol = {}
-        self._addLastColAction(NovelTreeColumn.HIDDEN, self.tr("Hidden"))
-        self._addLastColAction(NovelTreeColumn.POV,    self.tr("Point of View Character"))
-        self._addLastColAction(NovelTreeColumn.FOCUS,  self.tr("Focus Character"))
-        self._addLastColAction(NovelTreeColumn.PLOT,   self.tr("Novel Plot"))
+        self._addLastColAction(nwNovelExtra.HIDDEN, self.tr("Hidden"))
+        self._addLastColAction(nwNovelExtra.POV,    self.tr("Point of View Character"))
+        self._addLastColAction(nwNovelExtra.FOCUS,  self.tr("Focus Character"))
+        self._addLastColAction(nwNovelExtra.PLOT,   self.tr("Novel Plot"))
 
         self.mLastCol.addSeparator()
-        self.aLastColSize = self.mLastCol.addAction(self.tr("Column Size"))
+        self.aLastColSize = qtAddAction(self.mLastCol, self.tr("Column Size"))
         self.aLastColSize.triggered.connect(self._selectLastColumnSize)
 
         self.tbMore = NIconToolButton(self, iSz)
@@ -249,13 +237,16 @@ class GuiNovelToolBar(QWidget):
         self.outerBox.addWidget(self.tbNovel)
         self.outerBox.addWidget(self.tbRefresh)
         self.outerBox.addWidget(self.tbMore)
-        self.outerBox.setContentsMargins(mPx, mPx, 0, mPx)
+        self.outerBox.setContentsMargins(4, 2, 0, 2)
         self.outerBox.setSpacing(0)
 
         self.setLayout(self.outerBox)
 
         self.updateTheme()
 
+        # Connect Signals
+        SHARED.novelStructureChanged.connect(self._refreshNovelTree)
+
         logger.debug("Ready: GuiNovelToolBar")
 
         return
@@ -267,13 +258,9 @@ class GuiNovelToolBar(QWidget):
     def updateTheme(self) -> None:
         """Update theme elements."""
         # Icons
-        self.tbNovel.setThemeIcon("cls_novel")
-        self.tbRefresh.setThemeIcon("refresh")
-        self.tbMore.setThemeIcon("menu")
-
-        qPalette = self.palette()
-        qPalette.setBrush(QPalette.ColorRole.Window, qPalette.base())
-        self.setPalette(qPalette)
+        self.tbNovel.setThemeIcon("cls_novel", "red")
+        self.tbRefresh.setThemeIcon("refresh", "green")
+        self.tbMore.setThemeIcon("more_vertical")
 
         # StyleSheets
         buttonStyle = SHARED.theme.getStyleSheet(STYLES_MIN_TOOLBUTTON)
@@ -285,9 +272,11 @@ class GuiNovelToolBar(QWidget):
             "QComboBox {border-style: none; padding-left: 0;} "
             "QComboBox::drop-down {border-style: none}"
         )
-        self.novelValue.refreshNovelList()
+        self.novelValue.updateTheme()
         self.tbNovel.setVisible(self.novelValue.count() > 1)
 
+        self.forceRefreshNovelTree()
+
         return
 
     def clearContent(self) -> None:
@@ -299,30 +288,67 @@ class GuiNovelToolBar(QWidget):
     def buildNovelRootMenu(self) -> None:
         """Build the novel root menu."""
         self.novelValue.refreshNovelList()
+        self.novelView.setCurrentNovel(self.novelValue.handle)
         self.tbNovel.setVisible(self.novelValue.count() > 1)
         return
 
     def setCurrentRoot(self, rootHandle: str | None) -> None:
         """Set the current active root handle."""
+        if rootHandle is None or rootHandle not in SHARED.project.tree:
+            rootHandle = self.novelValue.firstHandle
         self.novelValue.setHandle(rootHandle)
-        self.novelView.novelTree.refreshTree(rootHandle=rootHandle, overRide=True)
+        SHARED.project.data.setLastHandle(rootHandle, "novel")
+        self.novelView.setCurrentNovel(rootHandle)
+        self.novelView.novelTree.setAccessibleName(self.novelValue.currentText())
         return
 
-    def setLastColType(self, colType: NovelTreeColumn, doRefresh: bool = True) -> None:
+    def setLastColType(self, colType: nwNovelExtra, doRefresh: bool = True) -> None:
         """Set the last column type."""
         self.aLastCol[colType].setChecked(True)
-        self.novelView.novelTree.setLastColType(colType, doRefresh=doRefresh)
+        self.novelView.novelTree.setLastColType(colType)
+        if doRefresh:
+            self.forceRefreshNovelTree()
+            self.novelView.novelTree.resizeColumns()
+        return
+
+    def setActive(self, state: bool) -> None:
+        """Set the widget active state, which enables automatic tree
+        refresh when content structure changes.
+        """
+        self._active = state
+        if (
+            self._active
+            and (handle := self.novelValue.handle)
+            and self._refresh.get(handle, False)
+        ):
+            self._refreshNovelTree(self.novelValue.handle)
         return
 
     ##
-    #  Private Slots
+    #  Public Slots
     ##
 
     @pyqtSlot()
-    def _refreshNovelTree(self) -> None:
+    def forceRefreshNovelTree(self) -> None:
         """Rebuild the current tree."""
-        rootHandle = SHARED.project.data.getLastHandle("novelTree")
-        self.novelView.novelTree.refreshTree(rootHandle=rootHandle, overRide=True)
+        if tHandle := self.novelValue.handle:
+            self.novelView.setCurrentNovel(tHandle)
+            SHARED.project.index.refreshNovelModel(tHandle)
+            self._refresh[tHandle] = False
+        return
+
+    ##
+    #  Private Slots
+    ##
+
+    @pyqtSlot(str)
+    def _refreshNovelTree(self, tHandle: str) -> None:
+        """Refresh or schedule refresh of a novel tree."""
+        if self._active:
+            SHARED.project.index.refreshNovelModel(tHandle)
+            self._refresh[tHandle] = False
+        else:
+            self._refresh[tHandle] = True
         return
 
     @pyqtSlot()
@@ -334,16 +360,16 @@ class GuiNovelToolBar(QWidget):
         )
         if isOk:
             self.novelView.novelTree.setLastColSize(newSize)
-            self._refreshNovelTree()
+            self.novelView.novelTree.resizeColumns()
         return
 
     ##
     #  Internal Functions
     ##
 
-    def _addLastColAction(self, colType: NovelTreeColumn, actionLabel: str) -> None:
+    def _addLastColAction(self, colType: nwNovelExtra, actionLabel: str) -> None:
         """Add a column selection entry to the last column menu."""
-        aLast = self.mLastCol.addAction(actionLabel)
+        aLast = qtAddAction(self.mLastCol, actionLabel)
         aLast.setCheckable(True)
         aLast.setActionGroup(self.gLastCol)
         aLast.triggered.connect(qtLambda(self.setLastColType, colType))
@@ -351,18 +377,7 @@ class GuiNovelToolBar(QWidget):
         return
 
 
-class GuiNovelTree(QTreeWidget):
-
-    C_DATA  = 0
-    C_TITLE = 0
-    C_WORDS = 1
-    C_EXTRA = 2
-    C_MORE  = 3
-
-    D_HANDLE = QtUserRole
-    D_TITLE  = QtUserRole + 1
-    D_KEY    = QtUserRole + 2
-    D_EXTRA  = QtUserRole + 3
+class GuiNovelTree(NTreeView):
 
     def __init__(self, novelView: GuiNovelView) -> None:
         super().__init__(parent=novelView)
@@ -372,63 +387,30 @@ class GuiNovelTree(QTreeWidget):
         self.novelView = novelView
 
         # Internal Variables
-        self._lastBuild   = 0
-        self._lastCol     = NovelTreeColumn.POV
-        self._lastColSize = 0.25
         self._actHandle   = None
-        self._treeMap: dict[str, QTreeWidgetItem] = {}
-
-        # Cached Strings
-        self._povLabel = trConst(nwLabels.KEY_NAME[nwKeyWords.POV_KEY])
-        self._focLabel = trConst(nwLabels.KEY_NAME[nwKeyWords.FOCUS_KEY])
-        self._pltLabel = trConst(nwLabels.KEY_NAME[nwKeyWords.PLOT_KEY])
-
-        # Build GUI
-        # =========
-
-        iPx = SHARED.theme.baseIconHeight
-        iSz = SHARED.theme.baseIconSize
-        cMg = CONFIG.pxInt(6)
+        self._lastColType = nwNovelExtra.POV
+        self._lastColSize = 0.25
 
-        self.setIconSize(iSz)
+        # Widget Setup
+        self.setIconSize(SHARED.theme.baseIconSize)
         self.setFrameStyle(QFrame.Shape.NoFrame)
         self.setUniformRowHeights(True)
         self.setAllColumnsShowFocus(True)
         self.setHeaderHidden(True)
-        self.setIndentation(0)
-        self.setColumnCount(4)
-        self.setSelectionBehavior(QAbstractItemView.SelectionBehavior.SelectRows)
-        self.setSelectionMode(QAbstractItemView.SelectionMode.SingleSelection)
-        self.setExpandsOnDoubleClick(False)
+        self.setIndentation(2)
         self.setDragEnabled(False)
 
-        # Lock the column sizes
-        treeHeader = self.header()
-        treeHeader.setStretchLastSection(False)
-        treeHeader.setMinimumSectionSize(iPx + cMg)
-        treeHeader.setSectionResizeMode(self.C_TITLE, QtHeaderStretch)
-        treeHeader.setSectionResizeMode(self.C_WORDS, QtHeaderToContents)
-        treeHeader.setSectionResizeMode(self.C_EXTRA, QtHeaderToContents)
-        treeHeader.setSectionResizeMode(self.C_MORE, QtHeaderToContents)
-
-        # Pre-Generate Tree Formatting
-        fH1 = self.font()
-        fH1.setBold(True)
-        fH1.setUnderline(True)
-
-        fH2 = self.font()
-        fH2.setBold(True)
-
-        self._hFonts = [self.font(), fH1, fH2, self.font(), self.font()]
+        # Set selection options
+        self.setSelectionBehavior(QAbstractItemView.SelectionBehavior.SelectRows)
+        self.setSelectionMode(QAbstractItemView.SelectionMode.SingleSelection)
 
         # Connect signals
-        self.clicked.connect(self._treeItemClicked)
-        self.itemDoubleClicked.connect(self._treeDoubleClick)
-        self.itemSelectionChanged.connect(self._treeSelectionChange)
+        self.clicked.connect(self._onSingleClick)
+        self.doubleClicked.connect(self._onDoubleClick)
+        self.middleClicked.connect(self._onMiddleClick)
 
         # Set custom settings
         self.initSettings()
-        self.updateTheme()
 
         logger.debug("Ready: GuiNovelTree")
 
@@ -436,23 +418,14 @@ class GuiNovelTree(QTreeWidget):
 
     def initSettings(self) -> None:
         """Set or update tree widget settings."""
-        # Scroll bars
         if CONFIG.hideVScroll:
             self.setVerticalScrollBarPolicy(QtScrollAlwaysOff)
         else:
             self.setVerticalScrollBarPolicy(QtScrollAsNeeded)
-
         if CONFIG.hideHScroll:
             self.setHorizontalScrollBarPolicy(QtScrollAlwaysOff)
         else:
             self.setHorizontalScrollBarPolicy(QtScrollAsNeeded)
-
-        return
-
-    def updateTheme(self) -> None:
-        """Update theme elements."""
-        iPx = SHARED.theme.baseIconHeight
-        self._pMore = SHARED.theme.loadDecoration("deco_doc_more", h=iPx)
         return
 
     ##
@@ -460,313 +433,180 @@ class GuiNovelTree(QTreeWidget):
     ##
 
     @property
-    def lastColType(self) -> NovelTreeColumn:
-        return self._lastCol
+    def lastColType(self) -> nwNovelExtra:
+        """The data type of the extra column."""
+        return self._lastColType
 
     @property
     def lastColSize(self) -> int:
+        """Return the size of the extra column."""
         return int(self._lastColSize * 100)
 
     ##
-    #  Class Methods
+    #  Getters
     ##
 
-    def clearContent(self) -> None:
-        """Clear the GUI content and the related maps."""
-        self.clear()
-        self._treeMap = {}
-        self._lastBuild = 0
-        return
-
-    def refreshTree(self, rootHandle: str | None = None, overRide: bool = False) -> None:
-        """Refresh the tree if it has been changed."""
-        logger.debug("Requesting refresh of the novel tree")
-        if rootHandle is None:
-            rootHandle = SHARED.project.tree.findRoot(nwItemClass.NOVEL)
-
-        titleKey = None
-        if selItems := self.selectedItems():
-            titleKey = selItems[0].data(self.C_DATA, self.D_KEY)
-
-        self._populateTree(rootHandle)
-        SHARED.project.data.setLastHandle(rootHandle, "novelTree")
-
-        if titleKey is not None and titleKey in self._treeMap:
-            self._treeMap[titleKey].setSelected(True)
-
-        return
-
-    def refreshHandle(self, tHandle: str) -> None:
-        """Refresh the data for a given handle."""
-        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]:
         """Get the currently selected or active handle. If multiple
         items are selected, return the first.
         """
-        selList = self.selectedItems()
-        trItem = selList[0] if selList else self.currentItem()
-        if isinstance(trItem, QTreeWidgetItem):
-            tHandle = trItem.data(self.C_DATA, self.D_HANDLE)
-            sTitle = trItem.data(self.C_DATA, self.D_TITLE)
-            return tHandle, sTitle
+        if (model := self._getModel()) and (index := self.currentIndex()).isValid():
+            return model.handle(index), model.key(index)
         return None, None
 
-    def setLastColType(self, colType: NovelTreeColumn, doRefresh: bool = True) -> None:
-        """Change the content type of the last column and rebuild."""
-        if self._lastCol != colType:
-            logger.debug("Changing last column to %s", colType.name)
-            self._lastCol = colType
-            self.setColumnHidden(self.C_EXTRA, colType == NovelTreeColumn.HIDDEN)
-            if doRefresh:
-                lastNovel = SHARED.project.data.getLastHandle("novelTree")
-                self.refreshTree(rootHandle=lastNovel, overRide=True)
-        return
+    ##
+    #  Setters
+    ##
 
-    def setLastColSize(self, colSize: int) -> None:
-        """Set the column size in integer values between 15 and 75."""
-        self._lastColSize = minmax(colSize, 15, 75)/100.0
+    def setNovelModel(self, tHandle: str | None) -> None:
+        """Set the current novel model."""
+        if tHandle and (model := SHARED.project.index.getNovelModel(tHandle)):
+            if model is not self.model():
+                self.setModel(model)
+                self.resizeColumns()
+        else:
+            self.clearContent()
         return
 
     def setActiveHandle(self, tHandle: str | None) -> None:
-        """Highlight the rows associated with a given handle."""
-        didScroll = False
-        brushOn = self.palette().alternateBase()
-        brushOff = self.palette().base()
-        if pHandle := self._actHandle:
-            for key, item in self._treeMap.items():
-                if key.startswith(pHandle):
-                    for i in range(self.columnCount()):
-                        item.setBackground(i, brushOff)
-        if tHandle:
-            for key, item in self._treeMap.items():
-                if key.startswith(tHandle):
-                    for i in range(self.columnCount()):
-                        item.setBackground(i, brushOn)
-                    if not didScroll:
-                        self.scrollToItem(item, QAbstractItemView.ScrollHint.PositionAtCenter)
-                        didScroll = True
-        self._actHandle = tHandle or None
+        """Set the handle to be highlighted."""
+        self._actHandle = tHandle
+        if viewport := self.viewport():
+            viewport.repaint()
         return
 
-    ##
-    #  Events
-    ##
+    def setLastColType(self, colType: nwNovelExtra) -> None:
+        """Set the extra column type."""
+        self._lastColType = colType
+        SHARED.project.index.setNovelModelExtraColumn(colType)
+        return
 
-    def mousePressEvent(self, event: QMouseEvent) -> None:
-        """Overload mousePressEvent to clear selection if clicking the
-        mouse in a blank area of the tree view, and to load a document
-        for viewing if the user middle-clicked.
-        """
-        super().mousePressEvent(event)
+    def setLastColSize(self, colSize: int) -> None:
+        """Set the extra column size between 15% and 75%."""
+        self._lastColSize = minmax(colSize, 15, 75)/100.0
+        return
 
-        if event.button() == QtMouseLeft:
-            selItem = self.indexAt(event.pos())
-            if not selItem.isValid():
-                self.clearSelection()
+    ##
+    #  Class Methods
+    ##
 
-        elif event.button() == QtMouseMiddle:
-            selItem = self.itemAt(event.pos())
-            if not isinstance(selItem, QTreeWidgetItem):
-                return
+    def clearContent(self) -> None:
+        """Clear the tree view."""
+        self.setModel(None)
+        return
 
-            tHandle, sTitle = self.getSelectedHandle()
-            if tHandle is None:
-                return
+    def resizeColumns(self) -> None:
+        """Set the correct column sizes."""
+        if (header := self.header()) and (model := self._getModel()) and (vp := self.viewport()):
+            header.setStretchLastSection(False)
+            header.setMinimumSectionSize(SHARED.theme.baseIconHeight + 6)
+            header.setSectionResizeMode(0, QtHeaderStretch)
+            header.setSectionResizeMode(1, QtHeaderToContents)
+            header.setSectionResizeMode(2, QtHeaderToContents)
+            if model.columns == 4:
+                header.setSectionResizeMode(3, QtHeaderToContents)
+                header.setMaximumSectionSize(int(self._lastColSize * vp.width()))
+        return
 
-            self.novelView.openDocumentRequest.emit(tHandle, nwDocMode.VIEW, sTitle or "", False)
+    ##
+    #  Overloads
+    ##
 
+    def drawRow(self, painter: QPainter, opt: QStyleOptionViewItem, index: QModelIndex) -> None:
+        """Draw a box on the active row."""
+        if (model := self._getModel()) and model.handle(index) == self._actHandle:
+            painter.fillRect(opt.rect, self.palette().alternateBase())
+        super().drawRow(painter, opt, index)
         return
 
-    def focusOutEvent(self, event: QFocusEvent) -> None:
-        """Clear the selection when the tree no longer has focus."""
-        super().focusOutEvent(event)
-        self.clearSelection()
-        return
+    ##
+    #  Events
+    ##
 
     def resizeEvent(self, event: QResizeEvent) -> None:
-        """Elide labels in the extra column."""
+        """Process size changed."""
         super().resizeEvent(event)
-        newW = event.size().width()
-        oldW = event.oldSize().width()
-        if newW != oldW:
-            eliW = int(self._lastColSize * newW)
-            fMetric = self.fontMetrics()
-            for i in range(self.topLevelItemCount()):
-                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.TextElideMode.ElideRight, eliW)
-                    )
+        self.resizeColumns()
         return
 
     ##
     #  Private Slots
     ##
 
-    @pyqtSlot("QModelIndex")
-    def _treeItemClicked(self, index: QModelIndex) -> None:
-        """The user clicked on an item in the tree."""
-        if index.column() == self.C_MORE:
-            tHandle = index.siblingAtColumn(self.C_DATA).data(self.D_HANDLE)
-            sTitle = index.siblingAtColumn(self.C_DATA).data(self.D_TITLE)
-            tipPos = self.mapToGlobal(self.visualRect(index).topRight())
-            self._popMetaBox(tipPos, tHandle, sTitle)
-        return
-
-    @pyqtSlot()
-    def _treeSelectionChange(self) -> None:
-        """Extract the handle and line number of the currently selected
-        title, and send it to the tree meta panel.
-        """
-        tHandle, _ = self.getSelectedHandle()
-        if tHandle is not None:
-            self.novelView.selectedItemChanged.emit(tHandle)
-        return
-
-    @pyqtSlot("QTreeWidgetItem*", int)
-    def _treeDoubleClick(self, item: QTreeWidgetItem, column: int) -> None:
-        """Extract the handle and line number of the title double-
-        clicked, and send it to the main gui class for opening in the
-        document editor.
-        """
-        tHandle, sTitle = self.getSelectedHandle()
-        self.novelView.openDocumentRequest.emit(tHandle, nwDocMode.EDIT, sTitle or "", True)
+    @pyqtSlot(QModelIndex)
+    def _onSingleClick(self, index: QModelIndex) -> None:
+        """The user single-clicked an index."""
+        if index.isValid() and (model := self._getModel()):
+            if (tHandle := model.handle(index)) and (sTitle := model.key(index)):
+                self.novelView.selectedItemChanged.emit(tHandle)
+                if index.column() == model.columnCount(index) - 1:
+                    pos = self.mapToGlobal(self.visualRect(index).topRight())
+                    self._popMetaBox(pos, tHandle, sTitle)
+        return
+
+    @pyqtSlot(QModelIndex)
+    def _onDoubleClick(self, index: QModelIndex) -> None:
+        """The user double-clicked an index."""
+        if (
+            (model := self._getModel())
+            and (tHandle := model.handle(index))
+            and (sTitle := model.key(index))
+        ):
+            self.novelView.openDocumentRequest.emit(tHandle, nwDocMode.EDIT, sTitle, False)
+        return
+
+    @pyqtSlot(QModelIndex)
+    def _onMiddleClick(self, index: QModelIndex) -> None:
+        """The user middle-clicked an index."""
+        if (
+            (model := self._getModel())
+            and (tHandle := model.handle(index))
+            and (sTitle := model.key(index))
+        ):
+            self.novelView.openDocumentRequest.emit(tHandle, nwDocMode.VIEW, sTitle, False)
         return
 
     ##
     #  Internal Functions
     ##
 
-    def _populateTree(self, rootHandle: str | None) -> None:
-        """Build the tree based on the project index."""
-        self.clearContent()
-        tStart = time()
-        logger.debug("Building novel tree for root item '%s'", rootHandle)
-
-        novStruct = SHARED.project.index.novelStructure(rootHandle=rootHandle, activeOnly=True)
-        for tKey, tHandle, sTitle, novIdx in novStruct:
-            if novIdx.level == "H0":
-                continue
-
-            newItem = QTreeWidgetItem()
-            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, QtAlignRight)
-
-            self._updateTreeItemValues(newItem, novIdx, tHandle, sTitle)
-            self._treeMap[tKey] = newItem
-            self.addTopLevelItem(newItem)
-
-        self.setActiveHandle(self._actHandle)
-
-        logger.debug("Novel Tree built in %.3f ms", (time() - tStart)*1000)
-        self._lastBuild = time()
-
-        return
-
-    def _updateTreeItemValues(self, trItem: QTreeWidgetItem, idxItem: IndexHeading,
-                              tHandle: str, sTitle: str) -> None:
-        """Set the tree item values from the index entry."""
-        iLevel = nwStyles.H_LEVEL.get(idxItem.level, 0)
-        hDec = SHARED.theme.getHeaderDecoration(iLevel)
-
-        trItem.setData(self.C_TITLE, QtDecoration, 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, QtDecoration, self._pMore)
-
-        # Custom column
-        mW = int(self._lastColSize * self.viewport().width())
-        lastText, toolTip = self._getLastColumnText(tHandle, sTitle)
-        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)
-
-        return
-
-    def _getLastColumnText(self, tHandle: str, sTitle: str) -> tuple[str, str]:
-        """Generate text for the last column based on user settings."""
-        if self._lastCol == NovelTreeColumn.HIDDEN:
-            return "", ""
-
-        refData = []
-        refName = ""
-        refs = SHARED.project.index.getReferences(tHandle, sTitle)
-        if self._lastCol == NovelTreeColumn.POV:
-            refData = refs[nwKeyWords.POV_KEY]
-            refName = self._povLabel
-
-        elif self._lastCol == NovelTreeColumn.FOCUS:
-            refData = refs[nwKeyWords.FOCUS_KEY]
-            refName = self._focLabel
-
-        elif self._lastCol == NovelTreeColumn.PLOT:
-            refData = refs[nwKeyWords.PLOT_KEY]
-            refName = self._pltLabel
-
-        if refData:
-            toolText = ", ".join(refData)
-            return toolText, f"{refName}: {toolText}"
-
-        return "", ""
+    def _getModel(self) -> NovelModel | None:
+        """Return the model, if it exists."""
+        if isinstance(model := self.model(), NovelModel):
+            return model
+        return None
 
     def _popMetaBox(self, qPos: QPoint, tHandle: str, sTitle: str) -> None:
         """Show the novel meta data box."""
-        logger.debug("Generating meta data tooltip for '%s:%s'", tHandle, sTitle)
-
-        pIndex = SHARED.project.index
-        novIdx = pIndex.getItemHeading(tHandle, sTitle)
-        refTags = pIndex.getReferences(tHandle, sTitle)
-        if not novIdx:
+        def appendTags(refs: dict, key: str, lines: list[str]) -> None:
+            """Generate a reference list for a given reference key."""
+            if tags := ", ".join(refs.get(key, [])):
+                lines.append(f"<b>{trConst(nwLabels.KEY_NAME[key])}:</b> {tags}")
             return
 
-        synopText = novIdx.synopsis
-        if synopText:
-            synopLabel = trConst(nwLabels.OUTLINE_COLS[nwOutline.SYNOP])
-            synopText = f"<p><b>{synopLabel}</b>: {synopText}</p>"
-
-        refLines = []
-        refLines = self._appendMetaTag(refTags, nwKeyWords.POV_KEY, refLines)
-        refLines = self._appendMetaTag(refTags, nwKeyWords.FOCUS_KEY, refLines)
-        refLines = self._appendMetaTag(refTags, nwKeyWords.CHAR_KEY, refLines)
-        refLines = self._appendMetaTag(refTags, nwKeyWords.PLOT_KEY, refLines)
-        refLines = self._appendMetaTag(refTags, nwKeyWords.TIME_KEY, refLines)
-        refLines = self._appendMetaTag(refTags, nwKeyWords.WORLD_KEY, refLines)
-        refLines = self._appendMetaTag(refTags, nwKeyWords.OBJECT_KEY, refLines)
-        refLines = self._appendMetaTag(refTags, nwKeyWords.ENTITY_KEY, refLines)
-        refLines = self._appendMetaTag(refTags, nwKeyWords.CUSTOM_KEY, refLines)
-
-        refText = ""
-        if refLines:
-            refList = "<br>".join(refLines)
-            refText = f"<p>{refList}</p>"
-
-        ttText = refText + synopText or self.tr("No meta data")
-        if ttText:
-            QToolTip.showText(qPos, ttText)
-
-        return
-
-    @staticmethod
-    def _appendMetaTag(refs: dict, key: str, lines: list[str]) -> list[str]:
-        """Generate a reference list for a given reference key."""
-        tags = ", ".join(refs.get(key, []))
-        if tags:
-            lines.append(f"<b>{trConst(nwLabels.KEY_NAME[key])}</b>: {tags}")
-        return lines
+        if head := SHARED.project.index.getItemHeading(tHandle, sTitle):
+            logger.debug("Generating meta data tooltip for '%s:%s'", tHandle, sTitle)
+            if synopsis := head.synopsis:
+                label = trConst(nwLabels.OUTLINE_COLS[nwOutline.SYNOP])
+                synopsis = f"<p><b>{label}:</b> {synopsis}</p>"
+
+            lines = []
+            if head := SHARED.project.index.getItemHeading(tHandle, sTitle):
+                tags = head.getReferences()
+                appendTags(tags, nwKeyWords.POV_KEY, lines)
+                appendTags(tags, nwKeyWords.FOCUS_KEY, lines)
+                appendTags(tags, nwKeyWords.CHAR_KEY, lines)
+                appendTags(tags, nwKeyWords.PLOT_KEY, lines)
+                appendTags(tags, nwKeyWords.TIME_KEY, lines)
+                appendTags(tags, nwKeyWords.WORLD_KEY, lines)
+                appendTags(tags, nwKeyWords.OBJECT_KEY, lines)
+                appendTags(tags, nwKeyWords.ENTITY_KEY, lines)
+                appendTags(tags, nwKeyWords.CUSTOM_KEY, lines)
+
+            text = ""
+            if lines:
+                refs = "<br>".join(lines)
+                text = f"<p>{refs}</p>"
+            if tooltip := (text + synopsis or self.tr("No meta data")):
+                QToolTip.showText(qPos, tooltip)
+        return