novelWriter 2.5.1__py3-none-any.whl → 2.6b1__py3-none-any.whl

novelwriter/gui/projtree.py

@@ -29,7 +29,6 @@ from __future__ import annotations
 import logging
 
 from enum import Enum
-from time import time
 
 from PyQt5.QtCore import QPoint, Qt, QTimer, pyqtSignal, pyqtSlot
 from PyQt5.QtGui import QDragEnterEvent, QDragMoveEvent, QDropEvent, QIcon, QMouseEvent, QPalette
@@ -39,8 +38,8 @@ from PyQt5.QtWidgets import (
 )
 
 from novelwriter import CONFIG, SHARED
-from novelwriter.common import minmax
-from novelwriter.constants import nwHeaders, nwLabels, nwUnicode, trConst
+from novelwriter.common import minmax, qtLambda
+from novelwriter.constants import nwLabels, nwStyles, nwUnicode, trConst
 from novelwriter.core.coretools import DocDuplicator, DocMerger, DocSplitter
 from novelwriter.core.item import NWItem
 from novelwriter.dialogs.docmerge import GuiDocMerge
@@ -51,8 +50,8 @@ from novelwriter.enum import nwDocMode, nwItemClass, nwItemLayout, nwItemType
 from novelwriter.extensions.modified import NIconToolButton
 from novelwriter.gui.theme import STYLES_MIN_TOOLBUTTON
 from novelwriter.types import (
-    QtAlignLeft, QtAlignRight, QtMouseLeft, QtMouseMiddle, QtSizeExpanding,
-    QtUserRole
+    QtAlignLeft, QtAlignRight, QtMouseLeft, QtMouseMiddle, QtScrollAlwaysOff,
+    QtScrollAsNeeded, QtSizeExpanding, QtUserRole
 )
 
 logger = logging.getLogger(__name__)
@@ -97,37 +96,37 @@ class GuiProjectView(QWidget):
         self.keyMoveUp = QShortcut(self.projTree)
         self.keyMoveUp.setKey("Ctrl+Up")
         self.keyMoveUp.setContext(Qt.ShortcutContext.WidgetShortcut)
-        self.keyMoveUp.activated.connect(lambda: self.projTree.moveTreeItem(-1))
+        self.keyMoveUp.activated.connect(qtLambda(self.projTree.moveTreeItem, -1))
 
         self.keyMoveDn = QShortcut(self.projTree)
         self.keyMoveDn.setKey("Ctrl+Down")
         self.keyMoveDn.setContext(Qt.ShortcutContext.WidgetShortcut)
-        self.keyMoveDn.activated.connect(lambda: self.projTree.moveTreeItem(1))
+        self.keyMoveDn.activated.connect(qtLambda(self.projTree.moveTreeItem, 1))
 
         self.keyGoPrev = QShortcut(self.projTree)
         self.keyGoPrev.setKey("Alt+Up")
         self.keyGoPrev.setContext(Qt.ShortcutContext.WidgetShortcut)
-        self.keyGoPrev.activated.connect(lambda: self.projTree.moveToNextItem(-1))
+        self.keyGoPrev.activated.connect(qtLambda(self.projTree.moveToNextItem, -1))
 
         self.keyGoNext = QShortcut(self.projTree)
         self.keyGoNext.setKey("Alt+Down")
         self.keyGoNext.setContext(Qt.ShortcutContext.WidgetShortcut)
-        self.keyGoNext.activated.connect(lambda: self.projTree.moveToNextItem(1))
+        self.keyGoNext.activated.connect(qtLambda(self.projTree.moveToNextItem, 1))
 
         self.keyGoUp = QShortcut(self.projTree)
         self.keyGoUp.setKey("Alt+Left")
         self.keyGoUp.setContext(Qt.ShortcutContext.WidgetShortcut)
-        self.keyGoUp.activated.connect(lambda: self.projTree.moveToLevel(-1))
+        self.keyGoUp.activated.connect(qtLambda(self.projTree.moveToLevel, -1))
 
         self.keyGoDown = QShortcut(self.projTree)
         self.keyGoDown.setKey("Alt+Right")
         self.keyGoDown.setContext(Qt.ShortcutContext.WidgetShortcut)
-        self.keyGoDown.activated.connect(lambda: self.projTree.moveToLevel(1))
+        self.keyGoDown.activated.connect(qtLambda(self.projTree.moveToLevel, 1))
 
         self.keyContext = QShortcut(self.projTree)
         self.keyContext.setKey("Ctrl+.")
         self.keyContext.setContext(Qt.ShortcutContext.WidgetShortcut)
-        self.keyContext.activated.connect(lambda: self.projTree.openContextOnSelected())
+        self.keyContext.activated.connect(self.projTree.openContextMenu)
 
         # Signals
         self.selectedItemChanged.connect(self.projBar.treeSelectionChanged)
@@ -138,7 +137,6 @@ class GuiProjectView(QWidget):
         self.emptyTrash = self.projTree.emptyTrash
         self.requestDeleteItem = self.projTree.requestDeleteItem
         self.getSelectedHandle = self.projTree.getSelectedHandle
-        self.changedSince = self.projTree.changedSince
 
         return
 
@@ -211,6 +209,12 @@ class GuiProjectView(QWidget):
         self.projTree.setSelectedHandle(tHandle, doScroll=doScroll)
         return
 
+    @pyqtSlot(str)
+    def setActiveHandle(self, tHandle: str | None) -> None:
+        """Highlight the active handle."""
+        self.projTree.setActiveHandle(tHandle)
+        return
+
     @pyqtSlot(str)
     def updateItemValues(self, tHandle: str) -> None:
         """Update tree item."""
@@ -286,38 +290,38 @@ class GuiProjectToolBar(QWidget):
         # Move Buttons
         self.tbMoveU = NIconToolButton(self, iSz)
         self.tbMoveU.setToolTip("%s [Ctrl+Up]" % self.tr("Move Up"))
-        self.tbMoveU.clicked.connect(lambda: self.projTree.moveTreeItem(-1))
+        self.tbMoveU.clicked.connect(qtLambda(self.projTree.moveTreeItem, -1))
 
         self.tbMoveD = NIconToolButton(self, iSz)
         self.tbMoveD.setToolTip("%s [Ctrl+Down]" % self.tr("Move Down"))
-        self.tbMoveD.clicked.connect(lambda: self.projTree.moveTreeItem(1))
+        self.tbMoveD.clicked.connect(qtLambda(self.projTree.moveTreeItem, 1))
 
         # Add Item Menu
         self.mAdd = QMenu(self)
 
         self.aAddEmpty = self.mAdd.addAction(trConst(nwLabels.ITEM_DESCRIPTION["document"]))
         self.aAddEmpty.triggered.connect(
-            lambda: self.projTree.newTreeItem(nwItemType.FILE, hLevel=0, isNote=False)
+            qtLambda(self.projTree.newTreeItem, nwItemType.FILE, hLevel=0, isNote=False)
         )
 
         self.aAddChap = self.mAdd.addAction(trConst(nwLabels.ITEM_DESCRIPTION["doc_h2"]))
         self.aAddChap.triggered.connect(
-            lambda: self.projTree.newTreeItem(nwItemType.FILE, hLevel=2, isNote=False)
+            qtLambda(self.projTree.newTreeItem, nwItemType.FILE, hLevel=2, isNote=False)
         )
 
         self.aAddScene = self.mAdd.addAction(trConst(nwLabels.ITEM_DESCRIPTION["doc_h3"]))
         self.aAddScene.triggered.connect(
-            lambda: self.projTree.newTreeItem(nwItemType.FILE, hLevel=3, isNote=False)
+            qtLambda(self.projTree.newTreeItem, nwItemType.FILE, hLevel=3, isNote=False)
         )
 
         self.aAddNote = self.mAdd.addAction(trConst(nwLabels.ITEM_DESCRIPTION["note"]))
         self.aAddNote.triggered.connect(
-            lambda: self.projTree.newTreeItem(nwItemType.FILE, hLevel=1, isNote=True)
+            qtLambda(self.projTree.newTreeItem, nwItemType.FILE, hLevel=1, isNote=True)
         )
 
         self.aAddFolder = self.mAdd.addAction(trConst(nwLabels.ITEM_DESCRIPTION["folder"]))
         self.aAddFolder.triggered.connect(
-            lambda: self.projTree.newTreeItem(nwItemType.FOLDER)
+            qtLambda(self.projTree.newTreeItem, nwItemType.FOLDER)
         )
 
         self.mTemplates = _UpdatableMenu(self.mAdd)
