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

novelwriter/gui/projtree.py

@@ -6,9 +6,10 @@ File History:
 Created: 2018-09-29 [0.0.1]  GuiProjectTree
 Created: 2022-06-06 [2.0rc1] GuiProjectView
 Created: 2022-06-06 [2.0rc1] GuiProjectToolBar
+Created: 2023-11-22 [2.2rc1] _TreeContextMenu
 
 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
@@ -31,15 +32,18 @@ from enum import Enum
 from time import time
 from typing import TYPE_CHECKING
 
-from PyQt5.QtGui import QDragEnterEvent, QDragMoveEvent, QDropEvent, QMouseEvent, QPalette
+from PyQt5.QtGui import (
+    QDragEnterEvent, QDragMoveEvent, QDropEvent, QIcon, QMouseEvent, QPalette
+)
 from PyQt5.QtCore import QPoint, QTimer, Qt, QSize, pyqtSignal, pyqtSlot
 from PyQt5.QtWidgets import (
-    QAbstractItemView, QDialog, QFrame, QHBoxLayout, QHeaderView, QLabel,
-    QMenu, QShortcut, QSizePolicy, QToolButton, QTreeWidget, QTreeWidgetItem,
-    QVBoxLayout, QWidget
+    QAbstractItemView, QAction, QDialog, QFrame, QHBoxLayout, QHeaderView,
+    QLabel, QMenu, QShortcut, QSizePolicy, QToolButton, QTreeWidget,
+    QTreeWidgetItem, QVBoxLayout, QWidget
 )
 
 from novelwriter import CONFIG, SHARED
+from novelwriter.enum import nwDocMode, nwItemType, nwItemClass, nwItemLayout
 from novelwriter.common import minmax
 from novelwriter.constants import nwHeaders, nwUnicode, trConst, nwLabels
 from novelwriter.core.item import NWItem
@@ -47,10 +51,7 @@ from novelwriter.core.coretools import DocDuplicator, DocMerger, DocSplitter
 from novelwriter.dialogs.docmerge import GuiDocMerge
 from novelwriter.dialogs.docsplit import GuiDocSplit
 from novelwriter.dialogs.editlabel import GuiEditLabel
-from novelwriter.dialogs.projsettings import GuiProjectSettings
-from novelwriter.enum import (
-    nwDocMode, nwItemType, nwItemClass, nwItemLayout, nwWidget
-)
+from novelwriter.dialogs.projectsettings import GuiProjectSettings
 
 if TYPE_CHECKING:  # pragma: no cover
     from novelwriter.guimain import GuiMain
@@ -132,7 +133,9 @@ class GuiProjectView(QWidget):
         self.keyContext.activated.connect(lambda: self.projTree.openContextOnSelected())
 
         # Signals
-        self.selectedItemChanged.connect(self.projBar._treeSelectionChanged)
+        self.selectedItemChanged.connect(self.projBar.treeSelectionChanged)
+        self.projTree.itemRefreshed.connect(self.projBar.treeItemRefreshed)
+        self.projBar.newDocumentFromTemplate.connect(self.createFileFromTemplate)
 
         # Function Mappings
         self.emptyTrash = self.projTree.emptyTrash
@@ -158,7 +161,7 @@ class GuiProjectView(QWidget):
         self.projTree.initSettings()
         return
 
-    def clearProjectView(self) -> None:
+    def closeProjectTasks(self) -> None:
         """Clear project-related GUI content."""
         self.projBar.clearContent()
         self.projBar.setEnabled(False)
@@ -167,7 +170,7 @@ class GuiProjectView(QWidget):
 
     def openProjectTasks(self) -> None:
         """Run open project tasks."""
-        self.projBar.buildQuickLinkMenu()
+        self.projBar.buildQuickLinksMenu()
         self.projBar.setEnabled(True)
         return
 
