novelWriter 2.2rc1__py3-none-any.whl → 2.3__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)
 
@@ -474,10 +505,15 @@ class GuiProjectTree(QTreeWidget):
         self.mainGui  = projView.mainGui
 
         # Internal Variables
-        self._treeMap = {}
+        self._treeMap: dict[str, QTreeWidgetItem] = {}
         self._timeChanged = 0.0
         self._popAlert = None
 
+        # Cached Translations
+        self.trActive = self.tr("Active")
+        self.trInactive = self.tr("Inactive")
+        self.trPermDelete = self.tr("Permanently delete {0} file(s) from Trash?")
+
         # Build GUI
         # =========
 
@@ -524,10 +560,6 @@ class GuiProjectTree(QTreeWidget):
         trRoot = self.invisibleRootItem()
         trRoot.setFlags(trRoot.flags() ^ Qt.ItemFlag.ItemIsDropEnabled)
 
-        # Cached values
-        self._lblActive = self.tr("Active")
-        self._lblInactive = self.tr("Inactive")
-
         # Set selection options
         self.setSelectionMode(QAbstractItemView.SelectionMode.ExtendedSelection)
         self.setSelectionBehavior(QAbstractItemView.SelectionBehavior.SelectRows)
@@ -588,7 +620,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 +660,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 +711,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 +808,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 +822,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,19 +894,16 @@ 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
 
-        msgYes = SHARED.question(
-            self.tr("Permanently delete {0} file(s) from Trash?").format(nTrash)
-        )
-        if not msgYes:
+        if not SHARED.question(self.trPermDelete.format(nTrash)):
             logger.info("Action cancelled by user")
             return False
 
@@ -1017,7 +1050,7 @@ class GuiProjectTree(QTreeWidget):
 
         if nwItem.isFileType():
             iconName = "checked" if nwItem.isActive else "unchecked"
-            toolTip = self._lblActive if nwItem.isActive else self._lblInactive
+            toolTip = self.trActive if nwItem.isActive else self.trInactive
             trItem.setToolTip(self.C_ACTIVE, toolTip)
         else:
             iconName = "noncheckable"
@@ -1030,6 +1063,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:
@@ -1091,9 +1127,8 @@ class GuiProjectTree(QTreeWidget):
         """Get the currently selected handle. If multiple items are
         selected, return the first.
         """
-        selItem = self.selectedItems()
-        if selItem:
-            return selItem[0].data(self.C_DATA, self.D_HANDLE)
+        if items := self.selectedItems():
+            return items[0].data(self.C_DATA, self.D_HANDLE)
         return None
 
     def setSelectedHandle(self, tHandle: str | None, doScroll: bool = False) -> bool:
@@ -1105,9 +1140,8 @@ class GuiProjectTree(QTreeWidget):
         if tHandle in self._treeMap:
             self.setCurrentItem(self._treeMap[tHandle])
 
-        selIndex = self.selectedIndexes()
-        if selIndex and doScroll:
-            self.scrollTo(selIndex[0], QAbstractItemView.ScrollHint.PositionAtCenter)
+        if (indexes := self.selectedIndexes()) and doScroll:
+            self.scrollTo(indexes[0], QAbstractItemView.ScrollHint.PositionAtCenter)
 
         return True
 
@@ -1122,10 +1156,8 @@ class GuiProjectTree(QTreeWidget):
 
     def openContextOnSelected(self) -> bool:
         """Open the context menu on the current selected item."""
-        selItem = self.selectedItems()
-        if selItem:
-            pos = self.visualItemRect(selItem[0]).center()
-            return self._openContextMenu(pos)
+        if items := self.selectedItems():
+            return self._openContextMenu(self.visualItemRect(items[0]).center())
         return False
 
     def changedSince(self, checkTime: float) -> bool:
@@ -1359,8 +1391,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 +1665,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:
@@ -1644,13 +1740,13 @@ class _TreeContextMenu(QMenu):
 
         self._item = nwItem
         self._handle = nwItem.itemHandle
-        self._items: list[str] = []
+        self._items: list[NWItem] = []
 
         logger.debug("Ready: _TreeContextMenu")
 
         return
 
-    def __del__(self):  # pragma: no cover
+    def __del__(self) -> None:  # pragma: no cover
         logger.debug("Delete: _TreeContextMenu")
         return
 
@@ -1675,10 +1771,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)
 
@@ -1692,13 +1793,17 @@ class _TreeContextMenu(QMenu):
 
         return
 
-    def buildMultiSelectMenu(self, items: list[str]) -> None:
+    def buildMultiSelectMenu(self, handles: list[str]) -> None:
         """Build the multi-select menu."""
-        self._items = items
+        self._items = []
+        for tHandle in handles:
+            if (tItem := SHARED.project.tree[tHandle]):
+                self._items.append(tItem)
+
         self._itemActive(True)
         self._itemStatusImport(True)
         self.addSeparator()
-        self._moveToTrash(True)
+        self._multiMoveToTrash()
         return
 
     ##
