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

novelwriter/gui/theme.py

@@ -67,12 +67,13 @@ class GuiTheme:
         self.themeLicense     = ""
         self.themeLicenseUrl  = ""
         self.themeIcons       = ""
+        self.isLightTheme     = True
 
         # GUI
-        self.statNone    = [120, 120, 120]
-        self.statUnsaved = [200, 15, 39]
-        self.statSaved   = [2, 133, 37]
-        self.helpText    = [0, 0, 0]
+        self.statNone    = QColor(120, 120, 120)
+        self.statUnsaved = QColor(200, 15, 39)
+        self.statSaved   = QColor(2, 133, 37)
+        self.helpText    = QColor(0, 0, 0)
 
         # Loaded Syntax Settings
         # ======================
@@ -87,23 +88,24 @@ class GuiTheme:
         self.syntaxLicenseUrl  = ""
 
         # Colours
-        self.colBack   = [255, 255, 255]
-        self.colText   = [0, 0, 0]
-        self.colLink   = [0, 0, 0]
-        self.colHead   = [0, 0, 0]
-        self.colHeadH  = [0, 0, 0]
-        self.colEmph   = [0, 0, 0]
-        self.colDialN  = [0, 0, 0]
-        self.colDialD  = [0, 0, 0]
-        self.colDialS  = [0, 0, 0]
-        self.colHidden = [0, 0, 0]
-        self.colCode   = [0, 0, 0]
-        self.colKey    = [0, 0, 0]
-        self.colVal    = [0, 0, 0]
-        self.colSpell  = [0, 0, 0]
-        self.colError  = [0, 0, 0]
-        self.colRepTag = [0, 0, 0]
-        self.colMod    = [0, 0, 0]
+        self.colBack   = QColor(255, 255, 255)
+        self.colText   = QColor(0, 0, 0)
+        self.colLink   = QColor(0, 0, 0)
+        self.colHead   = QColor(0, 0, 0)
+        self.colHeadH  = QColor(0, 0, 0)
+        self.colEmph   = QColor(0, 0, 0)
+        self.colDialN  = QColor(0, 0, 0)
+        self.colDialD  = QColor(0, 0, 0)
+        self.colDialS  = QColor(0, 0, 0)
+        self.colHidden = QColor(0, 0, 0)
+        self.colCode   = QColor(0, 0, 0)
+        self.colKey    = QColor(0, 0, 0)
+        self.colVal    = QColor(0, 0, 0)
+        self.colOpt    = QColor(0, 0, 0)
+        self.colSpell  = QColor(0, 0, 0)
+        self.colError  = QColor(0, 0, 0)
+        self.colRepTag = QColor(0, 0, 0)
+        self.colMod    = QColor(0, 0, 0)
 
         # Class Setup
         # ===========
@@ -112,7 +114,7 @@ class GuiTheme:
         self._setGuiFont()
 
         # Load Themes
-        self._guiPalette  = QPalette()
+        self._guiPalette = QPalette()
         self._themeList: list[tuple[str, str]] = []
         self._syntaxList: list[tuple[str, str]] = []
         self._availThemes: dict[str, Path] = {}
@@ -254,13 +256,13 @@ class GuiTheme:
 
         backLNess = backCol.lightnessF()
         textLNess = textCol.lightnessF()
-
-        if self.helpText == [0, 0, 0]:
-            if backLNess > textLNess:
+        self.isLightTheme = backLNess > textLNess
+        if self.helpText == QColor(0, 0, 0):
+            if self.isLightTheme:
                 helpLCol = textLNess + 0.35*(backLNess - textLNess)
             else:
                 helpLCol = backLNess + 0.65*(textLNess - backLNess)
-            self.helpText = [int(255*helpLCol)]*3
+            self.helpText = QColor.fromHsl(0, 0, int(255*helpLCol))
 
         # Icons
         defaultIcons = "typicons_light" if backLNess >= 0.5 else "typicons_dark"
@@ -322,6 +324,7 @@ class GuiTheme:
             self.colCode   = self._parseColour(confParser, cnfSec, "shortcode")
             self.colKey    = self._parseColour(confParser, cnfSec, "keyword")
             self.colVal    = self._parseColour(confParser, cnfSec, "value")
+            self.colOpt    = self._parseColour(confParser, cnfSec, "optional")
             self.colSpell  = self._parseColour(confParser, cnfSec, "spellcheckline")
             self.colError  = self._parseColour(confParser, cnfSec, "errorline")
             self.colRepTag = self._parseColour(confParser, cnfSec, "replacetag")
@@ -367,22 +370,22 @@ class GuiTheme:
 
     def _setGuiFont(self) -> None:
         """Update the GUI's font style from settings."""
-        theFont = QFont()
+        font = QFont()
         fontDB = QFontDatabase()
         if CONFIG.guiFont not in fontDB.families():
             if CONFIG.osWindows and "Arial" in fontDB.families():
                 # On Windows we default to Arial if possible
-                theFont.setFamily("Arial")
-                theFont.setPointSize(10)
+                font.setFamily("Arial")
+                font.setPointSize(10)
             else:
-                theFont = fontDB.systemFont(QFontDatabase.GeneralFont)
-            CONFIG.guiFont = theFont.family()
-            CONFIG.guiFontSize = theFont.pointSize()
+                font = fontDB.systemFont(QFontDatabase.GeneralFont)
+            CONFIG.guiFont = font.family()
+            CONFIG.guiFontSize = font.pointSize()
         else:
-            theFont.setFamily(CONFIG.guiFont)
-            theFont.setPointSize(CONFIG.guiFontSize)
+            font.setFamily(CONFIG.guiFont)
+            font.setPointSize(CONFIG.guiFontSize)
 
-        qApp.setFont(theFont)
+        qApp.setFont(font)
 
         return
 
@@ -397,29 +400,14 @@ class GuiTheme:
 
         return True
 
-    def _parseColour(self, parser: NWConfigParser, section: str, name: str) -> list[int]:
+    def _parseColour(self, parser: NWConfigParser, section: str, name: str) -> QColor:
         """Parse a colour value from a config string."""
-        if parser.has_option(section, name):
-            values = parser.get(section, name).split(",")
-            result = []
-            try:
-                result.append(minmax(int(values[0]), 0, 255))
-                result.append(minmax(int(values[1]), 0, 255))
-                result.append(minmax(int(values[2]), 0, 255))
-            except Exception:
-                logger.error("Could not load theme colours for '%s' from config file", name)
-                result = [0, 0, 0]
-        else:
-            logger.warning("Could not find theme colours for '%s' in config file", name)
-            result = [0, 0, 0]
-        return result
+        return QColor(*parser.rdIntList(section, name, [0, 0, 0, 255]))
 
     def _setPalette(self, parser: NWConfigParser, section: str,
                     name: str, value: QPalette.ColorRole) -> None:
         """Set a palette colour value from a config string."""
-        self._guiPalette.setColor(
-            value, QColor(*self._parseColour(parser, section, name))
-        )
+        self._guiPalette.setColor(value, self._parseColour(parser, section, name))
         return
 
 # End Class GuiTheme
@@ -443,7 +431,7 @@ class GuiIcons:
     missing, a blank icon is returned and a warning issued.
     """
 
-    ICON_KEYS = {
+    ICON_KEYS: set[str] = {
         # Project and GUI Icons
         "novelwriter", "alert_error", "alert_info", "alert_question", "alert_warn",
         "build_excluded", "build_filtered", "build_included", "proj_chapter", "proj_details",
@@ -453,7 +441,7 @@ class GuiIcons:
 
         # Class Icons
         "cls_archive", "cls_character", "cls_custom", "cls_entity", "cls_none", "cls_novel",
-        "cls_object", "cls_plot", "cls_timeline", "cls_trash", "cls_world",
+        "cls_object", "cls_plot", "cls_template", "cls_timeline", "cls_trash", "cls_world",
 
         # Search Icons
         "search_cancel", "search_case", "search_loop", "search_preserve", "search_project",
@@ -464,9 +452,10 @@ class GuiIcons:
         "fmt_subscript", "fmt_superscript", "fmt_underline",
 
         # General Button Icons
-        "add", "backward", "bookmark", "browse", "checked", "close", "cross", "down", "edit",
-        "export", "forward", "maximise", "menu", "minimise", "noncheckable", "panel", "refresh",
-        "remove", "revert", "search_replace", "search", "settings", "unchecked", "up", "view",
+        "add", "add_document", "backward", "bookmark", "browse", "checked", "close", "cross",
+        "document", "down", "edit", "export", "forward", "import", "maximise", "menu", "minimise",
+        "more", "noncheckable", "panel", "refresh", "remove", "revert", "search_replace", "search",
+        "settings", "star", "unchecked", "up", "view",
 
         # Switches
         "sticky-on", "sticky-off",
@@ -478,13 +467,14 @@ class GuiIcons:
         "deco_doc_nt_n",
     }
 
-    TOGGLE_ICON_KEYS = {
+    TOGGLE_ICON_KEYS: dict[str, tuple[str, str]] = {
         "sticky": ("sticky-on", "sticky-off"),
         "bullet": ("bullet-on", "bullet-off"),
     }
 
-    IMAGE_MAP = {
-        "wiz-back": "wizard-back.jpg",
+    IMAGE_MAP: dict[str, tuple[str, str]] = {
+        "welcome":  ("welcome-light.jpg", "welcome-dark.jpg"),
+        "nw-text":  ("novelwriter-text-light.svg", "novelwriter-text-dark.svg"),
     }
 
     def __init__(self, mainTheme: GuiTheme) -> None:
@@ -598,7 +588,8 @@ class GuiIcons:
         if name in self._themeMap:
             imgPath = self._themeMap[name]
         elif name in self.IMAGE_MAP:
-            imgPath = CONFIG.assetPath("images") / self.IMAGE_MAP[name]
+            idx = 0 if self.mainTheme.isLightTheme else 1
+            imgPath = CONFIG.assetPath("images") / self.IMAGE_MAP[name][idx]
         else:
             logger.error("Decoration with name '%s' does not exist", name)
             return QPixmap()
@@ -608,12 +599,13 @@ class GuiIcons:
             return QPixmap()
 
         pixmap = QPixmap(str(imgPath))
+        tMode = Qt.TransformationMode.SmoothTransformation
         if w is not None and h is not None:
-            return pixmap.scaled(w, h, Qt.IgnoreAspectRatio, Qt.SmoothTransformation)
+            return pixmap.scaled(w, h, Qt.AspectRatioMode.IgnoreAspectRatio, tMode)
         elif w is None and h is not None:
-            return pixmap.scaledToHeight(h, Qt.SmoothTransformation)
+            return pixmap.scaledToHeight(h, tMode)
         elif w is not None and h is None:
-            return pixmap.scaledToWidth(w, Qt.SmoothTransformation)
+            return pixmap.scaledToWidth(w, tMode)
 
         return pixmap
 
@@ -632,8 +624,8 @@ class GuiIcons:
             pOne  = self.getPixmap(self.TOGGLE_ICON_KEYS[name][0], size)
             pTwo = self.getPixmap(self.TOGGLE_ICON_KEYS[name][1], size)
             icon = QIcon()
-            icon.addPixmap(pOne, QIcon.Normal, QIcon.On)
-            icon.addPixmap(pTwo, QIcon.Normal, QIcon.Off)
+            icon.addPixmap(pOne, QIcon.Mode.Normal, QIcon.State.On)
+            icon.addPixmap(pTwo, QIcon.Mode.Normal, QIcon.State.Off)
             return icon
         return QIcon()
 
@@ -641,7 +633,7 @@ class GuiIcons:
         """Return an icon from the icon buffer as a QPixmap. If it
         doesn't exist, return an empty QPixmap.
         """
-        return self.getIcon(name).pixmap(size[0], size[1], QIcon.Normal)
+        return self.getIcon(name).pixmap(size[0], size[1], QIcon.Mode.Normal)
 
     def getItemIcon(self, tType: nwItemType, tClass: nwItemClass,
                     tLayout: nwItemLayout, hLevel: str = "H0") -> QIcon:

novelwriter/guimain.py

@@ -30,14 +30,15 @@ from time import time
 from pathlib import Path
 from datetime import datetime
 
-from PyQt5.QtCore import Qt, QTimer, pyqtSlot
 from PyQt5.QtGui import QCloseEvent, QCursor, QIcon
+from PyQt5.QtCore import Qt, QTimer, pyqtSlot
 from PyQt5.QtWidgets import (
-    QDialog, QFileDialog, QHBoxLayout, QMainWindow, QMessageBox, QShortcut,
-    QSplitter, QStackedWidget, QVBoxLayout, QWidget, qApp
+    QFileDialog, QHBoxLayout, QMainWindow, QMessageBox, QShortcut, QSplitter,
+    QStackedWidget, QVBoxLayout, QWidget, qApp
 )
 
-from novelwriter import CONFIG, SHARED, __hexversion__
+from novelwriter import CONFIG, SHARED, __hexversion__, __version__
+from novelwriter.constants import nwConst
 from novelwriter.gui.theme import GuiTheme
 from novelwriter.gui.sidebar import GuiSideBar
 from novelwriter.gui.outline import GuiOutlineView
@@ -50,23 +51,19 @@ from novelwriter.gui.statusbar import GuiMainStatus
 from novelwriter.gui.itemdetails import GuiItemDetails
 from novelwriter.gui.docviewerpanel import GuiDocViewerPanel
 from novelwriter.dialogs.about import GuiAbout
-from novelwriter.dialogs.updates import GuiUpdates
-from novelwriter.dialogs.projload import GuiProjectLoad
 from novelwriter.dialogs.wordlist import GuiWordList
 from novelwriter.dialogs.preferences import GuiPreferences
-from novelwriter.dialogs.projdetails import GuiProjectDetails
-from novelwriter.dialogs.projsettings import GuiProjectSettings
+from novelwriter.dialogs.projectsettings import GuiProjectSettings
+from novelwriter.tools.welcome import GuiWelcome
 from novelwriter.tools.manuscript import GuiManuscript
-from novelwriter.tools.projwizard import GuiProjectWizard
 from novelwriter.tools.dictionaries import GuiDictionaries
+from novelwriter.tools.noveldetails import GuiNovelDetails
 from novelwriter.tools.writingstats import GuiWritingStats
-from novelwriter.core.coretools import ProjectBuilder
 
 from novelwriter.enum import (
-    nwDocAction, nwDocInsert, nwDocMode, nwItemType, nwItemClass, nwWidget, nwView
+    nwDocAction, nwDocInsert, nwDocMode, nwItemType, nwWidget, nwView
 )
-from novelwriter.common import hexToInt
-from novelwriter.constants import nwFiles
+from novelwriter.common import formatFileFilter, formatVersion, hexToInt
 
 logger = logging.getLogger(__name__)
 
@@ -82,13 +79,6 @@ class GuiMain(QMainWindow):
     function. Also, the project instance and theme instance are created
     here. These should be passed around to all other objects who need
     them and new instances of them should generally not be created.
-
-      * All other GUI classes that depend on any components from the
-        main GUI should be passed a reference to the instance of this
-        class.
-      * All non-GUI classes can be passed a reference to the NWProject
-        instance if the Main GUI is not needed (which it generally
-        shouldn't need).
     """
 
     def __init__(self) -> None:
@@ -359,12 +349,18 @@ class GuiMain(QMainWindow):
             self.openProject(cmdOpen)
 
         if not SHARED.hasProject:
-            self.showProjectLoadDialog()
+            self.showWelcomeDialog()
 
-        # Determine whether release notes need to be shown or not
+        # If this is a new release, let the user know
         if hexToInt(CONFIG.lastNotes) < hexToInt(__hexversion__):
             CONFIG.lastNotes = __hexversion__
-            self.showAboutNWDialog(showNotes=True)
+            trVersion = self.tr(
+                "You are now running novelWriter version {0}.".format(formatVersion(__version__))
+            )
+            trRelease = self.tr(
+                "Please check the {0}release notes{1} for further details."
+            ).format(f"<a href='{nwConst.URL_RELEASES}'>", "</a>")
+            SHARED.info(f"{trVersion}<br>{trRelease}")
 
         return
 
@@ -372,42 +368,6 @@ class GuiMain(QMainWindow):
     #  Project Actions
     ##
 
-    def newProject(self, projData: dict | None = None) -> bool:
-        """Create a new project via the new project wizard."""
-        if SHARED.hasProject:
-            if not self.closeProject():
-                SHARED.error(self.tr(
-                    "Cannot create a new project when another project is open."
-                ))
-                return False
-
-        if projData is None:
-            projData = self.showNewProjectDialog()
-
-        if projData is None:
-            return False
-
-        projPath = projData.get("projPath", None)
-        if projPath is None or projData is None:
-            logger.error("No projData or projPath set")
-            return False
-
-        if (Path(projPath) / nwFiles.PROJ_FILE).is_file():
-            SHARED.error(self.tr(
-                "A project already exists in that location. "
-                "Please choose another folder."
-            ))
-            return False
-
-        logger.info("Creating new project")
-        nwProject = ProjectBuilder()
-        if nwProject.buildProject(projData):
-            self.openProject(projPath)
-        else:
-            return False
-
-        return True
-
     def closeProject(self, isYes: bool = False) -> bool:
         """Close the project if one is open. isYes is passed on from the
         close application event so the user doesn't get prompted twice
@@ -446,7 +406,7 @@ class GuiMain(QMainWindow):
             self.docViewerPanel.closeProjectTasks()
             self.outlineView.closeProjectTasks()
             self.novelView.closeProjectTasks()
-            self.projView.clearProjectView()
+            self.projView.closeProjectTasks()
             self.itemDetails.clearDetails()
             self.mainStatus.clearStatus()
 
@@ -462,8 +422,7 @@ class GuiMain(QMainWindow):
         if projFile is None:
             return False
 
-        # Make sure any open project is cleared out first before we load
-        # another one
+        # Make sure any open project is cleared out first
         if not self.closeProject():
             return False
 
@@ -711,14 +670,9 @@ class GuiMain(QMainWindow):
             return False
 
         lastPath = CONFIG.lastPath()
-        extFilter = [
-            self.tr("Text files ({0})").format("*.txt"),
-            self.tr("Markdown files ({0})").format("*.md"),
-            self.tr("novelWriter files ({0})").format("*.nwd"),
-            self.tr("All files ({0})").format("*"),
-        ]
+        ffilter = formatFileFilter(["*.txt", "*.md", "*.nwd", "*"])
         loadFile, _ = QFileDialog.getOpenFileName(
-            self, self.tr("Import File"), str(lastPath), filter=";;".join(extFilter)
+            self, self.tr("Import File"), str(lastPath), filter=ffilter
         )
         if not loadFile:
             return False
@@ -726,10 +680,10 @@ class GuiMain(QMainWindow):
         if loadFile.strip() == "":
             return False
 
-        theText = None
+        text = None
         try:
             with open(loadFile, mode="rt", encoding="utf-8") as inFile:
-                theText = inFile.read()
+                text = inFile.read()
             CONFIG.setLastPath(loadFile)
         except Exception as exc:
             SHARED.error(self.tr(
@@ -751,7 +705,7 @@ class GuiMain(QMainWindow):
             if not msgYes:
                 return False
 
-        self.docEditor.replaceText(theText)
+        self.docEditor.replaceText(text)
 
         return True
 
@@ -838,33 +792,14 @@ class GuiMain(QMainWindow):
     #  Main Dialogs
     ##
 
-    def showProjectLoadDialog(self) -> None:
-        """Open the projects dialog for selecting either existing
-        projects from a cache of recently opened projects, or provide a
-        browse button for projects not yet cached. Selecting to create a
-        new project is forwarded to the new project wizard.
-        """
-        dlgProj = GuiProjectLoad(self)
-        dlgProj.exec_()
-
-        if dlgProj.result() == QDialog.Accepted:
-            if dlgProj.openState == GuiProjectLoad.OPEN_STATE:
-                self.openProject(dlgProj.openPath)
-            elif dlgProj.openState == GuiProjectLoad.NEW_STATE:
-                self.newProject()
-
+    @pyqtSlot()
+    def showWelcomeDialog(self) -> None:
+        """Open the welcome dialog."""
+        dialog = GuiWelcome(self)
+        dialog.openProjectRequest.connect(self._openProject)
+        dialog.exec_()
         return
 
-    def showNewProjectDialog(self) -> dict | None:
-        """Open the wizard and assemble a project options dict."""
-        newProj = GuiProjectWizard(self)
-        newProj.exec_()
-
-        if newProj.result() == QDialog.Accepted:
-            return self._assembleProjectWizardData(newProj)
-
-        return None
-
     @pyqtSlot()
     def showPreferencesDialog(self) -> None:
         """Open the preferences dialog."""
@@ -875,19 +810,19 @@ class GuiMain(QMainWindow):
 
     @pyqtSlot()
     @pyqtSlot(int)
-    def showProjectSettingsDialog(self, focusTab: int = GuiProjectSettings.TAB_MAIN) -> None:
+    def showProjectSettingsDialog(self, focusTab: int = GuiProjectSettings.PAGE_SETTINGS) -> None:
         """Open the project settings dialog."""
         if SHARED.hasProject:
-            dialog = GuiProjectSettings(self, focusTab=focusTab)
+            dialog = GuiProjectSettings(self, gotoPage=focusTab)
             dialog.newProjectSettingsReady.connect(self._processProjectSettingsChanges)
             dialog.exec_()
         return
 
     @pyqtSlot()
-    def showProjectDetailsDialog(self) -> None:
-        """Open the project details dialog."""
+    def showNovelDetailsDialog(self) -> None:
+        """Open the novel details dialog."""
         if SHARED.hasProject:
-            dialog = GuiProjectDetails(self)
+            dialog = GuiNovelDetails(self)
             dialog.setModal(True)
             dialog.show()
             dialog.raise_()
@@ -931,7 +866,7 @@ class GuiMain(QMainWindow):
         return
 
     @pyqtSlot()
-    def showAboutNWDialog(self, showNotes: bool = False) -> None:
+    def showAboutNWDialog(self) -> None:
         """Show the novelWriter about dialog."""
         dialog = GuiAbout(self)
         dialog.setModal(True)
@@ -939,8 +874,6 @@ class GuiMain(QMainWindow):
         dialog.raise_()
         qApp.processEvents()
         dialog.populateGUI()
-        if showNotes:
-            dialog.showReleaseNotes()
         return
 
     @pyqtSlot()
@@ -950,17 +883,6 @@ class GuiMain(QMainWindow):
         msgBox.aboutQt(self, "About Qt")
         return
 
-    @pyqtSlot()
-    def showUpdatesDialog(self) -> None:
-        """Show the check for updates dialog."""
-        dialog = GuiUpdates(self)
-        dialog.setModal(True)
-        dialog.show()
-        dialog.raise_()
-        qApp.processEvents()
-        dialog.checkLatest()
-        return
-
     @pyqtSlot()
     def showDictionariesDialog(self) -> None:
         """Show the download dictionaries dialog."""
@@ -1179,13 +1101,15 @@ class GuiMain(QMainWindow):
 
         return
 
-    @pyqtSlot()
-    def _processProjectSettingsChanges(self) -> None:
+    @pyqtSlot(bool)
+    def _processProjectSettingsChanges(self, rebuildTrees: bool) -> None:
         """Refresh data dependent on project settings."""
         logger.debug("Applying new project settings")
         SHARED.updateSpellCheckLanguage()
         self.itemDetails.refreshDetails()
         self._updateWindowTitle(SHARED.project.data.name)
+        if rebuildTrees:
+            self.rebuildTrees()
         return
 
     @pyqtSlot()
@@ -1207,6 +1131,13 @@ class GuiMain(QMainWindow):
                 self.viewDocument(tHandle=tHandle, sTitle=sTitle)
         return
 
+    @pyqtSlot(Path)
+    def _openProject(self, path: Path) -> None:
+        """Handle an open project request."""
+        qApp.processEvents()
+        self.openProject(path)
+        return
+
     @pyqtSlot(str, nwDocMode, str, bool)
     def _openDocument(self, tHandle: str, mode: nwDocMode, sTitle: str, setFocus: bool) -> None:
         """Handle an open document request."""
@@ -1461,44 +1392,6 @@ class GuiMain(QMainWindow):
         self.setWindowTitle(winTitle)
         return
 
-    def _assembleProjectWizardData(self, newProj: GuiProjectWizard) -> dict:
-        """Extract the user choices from the New Project Wizard and
-        store them in a dictionary.
-        """
-        projData = {
-            "projName": newProj.field("projName"),
-            "projTitle": newProj.field("projTitle"),
-            "projAuthor": newProj.field("projAuthor"),
-            "projPath": newProj.field("projPath"),
-            "popSample": newProj.field("popSample"),
-            "popMinimal": newProj.field("popMinimal"),
-            "popCustom": newProj.field("popCustom"),
-            "addRoots": [],
-            "addNotes": False,
-            "numChapters": 0,
-            "numScenes": 0,
-        }
-        if newProj.field("popCustom"):
-            addRoots = []
-            if newProj.field("addPlot"):
-                addRoots.append(nwItemClass.PLOT)
-            if newProj.field("addChar"):
-                addRoots.append(nwItemClass.CHARACTER)
-            if newProj.field("addWorld"):
-                addRoots.append(nwItemClass.WORLD)
-            projData["addRoots"] = addRoots
-            projData["addNotes"] = newProj.field("addNotes")
-            projData["numChapters"] = newProj.field("numChapters")
-            projData["numScenes"] = newProj.field("numScenes")
-
-        try:
-            langIdx = newProj.field("projLang")
-            projData["projLang"] = CONFIG.listLanguages(CONFIG.LANG_PROJ)[langIdx][0]
-        except Exception:
-            projData["projLang"] = "en_GB"
-
-        return projData
-
     def _getTagSource(self, tag: str) -> tuple[str | None, str | None]:
         """Handle the index lookup of a tag and display an alert if the
         tag cannot be found.