@@ -213,10 +216,17 @@ class GuiProjectView(QWidget):
 
     @pyqtSlot(str)
     def updateItemValues(self, tHandle: str) -> None:
-        """Update tree item"""
+        """Update tree item."""
         self.projTree.setTreeItemValues(tHandle)
         return
 
+    @pyqtSlot(str)
+    def createFileFromTemplate(self, tHandle: str) -> None:
+        """Create a new document from a template."""
+        logger.debug("Template selected: '%s'", tHandle)
+        self.projTree.newTreeItem(nwItemType.FILE, copyDoc=tHandle)
+        return
+
     @pyqtSlot(str, int, int, int)
     def updateCounts(self, tHandle: str, cCount: int, wCount: int, pCount: int) -> None:
         """Slot for updating the word count of a specific item."""
@@ -226,8 +236,8 @@ class GuiProjectView(QWidget):
 
     @pyqtSlot(str)
     def updateRootItem(self, tHandle: str) -> None:
-        """If any root item changes, rebuild the quick link menu."""
-        self.projBar.buildQuickLinkMenu()
+        """Process root item changes."""
+        self.projBar.buildQuickLinksMenu()
         return
 
 # END Class GuiProjectView
@@ -235,6 +245,8 @@ class GuiProjectView(QWidget):
 
 class GuiProjectToolBar(QWidget):
 
+    newDocumentFromTemplate = pyqtSignal(str)
+
     def __init__(self, projView: GuiProjectView) -> None:
         super().__init__(parent=projView)
 
@@ -304,6 +316,11 @@ class GuiProjectToolBar(QWidget):
             lambda: self.projTree.newTreeItem(nwItemType.FOLDER)
         )
 
+        self.mTemplates = _UpdatableMenu(self.mAdd)
+        self.mTemplates.setActionsVisible(False)
+        self.mTemplates.menuItemTriggered.connect(lambda h: self.newDocumentFromTemplate.emit(h))
+        self.mAdd.addMenu(self.mTemplates)
+
         self.mAddRoot = self.mAdd.addMenu(trConst(nwLabels.ITEM_DESCRIPTION["root"]))
         self._buildRootMenu()
 
@@ -384,7 +401,7 @@ class GuiProjectToolBar(QWidget):
         self.tbAdd.setIcon(SHARED.theme.getIcon("add"))
         self.tbMore.setIcon(SHARED.theme.getIcon("menu"))
 
-        self.buildQuickLinkMenu()
+        self.buildQuickLinksMenu()
         self._buildRootMenu()
 
         return
@@ -392,21 +409,48 @@ class GuiProjectToolBar(QWidget):
     def clearContent(self) -> None:
         """Clear dynamic content on the tool bar."""
         self.mQuick.clear()
+        self.mTemplates.clearMenu()
         return
 
-    def buildQuickLinkMenu(self) -> None:
+    def buildQuickLinksMenu(self) -> None:
         """Build the quick link menu."""
         logger.debug("Rebuilding quick links menu")
         self.mQuick.clear()
