novelWriter 2.7.4__py3-none-any.whl → 2.8b1__py3-none-any.whl

novelwriter/shared.py

@@ -21,10 +21,11 @@ General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program. If not, see <https://www.gnu.org/licenses/>.
-"""
+"""  # noqa
 from __future__ import annotations
 
 import logging
+import re
 
 from enum import Enum
 from pathlib import Path
@@ -32,15 +33,17 @@ from time import time
 from typing import TYPE_CHECKING, TypeVar
 
 from PyQt6.QtCore import QObject, QRunnable, QThreadPool, QTimer, QUrl, pyqtSignal, pyqtSlot
-from PyQt6.QtGui import QDesktopServices, QFont
-from PyQt6.QtWidgets import QFileDialog, QFontDialog, QMessageBox, QWidget
+from PyQt6.QtGui import QDesktopServices, QFont, QScreen
+from PyQt6.QtWidgets import QApplication, 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
+from novelwriter.enum import nwChange, nwItemClass, nwStandardButton
 
 if TYPE_CHECKING:
+    from collections.abc import Callable
+
     from novelwriter.core.project import NWProject
     from novelwriter.core.status import T_StatusKind
     from novelwriter.gui.theme import GuiTheme
@@ -50,8 +53,16 @@ logger = logging.getLogger(__name__)
 
 NWWidget = TypeVar("NWWidget", bound=QWidget)
 
+RX_HTML = re.compile(r"<.*?>")
+
 
 class SharedData(QObject):
+    """Shared Data Singleton.
+
+    This is the class instantiated as the SHARED singleton. It holds
+    various globally needed data and pointers to important objects like
+    the main GUI, the current project, and the GUI theme.
+    """
 
     __slots__ = (
         "_gui", "_idleRefTime", "_idleTime", "_lastAlert", "_lockedBy",
@@ -91,8 +102,6 @@ class SharedData(QObject):
         self._clock.setInterval(1000)
         self._clock.timeout.connect(lambda: self.mainClockTick.emit())
 
-        return
-
     ##
     #  Properties
     ##
@@ -150,6 +159,11 @@ class SharedData(QObject):
         """Return the last alert message."""
         return self._lastAlert
 
+    @property
+    def mainScreen(self) -> QScreen | None:
+        """Return the screen of the main window."""
+        return QApplication.screenAt(self.mainGui.rect().center())
+
     ##
     #  Setters
     ##
@@ -159,7 +173,6 @@ class SharedData(QObject):
         if state is not self._focusMode:
             self._focusMode = state
             self.focusModeChanged.emit(state)
-        return
 
     ##
     #  Methods
@@ -170,7 +183,7 @@ class SharedData(QObject):
         is created.
         """
         self._theme = theme
-        return
+        self._theme.initThemes()
 
     def initSharedData(self, gui: GuiMain) -> None:
         """Initialise the SharedData instance. This must be called as
@@ -183,7 +196,6 @@ class SharedData(QObject):
         logger.debug("Ready: SharedData")
         if pool := QThreadPool.globalInstance():
             logger.debug("Thread Pool Max Count: %d", pool.maxThreadCount())
-        return
 
     def closeDocument(self, tHandle: str | None = None) -> None:
         """Close the document editor, optionally a specific document."""
@@ -191,7 +203,6 @@ class SharedData(QObject):
             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:
         """Save the editor content, optionally a specific document."""
@@ -202,7 +213,6 @@ class SharedData(QObject):
         ):
             logger.debug("Saving editor document before action")
             docEditor.saveText()
-        return
 
     def openProject(self, path: str | Path, clearLock: bool = False) -> bool:
         """Open a project."""
@@ -235,7 +245,6 @@ class SharedData(QObject):
         self.project.closeProject(self._idleTime)
         self._resetProject()
         self._resetIdleTimer()
-        return
 
     def updateSpellCheckLanguage(self, reload: bool = False) -> None:
         """Update the active spell check language from settings."""
@@ -245,7 +254,6 @@ class SharedData(QObject):
             self.spelling.setLanguage(language)
             _, provider = self.spelling.describeDict()
             self.spellLanguageChanged.emit(language, provider)
-        return
 
     def updateIdleTime(self, currTime: float, userIdle: bool) -> None:
         """Update the idle time record. If the userIdle flag is True,
@@ -256,27 +264,40 @@ class SharedData(QObject):
         if userIdle:
             self._idleTime += currTime - self._idleRefTime
         self._idleRefTime = currTime
-        return
+
+    def initMainProgress(self, maximum: int, inclusive: bool = False) -> None:
+        """Start a session for the main progress bar."""
+        if gui := self._gui:
+            gui.mainProgress.setMaximum(maximum - (1 if inclusive else 0))
+            gui.mainProgress.setValue(0)
+
+    def incMainProgress(self) -> None:
+        """Increment the value for the main progress bar."""
+        if gui := self._gui:
+            gui.mainProgress.setValue(gui.mainProgress.value() + 1)
+            QApplication.processEvents()
+
+    def clearMainProgress(self, delay: float = 1.0) -> None:
+        """Clear the main progress bar."""
+        if gui := self._gui:
+            QTimer.singleShot(int(delay*1000), gui.mainProgress.reset)
 
     def newStatusMessage(self, message: str) -> None:
         """Request a new status message. This is a callable function for
         core classes that cannot emit signals on their own.
         """
         self.projectStatusMessage.emit(message)
-        return
 
     def setGlobalProjectState(self, state: bool) -> None:
         """Change the global project status. This is a callable function
         for core classes that cannot emit signals on their own.
         """
         self.projectStatusChanged.emit(state)
-        return
 
     def runInThreadPool(self, runnable: QRunnable, priority: int = 0) -> None:
         """Queue a runnable in the application thread pool."""
         if pool := QThreadPool.globalInstance():
             pool.start(runnable, priority=priority)
-        return
 
     def getProjectPath(
         self, parent: QWidget,
@@ -315,13 +336,11 @@ class SharedData(QObject):
     def openWebsite(self, url: str) -> None:
         """Open a URL in the system's default browser."""
         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 Proxies
@@ -333,37 +352,31 @@ class SharedData(QObject):
         """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()
-        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 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
 
     ##
     #  Alert Boxes
@@ -376,9 +389,8 @@ class SharedData(QObject):
         alert.setAlertType(_GuiAlert.INFO, False)
         self._lastAlert = alert.logMessage
         if log:
-            logger.info(self._lastAlert, stacklevel=2)
+            self._logMessage(self._lastAlert, logger.info)
         alert.exec()
-        return
 
     def warn(self, text: str, info: str = "", details: str = "", log: bool = True) -> None:
         """Open a warning alert box."""
@@ -387,9 +399,8 @@ class SharedData(QObject):
         alert.setAlertType(_GuiAlert.WARN, False)
         self._lastAlert = alert.logMessage
         if log:
-            logger.warning(self._lastAlert, stacklevel=2)
+            self._logMessage(self._lastAlert, logger.warning)
         alert.exec()
-        return
 
     def error(self, text: str, info: str = "", details: str = "", log: bool = True,
               exc: Exception | None = None) -> None:
@@ -401,9 +412,8 @@ class SharedData(QObject):
             alert.setException(exc)
         self._lastAlert = alert.logMessage
         if log:
-            logger.error(self._lastAlert, stacklevel=2)
+            self._logMessage(self._lastAlert, logger.error)
         alert.exec()
-        return
 
     def question(self, text: str, info: str = "", details: str = "", warn: bool = False) -> bool:
         """Open a question box."""
@@ -412,13 +422,17 @@ class SharedData(QObject):
         alert.setAlertType(_GuiAlert.WARN if warn else _GuiAlert.ASK, True)
         self._lastAlert = alert.logMessage
         alert.exec()
-        isYes = alert.result() == QMessageBox.StandardButton.Yes
-        return isYes
+        return alert.finalState
 
     ##
     #  Internal Functions
     ##
 
+    def _logMessage(self, message: str, log: Callable) -> None:
+        """Print message to log."""
+        for text in message.split("<br>"):
+            log(RX_HTML.sub("", text), stacklevel=3)
+
     def _resetProject(self) -> None:
         """Create a new project and spell checking instance."""
         from novelwriter.core.project import NWProject
@@ -430,13 +444,11 @@ class SharedData(QObject):
         self._spelling = NWSpellEnchant(self._project)
         self.updateSpellCheckLanguage()
         self._focusMode = False
-        return
 
     def _resetIdleTimer(self) -> None:
         """Reset the timer data for the idle timer."""
         self._idleRefTime = time()
         self._idleTime = 0.0
-        return
 
     def _closeToolDialogs(self) -> None:
         """Close all open tool dialogs."""
@@ -444,7 +456,6 @@ class SharedData(QObject):
         for widget in self.mainGui.children():
             if isinstance(widget, NToolDialog):
                 widget.close()
-        return
 
 
 class _GuiAlert(QMessageBox):
@@ -458,51 +469,71 @@ class _GuiAlert(QMessageBox):
         super().__init__(parent=parent)
         self._theme = theme
         self._message = ""
+        self._state = False
         logger.debug("Ready: _GuiAlert")
-        return
 
     def __del__(self) -> None:  # pragma: no cover
         logger.debug("Delete: _GuiAlert")
-        return
 
     @property
     def logMessage(self) -> str:
         return self._message
 
+    @property
+    def finalState(self) -> bool:
+        return self._state
+
     def setMessage(self, text: str, info: str, details: str) -> None:
         """Set the alert box message."""
         self._message = " ".join(filter(None, [text, info, details]))
         self.setText(text)
         self.setInformativeText(info)
         self.setDetailedText(details)
-        return
 
     def setException(self, exception: Exception) -> None:
         """Add exception details."""
         info = self.informativeText()
         text = f"<b>{type(exception).__name__}</b>: {exception!s}"
         self.setInformativeText(f"{info}<br>{text}" if info else text)
-        return
 
     def setAlertType(self, level: int, isYesNo: bool) -> None:
         """Set the type of alert and whether the dialog should have
         Yes/No buttons or just an Ok button.
         """
         if isYesNo:
-            self.setStandardButtons(QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No)
+            self._btnYes = self._theme.getStandardButton(nwStandardButton.YES, self)
+            self._btnYes.clicked.connect(self._onAccept)
+            self._btnNo  = self._theme.getStandardButton(nwStandardButton.NO, self)
+            self._btnNo.clicked.connect(self._onReject)
+            self.addButton(self._btnYes, QMessageBox.ButtonRole.YesRole)
+            self.addButton(self._btnNo, QMessageBox.ButtonRole.NoRole)
         else:
-            self.setStandardButtons(QMessageBox.StandardButton.Ok)
-        pSz = 2*self._theme.baseIconHeight
+            self._btnOk = self._theme.getStandardButton(nwStandardButton.OK, self)
+            self._btnOk.clicked.connect(self._onAccept)
+            self.addButton(self._btnOk, QMessageBox.ButtonRole.AcceptRole)
+
+        pSz = 2*self._theme.fontPixelSize
         if level == self.INFO:
-            self.setIconPixmap(self._theme.getPixmap("alert_info", (pSz, pSz), "blue"))
+            self.setIconPixmap(self._theme.getPixmap("alert_info", (pSz, pSz), "info"))
             self.setWindowTitle(self.tr("Information"))
         elif level == self.WARN:
-            self.setIconPixmap(self._theme.getPixmap("alert_warn", (pSz, pSz), "orange"))
+            self.setIconPixmap(self._theme.getPixmap("alert_warn", (pSz, pSz), "warning"))
             self.setWindowTitle(self.tr("Warning"))
         elif level == self.ERROR:
-            self.setIconPixmap(self._theme.getPixmap("alert_error", (pSz, pSz), "red"))
+            self.setIconPixmap(self._theme.getPixmap("alert_error", (pSz, pSz), "error"))
             self.setWindowTitle(self.tr("Error"))
         elif level == self.ASK:
-            self.setIconPixmap(self._theme.getPixmap("alert_question", (pSz, pSz), "blue"))
+            self.setIconPixmap(self._theme.getPixmap("alert_question", (pSz, pSz), "info"))
             self.setWindowTitle(self.tr("Question"))
-        return
+
+    @pyqtSlot()
+    def _onAccept(self) -> None:
+        """Process accepted state."""
+        self._state = True
+        self.close()
+
+    @pyqtSlot()
+    def _onReject(self) -> None:
+        """Process rejected state."""
+        self._state = False
+        self.close()

novelwriter/splash.py

@@ -20,7 +20,7 @@ General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program. If not, see <https://www.gnu.org/licenses/>.
-"""
+"""  # noqa
 from __future__ import annotations
 
 import logging
@@ -38,6 +38,14 @@ SPLASH_IMG = Path(__file__).parent / "assets" / "images" / "splash.png"
 
 
 class NSplashScreen(QSplashScreen):
+    """GUI: App Launch Splash Screen.
+
+    A small splash screen that is shown as novelWriter starts up. Its
+    primary purpose is to provide user feedback that the app is being
+    initiated when there are delays in the process while Qt waits for
+    responses from the OS, or has to load particularly large data sets
+    like when the system has a lot of fonts installed.
+    """
 
     __slots__ = ("_color", "_rect", "_text")
 
@@ -52,17 +60,14 @@ class NSplashScreen(QSplashScreen):
         self._color = QColor(26, 52, 78)
         self._rect = QRect(144, 110, 440, 30)
         self._text = ""
-        return
 
     def __del__(self) -> None:  # pragma: no cover
         logger.debug("Delete: NSplashScreen")
-        return
 
     def drawContents(self, painter: QPainter) -> None:
         """Draw the text message."""
         painter.setPen(self._color)
         painter.drawText(self._rect, Qt.AlignmentFlag.AlignLeft, self._text)
-        return
 
     def showStatus(self, message: str) -> None:
         """Update the status message."""
@@ -71,4 +76,3 @@ class NSplashScreen(QSplashScreen):
         if message:
             logger.info("[Splash] %s", message)
         sleep(0.025)
-        return

novelwriter/text/comments.py

@@ -21,7 +21,7 @@ General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program. If not, see <https://www.gnu.org/licenses/>.
-"""
+"""  # noqa
 from __future__ import annotations
 
 from novelwriter.enum import nwComment

novelwriter/text/counting.py

@@ -22,7 +22,7 @@ General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program. If not, see <https://www.gnu.org/licenses/>.
-"""
+"""  # noqa
 from __future__ import annotations
 
 import re
@@ -74,9 +74,11 @@ def preProcessText(text: str, keepHeaders: bool = True) -> list[str]:
 
 
 def standardCounter(text: str) -> tuple[int, int, int]:
-    """A counter that counts paragraphs, words and characters.
-    This is the standard counter that includes headings in the word and
-    character counts.
+    """Return a standard count.
+
+    A counter that counts paragraphs, words and characters. This is the
+    standard counter that includes headings in the word and character
+    counts.
     """
     cCount = 0
     wCount = 0
@@ -124,7 +126,9 @@ def standardCounter(text: str) -> tuple[int, int, int]:
 
 
 def bodyTextCounter(text: str) -> tuple[int, int, int]:
-    """A counter that counts body text words, characters, and characters
+    """Return a body text count.
+
+    A counter that counts body text words, characters, and characters
     without white spaces.
     """
     wCount = 0

novelwriter/text/patterns.py

@@ -21,7 +21,7 @@ General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program. If not, see <https://www.gnu.org/licenses/>.
-"""
+"""  # noqa
 from __future__ import annotations
 
 import re
@@ -32,18 +32,20 @@ from novelwriter.constants import nwRegEx, nwUnicode
 
 
 class RegExPatterns:
+    """Compiled RegEx Patterns."""
 
     AMBIGUOUS = (nwUnicode.U_APOS, nwUnicode.U_RSQUO)
 
     # Static RegExes
     _rxUrl     = re.compile(nwRegEx.URL, re.ASCII)
-    _rxWords   = re.compile(nwRegEx.WORDS, re.UNICODE)
-    _rxBreak   = re.compile(nwRegEx.BREAK, re.UNICODE)
-    _rxItalic  = re.compile(nwRegEx.FMT_EI, re.UNICODE)
-    _rxBold    = re.compile(nwRegEx.FMT_EB, re.UNICODE)
-    _rxStrike  = re.compile(nwRegEx.FMT_ST, re.UNICODE)
-    _rxSCPlain = re.compile(nwRegEx.FMT_SC, re.UNICODE)
-    _rxSCValue = re.compile(nwRegEx.FMT_SV, re.UNICODE)
+    _rxWords   = re.compile(nwRegEx.WORDS)
+    _rxBreak   = re.compile(nwRegEx.BREAK)
+    _rxItalic  = re.compile(nwRegEx.FMT_EI)
+    _rxBold    = re.compile(nwRegEx.FMT_EB)
+    _rxStrike  = re.compile(nwRegEx.FMT_ST)
+    _rxMark    = re.compile(nwRegEx.FMT_HL)
+    _rxSCPlain = re.compile(nwRegEx.FMT_SC)
+    _rxSCValue = re.compile(nwRegEx.FMT_SV)
 
     @property
     def url(self) -> re.Pattern:
@@ -75,6 +77,11 @@ class RegExPatterns:
         """Markdown strikethrough style."""
         return self._rxStrike
 
+    @property
+    def markdownMark(self) -> re.Pattern:
+        """Markdown highlight style."""
+        return self._rxMark
+
     @property
     def shortcodePlain(self) -> re.Pattern:
         """Plain shortcode style."""
@@ -108,7 +115,7 @@ class RegExPatterns:
                     rx.append(f"(?:{qO}[^{qO}]+{qC})")
                 if CONFIG.allowOpenDial:
                     rx.append(f"(?:{qO}.+?$)")
-            return re.compile("|".join(rx), re.UNICODE)
+            return re.compile("|".join(rx))
         return None
 
     @property
@@ -118,7 +125,7 @@ class RegExPatterns:
             qO = re.escape(compact(CONFIG.altDialogOpen))
             qC = re.escape(compact(CONFIG.altDialogClose))
             qB = r"\B" if (qO == qC or qC in self.AMBIGUOUS) else ""
-            return re.compile(f"{qO}.*?{qC}{qB}", re.UNICODE)
+            return re.compile(f"{qO}.*?{qC}{qB}")
         return None
 
 
@@ -126,6 +133,7 @@ REGEX_PATTERNS = RegExPatterns()
 
 
 class DialogParser:
+    """A callable parser for finding dialog regions in text."""
 
     __slots__ = (
         "_alternate", "_breakD", "_breakQ", "_dialog", "_enabled", "_mode",
@@ -141,7 +149,6 @@ class DialogParser:
         self._breakD = None
         self._breakQ = None
         self._mode = ""
-        return
 
     @property
     def enabled(self) -> bool:
@@ -163,13 +170,11 @@ class DialogParser:
         # Build narrator break RegExes
         if narrator := CONFIG.narratorBreak.strip()[:1]:
             punct = re.escape(".,:;!?")
-            self._breakD = re.compile(f"{narrator}.*?(?:{narrator}[{punct}]?|$)", re.UNICODE)
-            self._breakQ = re.compile(f"{narrator}.*?(?:{narrator}[{punct}]?)", re.UNICODE)
+            self._breakD = re.compile(f"{narrator}.*?(?:{narrator}[{punct}]?|$)")
+            self._breakQ = re.compile(f"{narrator}.*?(?:{narrator}[{punct}]?)")
             self._narrator = narrator
             self._mode = f" {narrator}"
 
-        return
-
     def __call__(self, text: str) -> list[tuple[int, int]]:
         """Caller wrapper for dialogue processing."""
         temp: list[int] = []

novelwriter/tools/dictionaries.py

@@ -20,7 +20,7 @@ General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program. If not, see <https://www.gnu.org/licenses/>.
-"""
+"""  # noqa
 from __future__ import annotations
 
 import logging
@@ -37,14 +37,21 @@ from PyQt6.QtWidgets import (
 
 from novelwriter import CONFIG, SHARED
 from novelwriter.common import formatFileFilter, formatInt, getFileSize, openExternalPath
+from novelwriter.enum import nwStandardButton
 from novelwriter.error import formatException
 from novelwriter.extensions.modified import NIconToolButton, NNonBlockingDialog
-from novelwriter.types import QtDialogClose, QtHexArgb
+from novelwriter.types import QtHexArgb, QtRoleDestruct
 
 logger = logging.getLogger(__name__)
 
 
 class GuiDictionaries(NNonBlockingDialog):
+    """GUI: Spell Check Dictionary Tool.
+
+    A helper tool for downloading and extracting dictionaries to a
+    location where Enchant can find them. This tool is only needed on
+    Windows.
+    """
 
     def __init__(self, parent: QWidget) -> None:
         super().__init__(parent=parent)
@@ -72,10 +79,10 @@ class GuiDictionaries(NNonBlockingDialog):
         self.huInfo.setOpenExternalLinks(True)
         self.huInfo.setWordWrap(True)
         self.huInput = QLineEdit(self)
-        self.huBrowse = NIconToolButton(self, iSz, "browse")
+        self.huBrowse = NIconToolButton(self, iSz, "browse", "systemio")
         self.huBrowse.clicked.connect(self._doBrowseHunspell)
         self.huImport = QPushButton(self.tr("Add Dictionary"), self)
-        self.huImport.setIcon(SHARED.theme.getIcon("add", "green"))
+        self.huImport.setIcon(SHARED.theme.getIcon("add", "add"))
         self.huImport.clicked.connect(self._doImportHunspell)
 
         self.huPathBox = QHBoxLayout()
@@ -90,7 +97,7 @@ class GuiDictionaries(NNonBlockingDialog):
         self.inInfo = QLabel(self.tr("Dictionary install location"), self)
         self.inPath = QLineEdit(self)
         self.inPath.setReadOnly(True)
-        self.inBrowse = NIconToolButton(self, iSz, "browse")
+        self.inBrowse = NIconToolButton(self, iSz, "browse", "systemio")
         self.inBrowse.clicked.connect(self._doOpenInstallLocation)
 
         self.inBox = QHBoxLayout()
@@ -104,8 +111,11 @@ class GuiDictionaries(NNonBlockingDialog):
         self.infoBox.setFrameStyle(QFrame.Shape.NoFrame)
 
         # Buttons
-        self.buttonBox = QDialogButtonBox(QtDialogClose, self)
-        self.buttonBox.rejected.connect(self.reject)
+        self.btnClose = SHARED.theme.getStandardButton(nwStandardButton.CLOSE, self)
+        self.btnClose.clicked.connect(self.reject)
+
+        self.btnBox = QDialogButtonBox(self)
+        self.btnBox.addButton(self.btnClose, QtRoleDestruct)
 
         # Assemble
         self.outerBox = QVBoxLayout()
@@ -117,17 +127,14 @@ class GuiDictionaries(NNonBlockingDialog):
         self.outerBox.addLayout(self.inBox, 0)
         self.outerBox.addWidget(self.infoBox, 1)
         self.outerBox.addSpacing(8)
-        self.outerBox.addWidget(self.buttonBox, 0)
+        self.outerBox.addWidget(self.btnBox, 0)
 
         self.setLayout(self.outerBox)
 
         logger.debug("Ready: GuiDictionaries")
 
-        return
-
     def __del__(self) -> None:  # pragma: no cover
         logger.debug("Delete: GuiDictionaries")
-        return
 
     def initDialog(self) -> bool:
         """Prepare and check that we can proceed."""
@@ -164,7 +171,6 @@ class GuiDictionaries(NNonBlockingDialog):
         """Capture the user closing the window."""
         event.accept()
         self.softDelete()
-        return
 
     ##
     #  Private Slots
@@ -182,7 +188,6 @@ class GuiDictionaries(NNonBlockingDialog):
         if soxFile:
             path = Path(soxFile).absolute()
             self.huInput.setText(str(path))
-        return
 
     @pyqtSlot()
     def _doImportHunspell(self) -> None:
@@ -202,14 +207,12 @@ class GuiDictionaries(NNonBlockingDialog):
                     self._appendLog(formatException(exc), err=True)
             else:
                 self._appendLog(procErr, err=True)
-        return
 
     @pyqtSlot()
     def _doOpenInstallLocation(self) -> None:
         """Open the dictionary folder."""
         if not openExternalPath(Path(self.inPath.text())):
             SHARED.error("Path not found.")
-        return
 
     ##
     #  Internal Functions
@@ -247,4 +250,3 @@ class GuiDictionaries(NNonBlockingDialog):
         cursor.movePosition(QTextCursor.MoveOperation.End)
         cursor.deleteChar()
         self.infoBox.setTextCursor(cursor)
-        return