novelWriter 2.2rc1__py3-none-any.whl → 2.3b1__py3-none-any.whl

novelwriter/guimain.py

@@ -6,7 +6,7 @@ File History:
 Created: 2018-09-22 [0.0.1] GuiMain
 
 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
@@ -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,24 +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.tools.lipsum import GuiLipsum
+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 getGuiItem, hexToInt
-from novelwriter.constants import nwFiles
+from novelwriter.common import formatFileFilter, formatVersion, hexToInt
 
 logger = logging.getLogger(__name__)
 
@@ -83,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:
@@ -338,19 +327,9 @@ class GuiMain(QMainWindow):
         self.asProjTimer.start()
         self.asDocTimer.start()
         self.mainStatus.clearStatus()
-
-        # Handle Windows Mode
         self.showNormal()
 
         logger.debug("Ready: GUI")
-
-        if __hexversion__[-2] == "a" and not CONFIG.isDebug:
-            SHARED.warn(
-                "You are running an untested development version of novelWriter. "
-                "Please be careful when you are working on live projects "
-                "and make sure you take regular backups."
-            )
-
         logger.info("novelWriter is ready ...")
         self.mainStatus.setStatusMessage(self.tr("novelWriter is ready ..."))
 
@@ -370,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
 
@@ -383,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
@@ -457,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()
 
@@ -473,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
 
@@ -617,7 +565,7 @@ class GuiMain(QMainWindow):
         if self.docEditor.loadText(tHandle, tLine):
             SHARED.project.data.setLastHandle(tHandle, "editor")
             self.projView.setSelectedHandle(tHandle, doScroll=doScroll)
-            self.novelView.setActiveHandle(tHandle)
+            self.novelView.setActiveHandle(tHandle, doScroll=doScroll)
             if changeFocus:
                 self.docEditor.setFocus()
         else:
@@ -722,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
@@ -737,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(
@@ -762,7 +705,7 @@ class GuiMain(QMainWindow):
             if not msgYes:
                 return False
 
-        self.docEditor.replaceText(theText)
+        self.docEditor.replaceText(text)
 
         return True
 
@@ -849,240 +792,108 @@ 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."""
-        dlgConf = GuiPreferences(self)
-        dlgConf.exec_()
-
-        if dlgConf.result() == QDialog.Accepted:
-            logger.debug("Applying new preferences")
-            self.initMain()
-            self.saveDocument()
-
-            if dlgConf.needsRestart:
-                SHARED.info(self.tr(
-                    "Some changes will not be applied until novelWriter has been restarted."
-                ))
-
-            if dlgConf.refreshTree:
-                self.projView.populateTree()
-
-            if dlgConf.updateTheme:
-                # We are doing this manually instead of connecting to
-                # qApp.paletteChanged since the processing order matters
-                SHARED.theme.loadTheme()
-                self.docEditor.updateTheme()
-                self.docViewer.updateTheme()
-                self.docViewerPanel.updateTheme()
-                self.sideBar.updateTheme()
-                self.projView.updateTheme()
-                self.novelView.updateTheme()
-                self.outlineView.updateTheme()
-                self.itemDetails.updateTheme()
-                self.mainStatus.updateTheme()
-
-            if dlgConf.updateSyntax:
-                SHARED.theme.loadSyntax()
-                self.docEditor.updateSyntaxColours()
-
-            self.docEditor.initEditor()
-            self.docViewer.initViewer()
-            self.projView.initSettings()
-            self.novelView.initSettings()
-            self.outlineView.initSettings()
-
-            self._updateStatusWordCount()
-
+        dialog = GuiPreferences(self)
+        dialog.newPreferencesReady.connect(self._processConfigChanges)
+        dialog.exec_()
         return
 
+    @pyqtSlot()
     @pyqtSlot(int)
-    def showProjectSettingsDialog(self, focusTab: int = GuiProjectSettings.TAB_MAIN) -> bool:
+    def showProjectSettingsDialog(self, focusTab: int = GuiProjectSettings.PAGE_SETTINGS) -> None:
         """Open the project settings dialog."""
-        if not SHARED.hasProject:
-            logger.error("No project open")
-            return False
-
-        dlgProj = GuiProjectSettings(self, focusTab=focusTab)
-        dlgProj.exec_()
-
-        if dlgProj.result() == QDialog.Accepted:
-            logger.debug("Applying new project settings")
-            SHARED.updateSpellCheckLanguage()
-            self.itemDetails.refreshDetails()
-            self._updateWindowTitle(SHARED.project.data.name)
-
-        return True
-
-    def showProjectDetailsDialog(self) -> bool:
-        """Open the project details dialog."""
-        if not SHARED.hasProject:
-            logger.error("No project open")
-            return False
-
-        dlgDetails = getGuiItem("GuiProjectDetails")
-        if dlgDetails is None:
-            dlgDetails = GuiProjectDetails(self)
-        assert isinstance(dlgDetails, GuiProjectDetails)
-
-        dlgDetails.setModal(True)
-        dlgDetails.show()
-        dlgDetails.raise_()
-        dlgDetails.updateValues()
+        if SHARED.hasProject:
+            dialog = GuiProjectSettings(self, gotoPage=focusTab)
+            dialog.newProjectSettingsReady.connect(self._processProjectSettingsChanges)
+            dialog.exec_()
+        return
 
-        return True
+    @pyqtSlot()
+    def showNovelDetailsDialog(self) -> None:
+        """Open the novel details dialog."""
+        if SHARED.hasProject:
+            dialog = GuiNovelDetails(self)
+            dialog.setModal(True)
+            dialog.show()
+            dialog.raise_()
+            qApp.processEvents()
+            dialog.updateValues()
+        return
 
     @pyqtSlot()
-    def showBuildManuscriptDialog(self) -> bool:
+    def showBuildManuscriptDialog(self) -> None:
         """Open the build manuscript dialog."""
-        if not SHARED.hasProject:
-            logger.error("No project open")
-            return False
-
-        dlgBuild = getGuiItem("GuiManuscript")
-        if dlgBuild is None:
-            dlgBuild = GuiManuscript(self)
-        assert isinstance(dlgBuild, GuiManuscript)
-
-        dlgBuild.setModal(False)
-        dlgBuild.show()
-        dlgBuild.raise_()
-        qApp.processEvents()
-
-        dlgBuild.loadContent()
-
-        return True
-
-    def showLoremIpsumDialog(self) -> bool:
-        """Open the insert lorem ipsum text dialog."""
-        if not SHARED.hasProject:
-            logger.error("No project open")
-            return False
-
-        dlgLipsum = getGuiItem("GuiLipsum")
-        if dlgLipsum is None:
-            dlgLipsum = GuiLipsum(self)
-        assert isinstance(dlgLipsum, GuiLipsum)
-
-        dlgLipsum.setModal(False)
-        dlgLipsum.show()
-        dlgLipsum.raise_()
-        qApp.processEvents()
-
-        return True
+        if SHARED.hasProject:
+            if (dialog := SHARED.findTopLevelWidget(GuiManuscript)) is None:
+                dialog = GuiManuscript(self)
+            dialog.setModal(False)
+            dialog.show()
+            dialog.raise_()
+            qApp.processEvents()
+            dialog.loadContent()
+        return
 
-    def showProjectWordListDialog(self) -> bool:
+    @pyqtSlot()
+    def showProjectWordListDialog(self) -> None:
         """Open the project word list dialog."""
-        if not SHARED.hasProject:
-            logger.error("No project open")
-            return False
-
-        dlgWords = GuiWordList(self)
-        dlgWords.exec_()
-
-        if dlgWords.result() == QDialog.Accepted:
-            logger.debug("Reloading word list")
-            SHARED.updateSpellCheckLanguage(reload=True)
-            self.docEditor.spellCheckDocument()
-
-        return True
+        if SHARED.hasProject:
+            dialog = GuiWordList(self)
+            dialog.newWordListReady.connect(self._processWordListChanges)
+            dialog.exec_()
+        return
 
-    def showWritingStatsDialog(self) -> bool:
+    @pyqtSlot()
+    def showWritingStatsDialog(self) -> None:
         """Open the session stats dialog."""
-        if not SHARED.hasProject:
-            logger.error("No project open")
-            return False
-
-        dlgStats = getGuiItem("GuiWritingStats")
-        if dlgStats is None:
-            dlgStats = GuiWritingStats(self)
-        assert isinstance(dlgStats, GuiWritingStats)
-
-        dlgStats.setModal(False)
-        dlgStats.show()
-        dlgStats.raise_()
-        qApp.processEvents()
-        dlgStats.populateGUI()
-
-        return True
-
-    def showAboutNWDialog(self, showNotes: bool = False) -> bool:
-        """Show the about dialog for novelWriter."""
-        dlgAbout = getGuiItem("GuiAbout")
-        if dlgAbout is None:
-            dlgAbout = GuiAbout(self)
-        assert isinstance(dlgAbout, GuiAbout)
+        if SHARED.hasProject:
+            if (dialog := SHARED.findTopLevelWidget(GuiWritingStats)) is None:
+                dialog = GuiWritingStats(self)
+            dialog.setModal(False)
+            dialog.show()
+            dialog.raise_()
+            qApp.processEvents()
+            dialog.populateGUI()
+        return
 
-        dlgAbout.setModal(True)
-        dlgAbout.show()
-        dlgAbout.raise_()
+    @pyqtSlot()
+    def showAboutNWDialog(self) -> None:
+        """Show the novelWriter about dialog."""
+        dialog = GuiAbout(self)
+        dialog.setModal(True)
+        dialog.show()
+        dialog.raise_()
         qApp.processEvents()
-        dlgAbout.populateGUI()
-
-        if showNotes:
-            dlgAbout.showReleaseNotes()
-
-        return True
+        dialog.populateGUI()
+        return
 
+    @pyqtSlot()
     def showAboutQtDialog(self) -> None:
-        """Show the about dialog for Qt."""
+        """Show the Qt about dialog."""
         msgBox = QMessageBox(self)
         msgBox.aboutQt(self, "About Qt")
         return
 
-    def showUpdatesDialog(self) -> None:
-        """Show the check for updates dialog."""
-        dlgUpdate = getGuiItem("GuiUpdates")
-        if dlgUpdate is None:
-            dlgUpdate = GuiUpdates(self)
-        assert isinstance(dlgUpdate, GuiUpdates)
-
-        dlgUpdate.setModal(True)
-        dlgUpdate.show()
-        dlgUpdate.raise_()
-        qApp.processEvents()
-        dlgUpdate.checkLatest()
-
-        return
-
     @pyqtSlot()
     def showDictionariesDialog(self) -> None:
         """Show the download dictionaries dialog."""
-        dlgDicts = GuiDictionaries(self)
-        dlgDicts.setModal(True)
-        dlgDicts.show()
-        dlgDicts.raise_()
+        dialog = GuiDictionaries(self)
+        dialog.setModal(True)
+        dialog.show()
+        dialog.raise_()
         qApp.processEvents()
-        if not dlgDicts.initDialog():
-            dlgDicts.close()
+        if not dialog.initDialog():
+            dialog.close()
             SHARED.error(self.tr("Could not initialise the dialog."))
-
         return
 
     def reportConfErr(self) -> bool:
@@ -1248,6 +1059,67 @@ class GuiMain(QMainWindow):
     #  Private Slots
     ##
 
+    @pyqtSlot(bool, bool, bool, bool)
+    def _processConfigChanges(self, restart: bool, tree: bool, theme: bool, syntax: bool) -> None:
+        """Refresh GUI based on flags from the Preferences dialog."""
+        logger.debug("Applying new preferences")
+        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()
+
+        if theme:
+            # We are doing this manually instead of connecting to
+            # qApp.paletteChanged since the processing order matters
+            SHARED.theme.loadTheme()
+            self.docEditor.updateTheme()
+            self.docViewer.updateTheme()
+            self.docViewerPanel.updateTheme()
+            self.sideBar.updateTheme()
+            self.projView.updateTheme()
+            self.novelView.updateTheme()
+            self.outlineView.updateTheme()
+            self.itemDetails.updateTheme()
+            self.mainStatus.updateTheme()
+
+        if syntax:
+            SHARED.theme.loadSyntax()
+            self.docEditor.updateSyntaxColours()
+
+        self.docEditor.initEditor()
+        self.docViewer.initViewer()
+        self.projView.initSettings()
+        self.novelView.initSettings()
+        self.outlineView.initSettings()
+        self._updateStatusWordCount()
+
+        return
+
+    @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()
+    def _processWordListChanges(self) -> None:
+        """Reload project word list."""
+        logger.debug("Reloading word list")
+        SHARED.updateSpellCheckLanguage(reload=True)
+        self.docEditor.spellCheckDocument()
+        return
+
     @pyqtSlot(str, nwDocMode)
     def _followTag(self, tag: str, mode: nwDocMode) -> None:
         """Follow a tag after user interaction with a link."""
@@ -1259,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."""
@@ -1331,6 +1210,8 @@ 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()
         return
 
     @pyqtSlot()
@@ -1474,8 +1355,8 @@ class GuiMain(QMainWindow):
         self.addAction(self.mainMenu.aReplaceNext)
 
         # Format
-        self.addAction(self.mainMenu.aFmtEmph)
-        self.addAction(self.mainMenu.aFmtStrong)
+        self.addAction(self.mainMenu.aFmtItalic)
+        self.addAction(self.mainMenu.aFmtBold)
         self.addAction(self.mainMenu.aFmtStrike)
         self.addAction(self.mainMenu.aFmtDQuote)
         self.addAction(self.mainMenu.aFmtSQuote)
@@ -1511,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.