-        for n, (tHandle, nwItem) in enumerate(SHARED.project.tree.iterRoots(None)):
-            aRoot = self.mQuick.addAction(nwItem.itemName)
-            aRoot.setData(tHandle)
-            aRoot.setIcon(SHARED.theme.getIcon(nwLabels.CLASS_ICON[nwItem.itemClass]))
-            aRoot.triggered.connect(
-                lambda n, tHandle=tHandle: self.projView.setSelectedHandle(tHandle, doScroll=True)
+        for tHandle, nwItem in SHARED.project.tree.iterRoots(None):
+            action = self.mQuick.addAction(nwItem.itemName)
+            action.setData(tHandle)
+            action.setIcon(SHARED.theme.getIcon(nwLabels.CLASS_ICON[nwItem.itemClass]))
+            action.triggered.connect(
+                lambda _, tHandle=tHandle: self.projView.setSelectedHandle(tHandle, doScroll=True)
             )
         return
 
+    ##
+    #  Public Slots
+    ##
+
+    @pyqtSlot(str, NWItem, QIcon)
+    def treeItemRefreshed(self, tHandle: str, nwItem: NWItem, icon: QIcon) -> None:
+        """Process change in tree items to update menu content."""
+        if nwItem.isTemplateFile() and nwItem.isActive:
+            self.mTemplates.addUpdate(tHandle, nwItem.itemName, icon)
+        elif tHandle in self.mTemplates:
+            self.mTemplates.remove(tHandle)
+        return
+
+    @pyqtSlot(str)
+    def treeSelectionChanged(self, tHandle: str) -> None:
+        """Toggle the visibility of the new item entries for novel
+        documents. They should only be visible if novel documents can
+        actually be added.
+        """
+        nwItem = SHARED.project.tree[tHandle]
+        allowDoc = isinstance(nwItem, NWItem) and nwItem.documentAllowed()
+        self.aAddEmpty.setVisible(allowDoc)
+        self.aAddChap.setVisible(allowDoc)
+        self.aAddScene.setVisible(allowDoc)
+        return
+
     ##
     #  Internal Functions
     ##
@@ -422,7 +466,6 @@ class GuiProjectToolBar(QWidget):
 
         self.mAddRoot.clear()
         addClass(nwItemClass.NOVEL)
-        addClass(nwItemClass.ARCHIVE)
         self.mAddRoot.addSeparator()
         addClass(nwItemClass.PLOT)
         addClass(nwItemClass.CHARACTER)
@@ -431,26 +474,12 @@ class GuiProjectToolBar(QWidget):
         addClass(nwItemClass.OBJECT)
         addClass(nwItemClass.ENTITY)
         addClass(nwItemClass.CUSTOM)
+        self.mAddRoot.addSeparator()
+        addClass(nwItemClass.ARCHIVE)
+        addClass(nwItemClass.TEMPLATE)
 
         return
 
-    ##
-    #  Private Slots
-    ##
-
-    @pyqtSlot(str)
-    def _treeSelectionChanged(self, tHandle: str) -> None:
-        """Toggle the visibility of the new item entries for novel
-        documents. They should only be visible if novel documents can
-        actually be added.
-        """
-        nwItem = SHARED.project.tree[tHandle]
-        allowDoc = isinstance(nwItem, NWItem) and nwItem.documentAllowed()
-        self.aAddEmpty.setVisible(allowDoc)
-        self.aAddChap.setVisible(allowDoc)
-        self.aAddScene.setVisible(allowDoc)
-        return
-
 # END Class GuiProjectToolBar
 
 
@@ -465,6 +494,8 @@ class GuiProjectTree(QTreeWidget):
     D_HANDLE = Qt.ItemDataRole.UserRole
     D_WORDS  = Qt.ItemDataRole.UserRole + 1
 
+    itemRefreshed = pyqtSignal(str, NWItem, QIcon)
+
     def __init__(self, projView: GuiProjectView) -> None:
         super().__init__(parent=projView)
 
@@ -588,7 +619,7 @@ class GuiProjectTree(QTreeWidget):
         return False
 
     def newTreeItem(self, itemType: nwItemType, itemClass: nwItemClass | None = None,
-                    hLevel: int = 1, isNote: bool = False) -> bool:
+                    hLevel: int = 1, isNote: bool = False, copyDoc: str | None = None) -> bool:
         """Add new item to the tree, with a given itemType (and
         itemClass if Root), and attach it to the selected handle. Also
         make sure the item is added in a place it can be added, and that
@@ -628,7 +659,10 @@ class GuiProjectTree(QTreeWidget):
             # Set default label and determine if new item is to be added
             # as child or sibling to the selected item
             if itemType == nwItemType.FILE:
-                if isNote:
+                if copyDoc and (cItem := SHARED.project.tree[copyDoc]):
+                    newLabel = cItem.itemName
+                    asChild = sIsParent and pItem.isDocumentLayout()
+                elif isNote:
                     newLabel = self.tr("New Note")
                     asChild = sIsParent
                 elif hLevel == 2:
@@ -676,12 +710,14 @@ class GuiProjectTree(QTreeWidget):
             return True
 
         # Handle new file creation
-        if itemType == nwItemType.FILE and hLevel > 0:
+        if itemType == nwItemType.FILE and copyDoc:
+            SHARED.project.copyFileContent(tHandle, copyDoc)
+        elif itemType == nwItemType.FILE and hLevel > 0:
             SHARED.project.writeNewFile(tHandle, hLevel, not isNote)
 
         # Add the new item to the project tree
         self.revealNewTreeItem(tHandle, nHandle=nHandle, wordCount=True)
-        self.mainGui.switchFocus(nwWidget.TREE)
+        self.projView.setTreeFocus()  # See issue #1376
 
         return True
 
@@ -771,8 +807,7 @@ class GuiProjectTree(QTreeWidget):
 
     def renameTreeItem(self, tHandle: str, name: str = "") -> None:
         """Open a dialog to edit the label of an item."""
-        tItem = SHARED.project.tree[tHandle]
-        if tItem:
+        if tItem := SHARED.project.tree[tHandle]:
             newLabel, dlgOk = GuiEditLabel.getLabel(self, text=name or tItem.itemName)
             if dlgOk:
                 tItem.setName(newLabel)
@@ -786,24 +821,24 @@ class GuiProjectTree(QTreeWidget):
         project structure, and must be called before any code that
         depends on this order to be up to date.
         """
