novelWriter 2.5.3__py3-none-any.whl → 2.6__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–2024, Veronica Berglyd Olsen
+Copyright (C) 2018 Veronica Berglyd Olsen and novelWriter contributors
 
 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
@@ -62,6 +62,7 @@ from novelwriter.tools.manuscript import GuiManuscript
 from novelwriter.tools.noveldetails import GuiNovelDetails
 from novelwriter.tools.welcome import GuiWelcome
 from novelwriter.tools.writingstats import GuiWritingStats
+from novelwriter.types import QtModShift
 
 logger = logging.getLogger(__name__)
 
@@ -212,15 +213,19 @@ class GuiMain(QMainWindow):
         SHARED.indexChangedTags.connect(self.docEditor.updateChangedTags)
         SHARED.indexChangedTags.connect(self.docViewerPanel.updateChangedTags)
         SHARED.indexCleared.connect(self.docViewerPanel.indexWasCleared)
-        SHARED.indexScannedText.connect(self.docViewerPanel.projectItemChanged)
-        SHARED.indexScannedText.connect(self.itemDetails.updateViewBox)
-        SHARED.indexScannedText.connect(self.projView.updateItemValues)
         SHARED.mainClockTick.connect(self._timeTick)
+        SHARED.projectItemChanged.connect(self.docEditor.onProjectItemChanged)
+        SHARED.projectItemChanged.connect(self.docViewer.onProjectItemChanged)
+        SHARED.projectItemChanged.connect(self.docViewerPanel.onProjectItemChanged)
+        SHARED.projectItemChanged.connect(self.itemDetails.onProjectItemChanged)
+        SHARED.projectItemChanged.connect(self.projView.onProjectItemChanged)
         SHARED.projectStatusChanged.connect(self.mainStatus.updateProjectStatus)
         SHARED.projectStatusMessage.connect(self.mainStatus.setStatusMessage)
+        SHARED.rootFolderChanged.connect(self.novelView.updateRootItem)
+        SHARED.rootFolderChanged.connect(self.outlineView.updateRootItem)
+        SHARED.rootFolderChanged.connect(self.projView.updateRootItem)
         SHARED.spellLanguageChanged.connect(self.mainStatus.setLanguage)
         SHARED.statusLabelsChanged.connect(self.docViewerPanel.updateStatusLabels)
-        SHARED.statusLabelsChanged.connect(self.projView.refreshUserLabels)
 
         self.mainMenu.requestDocAction.connect(self._passDocumentAction)
         self.mainMenu.requestDocInsert.connect(self._passDocumentInsert)
@@ -233,15 +238,7 @@ class GuiMain(QMainWindow):
 
         self.projView.openDocumentRequest.connect(self._openDocument)
         self.projView.projectSettingsRequest.connect(self.showProjectSettingsDialog)
-        self.projView.rootFolderChanged.connect(self.novelView.updateRootItem)
-        self.projView.rootFolderChanged.connect(self.outlineView.updateRootItem)
-        self.projView.rootFolderChanged.connect(self.projView.updateRootItem)
         self.projView.selectedItemChanged.connect(self.itemDetails.updateViewBox)
-        self.projView.treeItemChanged.connect(self.docEditor.updateDocInfo)
-        self.projView.treeItemChanged.connect(self.docViewer.updateDocInfo)
-        self.projView.treeItemChanged.connect(self.docViewerPanel.projectItemChanged)
-        self.projView.treeItemChanged.connect(self.itemDetails.updateViewBox)
-        self.projView.wordCountsChanged.connect(self._updateStatusWordCount)
 
         self.novelView.openDocumentRequest.connect(self._openDocument)
         self.novelView.selectedItemChanged.connect(self.itemDetails.updateViewBox)
@@ -249,25 +246,27 @@ class GuiMain(QMainWindow):
         self.projSearch.openDocumentSelectRequest.connect(self._openDocumentSelection)
         self.projSearch.selectedItemChanged.connect(self.itemDetails.updateViewBox)
 