novelwriter/shared.py

@@ -31,8 +31,10 @@ from typing import TYPE_CHECKING, TypeVar
 from pathlib import Path
 
 from PyQt5.QtCore import QObject, QRunnable, QThreadPool, pyqtSignal
-from PyQt5.QtWidgets import QMessageBox, QWidget
+from PyQt5.QtWidgets import QFileDialog, QMessageBox, QWidget
+from novelwriter.common import formatFileFilter
 
+from novelwriter.constants import nwFiles
 from novelwriter.core.spellcheck import NWSpellEnchant
 
 if TYPE_CHECKING:  # pragma: no cover
@@ -217,6 +219,18 @@ class SharedData(QObject):
         QThreadPool.globalInstance().start(runnable, priority=priority)
         return
 
+    def getProjectPath(self, parent: QWidget, path: str | Path | None = None,
+                       allowZip: bool = False) -> Path | None:
+        """Open the file dialog and select a novelWriter project file."""
+        label = (self.tr("novelWriter Project File or Zip File")
+                 if allowZip else self.tr("novelWriter Project File"))
+        ext = f"{nwFiles.PROJ_FILE} *.zip" if allowZip else nwFiles.PROJ_FILE
+        ffilter = formatFileFilter([(label, ext), "*"])
+        selected, _ = QFileDialog.getOpenFileName(
+            parent, self.tr("Open Project"), str(path or ""), filter=ffilter
+        )
+        return Path(selected) if selected else None
+
     def findTopLevelWidget(self, kind: type[NWWidget]) -> NWWidget | None:
         """Find a top level widget."""
         for widget in self.mainGui.children():

novelwriter/tools/dictionaries.py

@@ -37,7 +37,7 @@ from PyQt5.QtWidgets import (
 
 from novelwriter import CONFIG, SHARED
 from novelwriter.error import formatException
-from novelwriter.common import openExternalPath, formatInt, getFileSize
+from novelwriter.common import formatFileFilter, openExternalPath, formatInt, getFileSize
 
 logger = logging.getLogger(__name__)
 
@@ -180,12 +180,11 @@ class GuiDictionaries(QDialog):
     @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("*"),
-        ]
+        ffilter = formatFileFilter([
+            (self.tr("Free or Libre Office extension"), "*.sox *.oxt"), "*"
+        ])
         soxFile, _ = QFileDialog.getOpenFileName(
-            self, self.tr("Browse Files"), "", filter=";;".join(extFilter)
+            self, self.tr("Browse Files"), "", filter=ffilter
         )
         if soxFile:
             path = Path(soxFile).absolute()