@@ -1717,13 +1822,32 @@ 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:
             mSub = self.addMenu(self.tr("Set Active to ..."))
-            aOne = mSub.addAction(SHARED.theme.getIcon("checked"), self.tr("Active"))
+            aOne = mSub.addAction(SHARED.theme.getIcon("checked"), self.projTree.trActive)
             aOne.triggered.connect(lambda: self._iterItemActive(True))
-            aTwo = mSub.addAction(SHARED.theme.getIcon("unchecked"), self.tr("Inactive"))
+            aTwo = mSub.addAction(SHARED.theme.getIcon("unchecked"), self.projTree.trInactive)
             aTwo.triggered.connect(lambda: self._iterItemActive(False))
         else:
             action = self.addAction(self.tr("Toggle Active"))
@@ -1747,7 +1871,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 +1888,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
@@ -1838,10 +1962,14 @@ class _TreeContextMenu(QMenu):
 
         return
 
-    def _moveToTrash(self, multi: bool) -> None:
+    def _multiMoveToTrash(self) -> None:
         """Add move to Trash action."""
-        action = self.addAction(self.tr("Move to Trash"))
-        if multi:
+        areTrash = [i.itemClass == nwItemClass.TRASH for i in self._items]
+        if all(areTrash):
+            action = self.addAction(self.tr("Delete Permanently"))
+            action.triggered.connect(self._iterPermDelete)
+        elif not any(areTrash):
+            action = self.addAction(self.tr("Move to Trash"))
             action.triggered.connect(self._iterMoveToTrash)
         return
 
@@ -1853,10 +1981,19 @@ class _TreeContextMenu(QMenu):
     def _iterMoveToTrash(self) -> None:
         """Iterate through files and move them to Trash."""
         if SHARED.question(self.tr("Move {0} items to Trash?").format(len(self._items))):
-            for tHandle in self._items:
-                tItem = SHARED.project.tree[tHandle]
-                if tItem and tItem.isFileType():
-                    self.projTree.moveItemToTrash(tHandle, askFirst=False, flush=False)
+            for tItem in self._items:
+                if tItem.isFileType() and tItem.itemClass != nwItemClass.TRASH:
+                    self.projTree.moveItemToTrash(tItem.itemHandle, askFirst=False, flush=False)
+                self.projTree.saveTreeOrder()
+        return
+
+    @pyqtSlot()
+    def _iterPermDelete(self) -> None:
+        """Iterate through files and delete them."""
+        if SHARED.question(self.projTree.trPermDelete.format(len(self._items))):
+            for tItem in self._items:
+                if tItem.isFileType() and tItem.itemClass == nwItemClass.TRASH:
+                    self.projTree.permDeleteItem(tItem.itemHandle, askFirst=False, flush=False)
                 self.projTree.saveTreeOrder()
         return
 
@@ -1874,12 +2011,11 @@ class _TreeContextMenu(QMenu):
 
     def _iterItemActive(self, isActive: bool) -> None:
         """Set the active status of multiple items."""
-        for tHandle in self._items:
-            tItem = SHARED.project.tree[tHandle]
+        for tItem in self._items:
             if tItem and tItem.isFileType():
                 tItem.setActive(isActive)
-                self.projTree.setTreeItemValues(tHandle)
-                self.projTree._alertTreeChange(tHandle, flush=False)
+                self.projTree.setTreeItemValues(tItem.itemHandle)
+                self.projTree._alertTreeChange(tItem.itemHandle, flush=False)
         return
 
     def _changeItemStatus(self, key: str) -> None:
@@ -1891,12 +2027,11 @@ class _TreeContextMenu(QMenu):
 
     def _iterSetItemStatus(self, key: str) -> None:
         """Change the status value for multiple items."""
-        for tHandle in self._items:
-            tItem = SHARED.project.tree[tHandle]
+        for tItem in self._items:
             if tItem and tItem.isNovelLike():
                 tItem.setStatus(key)
-                self.projTree.setTreeItemValues(tHandle)
-                self.projTree._alertTreeChange(tHandle, flush=False)
+                self.projTree.setTreeItemValues(tItem.itemHandle)
+                self.projTree._alertTreeChange(tItem.itemHandle, flush=False)
         return
 
     def _changeItemImport(self, key: str) -> None:
@@ -1908,12 +2043,11 @@ class _TreeContextMenu(QMenu):
 
     def _iterSetItemImport(self, key: str) -> None:
         """Change the status value for multiple items."""
-        for tHandle in self._items:
-            tItem = SHARED.project.tree[tHandle]
+        for tItem in self._items:
             if tItem and not tItem.isNovelLike():
                 tItem.setImport(key)
-                self.projTree.setTreeItemValues(tHandle)
-                self.projTree._alertTreeChange(tHandle, flush=False)
+                self.projTree.setTreeItemValues(tItem.itemHandle)
+                self.projTree._alertTreeChange(tItem.itemHandle, flush=False)
         return
 
     def _changeItemLayout(self, itemLayout: nwItemLayout) -> None: