Refactor project signal proxies

novelwriter/core/index.py

@@ -122,7 +122,7 @@ class NWIndex:
         self._itemIndex.clear()
         self._indexChange = 0.0
         self._rootChange = {}
-        SHARED.indexSignalProxy({"event": "clearIndex"})
+        SHARED.emitIndexCleared(self._project)
         return
 
     def rebuild(self) -> None:
@@ -133,7 +133,7 @@ class NWIndex:
                 text = self._project.storage.getDocumentText(nwItem.itemHandle)
                 self.scanText(nwItem.itemHandle, text, blockSignal=True)
         self._indexBroken = False
-        SHARED.indexSignalProxy({"event": "buildIndex"})
+        SHARED.emitIndexAvailable(self._project)
         return
 
     def deleteHandle(self, tHandle: str) -> None:
@@ -143,10 +143,7 @@ class NWIndex:
         for tTag in delTags:
             del self._tagsIndex[tTag]
         del self._itemIndex[tHandle]
-        SHARED.indexSignalProxy({
+        SHARED.emitIndexChangedTags(self._project, [], delTags)
-            "event": "updateTags",
-            "deleted": delTags,
-        })
         return
 
     def reIndexHandle(self, tHandle: str | None) -> None:
@@ -212,7 +209,7 @@ class NWIndex:
                 self.reIndexHandle(fHandle)
 
         self._indexChange = time()
-        SHARED.indexSignalProxy({"event": "buildIndex"})
+        SHARED.emitIndexAvailable(self._project)
 
         logger.debug("Index loaded in %.3f ms", (time() - tStart)*1000)
 
@@ -367,11 +364,7 @@ class NWIndex:
                 del self._tagsIndex[tTag]
                 deleted.append(tTag)
             if updated or deleted:
-                SHARED.indexSignalProxy({
+                SHARED.emitIndexChangedTags(self._project, updated, deleted)
-                    "event": "updateTags",
-                    "updated": updated,
-                    "deleted": deleted,
-                })
 
         return
 

novelwriter/core/project.py

@@ -44,7 +44,7 @@ from novelwriter.core.options import OptionState
 from novelwriter.core.projectdata import NWProjectData
 from novelwriter.core.projectxml import ProjectXMLReader, ProjectXMLWriter, XMLReadState
 from novelwriter.core.sessions import NWSessionLog
-from novelwriter.core.status import T_StatusKinds, T_UpdateEntry
+from novelwriter.core.status import T_StatusKind, T_UpdateEntry
 from novelwriter.core.storage import NWStorage, NWStorageOpen
 from novelwriter.core.tree import NWTree
 from novelwriter.enum import nwItemClass, nwItemLayout, nwItemType
@@ -532,15 +532,15 @@ class NWProject:
                 self._data.itemImport.increment(nwItem.itemImport)
         return
 
-    def updateStatus(self, kind: T_StatusKinds, update: T_UpdateEntry) -> None:
+    def updateStatus(self, kind: T_StatusKind, update: T_UpdateEntry) -> None:
         """Update status or import entries."""
         if kind == "s":
             self._data.itemStatus.update(update)
-            SHARED.projectSignalProxy({"event": "statusLabels", "kind": kind})
+            SHARED.emitStatusLabelsChanged(self, kind)
             self._tree.refreshAllItems()
         elif kind == "i":
             self._data.itemImport.update(update)
-            SHARED.projectSignalProxy({"event": "statusLabels", "kind": kind})
+            SHARED.emitStatusLabelsChanged(self, kind)
             self._tree.refreshAllItems()
         return
 

novelwriter/core/status.py

@@ -66,7 +66,7 @@ class StatusEntry:
 NO_ENTRY = StatusEntry("", QColor(0, 0, 0), nwStatusShape.SQUARE, QIcon(), 0)
 
 T_UpdateEntry = list[tuple[str | None, StatusEntry]]
-T_StatusKinds = Literal["s", "i"]
+T_StatusKind = Literal["s", "i"]
 
 
 class NWStatus:
@@ -76,7 +76,7 @@ class NWStatus:
 
     __slots__ = ("_store", "_default", "_prefix", "_height")
 
-    def __init__(self, prefix: T_StatusKinds) -> None:
+    def __init__(self, prefix: T_StatusKind) -> None:
         self._store: dict[str, StatusEntry] = {}
         self._default = None
         self._prefix = prefix[:1]

novelwriter/core/tree.py

@@ -469,13 +469,9 @@ class NWTree:
         tHandle = item.itemHandle
         logger.debug("Item change: %s -> %s", tHandle, change.name)
         self._project.setProjectChanged(True)
-        SHARED.projectSignalProxy(
+        SHARED.emitProjectItemChanged(self._project, tHandle, change)
-            {"event": "itemChanged", "handle": tHandle, "change": change}
-        )
         if item.isRootType():
-            SHARED.projectSignalProxy(
+            SHARED.emitRootFolderChanged(self._project, tHandle, change)
-                {"event": "rootChanged", "handle": tHandle, "change": change}
-            )
         return
 
     def _getTrashNode(self) -> ProjectNode | None:

novelwriter/shared.py

@@ -42,6 +42,7 @@ 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
 
@@ -314,35 +315,45 @@ class SharedData(QObject):
         return
 
     ##
-    #  Signal Proxy
+    #  Signal Proxies
     ##
 
-    def indexSignalProxy(self, data: dict) -> None:
+    def emitIndexChangedTags(
-        """Emit signals on behalf of the index."""
+        self, project: NWProject, updated: list[str], deleted: list[str]
-        event = data.get("event")
+    ) -> None:
-        logger.debug("Signal Proxy: %s", event)
+        """Emit the indexChangedTags signal."""
-        if event == "updateTags":
+        if self._project and self._project.data.uuid == project.data.uuid:
-            self.indexChangedTags.emit(data.get("updated", []), data.get("deleted", []))
+            self.indexChangedTags.emit(updated, deleted)
-        elif event == "clearIndex":
+        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 projectSignalProxy(self, data: dict) -> None:
+    def emitStatusLabelsChanged(self, project: NWProject, kind: T_StatusKind) -> None:
-        """Emit signals on project data change."""
+        """Emit the statusLabelsChanged signal."""
-        event = data.get("event")
+        if self._project and self._project.data.uuid == project.data.uuid:
-        logger.debug("Signal Proxy: %s", event)
+            self.statusLabelsChanged.emit(kind)
-        if event == "statusLabels":
+        return
-            self.statusLabelsChanged.emit(data.get("kind", ""))
+
-        elif event == "itemChanged":
+    def emitProjectItemChanged(self, project: NWProject, handle: str, change: nwChange) -> None:
-            self.projectItemChanged.emit(
+        """Emit the projectItemChanged signal."""
-                data.get("handle", ""), data.get("change", nwChange.UPDATE)
+        if self._project and self._project.data.uuid == project.data.uuid:
-            )
+            self.projectItemChanged.emit(handle, change)
-        elif event == "rootChanged":
+        return
-            self.rootFolderChanged.emit(
+
-                data.get("handle", ""), data.get("change", nwChange.UPDATE)
+    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
 
     ##

tests/test_core/test_core_index.py

@@ -153,6 +153,7 @@ def testCoreIndex_LoadSave(qtbot, monkeypatch, prjLipsum, mockGUI, tstPaths):
     assert "7a992350f3eb6" in index._itemIndex
 
     # Close Project
+    SHARED._project = project  # Otherwise the signal is not emitted
     with qtbot.waitSignal(SHARED.indexCleared, timeout=1000):
         # Regression test for issue #1718
         project.closeProject()