novelWriter 2.6b1__py3-none-any.whl → 2.6b2__py3-none-any.whl

novelwriter/gui/search.py

@@ -30,15 +30,18 @@ from time import time
 from PyQt5.QtCore import Qt, pyqtSignal, pyqtSlot
 from PyQt5.QtGui import QCursor, QKeyEvent
 from PyQt5.QtWidgets import (
-    QApplication, QFrame, QHBoxLayout, QHeaderView, QLabel, QLineEdit,
-    QToolBar, QTreeWidget, QTreeWidgetItem, QVBoxLayout, QWidget
+    QApplication, QFrame, QHBoxLayout, QLabel, QLineEdit, QToolBar,
+    QTreeWidget, QTreeWidgetItem, QVBoxLayout, QWidget
 )
 
 from novelwriter import CONFIG, SHARED
 from novelwriter.common import checkInt, cssCol
 from novelwriter.core.coretools import DocSearch
 from novelwriter.core.item import NWItem
-from novelwriter.types import QtAlignMiddle, QtAlignRight, QtUserRole
+from novelwriter.types import (
+    QtAlignMiddle, QtAlignRight, QtHeaderStretch, QtHeaderToContents,
+    QtUserRole
+)
 
 logger = logging.getLogger(__name__)
 
@@ -120,8 +123,8 @@ class GuiProjectSearch(QWidget):
 
         treeHeader = self.searchResult.header()
         treeHeader.setStretchLastSection(False)
-        treeHeader.setSectionResizeMode(self.C_NAME, QHeaderView.ResizeMode.Stretch)
-        treeHeader.setSectionResizeMode(self.C_COUNT, QHeaderView.ResizeMode.ResizeToContents)
+        treeHeader.setSectionResizeMode(self.C_NAME, QtHeaderStretch)
+        treeHeader.setSectionResizeMode(self.C_COUNT, QtHeaderToContents)
 
         # Assemble
         self.headerBox = QHBoxLayout()
@@ -331,15 +334,11 @@ class GuiProjectSearch(QWidget):
         """Populate the result tree."""
         if results and nwItem:
             tHandle = nwItem.itemHandle
-            docIcon = SHARED.theme.getItemIcon(
-                nwItem.itemType, nwItem.itemClass,
-                nwItem.itemLayout, nwItem.mainHeading
-            )
             ext = "+" if capped else ""
 
             tItem = QTreeWidgetItem()
             tItem.setText(self.C_NAME, nwItem.itemName)
-            tItem.setIcon(self.C_NAME, docIcon)
+            tItem.setIcon(self.C_NAME, nwItem.getMainIcon())
             tItem.setData(self.C_NAME, self.D_HANDLE, tHandle)
             tItem.setText(self.C_COUNT, f"({len(results):n}{ext})")
             tItem.setTextAlignment(self.C_COUNT, QtAlignRight)

novelwriter/gui/theme.py

@@ -151,6 +151,9 @@ class GuiTheme:
         self.guiFont = QApplication.font()
         self.guiFontB = QApplication.font()
         self.guiFontB.setBold(True)
+        self.guiFontBU = QApplication.font()
+        self.guiFontBU.setBold(True)
+        self.guiFontBU.setUnderline(True)
         self.guiFontSmall = QApplication.font()
         self.guiFontSmall.setPointSizeF(0.9*self.guiFont.pointSizeF())
 
@@ -500,14 +503,15 @@ class GuiIcons:
 
         # Format Icons
         "fmt_bold", "fmt_bold-md", "fmt_italic", "fmt_italic-md", "fmt_mark", "fmt_strike",
-        "fmt_strike-md", "fmt_subscript", "fmt_superscript", "fmt_underline",
+        "fmt_strike-md", "fmt_subscript", "fmt_superscript", "fmt_underline", "margin_bottom",
+        "margin_left", "margin_right", "margin_top", "size_height", "size_width",
 
         # General Button Icons
         "add", "add_document", "backward", "bookmark", "browse", "checked", "close", "copy",
         "cross", "document", "down", "edit", "export", "font", "forward", "import", "list",
         "maximise", "menu", "minimise", "more", "noncheckable", "open", "panel", "quote",