-        self.docEditor.closeDocumentRequest.connect(self.closeDocEditor)
-        self.docEditor.docCountsChanged.connect(self.itemDetails.updateCounts)
-        self.docEditor.docCountsChanged.connect(self.projView.updateCounts)
+        self.docEditor.closeEditorRequest.connect(self.closeDocEditor)
         self.docEditor.docTextChanged.connect(self.projSearch.textChanged)
         self.docEditor.editedStatusChanged.connect(self.mainStatus.updateDocumentStatus)
+        self.docEditor.itemHandleChanged.connect(self.novelView.setActiveHandle)
+        self.docEditor.itemHandleChanged.connect(self.projView.setActiveHandle)
         self.docEditor.loadDocumentTagRequest.connect(self._followTag)
         self.docEditor.novelItemMetaChanged.connect(self.novelView.updateNovelItemMeta)
         self.docEditor.novelStructureChanged.connect(self.novelView.refreshTree)
-        self.docEditor.requestNewNoteCreation.connect(self.projView.createNewNote)
+        self.docEditor.openDocumentRequest.connect(self._openDocument)
+        self.docEditor.requestNewNoteCreation.connect(SHARED.createNewNote)
         self.docEditor.requestNextDocument.connect(self.openNextDocument)
         self.docEditor.requestProjectItemRenamed.connect(self.projView.renameTreeItem)
         self.docEditor.requestProjectItemSelected.connect(self.projView.setSelectedHandle)
         self.docEditor.spellCheckStateChanged.connect(self.mainMenu.setSpellCheckState)
-        self.docEditor.statusMessage.connect(self.mainStatus.setStatusMessage)
         self.docEditor.toggleFocusModeRequest.connect(self.toggleFocusMode)
+        self.docEditor.updateStatusMessage.connect(self.mainStatus.setStatusMessage)
 
         self.docViewer.closeDocumentRequest.connect(self.closeDocViewer)
         self.docViewer.documentLoaded.connect(self.docViewerPanel.updateHandle)
         self.docViewer.loadDocumentTagRequest.connect(self._followTag)
+        self.docViewer.openDocumentRequest.connect(self._openDocument)
         self.docViewer.reloadDocumentRequest.connect(self._reloadViewer)
         self.docViewer.requestProjectItemSelected.connect(self.projView.setSelectedHandle)
         self.docViewer.togglePanelVisibility.connect(self._toggleViewerPanelVisibility)
@@ -289,21 +288,30 @@ class GuiMain(QMainWindow):
         self.asDocTimer = QTimer(self)
         self.asDocTimer.timeout.connect(self._autoSaveDocument)
 
-        # Shortcuts and Actions
-        self._connectMenuActions()
-
+        # Shortcuts
         self.keyReturn = QShortcut(self)
-        self.keyReturn.setKey(Qt.Key.Key_Return)
+        self.keyReturn.setKey("Return")
         self.keyReturn.activated.connect(self._keyPressReturn)
 
+        self.keyShiftReturn = QShortcut(self)
+        self.keyShiftReturn.setKey("Shift+Return")
+        self.keyShiftReturn.activated.connect(self._keyPressReturn)
+
         self.keyEnter = QShortcut(self)
-        self.keyEnter.setKey(Qt.Key.Key_Enter)
+        self.keyEnter.setKey("Enter")
         self.keyEnter.activated.connect(self._keyPressReturn)
 
+        self.keyShiftEnter = QShortcut(self)
+        self.keyShiftEnter.setKey("Shift+Enter")
+        self.keyShiftEnter.activated.connect(self._keyPressReturn)
+
         self.keyEscape = QShortcut(self)
-        self.keyEscape.setKey(Qt.Key.Key_Escape)
+        self.keyEscape.setKey("Esc")
         self.keyEscape.activated.connect(self._keyPressEscape)
 
+        # Internal Variables
+        self._lastTotalCount = 0
+
         # Initialise Main GUI
         self.initMain()
         self.asProjTimer.start()
@@ -481,8 +489,7 @@ class GuiMain(QMainWindow):
             QApplication.processEvents()
             self.openDocument(lastEdited, doScroll=True)
 
-        lastViewed = SHARED.project.data.getLastHandle("viewer")
-        if lastViewed is not None:
+        if lastViewed := SHARED.project.data.getLastHandle("viewer"):
             QApplication.processEvents()
             self.viewDocument(lastViewed)
 