@@ -337,13 +341,17 @@ class GuiProjectToolBar(QWidget):
         self.mMore = QMenu(self)
 
         self.aExpand = self.mMore.addAction(self.tr("Expand All"))
-        self.aExpand.triggered.connect(lambda: self.projTree.setExpandedFromHandle(None, True))
+        self.aExpand.triggered.connect(
+            qtLambda(self.projTree.setExpandedFromHandle, None, True)
+        )
 
         self.aCollapse = self.mMore.addAction(self.tr("Collapse All"))
-        self.aCollapse.triggered.connect(lambda: self.projTree.setExpandedFromHandle(None, False))
+        self.aCollapse.triggered.connect(
+            qtLambda(self.projTree.setExpandedFromHandle, None, False)
+        )
 
         self.aEmptyTrash = self.mMore.addAction(self.tr("Empty Trash"))
-        self.aEmptyTrash.triggered.connect(lambda: self.projTree.emptyTrash())
+        self.aEmptyTrash.triggered.connect(qtLambda(self.projTree.emptyTrash))
 
         self.tbMore = NIconToolButton(self, iSz)
         self.tbMore.setToolTip(self.tr("More Options"))
@@ -416,7 +424,7 @@ class GuiProjectToolBar(QWidget):
             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)
+                qtLambda(self.projView.setSelectedHandle, tHandle, doScroll=True)
             )
         return
 
@@ -455,7 +463,9 @@ class GuiProjectToolBar(QWidget):
         def addClass(itemClass: nwItemClass) -> None:
             aNew = self.mAddRoot.addAction(trConst(nwLabels.CLASS_NAME[itemClass]))
             aNew.setIcon(SHARED.theme.getIcon(nwLabels.CLASS_ICON[itemClass]))
-            aNew.triggered.connect(lambda: self.projTree.newTreeItem(nwItemType.ROOT, itemClass))
+            aNew.triggered.connect(
+                qtLambda(self.projTree.newTreeItem, nwItemType.ROOT, itemClass)
+            )
             self.mAddRoot.addAction(aNew)
             return
 
@@ -498,8 +508,8 @@ class GuiProjectTree(QTreeWidget):
 
         # Internal Variables
         self._treeMap: dict[str, QTreeWidgetItem] = {}
-        self._timeChanged = 0.0
         self._popAlert = None
+        self._actHandle = None
 
         # Cached Translations
         self.trActive = self.tr("Active")
@@ -511,7 +521,7 @@ class GuiProjectTree(QTreeWidget):
 
         # Context Menu
         self.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
-        self.customContextMenuRequested.connect(self._openContextMenu)
+        self.customContextMenuRequested.connect(self.openContextMenu)
 
         # Tree Settings
         iPx = SHARED.theme.baseIconHeight
@@ -578,13 +588,13 @@ class GuiProjectTree(QTreeWidget):
         """Set or update tree widget settings."""
         # Scroll bars
         if CONFIG.hideVScroll:
-            self.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
+            self.setVerticalScrollBarPolicy(QtScrollAlwaysOff)
         else:
-            self.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAsNeeded)
+            self.setVerticalScrollBarPolicy(QtScrollAsNeeded)
         if CONFIG.hideHScroll:
-            self.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
+            self.setHorizontalScrollBarPolicy(QtScrollAlwaysOff)
         else:
-            self.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAsNeeded)
+            self.setHorizontalScrollBarPolicy(QtScrollAsNeeded)
         return
 
     ##
@@ -595,7 +605,6 @@ class GuiProjectTree(QTreeWidget):
         """Clear the GUI content and the related map."""
         self.clear()
         self._treeMap = {}
-        self._timeChanged = 0.0
         return
 
     def createNewNote(self, tag: str, itemClass: nwItemClass) -> None:
@@ -642,7 +651,7 @@ class GuiProjectTree(QTreeWidget):
 
             # Collect some information about the selected item
             qItem = self._getTreeItem(sHandle)
-            sLevel = nwHeaders.H_LEVEL.get(pItem.mainHeading, 0)
+            sLevel = nwStyles.H_LEVEL.get(pItem.mainHeading, 0)
             sIsParent = False if qItem is None else qItem.childCount() > 0
 
             if SHARED.project.tree.isTrash(sHandle):
@@ -1114,12 +1123,10 @@ class GuiProjectTree(QTreeWidget):
         """
         logger.debug("Building the project tree ...")
         self.clearTree()
-        count = 0
         for nwItem in SHARED.project.iterProjectItems():
-            count += 1
             self._addTreeItem(nwItem)
-        if count > 0:
-            logger.info("%d item(s) added to the project tree", count)
+        self.setActiveHandle(self._actHandle)
+        logger.info("%d item(s) added to the project tree", len(self._treeMap))
         return
 
     def getSelectedHandle(self) -> str | None:
@@ -1130,38 +1137,78 @@ class GuiProjectTree(QTreeWidget):
             return items[0].data(self.C_DATA, self.D_HANDLE)
         return None
 
-    def setSelectedHandle(self, tHandle: str | None, doScroll: bool = False) -> bool:
+    def setSelectedHandle(self, tHandle: str | None, doScroll: bool = False) -> None:
         """Set a specific handle as the selected item."""
-        tItem = self._getTreeItem(tHandle)
-        if tItem is None:
-            return False
-
         if tHandle in self._treeMap:
             self.setCurrentItem(self._treeMap[tHandle])
+            if (indexes := self.selectedIndexes()) and doScroll:
+                self.scrollTo(indexes[0], QAbstractItemView.ScrollHint.PositionAtCenter)
+        return
 
-        if (indexes := self.selectedIndexes()) and doScroll:
-            self.scrollTo(indexes[0], QAbstractItemView.ScrollHint.PositionAtCenter)
-
-        return True
+    def setActiveHandle(self, tHandle: str | None) -> None:
+        """Highlight the rows associated with a given handle."""
+        brushOn = self.palette().alternateBase()
+        brushOff = self.palette().base()
+        if (pHandle := self._actHandle) and (item := self._treeMap.get(pHandle)):
+            for i in range(self.columnCount()):
+                item.setBackground(i, brushOff)
+        if tHandle and (item := self._treeMap.get(tHandle)):
+            for i in range(self.columnCount()):
+                item.setBackground(i, brushOn)
+        self._actHandle = tHandle or None
+        return
 
     def setExpandedFromHandle(self, tHandle: str | None, isExpanded: bool) -> None:
         """Iterate through items below tHandle and change expanded
         status for all child items. If tHandle is None, it affects the
         entire tree.
         """
-        trItem = self._getTreeItem(tHandle) or self.invisibleRootItem()
-        self._recursiveSetExpanded(trItem, isExpanded)
+        item = self._getTreeItem(tHandle) or self.invisibleRootItem()
+        self._recursiveSetExpanded(item, isExpanded)
         return
 
-    def openContextOnSelected(self) -> bool:
-        """Open the context menu on the current selected item."""
-        if items := self.selectedItems():
-            return self._openContextMenu(self.visualItemRect(items[0]).center())
-        return False
+    ##
+    #  Public Slots
+    ##
+
+    @pyqtSlot()
+    @pyqtSlot("QPoint")
+    def openContextMenu(self, clickPos: QPoint | None = None) -> None:
+        """The user right clicked an element in the project tree, so we
+        open a context menu in-place.
+        """
+        if clickPos is None and (items := self.selectedItems()):
+            clickPos = self.visualItemRect(items[0]).center()
+
+        if clickPos is not None:
+            tItem = None
+            tHandle = None
+            hasChild = False
+            sItem = self.itemAt(clickPos)
+            sItems = self.selectedItems()
+            if isinstance(sItem, QTreeWidgetItem):
+                tHandle = sItem.data(self.C_DATA, self.D_HANDLE)
+                tItem = SHARED.project.tree[tHandle]
+                hasChild = sItem.childCount() > 0
+
+            if tItem is None or tHandle is None:
+                logger.debug("No item found")
+                return
+
+            ctxMenu = _TreeContextMenu(self, tItem)
+            trashHandle = SHARED.project.tree.trashRoot
+            if trashHandle and tHandle == trashHandle:
+                ctxMenu.buildTrashMenu()
+            elif len(sItems) > 1:
+                handles = [str(x.data(self.C_DATA, self.D_HANDLE)) for x in sItems]
+                ctxMenu.buildMultiSelectMenu(handles)
+            else:
+                ctxMenu.buildSingleSelectMenu(hasChild)
 
-    def changedSince(self, checkTime: float) -> bool:
-        """Check if the tree has changed since a given time."""
-        return self._timeChanged > checkTime
+            ctxMenu.exec(self.viewport().mapToGlobal(clickPos))
+            ctxMenu.deleteLater()
+
+        return
 
     ##
     #  Private Slots
@@ -1204,40 +1251,6 @@ class GuiProjectTree(QTreeWidget):
 
         return
 
-    @pyqtSlot("QPoint")
-    def _openContextMenu(self, clickPos: QPoint) -> bool:
-        """The user right clicked an element in the project tree, so we
-        open a context menu in-place.
-        """
-        tItem = None
-        tHandle = None
-        hasChild = False
-        sItem = self.itemAt(clickPos)
-        sItems = self.selectedItems()
-        if isinstance(sItem, QTreeWidgetItem):
-            tHandle = sItem.data(self.C_DATA, self.D_HANDLE)
-            tItem = SHARED.project.tree[tHandle]
-            hasChild = sItem.childCount() > 0
-
-        if tItem is None or tHandle is None:
-            logger.debug("No item found")
-            return False
-
-        ctxMenu = _TreeContextMenu(self, tItem)
-        trashHandle = SHARED.project.tree.trashRoot
-        if trashHandle and tHandle == trashHandle:
-            ctxMenu.buildTrashMenu()
-        elif len(sItems) > 1:
-            handles = [str(x.data(self.C_DATA, self.D_HANDLE)) for x in sItems]
-            ctxMenu.buildMultiSelectMenu(handles)
-        else:
-            ctxMenu.buildSingleSelectMenu(hasChild)
-
-        ctxMenu.exec(self.viewport().mapToGlobal(clickPos))
-        ctxMenu.deleteLater()
-
-        return True
-
     @pyqtSlot()
     def _doAutoScroll(self) -> None:
         """Scroll one item up or down based on direction value."""
@@ -1377,11 +1390,6 @@ class GuiProjectTree(QTreeWidget):
 
         return
 
-    def _getItemWordCount(self, tHandle: str) -> int:
-        """Return the word count of a given item handle."""
-        tItem = self._getTreeItem(tHandle)
-        return int(tItem.data(self.C_DATA, self.D_WORDS)) if tItem else 0
-
     def _getTreeItem(self, tHandle: str | None) -> QTreeWidgetItem | None:
         """Return the QTreeWidgetItem of a given item handle."""
         return self._treeMap.get(tHandle, None) if tHandle else None
@@ -1638,7 +1646,6 @@ class GuiProjectTree(QTreeWidget):
         signals. A flush is only needed if an item is moved, created or
         deleted.
         """
-        self._timeChanged = time()
         SHARED.project.setProjectChanged(True)
         if flush:
             self.saveTreeOrder()
@@ -1765,7 +1772,7 @@ class _TreeContextMenu(QMenu):
 
         # Edit Item Settings
         action = self.addAction(self.tr("Rename"))
-        action.triggered.connect(lambda: self.projTree.renameTreeItem(self._handle))
+        action.triggered.connect(qtLambda(self.projTree.renameTreeItem, self._handle))
         if isFile:
             self._itemHeader()
             self._itemActive(False)
@@ -1801,13 +1808,15 @@ class _TreeContextMenu(QMenu):
     def _docActions(self) -> None:
         """Add document actions."""
         action = self.addAction(self.tr("Open Document"))
-        action.triggered.connect(
-            lambda: self.projView.openDocumentRequest.emit(self._handle, nwDocMode.EDIT, "", True)
-        )
+        action.triggered.connect(qtLambda(
+            self.projView.openDocumentRequest.emit,
+            self._handle, nwDocMode.EDIT, "", True
+        ))
         action = self.addAction(self.tr("View Document"))
-        action.triggered.connect(
-            lambda: self.projView.openDocumentRequest.emit(self._handle, nwDocMode.VIEW, "", False)
-        )
+        action.triggered.connect(qtLambda(
+            self.projView.openDocumentRequest.emit,
+            self._handle, nwDocMode.VIEW, "", False
+        ))
         return
 
     def _itemCreation(self) -> None:
@@ -1826,7 +1835,7 @@ class _TreeContextMenu(QMenu):
         if hItem := SHARED.project.index.getItemHeading(self._handle, "T0001"):
             action = self.addAction(self.tr("Rename to Heading"))
             action.triggered.connect(
-                lambda: self.projTree.renameTreeItem(self._handle, hItem.title)
+                qtLambda(self.projTree.renameTreeItem, self._handle, hItem.title)
             )
         return
 
@@ -1835,9 +1844,9 @@ class _TreeContextMenu(QMenu):
         if multi:
             mSub = self.addMenu(self.tr("Set Active to ..."))
             aOne = mSub.addAction(SHARED.theme.getIcon("checked"), self.projTree.trActive)
-            aOne.triggered.connect(lambda: self._iterItemActive(True))
+            aOne.triggered.connect(qtLambda(self._iterItemActive, True))
             aTwo = mSub.addAction(SHARED.theme.getIcon("unchecked"), self.projTree.trInactive)
-            aTwo.triggered.connect(lambda: self._iterItemActive(False))
+            aTwo.triggered.connect(qtLambda(self._iterItemActive, False))
         else:
             action = self.addAction(self.tr("Toggle Active"))
             action.triggered.connect(self._toggleItemActive)
@@ -1848,37 +1857,39 @@ class _TreeContextMenu(QMenu):
         if self._item.isNovelLike():
             menu = self.addMenu(self.tr("Set Status to ..."))
             current = self._item.itemStatus
-            for n, (key, entry) in enumerate(SHARED.project.data.itemStatus.iterItems()):
+            for key, entry in SHARED.project.data.itemStatus.iterItems():
                 name = entry.name
                 if not multi and current == key:
                     name += f" ({nwUnicode.U_CHECK})"
                 action = menu.addAction(entry.icon, name)
                 if multi:
-                    action.triggered.connect(lambda n, key=key: self._iterSetItemStatus(key))
+                    action.triggered.connect(qtLambda(self._iterSetItemStatus, key))
                 else:
-                    action.triggered.connect(lambda n, key=key: self._changeItemStatus(key))
+                    action.triggered.connect(qtLambda(self._changeItemStatus, key))
             menu.addSeparator()
             action = menu.addAction(self.tr("Manage Labels ..."))
-            action.triggered.connect(
-                lambda: self.projView.projectSettingsRequest.emit(GuiProjectSettings.PAGE_STATUS)
-            )
+            action.triggered.connect(qtLambda(
+                self.projView.projectSettingsRequest.emit,
+                GuiProjectSettings.PAGE_STATUS
+            ))
         else:
             menu = self.addMenu(self.tr("Set Importance to ..."))
             current = self._item.itemImport
-            for n, (key, entry) in enumerate(SHARED.project.data.itemImport.iterItems()):
+            for key, entry in SHARED.project.data.itemImport.iterItems():
                 name = entry.name
                 if not multi and current == key:
                     name += f" ({nwUnicode.U_CHECK})"
                 action = menu.addAction(entry.icon, name)
                 if multi:
-                    action.triggered.connect(lambda n, key=key: self._iterSetItemImport(key))
+                    action.triggered.connect(qtLambda(self._iterSetItemImport, key))
                 else:
-                    action.triggered.connect(lambda n, key=key: self._changeItemImport(key))
+                    action.triggered.connect(qtLambda(self._changeItemImport, key))
             menu.addSeparator()
             action = menu.addAction(self.tr("Manage Labels ..."))