-        "refresh", "remove", "revert", "search_replace", "search", "settings", "star", "unchecked",
-        "up", "view",
+        "refresh", "remove", "revert", "search_replace", "search", "settings", "star", "toolbar",
+        "unchecked", "up", "view",
 
         # Switches
         "sticky-on", "sticky-off",

novelwriter/guimain.py

@@ -44,7 +44,7 @@ from novelwriter.dialogs.about import GuiAbout
 from novelwriter.dialogs.preferences import GuiPreferences
 from novelwriter.dialogs.projectsettings import GuiProjectSettings
 from novelwriter.dialogs.wordlist import GuiWordList
-from novelwriter.enum import nwDocAction, nwDocInsert, nwDocMode, nwFocus, nwView
+from novelwriter.enum import nwDocAction, nwDocInsert, nwDocMode, nwFocus, nwItemType, nwView
 from novelwriter.gui.doceditor import GuiDocEditor
 from novelwriter.gui.docviewer import GuiDocViewer
 from novelwriter.gui.docviewerpanel import GuiDocViewerPanel
@@ -62,6 +62,7 @@ from novelwriter.tools.manuscript import GuiManuscript
 from novelwriter.tools.noveldetails import GuiNovelDetails
 from novelwriter.tools.welcome import GuiWelcome
 from novelwriter.tools.writingstats import GuiWritingStats
+from novelwriter.types import QtModShift
 
 logger = logging.getLogger(__name__)
 
@@ -212,15 +213,19 @@ class GuiMain(QMainWindow):
         SHARED.indexChangedTags.connect(self.docEditor.updateChangedTags)
         SHARED.indexChangedTags.connect(self.docViewerPanel.updateChangedTags)
         SHARED.indexCleared.connect(self.docViewerPanel.indexWasCleared)
-        SHARED.indexScannedText.connect(self.docViewerPanel.projectItemChanged)
-        SHARED.indexScannedText.connect(self.itemDetails.updateViewBox)
-        SHARED.indexScannedText.connect(self.projView.updateItemValues)
         SHARED.mainClockTick.connect(self._timeTick)
+        SHARED.projectItemChanged.connect(self.docEditor.onProjectItemChanged)
+        SHARED.projectItemChanged.connect(self.docViewer.onProjectItemChanged)
+        SHARED.projectItemChanged.connect(self.docViewerPanel.onProjectItemChanged)
+        SHARED.projectItemChanged.connect(self.itemDetails.onProjectItemChanged)
+        SHARED.projectItemChanged.connect(self.projView.onProjectItemChanged)
         SHARED.projectStatusChanged.connect(self.mainStatus.updateProjectStatus)
         SHARED.projectStatusMessage.connect(self.mainStatus.setStatusMessage)
+        SHARED.rootFolderChanged.connect(self.novelView.updateRootItem)
+        SHARED.rootFolderChanged.connect(self.outlineView.updateRootItem)
+        SHARED.rootFolderChanged.connect(self.projView.updateRootItem)
         SHARED.spellLanguageChanged.connect(self.mainStatus.setLanguage)
         SHARED.statusLabelsChanged.connect(self.docViewerPanel.updateStatusLabels)
-        SHARED.statusLabelsChanged.connect(self.projView.refreshUserLabels)
 
         self.mainMenu.requestDocAction.connect(self._passDocumentAction)
         self.mainMenu.requestDocInsert.connect(self._passDocumentInsert)
@@ -233,15 +238,7 @@ class GuiMain(QMainWindow):
 
         self.projView.openDocumentRequest.connect(self._openDocument)
         self.projView.projectSettingsRequest.connect(self.showProjectSettingsDialog)
-        self.projView.rootFolderChanged.connect(self.novelView.updateRootItem)
-        self.projView.rootFolderChanged.connect(self.outlineView.updateRootItem)
-        self.projView.rootFolderChanged.connect(self.projView.updateRootItem)
         self.projView.selectedItemChanged.connect(self.itemDetails.updateViewBox)
-        self.projView.treeItemChanged.connect(self.docEditor.updateDocInfo)
-        self.projView.treeItemChanged.connect(self.docViewer.updateDocInfo)
-        self.projView.treeItemChanged.connect(self.docViewerPanel.projectItemChanged)
-        self.projView.treeItemChanged.connect(self.itemDetails.updateViewBox)
-        self.projView.wordCountsChanged.connect(self._updateStatusWordCount)
 
         self.novelView.openDocumentRequest.connect(self._openDocument)
         self.novelView.selectedItemChanged.connect(self.itemDetails.updateViewBox)
@@ -250,8 +247,6 @@ class GuiMain(QMainWindow):
         self.projSearch.selectedItemChanged.connect(self.itemDetails.updateViewBox)
 
         self.docEditor.closeEditorRequest.connect(self.closeDocEditor)
-        self.docEditor.docCountsChanged.connect(self.itemDetails.updateCounts)
-        self.docEditor.docCountsChanged.connect(self.projView.updateCounts)
         self.docEditor.docTextChanged.connect(self.projSearch.textChanged)
         self.docEditor.editedStatusChanged.connect(self.mainStatus.updateDocumentStatus)
         self.docEditor.itemHandleChanged.connect(self.novelView.setActiveHandle)
@@ -259,7 +254,8 @@ class GuiMain(QMainWindow):
         self.docEditor.loadDocumentTagRequest.connect(self._followTag)
         self.docEditor.novelItemMetaChanged.connect(self.novelView.updateNovelItemMeta)
         self.docEditor.novelStructureChanged.connect(self.novelView.refreshTree)
-        self.docEditor.requestNewNoteCreation.connect(self.projView.createNewNote)
+        self.docEditor.openDocumentRequest.connect(self._openDocument)
+        self.docEditor.requestNewNoteCreation.connect(SHARED.createNewNote)
         self.docEditor.requestNextDocument.connect(self.openNextDocument)
         self.docEditor.requestProjectItemRenamed.connect(self.projView.renameTreeItem)
         self.docEditor.requestProjectItemSelected.connect(self.projView.setSelectedHandle)
@@ -297,14 +293,25 @@ class GuiMain(QMainWindow):
         self.keyReturn.setKey("Return")
         self.keyReturn.activated.connect(self._keyPressReturn)
 
+        self.keyShiftReturn = QShortcut(self)
+        self.keyShiftReturn.setKey("Shift+Return")
+        self.keyShiftReturn.activated.connect(self._keyPressReturn)
+
         self.keyEnter = QShortcut(self)
         self.keyEnter.setKey("Enter")
         self.keyEnter.activated.connect(self._keyPressReturn)
 
+        self.keyShiftEnter = QShortcut(self)
+        self.keyShiftEnter.setKey("Shift+Enter")
+        self.keyShiftEnter.activated.connect(self._keyPressReturn)
+
         self.keyEscape = QShortcut(self)
         self.keyEscape.setKey("Esc")
         self.keyEscape.activated.connect(self._keyPressEscape)
 
+        # Internal Variables
+        self._lastTotalCount = 0
+
         # Initialise Main GUI
         self.initMain()
         self.asProjTimer.start()
@@ -502,11 +509,9 @@ class GuiMain(QMainWindow):
 
     def saveProject(self, autoSave: bool = False) -> bool:
         """Save the current project."""
-        if not SHARED.hasProject:
-            logger.error("No project open")
-            return False
-        self.projView.saveProjectTasks()
-        return SHARED.saveProject(autoSave=autoSave)
+        if SHARED.hasProject:
+            return SHARED.saveProject(autoSave=autoSave)
+        return False
 
     ##
     #  Document Actions
@@ -718,8 +723,11 @@ class GuiMain(QMainWindow):
                 logger.warning("No item selected")
                 return
 