-        theList = []
+        items = []
         for i in range(self.topLevelItemCount()):
             item = self.topLevelItem(i)
             if isinstance(item, QTreeWidgetItem):
-                theList = self._scanChildren(theList, item, i)
+                items = self._scanChildren(items, item, i)
         logger.debug("Saving project tree item order")
-        SHARED.project.setTreeOrder(theList)
+        SHARED.project.setTreeOrder(items)
         return
 
     def getTreeFromHandle(self, tHandle: str) -> list[str]:
         """Recursively return all the child items starting from a given
         item handle.
         """
-        theList = []
-        theItem = self._getTreeItem(tHandle)
-        if theItem is not None:
-            theList = self._scanChildren(theList, theItem, 0)
-        return theList
+        result = []
+        tIten = self._getTreeItem(tHandle)
+        if tIten is not None:
+            result = self._scanChildren(result, tIten, 0)
+        return result
 
     def requestDeleteItem(self, tHandle: str | None = None) -> bool:
         """Request an item deleted from the project tree. This function
@@ -858,11 +893,11 @@ class GuiProjectTree(QTreeWidget):
             SHARED.info(self.tr("There is currently no Trash folder in this project."))
             return False
 
-        theTrash = self.getTreeFromHandle(trashHandle)
-        if trashHandle in theTrash:
-            theTrash.remove(trashHandle)
+        trashItems = self.getTreeFromHandle(trashHandle)
+        if trashHandle in trashItems:
+            trashItems.remove(trashHandle)
 
-        nTrash = len(theTrash)
+        nTrash = len(trashItems)
         if nTrash == 0:
             SHARED.info(self.tr("The Trash folder is already empty."))
             return False
@@ -1030,6 +1065,9 @@ class GuiProjectTree(QTreeWidget):
             trFont.setUnderline(hLevel == "H1")
             trItem.setFont(self.C_NAME, trFont)
 
+        # Emit Refresh Signal
+        self.itemRefreshed.emit(tHandle, nwItem, itemIcon)
+
         return
 
     def propagateCount(self, tHandle: str, newCount: int, countChildren: bool = False) -> None:
@@ -1359,8 +1397,7 @@ class GuiProjectTree(QTreeWidget):
         not including) a given item.
         """
         if isinstance(trItem, QTreeWidgetItem):