-            action.triggered.connect(
-                lambda: self.projView.projectSettingsRequest.emit(GuiProjectSettings.PAGE_IMPORT)
-            )
+            action.triggered.connect(qtLambda(
+                self.projView.projectSettingsRequest.emit,
+                GuiProjectSettings.PAGE_IMPORT
+            ))
         return
 
     def _itemTransform(self, isFile: bool, isFolder: bool, hasChild: bool) -> None:
@@ -1897,33 +1908,33 @@ class _TreeContextMenu(QMenu):
 
         if isNoteFile and self._item.documentAllowed():
             action = menu.addAction(self.tr("Convert to {0}").format(trDoc))
-            action.triggered.connect(lambda: self._changeItemLayout(loDoc))
+            action.triggered.connect(qtLambda(self._changeItemLayout, loDoc))
 
         if isDocFile:
             action = menu.addAction(self.tr("Convert to {0}").format(trNote))
-            action.triggered.connect(lambda: self._changeItemLayout(loNote))
+            action.triggered.connect(qtLambda(self._changeItemLayout, loNote))
 
         if isFolder and self._item.documentAllowed():
             action = menu.addAction(self.tr("Convert to {0}").format(trDoc))
-            action.triggered.connect(lambda: self._covertFolderToFile(loDoc))
+            action.triggered.connect(qtLambda(self._covertFolderToFile, loDoc))
 
         if isFolder:
             action = menu.addAction(self.tr("Convert to {0}").format(trNote))
-            action.triggered.connect(lambda: self._covertFolderToFile(loNote))
+            action.triggered.connect(qtLambda(self._covertFolderToFile, loNote))
 
         if hasChild and isFile:
             action = menu.addAction(self.tr("Merge Child Items into Self"))
-            action.triggered.connect(lambda: tree._mergeDocuments(tHandle, False))
+            action.triggered.connect(qtLambda(tree._mergeDocuments, tHandle, False))
             action = menu.addAction(self.tr("Merge Child Items into New"))
-            action.triggered.connect(lambda: tree._mergeDocuments(tHandle, True))
+            action.triggered.connect(qtLambda(tree._mergeDocuments, tHandle, True))
 
         if hasChild and isFolder:
             action = menu.addAction(self.tr("Merge Documents in Folder"))
-            action.triggered.connect(lambda: tree._mergeDocuments(tHandle, True))
+            action.triggered.connect(qtLambda(tree._mergeDocuments, tHandle, True))
 
         if isFile:
             action = menu.addAction(self.tr("Split Document by Headings"))
-            action.triggered.connect(lambda: tree._splitDocument(tHandle))
+            action.triggered.connect(qtLambda(tree._splitDocument, tHandle))
 
         return
 
@@ -1933,19 +1944,19 @@ class _TreeContextMenu(QMenu):
         tHandle = self._handle
         if hasChild:
             action = self.addAction(self.tr("Expand All"))
-            action.triggered.connect(lambda: tree.setExpandedFromHandle(tHandle, True))
+            action.triggered.connect(qtLambda(tree.setExpandedFromHandle, tHandle, True))
             action = self.addAction(self.tr("Collapse All"))
-            action.triggered.connect(lambda: tree.setExpandedFromHandle(tHandle, False))
+            action.triggered.connect(qtLambda(tree.setExpandedFromHandle, tHandle, False))
 
         action = self.addAction(self.tr("Duplicate"))
-        action.triggered.connect(lambda: tree._duplicateFromHandle(tHandle))
+        action.triggered.connect(qtLambda(tree._duplicateFromHandle, tHandle))
 
         if self._item.itemClass == nwItemClass.TRASH or isRoot or (isFolder and not hasChild):
             action = self.addAction(self.tr("Delete Permanently"))
-            action.triggered.connect(lambda: tree.permDeleteItem(tHandle))
+            action.triggered.connect(qtLambda(tree.permDeleteItem, tHandle))
         else:
             action = self.addAction(self.tr("Move to Trash"))
-            action.triggered.connect(lambda: tree.moveItemToTrash(tHandle))
+            action.triggered.connect(qtLambda(tree.moveItemToTrash, tHandle))
 
         return
 

novelwriter/gui/sidebar.py

