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

novelwriter/shared.py

@@ -3,10 +3,11 @@ novelWriter – Shared Data Class
 ===============================
 
 File History:
-Created: 2023-08-10 [2.1rc1]
+Created: 2023-08-10 [2.1rc1] SharedData
+Created: 2023-08-14 [2.1rc1] _GuiAlert
 
 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
@@ -26,7 +27,7 @@ from __future__ import annotations
 import logging
 
 from time import time
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, TypeVar
 from pathlib import Path
 
 from PyQt5.QtCore import QObject, QRunnable, QThreadPool, pyqtSignal
@@ -41,17 +42,23 @@ if TYPE_CHECKING:  # pragma: no cover
 
 logger = logging.getLogger(__name__)
 
+NWWidget = TypeVar("NWWidget", bound=QWidget)
+
 
 class SharedData(QObject):
 
     __slots__ = (
-        "_gui", "_theme", "_project", "_spelling", "_lockedBy", "_alert",
+        "_gui", "_theme", "_project", "_spelling", "_lockedBy", "_lastAlert",
         "_idleTime", "_idleRefTime",
     )
 
     projectStatusChanged = pyqtSignal(bool)
     projectStatusMessage = pyqtSignal(str)
     spellLanguageChanged = pyqtSignal(str, str)
+    indexScannedText = pyqtSignal(str)
+    indexChangedTags = pyqtSignal(list, list)
+    indexCleared = pyqtSignal()
+    indexAvailable = pyqtSignal()
 
     def __init__(self) -> None:
         super().__init__()
@@ -64,7 +71,7 @@ class SharedData(QObject):
 
         # Settings
         self._lockedBy = None
-        self._alert = None
+        self._lastAlert = ""
         self._idleTime = 0.0
         self._idleRefTime = time()
 
@@ -118,9 +125,9 @@ class SharedData(QObject):
         return self._idleTime
 
     @property
-    def alert(self) -> _GuiAlert | None:
-        """Return a pointer to the last alert box."""
-        return self._alert
+    def lastAlert(self) -> str:
+        """Return the last alert message."""
+        return self._lastAlert
 
     ##
     #  Methods
@@ -171,7 +178,7 @@ class SharedData(QObject):
         return
 
     def updateSpellCheckLanguage(self, reload: bool = False) -> None:
-        """Update the active spell check langauge from settings."""
+        """Update the active spell check language from settings."""
         from novelwriter import CONFIG
         language = self.project.data.spellLang or CONFIG.spellLanguage
         if language != self.spelling.spellLanguage or reload:
@@ -210,50 +217,84 @@ class SharedData(QObject):
         QThreadPool.globalInstance().start(runnable, priority=priority)
         return
 
+    def findTopLevelWidget(self, kind: type[NWWidget]) -> NWWidget | None:
+        """Find a top level widget."""
+        for widget in self.mainGui.children():
+            if isinstance(widget, kind):
+                return widget
+        return None
+
+    ##
+    #  Signal Proxy
+    ##
+
+    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":
+            self.indexCleared.emit()
+        elif event == "buildIndex":
+            self.indexAvailable.emit()
+        return
+
     ##
     #  Alert Boxes
     ##
 
     def info(self, text: str, info: str = "", details: str = "", log: bool = True) -> None:
         """Open an information alert box."""
-        self._alert = _GuiAlert(self.mainGui, self.theme)
-        self._alert.setMessage(text, info, details)
-        self._alert.setAlertType(_GuiAlert.INFO, False)
+        alert = _GuiAlert(self.mainGui, self.theme)
+        alert.setMessage(text, info, details)
+        alert.setAlertType(_GuiAlert.INFO, False)
+        self._lastAlert = alert.logMessage
         if log:
-            logger.info(self._alert.logMessage, stacklevel=2)
-        self._alert.exec_()
+            logger.info(self._lastAlert, stacklevel=2)
+        alert.exec_()
+        alert.deleteLater()
         return
 
     def warn(self, text: str, info: str = "", details: str = "", log: bool = True) -> None:
         """Open a warning alert box."""
-        self._alert = _GuiAlert(self.mainGui, self.theme)
-        self._alert.setMessage(text, info, details)
-        self._alert.setAlertType(_GuiAlert.WARN, False)
+        alert = _GuiAlert(self.mainGui, self.theme)
+        alert.setMessage(text, info, details)
+        alert.setAlertType(_GuiAlert.WARN, False)
+        self._lastAlert = alert.logMessage
         if log:
-            logger.warning(self._alert.logMessage, stacklevel=2)
-        self._alert.exec_()
+            logger.warning(self._lastAlert, stacklevel=2)
+        alert.exec_()
+        alert.deleteLater()
         return
 
     def error(self, text: str, info: str = "", details: str = "", log: bool = True,
               exc: Exception | None = None) -> None:
         """Open an error alert box."""
-        self._alert = _GuiAlert(self.mainGui, self.theme)
-        self._alert.setMessage(text, info, details)
-        self._alert.setAlertType(_GuiAlert.ERROR, False)
+        alert = _GuiAlert(self.mainGui, self.theme)
+        alert.setMessage(text, info, details)
+        alert.setAlertType(_GuiAlert.ERROR, False)
         if exc:
-            self._alert.setException(exc)
+            alert.setException(exc)
+        self._lastAlert = alert.logMessage
         if log:
-            logger.error(self._alert.logMessage, stacklevel=2)
-        self._alert.exec_()
+            logger.error(self._lastAlert, stacklevel=2)
+        alert.exec_()
+        alert.deleteLater()
         return
 
     def question(self, text: str, info: str = "", details: str = "", warn: bool = False) -> bool:
         """Open a question box."""
-        self._alert = _GuiAlert(self.mainGui, self.theme)
-        self._alert.setMessage(text, info, details)
-        self._alert.setAlertType(_GuiAlert.WARN if warn else _GuiAlert.ASK, True)
-        self._alert.exec_()
-        return self._alert.result() == QMessageBox.Yes
+        alert = _GuiAlert(self.mainGui, self.theme)
+        alert.setMessage(text, info, details)
+        alert.setAlertType(_GuiAlert.WARN if warn else _GuiAlert.ASK, True)
+        self._lastAlert = alert.logMessage
+        alert.exec_()
+        isYes = alert.result() == QMessageBox.StandardButton.Yes
+        alert.deleteLater()
+        return isYes
 
     ##
     #  Internal Functions
@@ -290,6 +331,11 @@ class _GuiAlert(QMessageBox):
         super().__init__(parent=parent)
         self._theme = theme
         self._message = ""
+        logger.debug("Ready: _GuiAlert")
+        return
+
+    def __del__(self) -> None:  # pragma: no cover
+        logger.debug("Delete: _GuiAlert")
         return
 
     @property

novelwriter/tools/dictionaries.py

@@ -0,0 +1,268 @@
+"""
+novelWriter – GUI Dictionary Downloader
+=======================================
+
+File History:
+Created: 2023-11-19 [2.2rc1] GuiDictionaries
+
+This file is a part of novelWriter
+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
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+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/>.
+"""
+from __future__ import annotations
+
+import logging
+
+from pathlib import Path
+from zipfile import ZipFile
+
+from PyQt5.QtGui import QCloseEvent, QTextCursor
+from PyQt5.QtCore import pyqtSlot
+from PyQt5.QtWidgets import (
+    QDialog, QDialogButtonBox, QFileDialog, QFrame, QHBoxLayout, QLabel,
+    QLineEdit, QPlainTextEdit, QPushButton, QVBoxLayout, QWidget, qApp
+)
+
+from novelwriter import CONFIG, SHARED
+from novelwriter.error import formatException
+from novelwriter.common import openExternalPath, formatInt, getFileSize
+
+logger = logging.getLogger(__name__)
+
+
+class GuiDictionaries(QDialog):
+
+    def __init__(self, parent: QWidget) -> None:
+        super().__init__(parent=parent)
+
+        logger.debug("Create: GuiDictionaries")
+        self.setObjectName("GuiDictionaries")
+        self.setWindowTitle(self.tr("Add Dictionaries"))
+
+        self._installPath = None
+        self._currDicts = set()
+
+        iPx = CONFIG.pxInt(4)
+        mPx = CONFIG.pxInt(8)
+        sPx = CONFIG.pxInt(16)
+
+        self.setMinimumWidth(CONFIG.pxInt(500))
+        self.setMinimumHeight(CONFIG.pxInt(300))
+
+        # Hunspell Dictionaries
+        foUrl = "https://www.freeoffice.com/en/download/dictionaries"
+        loUrl = "https://extensions.libreoffice.org"
+        self.huInfo = QLabel("<br>".join([
+            self.tr("Download a dictionary from one of the links, and add it below."),
+            f"&nbsp;\u203a <a href='{foUrl}'>{foUrl}</a>",
+            f"&nbsp;\u203a <a href='{loUrl}'>{loUrl}</a>",
+        ]))
+        self.huInfo.setOpenExternalLinks(True)
+        self.huInfo.setWordWrap(True)
+        self.huInput = QLineEdit(self)
+        self.huBrowse = QPushButton(self)
+        self.huBrowse.setIcon(SHARED.theme.getIcon("browse"))
+        self.huBrowse.clicked.connect(self._doBrowseHunspell)
+        self.huImport = QPushButton(self.tr("Add Dictionary"), self)
+        self.huImport.setIcon(SHARED.theme.getIcon("add"))
+        self.huImport.clicked.connect(self._doImportHunspell)
+
+        self.huPathBox = QHBoxLayout()
+        self.huPathBox.addWidget(self.huInput)
+        self.huPathBox.addWidget(self.huBrowse)
+        self.huPathBox.setSpacing(iPx)
+        self.huAddBox = QHBoxLayout()
+        self.huAddBox.addStretch(1)
+        self.huAddBox.addWidget(self.huImport)
+
+        # Install Path
+        self.inInfo = QLabel(self.tr("Dictionary install location"))
+        self.inPath = QLineEdit(self)
+        self.inPath.setReadOnly(True)
+        self.inBrowse = QPushButton(self)
+        self.inBrowse.setIcon(SHARED.theme.getIcon("browse"))
+        self.inBrowse.clicked.connect(self._doOpenInstallLocation)
+
+        self.inBox = QHBoxLayout()
+        self.inBox.addWidget(self.inPath)
+        self.inBox.addWidget(self.inBrowse)
+        self.inBox.setSpacing(iPx)
+
+        # Info Box
+        self.infoBox = QPlainTextEdit(self)
+        self.infoBox.setReadOnly(True)
+        self.infoBox.setFixedHeight(4*SHARED.theme.fontPixelSize)
+        self.infoBox.setFrameStyle(QFrame.Shape.NoFrame)
+
+        # Buttons
+        self.buttonBox = QDialogButtonBox(QDialogButtonBox.Close)
+        self.buttonBox.rejected.connect(self._doClose)
+
+        # Assemble
+        self.innerBox = QVBoxLayout()
+        self.innerBox.addWidget(self.huInfo)
+        self.innerBox.addLayout(self.huPathBox)
+        self.innerBox.addLayout(self.huAddBox)
+        self.innerBox.addSpacing(mPx)
+        self.innerBox.addWidget(self.inInfo)
+        self.innerBox.addLayout(self.inBox)
+        self.innerBox.addWidget(self.infoBox)
+        self.innerBox.setSpacing(iPx)
+
+        self.outerBox = QVBoxLayout()
+        self.outerBox.addLayout(self.innerBox, 0)
+        self.outerBox.addStretch(1)
+        self.outerBox.addWidget(self.buttonBox, 0)
+        self.outerBox.setSpacing(sPx)
+
+        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."""
+        try:
+            import enchant
+            path = Path(enchant.get_user_config_dir())
+        except Exception:
+            logger.error("Could not get enchant path")
+            return False
+
+        self._installPath = Path(path).resolve()
+        if path.is_dir():
+            self.inPath.setText(str(path))
+            hunspell = path / "hunspell"
+            if hunspell.is_dir():
+                self._currDicts = set(
+                    i.stem for i in hunspell.iterdir() if i.is_file() and i.suffix == ".aff"
+                )
+            self._appendLog(self.tr(
+                "Additional dictionaries found: {0}"
+            ).format(len(self._currDicts)))
+
+        qApp.processEvents()
+        self.adjustSize()
+
+        return True
+
+    ##
+    #  Events
+    ##
+
+    def closeEvent(self, event: QCloseEvent) -> None:
+        """Capture the user closing the window."""
+        event.accept()
+        self.deleteLater()
+        return
+
+    ##
+    #  Private Slots
+    ##
+
+    @pyqtSlot()
+    def _doBrowseHunspell(self):
+        """Browse for a Free/Libre Office dictionary."""
+        extFilter = [
+            self.tr("Free or Libre Office extension ({0})").format("*.sox *.oxt"),
+            self.tr("All files ({0})").format("*"),
+        ]
+        soxFile, _ = QFileDialog.getOpenFileName(
+            self, self.tr("Browse Files"), "", filter=";;".join(extFilter)
+        )
+        if soxFile:
+            path = Path(soxFile).absolute()
+            self.huInput.setText(str(path))
+        return
+
+    @pyqtSlot()
+    def _doImportHunspell(self):
+        """Import a hunspell dictionary from .sox or .oxt file."""
+        procErr = self.tr("Could not process dictionary file")
+        if self._installPath:
+            temp = self.huInput.text()
+            if temp and (path := Path(temp)).is_file():
+                hunspell = self._installPath / "hunspell"
+                hunspell.mkdir(exist_ok=True)
+                try:
+                    nAff, nDic = self._extractDicts(path, hunspell)
+                    if nAff == 0 or nDic == 0:
+                        self._appendLog(procErr, err=True)
+                except Exception as exc:
+                    self._appendLog(procErr, err=True)
+                    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
+
+    @pyqtSlot()
+    def _doClose(self) -> None:
+        """Close the dialog."""
+        self.close()
+        return
+
+    ##
+    #  Internal Functions
+    ##
+
+    def _extractDicts(self, path: Path, output: Path) -> tuple[int, int]:
+        """Extract a zip archive and return the number of .aff and .dic
+        files found in it.
+        """
+        nAff = nDic = 0
+        with ZipFile(path, mode="r") as zipObj:
+            for item in zipObj.namelist():
+                zPath = Path(item)
+                if zPath.suffix not in (".aff", ".dic"):
+                    continue
+                nAff += 1 if zPath.suffix == ".aff" else 0
+                nDic += 1 if zPath.suffix == ".dic" else 0
+                with zipObj.open(item) as zF:
+                    oPath = output / zPath.name
+                    oPath.write_bytes(zF.read())
+                    size = getFileSize(oPath)
+                    self._appendLog(self.tr(
+                        "Added: {0} [{1}B]"
+                    ).format(zPath.name, formatInt(size)))
+        return nAff, nDic
+
+    def _appendLog(self, text: str, err: bool = False) -> None:
+        """Append a line to the log output."""
+        cursor = self.infoBox.textCursor()
+        cursor.movePosition(QTextCursor.MoveOperation.End)
+        if cursor.position() > 0:
+            cursor.insertText("\n")
+        if err:
+            cursor.insertHtml(f"<font color='red'>{text}</font>")
+        else:
+            cursor.insertText(text)
+        cursor.movePosition(QTextCursor.MoveOperation.End)
+        cursor.deleteChar()
+        self.infoBox.setTextCursor(cursor)
+        return
+
+# END Class GuiDictionaries

novelwriter/tools/lipsum.py

@@ -3,10 +3,10 @@ novelWriter – Lorem Ipsum Tool
 ==============================
 
 File History:
-Created: 2022-04-02 [2.0rc1]
+Created: 2022-04-02 [2.0rc1] GuiLipsum
 
 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
@@ -26,10 +26,10 @@ from __future__ import annotations
 import random
 import logging
 
-from PyQt5.QtCore import Qt
+from PyQt5.QtCore import Qt, pyqtSlot
 from PyQt5.QtWidgets import (
-    QDialog, QGridLayout, QHBoxLayout, QVBoxLayout, QLabel, QDialogButtonBox,
-    QSpinBox
+    QDialog, QDialogButtonBox, QGridLayout, QHBoxLayout, QLabel, QSpinBox,
+    QVBoxLayout, QWidget
 )
 
 from novelwriter import CONFIG, SHARED
@@ -41,15 +41,15 @@ logger = logging.getLogger(__name__)
 
 class GuiLipsum(QDialog):
 
-    def __init__(self, mainGui):
-        super().__init__(parent=mainGui)
+    def __init__(self, parent: QWidget) -> None:
+        super().__init__(parent=parent)
 
         logger.debug("Create: GuiLipsum")
         self.setObjectName("GuiLipsum")
         if CONFIG.osDarwin:
             self.setWindowFlag(Qt.WindowType.Tool)
 
-        self.mainGui = mainGui
+        self._lipsumText = ""
 
         self.setWindowTitle(self.tr("Insert Placeholder Text"))
 
@@ -92,14 +92,16 @@ class GuiLipsum(QDialog):
 
         # Buttons
         self.buttonBox = QDialogButtonBox()
-        self.buttonBox.rejected.connect(self._doClose)
+        self.buttonBox.rejected.connect(self.close)
 
         self.btnClose = self.buttonBox.addButton(QDialogButtonBox.Close)
         self.btnClose.setAutoDefault(False)
 
-        self.btnSave = self.buttonBox.addButton(self.tr("Insert"), QDialogButtonBox.ActionRole)
-        self.btnSave.clicked.connect(self._doInsert)
-        self.btnSave.setAutoDefault(False)
+        self.btnInsert = self.buttonBox.addButton(self.tr("Insert"), QDialogButtonBox.ActionRole)
+        self.btnInsert.clicked.connect(self._doInsert)
+        self.btnInsert.setAutoDefault(False)
+
+        self.rejected.connect(self.close)
 
         # Assemble
         self.outerBox = QVBoxLayout()
@@ -112,33 +114,37 @@ class GuiLipsum(QDialog):
 
         return
 
-    def __del__(self):  # pragma: no cover
+    def __del__(self) -> None:  # pragma: no cover
         logger.debug("Delete: GuiLipsum")
         return
 
+    @property
+    def lipsumText(self) -> str:
+        """Return the generated text."""
+        return self._lipsumText
+
+    @classmethod
+    def getLipsum(cls, parent: QWidget) -> str:
+        """Pop the dialog and return the lipsum text."""
+        cls = GuiLipsum(parent)
+        cls.exec_()
+        text = cls.lipsumText
+        cls.deleteLater()
+        return text
+
     ##
-    #  Slots
+    #  Private Slots
     ##
 
-    def _doInsert(self):
-        """Load the text and insert it in the open document.
-        """
+    @pyqtSlot()
+    def _doInsert(self) -> None:
+        """Generate the text."""
         lipsumFile = CONFIG.assetPath("text") / "lipsum.txt"
         lipsumText = readTextFile(lipsumFile).splitlines()
-
         if self.randSwitch.isChecked():
             random.shuffle(lipsumText)
-
         pCount = self.paraCount.value()
-        inText = "\n\n".join(lipsumText[0:pCount]) + "\n\n"
-
-        self.mainGui.docEditor.insertText(inText)
-
-        return
-
-    def _doClose(self):
-        """Close the dialog window without doing anything.
-        """
+        self._lipsumText = "\n\n".join(lipsumText[0:pCount]) + "\n\n"
         self.close()
         return
 

novelwriter/tools/manusbuild.py

@@ -6,7 +6,7 @@ File History:
 Created: 2023-05-24 [2.1b1] GuiManuscriptBuild
 
 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,6 +27,7 @@ import logging
 
 from pathlib import Path
 
+from PyQt5.QtGui import QCloseEvent
 from PyQt5.QtCore import QSize, QTimer, Qt, pyqtSlot
 from PyQt5.QtWidgets import (
     QAbstractButton, QAbstractItemView, QDialog, QDialogButtonBox, QFileDialog,
@@ -36,7 +37,7 @@ from PyQt5.QtWidgets import (
 
 from novelwriter import CONFIG, SHARED
 from novelwriter.enum import nwBuildFmt
-from novelwriter.common import makeFileNameSafe
+from novelwriter.common import makeFileNameSafe, openExternalPath
 from novelwriter.constants import nwLabels
 from novelwriter.core.item import NWItem
 from novelwriter.core.docbuild import NWBuildDocument
@@ -175,9 +176,11 @@ class GuiManuscriptBuild(QDialog):
         self.buildBox.setVerticalSpacing(sp4)
 
         # Dialog Buttons
+        self.btnOpen = QPushButton(SHARED.theme.getIcon("browse"), self.tr("Open Folder"))
         self.btnBuild = QPushButton(SHARED.theme.getIcon("export"), self.tr("&Build"))
-        self.dlgButtons = QDialogButtonBox(QDialogButtonBox.Close)
-        self.dlgButtons.addButton(self.btnBuild, QDialogButtonBox.ActionRole)
+        self.dlgButtons = QDialogButtonBox(QDialogButtonBox.StandardButton.Close)
+        self.dlgButtons.addButton(self.btnOpen, QDialogButtonBox.ButtonRole.ActionRole)
+        self.dlgButtons.addButton(self.btnBuild, QDialogButtonBox.ButtonRole.ActionRole)
 
         # Assemble GUI
         # ============
@@ -227,7 +230,7 @@ class GuiManuscriptBuild(QDialog):
 
         return
 
-    def __del__(self):  # pragma: no cover
+    def __del__(self) -> None:  # pragma: no cover
         logger.debug("Delete: GuiManuscriptBuild")
         return
 
@@ -235,7 +238,7 @@ class GuiManuscriptBuild(QDialog):
     #  Events
     ##
 
-    def closeEvent(self, event):
+    def closeEvent(self, event: QCloseEvent) -> None:
         """Capture the user closing the window so we can save GUI
         settings.
         """
@@ -253,7 +256,10 @@ class GuiManuscriptBuild(QDialog):
         """Handle button clicks from the dialog button box."""
         role = self.dlgButtons.buttonRole(button)
         if role == QDialogButtonBox.ActionRole:
-            self._runBuild()
+            if button == self.btnBuild:
+                self._runBuild()
+            elif button == self.btnOpen:
+                self._openOutputFolder()
         elif role == QDialogButtonBox.RejectRole:
             self.close()
         return
@@ -325,7 +331,7 @@ class GuiManuscriptBuild(QDialog):
         self._build.setLastBuildName(bName)
         self._build.setLastFormat(bFormat)
 
-        QTimer.singleShot(1000, self._resetProgress)
+        QTimer.singleShot(3000, self._resetProgress)
 
         return True
 
@@ -338,8 +344,6 @@ class GuiManuscriptBuild(QDialog):
 
     def _saveSettings(self):
         """Save the user GUI settings."""
-        logger.debug("Saving GuiManuscriptBuild settings")
-
         winWidth  = CONFIG.rpxInt(self.width())
         winHeight = CONFIG.rpxInt(self.height())
 
@@ -347,6 +351,7 @@ class GuiManuscriptBuild(QDialog):
         fmtWidth = CONFIG.rpxInt(mainSplit[0])
         sumWidth = CONFIG.rpxInt(mainSplit[1])
 
+        logger.debug("Saving State: GuiManuscriptBuild")
         pOptions = SHARED.project.options
         pOptions.setValue("GuiManuscriptBuild", "winWidth", winWidth)
         pOptions.setValue("GuiManuscriptBuild", "winHeight", winHeight)
@@ -385,4 +390,9 @@ class GuiManuscriptBuild(QDialog):
 
         return
 
+    def _openOutputFolder(self):
+        """Open the build folder in the system's file explorer."""
+        openExternalPath(Path(self.buildPath.text()))
+        return
+
 # END Class GuiManuscriptBuild