-            chCount = trItem.childCount()
-            for i in range(chCount):
+            for i in range(trItem.childCount()):
                 chItem = trItem.child(i)
                 chItem.setExpanded(isExpanded)
                 self._recursiveSetExpanded(chItem, isExpanded)
@@ -1634,6 +1671,71 @@ class GuiProjectTree(QTreeWidget):
 # END Class GuiProjectTree
 
 
+class _UpdatableMenu(QMenu):
+
+    menuItemTriggered = pyqtSignal(str)
+
+    def __init__(self, parent: QWidget) -> None:
+        super().__init__(parent=parent)
+        self._map: dict[str, QAction] = {}
+        self.setTitle(self.tr("From Template"))
+        self.triggered.connect(self._actionTriggered)
+        return
+
+    def __contains__(self, tHandle: str) -> bool:
+        """Look up a handle in the menu."""
+        return tHandle in self._map
+
+    ##
+    #  Methods
+    ##
+
+    def addUpdate(self, tHandle: str, name: str, icon: QIcon) -> None:
+        """Add or update a template item."""
+        if tHandle in self._map:
+            action = self._map[tHandle]
+            action.setText(name)
+            action.setIcon(icon)
+        else:
+            action = QAction(icon, name, self)
+            action.setData(tHandle)
+            self.addAction(action)
+            self._map[tHandle] = action
+        self.setActionsVisible(True)
+        return
+
+    def remove(self, tHandle: str) -> None:
+        """Remove a template item."""
+        if action := self._map.pop(tHandle, None):
+            self.removeAction(action)
+        if not self._map:
+            self.setActionsVisible(False)
+        return
+
+    def clearMenu(self) -> None:
+        """Clear all menu content."""
+        self._map.clear()
+        self.clear()
+        return
+
+    def setActionsVisible(self, value: bool) -> None:
+        """Set the visibility of root action."""
+        self.menuAction().setVisible(value)
+        return
+
+    ##
+    #  Private Slots
+    ##
+
+    @pyqtSlot(QAction)
+    def _actionTriggered(self, action: QAction) -> None:
+        """Translate the menu trigger into an item trigger."""
+        self.menuItemTriggered.emit(str(action.data()))
+        return
+
+# END Class _UpdatableMenu
+
+
 class _TreeContextMenu(QMenu):
 
     def __init__(self, projTree: GuiProjectTree, nwItem: NWItem) -> None:
@@ -1650,7 +1752,7 @@ class _TreeContextMenu(QMenu):
 
         return
 
-    def __del__(self):  # pragma: no cover
+    def __del__(self) -> None:  # pragma: no cover
         logger.debug("Delete: _TreeContextMenu")
         return
 
@@ -1675,10 +1777,15 @@ class _TreeContextMenu(QMenu):
             self._docActions()
             self.addSeparator()
 
+        # Create New Items
+        self._itemCreation()
+        self.addSeparator()
+
         # Edit Item Settings
-        aLabel = self.addAction(self.tr("Rename"))
-        aLabel.triggered.connect(lambda: self.projTree.renameTreeItem(self._handle))
+        action = self.addAction(self.tr("Rename"))
+        action.triggered.connect(lambda: self.projTree.renameTreeItem(self._handle))
         if isFile:
+            self._itemHeader()
             self._itemActive(False)
         self._itemStatusImport(False)
 
@@ -1717,6 +1824,25 @@ class _TreeContextMenu(QMenu):
         )
         return
 