@@ -32,6 +32,7 @@ from PyQt5.QtGui import QPalette
 from PyQt5.QtWidgets import QMenu, QVBoxLayout, QWidget
 
 from novelwriter import CONFIG, SHARED
+from novelwriter.common import qtLambda
 from novelwriter.enum import nwView
 from novelwriter.extensions.eventfilters import StatusTipFilter
 from novelwriter.extensions.modified import NIconToolButton
@@ -54,7 +55,7 @@ class GuiSideBar(QWidget):
 
         self.mainGui = mainGui
 
-        iPx = int(1.2*SHARED.theme.baseButtonHeight)
+        iPx = int(1.25*SHARED.theme.baseButtonHeight)
         iSz = QSize(iPx, iPx)
 
         self.setContentsMargins(0, 0, 0, 0)
@@ -63,19 +64,19 @@ class GuiSideBar(QWidget):
         # Buttons
         self.tbProject = NIconToolButton(self, iSz)
         self.tbProject.setToolTip("{0} [Ctrl+T]".format(self.tr("Project Tree View")))
-        self.tbProject.clicked.connect(lambda: self.requestViewChange.emit(nwView.PROJECT))
+        self.tbProject.clicked.connect(qtLambda(self.requestViewChange.emit, nwView.PROJECT))
 
         self.tbNovel = NIconToolButton(self, iSz)
         self.tbNovel.setToolTip("{0} [Ctrl+T]".format(self.tr("Novel Tree View")))
-        self.tbNovel.clicked.connect(lambda: self.requestViewChange.emit(nwView.NOVEL))
+        self.tbNovel.clicked.connect(qtLambda(self.requestViewChange.emit, nwView.NOVEL))
 
         self.tbSearch = NIconToolButton(self, iSz)
         self.tbSearch.setToolTip("{0} [Ctrl+Shift+F]".format(self.tr("Project Search")))
-        self.tbSearch.clicked.connect(lambda: self.requestViewChange.emit(nwView.SEARCH))
+        self.tbSearch.clicked.connect(qtLambda(self.requestViewChange.emit, nwView.SEARCH))
 
         self.tbOutline = NIconToolButton(self, iSz)
         self.tbOutline.setToolTip("{0} [Ctrl+Shift+T]".format(self.tr("Novel Outline View")))
-        self.tbOutline.clicked.connect(lambda: self.requestViewChange.emit(nwView.OUTLINE))
+        self.tbOutline.clicked.connect(qtLambda(self.requestViewChange.emit, nwView.OUTLINE))
 
         self.tbBuild = NIconToolButton(self, iSz)
         self.tbBuild.setToolTip("{0} [F5]".format(self.tr("Build Manuscript")))
@@ -113,7 +114,7 @@ class GuiSideBar(QWidget):
         self.outerBox.addWidget(self.tbStats)
         self.outerBox.addWidget(self.tbSettings)
         self.outerBox.setContentsMargins(0, 0, 0, 0)
-        self.outerBox.setSpacing(CONFIG.pxInt(4))
+        self.outerBox.setSpacing(CONFIG.pxInt(6))
 
         self.setLayout(self.outerBox)
         self.updateTheme()

novelwriter/gui/theme.py

@@ -503,10 +503,11 @@ class GuiIcons:
         "fmt_strike-md", "fmt_subscript", "fmt_superscript", "fmt_underline",
 
         # General Button Icons
-        "add", "add_document", "backward", "bookmark", "browse", "checked", "close", "cross",
-        "document", "down", "edit", "export", "font", "forward", "import", "list", "maximise",
-        "menu", "minimise", "more", "noncheckable", "open", "panel", "quote", "refresh", "remove",
-        "revert", "search_replace", "search", "settings", "star", "unchecked", "up", "view",
+        "add", "add_document", "backward", "bookmark", "browse", "checked", "close", "copy",
+        "cross", "document", "down", "edit", "export", "font", "forward", "import", "list",
+        "maximise", "menu", "minimise", "more", "noncheckable", "open", "panel", "quote",
+        "refresh", "remove", "revert", "search_replace", "search", "settings", "star", "unchecked",
+        "up", "view",
 
         # Switches
         "sticky-on", "sticky-off",