@@ -502,17 +509,15 @@ class GuiMain(QMainWindow):
 
     def saveProject(self, autoSave: bool = False) -> bool:
         """Save the current project."""
-        if not SHARED.hasProject:
-            logger.error("No project open")
-            return False
-        self.projView.saveProjectTasks()
-        return SHARED.saveProject(autoSave=autoSave)
+        if SHARED.hasProject:
+            return SHARED.saveProject(autoSave=autoSave)
+        return False
 
     ##
     #  Document Actions
     ##
 
-    def closeDocument(self, beforeOpen: bool = False) -> None:
+    def closeDocument(self) -> None:
         """Close the document and clear the editor and title field."""
         if SHARED.hasProject:
             # Disable focus mode if it is active
@@ -520,8 +525,6 @@ class GuiMain(QMainWindow):
                 SHARED.setFocusMode(False)
             self.saveDocument()
             self.docEditor.clearEditor()
-            if not beforeOpen:
-                self.novelView.setActiveHandle(None)
         return
 
     def openDocument(
@@ -533,12 +536,8 @@ class GuiMain(QMainWindow):
         doScroll: bool = False
     ) -> bool:
         """Open a specific document, optionally at a given line."""
-        if not SHARED.hasProject:
-            logger.error("No project open")
-            return False
-
-        if not tHandle or not SHARED.project.tree.checkType(tHandle, nwItemType.FILE):
-            logger.debug("Requested item '%s' is not a document", tHandle)
+        if not (SHARED.hasProject and tHandle):
+            logger.error("Nothing to open open")
             return False
 
         if sTitle and tLine is None:
@@ -548,19 +547,15 @@ class GuiMain(QMainWindow):
         self._changeView(nwView.EDITOR)
         if tHandle == self.docEditor.docHandle:
             self.docEditor.setCursorLine(tLine)
-            if changeFocus:
-                self.docEditor.setFocus()
-            return True
-
-        self.closeDocument(beforeOpen=True)
-        if self.docEditor.loadText(tHandle, tLine):
-            SHARED.project.data.setLastHandle(tHandle, "editor")
-            self.projView.setSelectedHandle(tHandle, doScroll=doScroll)
-            self.novelView.setActiveHandle(tHandle, doScroll=doScroll)
-            if changeFocus:
-                self.docEditor.setFocus()
         else:
-            return False
+            self.closeDocument()
+            if self.docEditor.loadText(tHandle, tLine):
+                self.projView.setSelectedHandle(tHandle, doScroll=doScroll)
+            else:
+                return False
+
+        if changeFocus:
+            self.docEditor.setFocus()
 
         return True
 
@@ -728,8 +723,11 @@ class GuiMain(QMainWindow):
                 logger.warning("No item selected")
                 return
 
-            if tHandle:
-                self.openDocument(tHandle, sTitle=sTitle, changeFocus=False, doScroll=False)
+            if tHandle and SHARED.project.tree.checkType(tHandle, nwItemType.FILE):
+                if QApplication.keyboardModifiers() == QtModShift:
+                    self.viewDocument(tHandle)
+                else:
+                    self.openDocument(tHandle, sTitle=sTitle, changeFocus=False, doScroll=False)
 
         return
 
@@ -740,9 +738,8 @@ class GuiMain(QMainWindow):
             QApplication.setOverrideCursor(QCursor(Qt.CursorShape.WaitCursor))
             tStart = time()
 
-            self.projView.saveProjectTasks()
-            SHARED.project.index.rebuildIndex()
-            self.projView.populateTree()
+            SHARED.project.index.rebuild()
+            SHARED.project.tree.refreshAllItems()
             self.novelView.refreshTree()
 
             tEnd = time()
@@ -855,13 +852,11 @@ class GuiMain(QMainWindow):
 
     def closeMain(self) -> bool:
         """Save everything, and close novelWriter."""
-        if SHARED.hasProject:
-            msgYes = SHARED.question("%s<br>%s" % (
-                self.tr("Do you want to exit novelWriter?"),
-                self.tr("Changes are saved automatically.")
-            ))
-            if not msgYes:
-                return False
+        if SHARED.hasProject and not SHARED.question("%s<br>%s" % (
+            self.tr("Do you want to exit novelWriter?"),
+            self.tr("Changes are saved automatically.")
+        )):
+            return False
 
         logger.info("Exiting novelWriter")
 
@@ -906,11 +901,6 @@ class GuiMain(QMainWindow):
 
         return not self.splitView.isVisible()
 
-    def toggleFullScreenMode(self) -> None:
-        """Toggle full screen mode"""
-        self.setWindowState(self.windowState() ^ Qt.WindowState.WindowFullScreen)
-        return
-
     ##
     #  Events
     ##
@@ -926,6 +916,12 @@ class GuiMain(QMainWindow):
     #  Public Slots
     ##
 
+    @pyqtSlot()
+    def toggleFullScreenMode(self) -> None:
+        """Toggle full screen mode"""
+        self.setWindowState(self.windowState() ^ Qt.WindowState.WindowFullScreen)
+        return
+
     @pyqtSlot()
     def closeDocEditor(self) -> None:
         """Close the document editor. This does not hide the editor."""
@@ -961,12 +957,8 @@ class GuiMain(QMainWindow):
                 docEditor = True
             elif self.docViewer.isAncestorOf(new):
                 docViewer = True
-
             self.docEditor.changeFocusState(docEditor)
             self.docViewer.changeFocusState(docViewer)
-
-            logger.debug("Main focus switched to: %s", type(new).__name__)
-
         return
 
     @pyqtSlot(bool)
@@ -1055,13 +1047,8 @@ class GuiMain(QMainWindow):
         self.initMain()
         self.saveDocument()
 
-        if restart:
-            SHARED.info(self.tr(
-                "Some changes will not be applied until novelWriter has been restarted."
-            ))
-
         if tree:
-            self.projView.populateTree()
+            SHARED.project.tree.refreshAllItems()
 
         if theme:
             # We are doing this manually instead of connecting to
@@ -1087,8 +1074,16 @@ class GuiMain(QMainWindow):
         self.projView.initSettings()
         self.novelView.initSettings()
         self.outlineView.initSettings()
+
+        # Force update of word count
+        self._lastTotalCount = 0
         self._updateStatusWordCount()
 
+        if restart:
+            SHARED.info(self.tr(
+                "Some changes will not be applied until novelWriter has been restarted."
+            ))
+
         return
 
     @pyqtSlot()
@@ -1111,8 +1106,16 @@ class GuiMain(QMainWindow):
     @pyqtSlot(str, nwDocMode)
     def _followTag(self, tag: str, mode: nwDocMode) -> None:
         """Follow a tag after user interaction with a link."""
-        tHandle, sTitle = self._getTagSource(tag)
-        if tHandle is not None:
+        tHandle, sTitle = SHARED.project.index.getTagSource(tag)
+        if tHandle is None:
+            SHARED.error(self.tr(
+                "Could not find the reference for tag '{0}'. It either doesn't "
+                "exist, or the index is out of date. The index can be updated "
+                "from the Tools menu, or by pressing {1}."
+            ).format(
+                tag, "F9"
+            ))
+        else:
             if mode == nwDocMode.EDIT:
                 self.openDocument(tHandle, sTitle=sTitle)
             elif mode == nwDocMode.VIEW:
@@ -1216,8 +1219,10 @@ class GuiMain(QMainWindow):
             self.mainStatus.setUserIdle(editIdle or userIdle)
             SHARED.updateIdleTime(currTime, editIdle or userIdle)
             self.mainStatus.updateTime(idleTime=SHARED.projectIdleTime)
-            if CONFIG.memInfo and int(currTime) % 5 == 0:  # pragma: no cover
-                self.mainStatus.memInfo()
+            if int(currTime) % 5 == 0:
+                self._updateStatusWordCount()
+                if CONFIG.memInfo:  # pragma: no cover
+                    self.mainStatus.memInfo()
         return
 
     @pyqtSlot()
@@ -1245,15 +1250,19 @@ class GuiMain(QMainWindow):
         if not SHARED.hasProject:
             self.mainStatus.setProjectStats(0, 0)
 
-        SHARED.project.updateWordCounts()
-        if CONFIG.incNotesWCount:
-            iTotal = sum(SHARED.project.data.initCounts)
-            cTotal = sum(SHARED.project.data.currCounts)
-            self.mainStatus.setProjectStats(cTotal, cTotal - iTotal)
-        else:
-            iNovel, _ = SHARED.project.data.initCounts
-            cNovel, _ = SHARED.project.data.currCounts
-            self.mainStatus.setProjectStats(cNovel, cNovel - iNovel)
+        currentTotalCount = SHARED.project.currentTotalCount
+        if self._lastTotalCount != currentTotalCount:
+            self._lastTotalCount = currentTotalCount
+
+            SHARED.project.updateWordCounts()
+            if CONFIG.incNotesWCount:
+                iTotal = sum(SHARED.project.data.initCounts)
+                cTotal = sum(SHARED.project.data.currCounts)
+                self.mainStatus.setProjectStats(cTotal, cTotal - iTotal)
+            else:
+                iNovel, _ = SHARED.project.data.initCounts
+                cNovel, _ = SHARED.project.data.currCounts
+                self.mainStatus.setProjectStats(cNovel, cNovel - iNovel)
 
         return
 
@@ -1299,116 +1308,7 @@ class GuiMain(QMainWindow):
     #  Internal Functions
     ##
 
-    def _connectMenuActions(self) -> None:
-        """Connect to the main window all menu actions that need to be
-        available also when the main menu is hidden.
-        """
-        # Project
-        self.addAction(self.mainMenu.aSaveProject)
-        self.addAction(self.mainMenu.aEditItem)
-        self.addAction(self.mainMenu.aExitNW)
-
-        # Document
-        self.addAction(self.mainMenu.aSaveDoc)
-        self.addAction(self.mainMenu.aCloseDoc)
-
-        # Edit
-        self.addAction(self.mainMenu.aEditUndo)
-        self.addAction(self.mainMenu.aEditRedo)
-        self.addAction(self.mainMenu.aEditCut)
-        self.addAction(self.mainMenu.aEditCopy)
-        self.addAction(self.mainMenu.aEditPaste)
-        self.addAction(self.mainMenu.aSelectAll)
-        self.addAction(self.mainMenu.aSelectPar)
-
-        # View
-        self.addAction(self.mainMenu.aFocusMode)
-        self.addAction(self.mainMenu.aFullScreen)
-
-        # Insert
-        self.addAction(self.mainMenu.aInsENDash)
-        self.addAction(self.mainMenu.aInsEMDash)
-        self.addAction(self.mainMenu.aInsHorBar)
-        self.addAction(self.mainMenu.aInsFigDash)
-        self.addAction(self.mainMenu.aInsQuoteLS)
-        self.addAction(self.mainMenu.aInsQuoteRS)
-        self.addAction(self.mainMenu.aInsQuoteLD)
-        self.addAction(self.mainMenu.aInsQuoteRD)
-        self.addAction(self.mainMenu.aInsMSApos)
-        self.addAction(self.mainMenu.aInsEllipsis)
-        self.addAction(self.mainMenu.aInsPrime)
-        self.addAction(self.mainMenu.aInsDPrime)
-        self.addAction(self.mainMenu.aInsNBSpace)
-        self.addAction(self.mainMenu.aInsThinSpace)
-        self.addAction(self.mainMenu.aInsThinNBSpace)
-        self.addAction(self.mainMenu.aInsBullet)
-        self.addAction(self.mainMenu.aInsHyBull)
-        self.addAction(self.mainMenu.aInsFlower)
-        self.addAction(self.mainMenu.aInsPerMille)
-        self.addAction(self.mainMenu.aInsDegree)
-        self.addAction(self.mainMenu.aInsMinus)
-        self.addAction(self.mainMenu.aInsTimes)
-        self.addAction(self.mainMenu.aInsDivide)
-        self.addAction(self.mainMenu.aInsSynopsis)
-        self.addAction(self.mainMenu.aInsShort)
-
-        for mAction, _ in self.mainMenu.mInsKWItems.values():
-            self.addAction(mAction)
-
-        # Search
-        self.addAction(self.mainMenu.aFind)
-        self.addAction(self.mainMenu.aReplace)
-        self.addAction(self.mainMenu.aFindNext)
-        self.addAction(self.mainMenu.aFindPrev)
-        self.addAction(self.mainMenu.aReplaceNext)
-
-        # Format
-        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)
-        self.addAction(self.mainMenu.aFmtHead1)
-        self.addAction(self.mainMenu.aFmtHead2)
-        self.addAction(self.mainMenu.aFmtHead3)
-        self.addAction(self.mainMenu.aFmtHead4)
-        self.addAction(self.mainMenu.aFmtAlignLeft)
-        self.addAction(self.mainMenu.aFmtAlignCentre)
-        self.addAction(self.mainMenu.aFmtAlignRight)
-        self.addAction(self.mainMenu.aFmtIndentLeft)
-        self.addAction(self.mainMenu.aFmtIndentRight)
-        self.addAction(self.mainMenu.aFmtComment)
-        self.addAction(self.mainMenu.aFmtNoFormat)
-
-        # Tools
-        self.addAction(self.mainMenu.aSpellCheck)
-        self.addAction(self.mainMenu.aReRunSpell)
-        self.addAction(self.mainMenu.aPreferences)
-
-        # Help
-        self.addAction(self.mainMenu.aHelpDocs)
-        if isinstance(CONFIG.pdfDocs, Path):
-            self.addAction(self.mainMenu.aPdfDocs)
-
-        return
-
     def _updateWindowTitle(self, projName: str | None = None) -> None:
         """Set the window title and add the project's name."""
         self.setWindowTitle(" - ".join(filter(None, [projName, CONFIG.appName])))
         return
-
-    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.
-        """
-        tHandle, sTitle = SHARED.project.index.getTagSource(tag)
-        if tHandle is None:
-            SHARED.error(self.tr(
-                "Could not find the reference for tag '{0}'. It either doesn't "
-                "exist, or the index is out of date. The index can be updated "
-                "from the Tools menu, or by pressing {1}."
-            ).format(
-                tag, "F9"
-            ))
-            return None, None
-        return tHandle, sTitle

novelwriter/shared.py

@@ -7,7 +7,7 @@ Created: 2023-08-10 [2.1rc1] SharedData
 Created: 2023-08-14 [2.1rc1] _GuiAlert
 
 This file is a part of novelWriter
-Copyright 2018–2024, Veronica Berglyd Olsen
+Copyright (C) 2023 Veronica Berglyd Olsen and novelWriter contributors
 
 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,20 +26,23 @@ from __future__ import annotations
 
 import logging
 
+from enum import Enum
 from pathlib import Path
 from time import time
 from typing import TYPE_CHECKING, TypeVar
 
-from PyQt5.QtCore import QObject, QRunnable, QThreadPool, QTimer, pyqtSignal
-from PyQt5.QtGui import QFont
+from PyQt5.QtCore import QObject, QRunnable, QThreadPool, QTimer, QUrl, pyqtSignal, pyqtSlot
+from PyQt5.QtGui import QDesktopServices, QFont
 from PyQt5.QtWidgets import QFileDialog, QFontDialog, QMessageBox, QWidget
 
 from novelwriter.common import formatFileFilter
 from novelwriter.constants import nwFiles
 from novelwriter.core.spellcheck import NWSpellEnchant
+from novelwriter.enum import nwChange, nwItemClass
 
 if TYPE_CHECKING:  # pragma: no cover
     from novelwriter.core.project import NWProject
+    from novelwriter.core.status import T_StatusKind
     from novelwriter.gui.theme import GuiTheme
     from novelwriter.guimain import GuiMain
 
@@ -55,15 +58,16 @@ class SharedData(QObject):
         "_idleTime", "_idleRefTime",
     )
 
-    projectStatusChanged = pyqtSignal(bool)
-    projectStatusMessage = pyqtSignal(str)
-    spellLanguageChanged = pyqtSignal(str, str)
     focusModeChanged = pyqtSignal(bool)
-    indexScannedText = pyqtSignal(str)
+    indexAvailable = pyqtSignal()
     indexChangedTags = pyqtSignal(list, list)
     indexCleared = pyqtSignal()
-    indexAvailable = pyqtSignal()
     mainClockTick = pyqtSignal()
+    projectItemChanged = pyqtSignal(str, Enum)
+    rootFolderChanged = pyqtSignal(str, Enum)
+    projectStatusChanged = pyqtSignal(bool)
+    projectStatusMessage = pyqtSignal(str)
+    spellLanguageChanged = pyqtSignal(str, str)
     statusLabelsChanged = pyqtSignal(str)
 
     def __init__(self) -> None:
@@ -173,10 +177,12 @@ class SharedData(QObject):
         logger.debug("Thread Pool Max Count: %d", QThreadPool.globalInstance().maxThreadCount())
         return
 
-    def closeEditor(self, tHandle: str | None = None) -> None:
+    def closeDocument(self, tHandle: str | None = None) -> None:
         """Close the document editor, optionally a specific document."""
         if tHandle is None or tHandle == self.mainGui.docEditor.docHandle:
             self.mainGui.closeDocument()
+        if tHandle is None or tHandle == self.mainGui.docViewer.docHandle:
+            self.mainGui.closeViewerPanel()
         return
 
     def saveEditor(self, tHandle: str | None = None) -> None:
@@ -293,29 +299,61 @@ class SharedData(QObject):
         return None
 
     ##
-    #  Signal Proxy
+    #  Public Slots
     ##
 
-    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":
+    @pyqtSlot(str)
+    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
+    ##
+
+    def emitIndexChangedTags(
+        self, project: NWProject, updated: list[str], deleted: list[str]
+    ) -> None:
+        """Emit the indexChangedTags signal."""
+        if self._project and self._project.data.uuid == project.data.uuid:
+            self.indexChangedTags.emit(updated, deleted)
+        return
+
+    def emitIndexCleared(self, project: NWProject) -> None:
+        """Emit the indexCleared signal."""
+        if self._project and self._project.data.uuid == project.data.uuid:
             self.indexCleared.emit()
-        elif event == "buildIndex":
+        return
+
+    def emitIndexAvailable(self, project: NWProject) -> None:
+        """Emit the indexAvailable signal."""
+        if self._project and self._project.data.uuid == project.data.uuid:
             self.indexAvailable.emit()
         return
 
-    def projectSingalProxy(self, data: dict) -> None:
-        """Emit signals on project data change."""
-        event = data.get("event")
-        logger.debug("Received '%s' event from project data", event)
-        if event == "statusLabels":
-            self.statusLabelsChanged.emit(data.get("kind", ""))
+    def emitStatusLabelsChanged(self, project: NWProject, kind: T_StatusKind) -> None:
+        """Emit the statusLabelsChanged signal."""
+        if self._project and self._project.data.uuid == project.data.uuid:
+            self.statusLabelsChanged.emit(kind)
+        return
+
+    def emitProjectItemChanged(self, project: NWProject, handle: str, change: nwChange) -> None:
+        """Emit the projectItemChanged signal."""
+        if self._project and self._project.data.uuid == project.data.uuid:
+            self.projectItemChanged.emit(handle, change)
+        return
+
+    def emitRootFolderChanged(self, project: NWProject, handle: str, change: nwChange) -> None:
+        """Emit the rootFolderChanged signal."""
+        if self._project and self._project.data.uuid == project.data.uuid:
+            self.rootFolderChanged.emit(handle, change)
         return
 
     ##
@@ -376,6 +414,7 @@ class SharedData(QObject):
         """Create a new project and spell checking instance."""
         from novelwriter.core.project import NWProject
         if isinstance(self._project, NWProject):
+            self._project.clear()
             del self._project
             del self._spelling
         self._project = NWProject()
@@ -441,9 +480,9 @@ class _GuiAlert(QMessageBox):
         Yes/No buttons or just an Ok button.
         """
         if isYesNo:
-            self.setStandardButtons(QMessageBox.Yes | QMessageBox.No)
+            self.setStandardButtons(QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No)
         else:
-            self.setStandardButtons(QMessageBox.Ok)
+            self.setStandardButtons(QMessageBox.StandardButton.Ok)
         pSz = 2*self._theme.baseIconHeight
         if level == self.INFO:
             self.setIconPixmap(self._theme.getPixmap("alert_info", (pSz, pSz)))