+    def _itemCreation(self) -> None:
+        """Add create item actions."""
+        menu = self.addMenu(self.tr("Create New ..."))
+        menu.addAction(self.projView.projBar.aAddEmpty)
+        menu.addAction(self.projView.projBar.aAddChap)
+        menu.addAction(self.projView.projBar.aAddScene)
+        menu.addAction(self.projView.projBar.aAddNote)
+        menu.addAction(self.projView.projBar.aAddFolder)
+        return
+
+    def _itemHeader(self) -> None:
+        """Check if there is a header that can be used for rename."""
+        if hItem := SHARED.project.index.getItemHeader(self._handle, "T0001"):
+            action = self.addAction(self.tr("Rename to Heading"))
+            action.triggered.connect(
+                lambda: self.projTree.renameTreeItem(self._handle, hItem.title)
+            )
+        return
+
     def _itemActive(self, multi: bool) -> None:
         """Add Active/Inactive actions."""
         if multi:
@@ -1747,7 +1873,7 @@ class _TreeContextMenu(QMenu):
             menu.addSeparator()
             action = menu.addAction(self.tr("Manage Labels ..."))
             action.triggered.connect(
-                lambda: self.projView.projectSettingsRequest.emit(GuiProjectSettings.TAB_STATUS)
+                lambda: self.projView.projectSettingsRequest.emit(GuiProjectSettings.PAGE_STATUS)
             )
         else:
             menu = self.addMenu(self.tr("Set Importance to ..."))
@@ -1764,13 +1890,13 @@ class _TreeContextMenu(QMenu):
             menu.addSeparator()
             action = menu.addAction(self.tr("Manage Labels ..."))
             action.triggered.connect(
-                lambda: self.projView.projectSettingsRequest.emit(GuiProjectSettings.TAB_IMPORT)
+                lambda: self.projView.projectSettingsRequest.emit(GuiProjectSettings.PAGE_IMPORT)
             )
         return
 
     def _itemTransform(self, isFile: bool, isFolder: bool, hasChild: bool) -> None:
         """Add actions for the Transform menu."""
-        menu = self.addMenu(self.tr("Transform"))
+        menu = self.addMenu(self.tr("Transform ..."))
 
         tree = self.projTree
         tHandle = self._handle

novelwriter/gui/sidebar.py

@@ -3,10 +3,10 @@ novelWriter – GUI Main Window SideBar
 =====================================
 
 File History:
-Created: 2022-05-10 [2.0rc1]
+Created: 2022-05-10 [2.0rc1] GuiSideBar
 
 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,12 +27,13 @@ import logging
 
 from typing import TYPE_CHECKING
 
-from PyQt5.QtCore import QEvent, QPoint, Qt, QSize, pyqtSignal
 from PyQt5.QtGui import QPalette
+from PyQt5.QtCore import QEvent, QPoint, Qt, QSize, pyqtSignal
 from PyQt5.QtWidgets import QMenu, QToolButton, QVBoxLayout, QWidget
 
 from novelwriter import CONFIG, SHARED
 from novelwriter.enum import nwView
+from novelwriter.extensions.eventfilters import StatusTipFilter
 
 if TYPE_CHECKING:  # pragma: no cover
     from novelwriter.guimain import GuiMain
@@ -54,6 +55,7 @@ class GuiSideBar(QWidget):
         iPx = CONFIG.pxInt(24)
         iconSize = QSize(iPx, iPx)
         self.setContentsMargins(0, 0, 0, 0)
+        self.installEventFilter(StatusTipFilter(mainGui))
 
         # Buttons
         self.tbProject = QToolButton(self)
@@ -77,9 +79,9 @@ class GuiSideBar(QWidget):
         self.tbBuild.clicked.connect(self.mainGui.showBuildManuscriptDialog)
 
         self.tbDetails = QToolButton(self)
-        self.tbDetails.setToolTip("{0} [Shift+F6]".format(self.tr("Project Details")))
+        self.tbDetails.setToolTip("{0} [Shift+F6]".format(self.tr("Novel Details")))
         self.tbDetails.setIconSize(iconSize)