-            if tHandle:
-                self.openDocument(tHandle, sTitle=sTitle, changeFocus=False, doScroll=False)
+            if tHandle and SHARED.project.tree.checkType(tHandle, nwItemType.FILE):
+                if QApplication.keyboardModifiers() == QtModShift:
+                    self.viewDocument(tHandle)
+                else:
+                    self.openDocument(tHandle, sTitle=sTitle, changeFocus=False, doScroll=False)
 
         return
 
@@ -730,9 +738,8 @@ class GuiMain(QMainWindow):
             QApplication.setOverrideCursor(QCursor(Qt.CursorShape.WaitCursor))
             tStart = time()
 
-            self.projView.saveProjectTasks()
-            SHARED.project.index.rebuildIndex()
-            self.projView.populateTree()
+            SHARED.project.index.rebuild()
+            SHARED.project.tree.refreshAllItems()
             self.novelView.refreshTree()
 
             tEnd = time()
@@ -1044,13 +1051,8 @@ class GuiMain(QMainWindow):
         self.initMain()
         self.saveDocument()
 
-        if restart:
-            SHARED.info(self.tr(
-                "Some changes will not be applied until novelWriter has been restarted."
-            ))
-
         if tree:
-            self.projView.populateTree()
+            SHARED.project.tree.refreshAllItems()
 
         if theme:
             # We are doing this manually instead of connecting to
@@ -1076,8 +1078,16 @@ class GuiMain(QMainWindow):
         self.projView.initSettings()
         self.novelView.initSettings()
         self.outlineView.initSettings()
+
+        # Force update of word count
+        self._lastTotalCount = 0
         self._updateStatusWordCount()
 
+        if restart:
+            SHARED.info(self.tr(
+                "Some changes will not be applied until novelWriter has been restarted."
+            ))
+
         return
 
     @pyqtSlot()
@@ -1213,8 +1223,10 @@ class GuiMain(QMainWindow):
             self.mainStatus.setUserIdle(editIdle or userIdle)
             SHARED.updateIdleTime(currTime, editIdle or userIdle)
             self.mainStatus.updateTime(idleTime=SHARED.projectIdleTime)
-            if CONFIG.memInfo and int(currTime) % 5 == 0:  # pragma: no cover
-                self.mainStatus.memInfo()
+            if int(currTime) % 5 == 0:
+                self._updateStatusWordCount()
+                if CONFIG.memInfo:  # pragma: no cover
+                    self.mainStatus.memInfo()
         return
 
     @pyqtSlot()
@@ -1242,15 +1254,19 @@ class GuiMain(QMainWindow):
         if not SHARED.hasProject:
             self.mainStatus.setProjectStats(0, 0)
 
-        SHARED.project.updateWordCounts()
-        if CONFIG.incNotesWCount:
-            iTotal = sum(SHARED.project.data.initCounts)
-            cTotal = sum(SHARED.project.data.currCounts)
-            self.mainStatus.setProjectStats(cTotal, cTotal - iTotal)
-        else:
-            iNovel, _ = SHARED.project.data.initCounts
-            cNovel, _ = SHARED.project.data.currCounts
-            self.mainStatus.setProjectStats(cNovel, cNovel - iNovel)
+        currentTotalCount = SHARED.project.currentTotalCount
+        if self._lastTotalCount != currentTotalCount:
+            self._lastTotalCount = currentTotalCount
+
+            SHARED.project.updateWordCounts()
+            if CONFIG.incNotesWCount:
+                iTotal = sum(SHARED.project.data.initCounts)
+                cTotal = sum(SHARED.project.data.currCounts)
+                self.mainStatus.setProjectStats(cTotal, cTotal - iTotal)
+            else:
+                iNovel, _ = SHARED.project.data.initCounts
+                cNovel, _ = SHARED.project.data.currCounts
+                self.mainStatus.setProjectStats(cNovel, cNovel - iNovel)
 
         return
 

novelwriter/shared.py

@@ -26,6 +26,7 @@ from __future__ import annotations
 
 import logging
 
+from enum import Enum
 from pathlib import Path
 from time import time
 from typing import TYPE_CHECKING, TypeVar
@@ -37,9 +38,11 @@ from PyQt5.QtWidgets import QFileDialog, QFontDialog, QMessageBox, QWidget
 from novelwriter.common import formatFileFilter
 from novelwriter.constants import nwFiles
 from novelwriter.core.spellcheck import NWSpellEnchant
+from novelwriter.enum import nwChange, nwItemClass
 
 if TYPE_CHECKING:  # pragma: no cover
     from novelwriter.core.project import NWProject
+    from novelwriter.core.status import T_StatusKind
     from novelwriter.gui.theme import GuiTheme
     from novelwriter.guimain import GuiMain
 
@@ -55,15 +58,16 @@ class SharedData(QObject):
         "_idleTime", "_idleRefTime",
     )
 
-    projectStatusChanged = pyqtSignal(bool)
-    projectStatusMessage = pyqtSignal(str)
-    spellLanguageChanged = pyqtSignal(str, str)
     focusModeChanged = pyqtSignal(bool)
-    indexScannedText = pyqtSignal(str)
+    indexAvailable = pyqtSignal()
     indexChangedTags = pyqtSignal(list, list)
     indexCleared = pyqtSignal()
-    indexAvailable = pyqtSignal()
     mainClockTick = pyqtSignal()
+    projectItemChanged = pyqtSignal(str, Enum)
+    rootFolderChanged = pyqtSignal(str, Enum)
+    projectStatusChanged = pyqtSignal(bool)
+    projectStatusMessage = pyqtSignal(str)
+    spellLanguageChanged = pyqtSignal(str, str)
     statusLabelsChanged = pyqtSignal(str)
 
     def __init__(self) -> None:
@@ -173,10 +177,12 @@ class SharedData(QObject):
         logger.debug("Thread Pool Max Count: %d", QThreadPool.globalInstance().maxThreadCount())
         return
 
-    def closeEditor(self, tHandle: str | None = None) -> None:
+    def closeDocument(self, tHandle: str | None = None) -> None:
         """Close the document editor, optionally a specific document."""
         if tHandle is None or tHandle == self.mainGui.docEditor.docHandle:
             self.mainGui.closeDocument()
+        if tHandle is None or tHandle == self.mainGui.docViewer.docHandle:
+            self.mainGui.closeViewerPanel()
         return
 
     def saveEditor(self, tHandle: str | None = None) -> None:
@@ -302,30 +308,52 @@ class SharedData(QObject):
         QDesktopServices.openUrl(QUrl(url))
         return
 
+    @pyqtSlot(str, nwItemClass)
+    def createNewNote(self, tag: str, itemClass: nwItemClass) -> None:
+        """Process new note request."""
+        self.project.createNewNote(tag, itemClass)
+        return
+
     ##
-    #  Signal Proxy
+    #  Signal Proxies
     ##
 
-    def indexSignalProxy(self, data: dict) -> None:
-        """Emit signals on behalf of the index."""
-        event = data.get("event")
-        logger.debug("Received '%s' event from the index", event)
-        if event == "updateTags":
-            self.indexChangedTags.emit(data.get("updated", []), data.get("deleted", []))
-        elif event == "scanText":
-            self.indexScannedText.emit(data.get("handle", ""))
-        elif event == "clearIndex":
+    def emitIndexChangedTags(
+        self, project: NWProject, updated: list[str], deleted: list[str]
+    ) -> None:
+        """Emit the indexChangedTags signal."""
+        if self._project and self._project.data.uuid == project.data.uuid:
+            self.indexChangedTags.emit(updated, deleted)
+        return
+
+    def emitIndexCleared(self, project: NWProject) -> None:
+        """Emit the indexCleared signal."""
+        if self._project and self._project.data.uuid == project.data.uuid:
             self.indexCleared.emit()
-        elif event == "buildIndex":
+        return
+
+    def emitIndexAvailable(self, project: NWProject) -> None:
+        """Emit the indexAvailable signal."""
+        if self._project and self._project.data.uuid == project.data.uuid:
             self.indexAvailable.emit()
         return
 
-    def projectSingalProxy(self, data: dict) -> None:
-        """Emit signals on project data change."""
-        event = data.get("event")
-        logger.debug("Received '%s' event from project data", event)
-        if event == "statusLabels":
-            self.statusLabelsChanged.emit(data.get("kind", ""))
+    def emitStatusLabelsChanged(self, project: NWProject, kind: T_StatusKind) -> None:
+        """Emit the statusLabelsChanged signal."""
+        if self._project and self._project.data.uuid == project.data.uuid:
+            self.statusLabelsChanged.emit(kind)
+        return
+
+    def emitProjectItemChanged(self, project: NWProject, handle: str, change: nwChange) -> None:
+        """Emit the projectItemChanged signal."""
+        if self._project and self._project.data.uuid == project.data.uuid:
+            self.projectItemChanged.emit(handle, change)
+        return
+
+    def emitRootFolderChanged(self, project: NWProject, handle: str, change: nwChange) -> None:
+        """Emit the rootFolderChanged signal."""
+        if self._project and self._project.data.uuid == project.data.uuid:
+            self.rootFolderChanged.emit(handle, change)
         return
 
     ##
@@ -386,6 +414,7 @@ class SharedData(QObject):
         """Create a new project and spell checking instance."""
         from novelwriter.core.project import NWProject
         if isinstance(self._project, NWProject):
+            self._project.clear()
             del self._project
             del self._spelling
         self._project = NWProject()

novelwriter/text/patterns.py

@@ -28,11 +28,13 @@ import re
 
 from novelwriter import CONFIG
 from novelwriter.common import compact, uniqueCompact
-from novelwriter.constants import nwRegEx
+from novelwriter.constants import nwRegEx, nwUnicode
 
 
 class RegExPatterns:
 
+    AMBIGUOUS = (nwUnicode.U_APOS, nwUnicode.U_RSQUO)
+
     # Static RegExes
     _rxUrl     = re.compile(nwRegEx.URL, re.ASCII)
     _rxWords   = re.compile(nwRegEx.WORDS, re.UNICODE)
@@ -87,16 +89,25 @@ class RegExPatterns:
     def dialogStyle(self) -> re.Pattern | None:
         """Dialogue detection rule based on user settings."""
         if CONFIG.dialogStyle > 0:
-            end = "|$" if CONFIG.allowOpenDial else ""
             rx = []
             if CONFIG.dialogStyle in (1, 3):
                 qO = CONFIG.fmtSQuoteOpen.strip()[:1]
                 qC = CONFIG.fmtSQuoteClose.strip()[:1]
-                rx.append(f"(?:\\B{qO}.*?(?:{qC}\\B{end}))")
+                if qO == qC:
+                    rx.append(f"(?:\\B{qO}.+?{qC}\\B)")
+                else:
+                    rx.append(f"(?:{qO}[^{qO}]+{qC})")
+                if CONFIG.allowOpenDial:
+                    rx.append(f"(?:{qO}.+?$)")
             if CONFIG.dialogStyle in (2, 3):
                 qO = CONFIG.fmtDQuoteOpen.strip()[:1]
                 qC = CONFIG.fmtDQuoteClose.strip()[:1]
-                rx.append(f"(?:\\B{qO}.*?(?:{qC}\\B{end}))")
+                if qO == qC:
+                    rx.append(f"(?:\\B{qO}.+?{qC}\\B)")
+                else:
+                    rx.append(f"(?:{qO}[^{qO}]+{qC})")
+                if CONFIG.allowOpenDial:
+                    rx.append(f"(?:{qO}.+?$)")
             return re.compile("|".join(rx), re.UNICODE)
         return None
 
@@ -106,7 +117,8 @@ class RegExPatterns:
         if CONFIG.altDialogOpen and CONFIG.altDialogClose:
             qO = re.escape(compact(CONFIG.altDialogOpen))
             qC = re.escape(compact(CONFIG.altDialogClose))
-            return re.compile(f"\\B{qO}.*?{qC}\\B", re.UNICODE)
+            qB = r"\B" if (qO == qC or qC in self.AMBIGUOUS) else ""
+            return re.compile(f"{qO}.*?{qC}{qB}", re.UNICODE)
         return None
 
 

novelwriter/tools/manusbuild.py

@@ -179,14 +179,20 @@ class GuiManuscriptBuild(NDialog):
         self.buildBox.setVerticalSpacing(sp4)
 
         # Dialog Buttons
+        self.buttonBox = QDialogButtonBox(self)
+
         self.btnOpen = QPushButton(SHARED.theme.getIcon("browse"), self.tr("Open Folder"), self)
         self.btnOpen.setIconSize(bSz)
+        self.btnOpen.setAutoDefault(False)
+        self.buttonBox.addButton(self.btnOpen, QtRoleAction)
+
         self.btnBuild = QPushButton(SHARED.theme.getIcon("export"), self.tr("&Build"), self)
         self.btnBuild.setIconSize(bSz)
+        self.btnBuild.setAutoDefault(True)
+        self.buttonBox.addButton(self.btnBuild, QtRoleAction)
 
-        self.dlgButtons = QDialogButtonBox(QtDialogClose, self)
-        self.dlgButtons.addButton(self.btnOpen, QtRoleAction)
-        self.dlgButtons.addButton(self.btnBuild, QtRoleAction)
+        self.btnClose = self.buttonBox.addButton(QtDialogClose)
+        self.btnClose.setAutoDefault(False)
 
         # Assemble GUI
         # ============
@@ -213,7 +219,7 @@ class GuiManuscriptBuild(NDialog):
         self.outerBox.addSpacing(sp4)
         self.outerBox.addLayout(self.buildBox, 0)
         self.outerBox.addSpacing(sp16)
-        self.outerBox.addWidget(self.dlgButtons, 0)
+        self.outerBox.addWidget(self.buttonBox, 0)
         self.outerBox.setSpacing(0)
 
         self.setLayout(self.outerBox)
@@ -229,7 +235,7 @@ class GuiManuscriptBuild(NDialog):
         # Signals
         self.btnReset.clicked.connect(self._doResetBuildName)
         self.btnBrowse.clicked.connect(self._doSelectPath)
-        self.dlgButtons.clicked.connect(self._dialogButtonClicked)
+        self.buttonBox.clicked.connect(self._dialogButtonClicked)
         self.listFormats.itemSelectionChanged.connect(self._resetProgress)
 
         logger.debug("Ready: GuiManuscriptBuild")
@@ -260,7 +266,7 @@ class GuiManuscriptBuild(NDialog):
     @pyqtSlot("QAbstractButton*")
     def _dialogButtonClicked(self, button: QAbstractButton) -> None:
         """Handle button clicks from the dialog button box."""
-        role = self.dlgButtons.buttonRole(button)
+        role = self.buttonBox.buttonRole(button)
         if role == QtRoleAction:
             if button == self.btnBuild:
                 self._runBuild()
@@ -388,13 +394,9 @@ class GuiManuscriptBuild(NDialog):
                     if isinstance(rItem, NWItem):
                         rootMap[rHandle] = rItem.itemName
 
-                itemIcon = SHARED.theme.getItemIcon(
-                    nwItem.itemType, nwItem.itemClass,
-                    nwItem.itemLayout, nwItem.mainHeading
-                )
                 rootName = rootMap.get(rHandle, "??????")
                 item = QListWidgetItem(f"{rootName}: {nwItem.itemName}")
-                item.setIcon(itemIcon)
+                item.setIcon(nwItem.getMainIcon())
                 self.listContent.addItem(item)
 
         return