-        self.tbDetails.clicked.connect(self.mainGui.showProjectDetailsDialog)
+        self.tbDetails.clicked.connect(self.mainGui.showNovelDetailsDialog)
 
         self.tbStats = QToolButton(self)
         self.tbStats.setToolTip("{0} [F6]".format(self.tr("Writing Statistics")))
@@ -162,11 +164,10 @@ class GuiSideBar(QWidget):
 
 class _PopRightMenu(QMenu):
 
-    def event(self, event: QEvent):
+    def event(self, event: QEvent) -> bool:
         """Overload the show event and move the menu popup location."""
         if event.type() == QEvent.Show:
-            parent = self.parent()
-            if isinstance(parent, QWidget):
+            if isinstance(parent := self.parent(), QWidget):
                 offset = QPoint(parent.width(), parent.height() - self.height())
                 self.move(parent.mapToGlobal(offset))
         return super(_PopRightMenu, self).event(event)

novelwriter/gui/statusbar.py

@@ -3,10 +3,10 @@ novelWriter – GUI Main Window Status Bar
 ========================================
 
 File History:
-Created: 2019-04-20 [0.0.1]
+Created: 2019-04-20 [0.0.1] GuiMainStatus
 
 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,9 +27,9 @@ import logging
 
 from time import time
 from typing import TYPE_CHECKING, Literal
+from datetime import datetime
 
 from PyQt5.QtCore import pyqtSlot, QLocale
-from PyQt5.QtGui import QColor
 from PyQt5.QtWidgets import qApp, QStatusBar, QLabel
 
 from novelwriter import CONFIG, SHARED
@@ -50,12 +50,13 @@ class GuiMainStatus(QStatusBar):
 
         logger.debug("Create: GuiMainStatus")
 
-        self._refTime  = -1.0
+        self._refTime = -1.0
         self._userIdle = False
+        self._debugInfo = False
 
-        colNone = QColor(*SHARED.theme.statNone)
-        colSaved = QColor(*SHARED.theme.statSaved)
-        colUnsaved = QColor(*SHARED.theme.statUnsaved)
+        colNone = SHARED.theme.statNone
+        colSaved = SHARED.theme.statSaved
+        colUnsaved = SHARED.theme.statUnsaved
 
         iPx = SHARED.theme.baseIconSize
 
@@ -223,4 +224,45 @@ class GuiMainStatus(QStatusBar):
         self.setDocumentStatus(StatusLED.S_BAD if status else StatusLED.S_GOOD)
         return
 
+    ##
+    #  Debug
+    ##
+
+    def memInfo(self) -> None:  # pragma: no cover
+        """Display memory info on the status bar. This is used to
+        investigate memory usage and Qt widgets that get left in memory.
+        Enabled by the --meminfo command line flag.
+
+        By default, this tracks memory usage diff after launch. To track
+        full memory usage, set environment variable PYTHONTRACEMALLOC=1
+        before starting novelWriter.
+        """
+        import tracemalloc
+        from collections import Counter
+
+        widgets = qApp.allWidgets()
+        if not self._debugInfo:
+            if tracemalloc.is_tracing():
+                self._traceMallocRef = "Total"
+            else:
+                self._traceMallocRef = "Relative"
+                tracemalloc.start()
+            self._debugInfo = True
+            self._wCounts = Counter([type(x).__name__ for x in widgets])
+
+        if hasattr(self, "_wCounts"):
+            diff = Counter([type(x).__name__ for x in widgets]) - self._wCounts
+            for name, count in diff.items():
+                logger.debug("Widget '%s': +%d", name, count)
+
+        mem = tracemalloc.get_traced_memory()
+        stamp = datetime.now().strftime("%H:%M:%S")
+        self.showMessage((
+            f"Debug [{stamp}]"
+            f" \u2013 Widgets: {len(widgets)}"
+            f" \u2013 {self._traceMallocRef} Memory: {mem[0]:n}"
+            f" \u2013 Peak: {mem[1]:n}"
+        ), 6000)
+        return
+
 # END Class GuiMainStatus