novelWriter 2.5.3__py3-none-any.whl → 2.6__py3-none-any.whl

novelwriter/gui/doceditor.py

@@ -14,7 +14,7 @@ Created:   2023-11-06 [2.2b1] MetaCompleter
 Created:   2023-11-07 [2.2b1] GuiDocToolBar
 
 This file is a part of novelWriter
-Copyright 2018–2024, Veronica Berglyd Olsen
+Copyright (C) 2018 Veronica Berglyd Olsen and novelWriter contributors
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -42,8 +42,9 @@ from PyQt5.QtCore import (
     pyqtSlot
 )
 from PyQt5.QtGui import (
-    QColor, QCursor, QKeyEvent, QKeySequence, QMouseEvent, QPalette, QPixmap,
-    QResizeEvent, QTextBlock, QTextCursor, QTextDocument, QTextOption
+    QColor, QCursor, QDragEnterEvent, QDragMoveEvent, QDropEvent, QKeyEvent,
+    QKeySequence, QMouseEvent, QPalette, QPixmap, QResizeEvent, QTextBlock,
+    QTextCursor, QTextDocument, QTextOption
 )
 from PyQt5.QtWidgets import (
     QAction, QApplication, QFrame, QGridLayout, QHBoxLayout, QLabel, QLineEdit,
@@ -51,10 +52,13 @@ from PyQt5.QtWidgets import (
 )
 
 from novelwriter import CONFIG, SHARED
-from novelwriter.common import minmax, transferCase
+from novelwriter.common import decodeMimeHandles, fontMatcher, minmax, qtLambda, transferCase
 from novelwriter.constants import nwConst, nwKeyWords, nwShortcode, nwUnicode
 from novelwriter.core.document import NWDocument
-from novelwriter.enum import nwComment, nwDocAction, nwDocInsert, nwDocMode, nwItemClass, nwTrinary
+from novelwriter.enum import (
+    nwChange, nwComment, nwDocAction, nwDocInsert, nwDocMode, nwItemClass,
+    nwItemType, nwTrinary
+)
 from novelwriter.extensions.configlayout import NColourLabel
 from novelwriter.extensions.eventfilters import WheelEventFilter
 from novelwriter.extensions.modified import NIconToggleButton, NIconToolButton
@@ -66,7 +70,7 @@ from novelwriter.tools.lipsum import GuiLipsum
 from novelwriter.types import (
     QtAlignCenterTop, QtAlignJustify, QtAlignLeft, QtAlignLeftTop,
     QtAlignRight, QtKeepAnchor, QtModCtrl, QtModNone, QtModShift, QtMouseLeft,
-    QtMoveAnchor, QtMoveLeft, QtMoveRight
+    QtMoveAnchor, QtMoveLeft, QtMoveRight, QtScrollAlwaysOff, QtScrollAsNeeded
 )
 
 logger = logging.getLogger(__name__)
@@ -83,26 +87,34 @@ class _SelectAction(Enum):
 class GuiDocEditor(QPlainTextEdit):
     """Gui Widget: Main Document Editor"""
 
+    __slots__ = (
+        "_nwDocument", "_nwItem", "_docChanged", "_docHandle", "_vpMargin",
+        "_lastEdit", "_lastActive", "_lastFind", "_doReplace", "_autoReplace",
+        "_completer", "_qDocument", "_keyContext", "_followTag1", "_followTag2",
+        "_timerDoc", "_wCounterDoc", "_timerSel", "_wCounterSel",
+    )
+
     MOVE_KEYS = (
         Qt.Key.Key_Left, Qt.Key.Key_Right, Qt.Key.Key_Up, Qt.Key.Key_Down,
         Qt.Key.Key_PageUp, Qt.Key.Key_PageDown
     )
 
     # Custom Signals
-    statusMessage = pyqtSignal(str)
-    docCountsChanged = pyqtSignal(str, int, int, int)
+    closeEditorRequest = pyqtSignal()
     docTextChanged = pyqtSignal(str, float)
     editedStatusChanged = pyqtSignal(bool)
+    itemHandleChanged = pyqtSignal(str)
     loadDocumentTagRequest = pyqtSignal(str, Enum)
-    novelStructureChanged = pyqtSignal()
     novelItemMetaChanged = pyqtSignal(str)
-    spellCheckStateChanged = pyqtSignal(bool)
-    closeDocumentRequest = pyqtSignal()
-    toggleFocusModeRequest = pyqtSignal()
-    requestProjectItemSelected = pyqtSignal(str, bool)
-    requestProjectItemRenamed = pyqtSignal(str, str)
+    novelStructureChanged = pyqtSignal()
+    openDocumentRequest = pyqtSignal(str, Enum, str, bool)
     requestNewNoteCreation = pyqtSignal(str, nwItemClass)
     requestNextDocument = pyqtSignal(str, bool)
+    requestProjectItemRenamed = pyqtSignal(str, str)
+    requestProjectItemSelected = pyqtSignal(str, bool)
+    spellCheckStateChanged = pyqtSignal(bool)
+    toggleFocusModeRequest = pyqtSignal()
+    updateStatusMessage = pyqtSignal(str)
 
     def __init__(self, parent: QWidget) -> None:
         super().__init__(parent=parent)
@@ -123,18 +135,8 @@ class GuiDocEditor(QPlainTextEdit):
         self._lastFind   = None   # Position of the last found search word
         self._doReplace  = False  # Switch to temporarily disable auto-replace
 
-        # Typography Cache
-        self._typPadChar = " "
-        self._typDQuoteO = '"'
-        self._typDQuoteC = '"'
-        self._typSQuoteO = "'"
-        self._typSQuoteC = "'"
-        self._typRepDQuote = False
-        self._typRepSQuote = False
-        self._typRepDash = False
-        self._typRepDots = False
-        self._typPadBefore = ""
-        self._typPadAfter = ""
+        # Auto-Replace
+        self._autoReplace = TextAutoReplace()
 
         # Completer
         self._completer = MetaCompleter(self)
@@ -169,40 +171,41 @@ class GuiDocEditor(QPlainTextEdit):
         self.setMinimumWidth(CONFIG.pxInt(300))
         self.setAutoFillBackground(True)
         self.setFrameStyle(QFrame.Shape.NoFrame)
+        self.setAcceptDrops(True)
 
         # Custom Shortcuts
-        self.keyContext = QShortcut(self)
-        self.keyContext.setKey("Ctrl+.")
-        self.keyContext.setContext(Qt.ShortcutContext.WidgetShortcut)
-        self.keyContext.activated.connect(self._openContextFromCursor)
+        self._keyContext = QShortcut(self)
+        self._keyContext.setKey("Ctrl+.")
+        self._keyContext.setContext(Qt.ShortcutContext.WidgetShortcut)
+        self._keyContext.activated.connect(self._openContextFromCursor)
 
-        self.followTag1 = QShortcut(self)
-        self.followTag1.setKey(Qt.Key.Key_Return | QtModCtrl)
-        self.followTag1.setContext(Qt.ShortcutContext.WidgetShortcut)
-        self.followTag1.activated.connect(self._processTag)
+        self._followTag1 = QShortcut(self)
+        self._followTag1.setKey("Ctrl+Return")
+        self._followTag1.setContext(Qt.ShortcutContext.WidgetShortcut)
+        self._followTag1.activated.connect(self._processTag)
 
-        self.followTag2 = QShortcut(self)
-        self.followTag2.setKey(Qt.Key.Key_Enter | QtModCtrl)
-        self.followTag2.setContext(Qt.ShortcutContext.WidgetShortcut)
-        self.followTag2.activated.connect(self._processTag)
+        self._followTag2 = QShortcut(self)
+        self._followTag2.setKey("Ctrl+Enter")
+        self._followTag2.setContext(Qt.ShortcutContext.WidgetShortcut)
+        self._followTag2.activated.connect(self._processTag)
 
         # Set Up Document Word Counter
-        self.timerDoc = QTimer(self)
-        self.timerDoc.timeout.connect(self._runDocumentTasks)
-        self.timerDoc.setInterval(5000)
+        self._timerDoc = QTimer(self)
+        self._timerDoc.timeout.connect(self._runDocumentTasks)
+        self._timerDoc.setInterval(5000)
 
-        self.wCounterDoc = BackgroundWordCounter(self)
-        self.wCounterDoc.setAutoDelete(False)
-        self.wCounterDoc.signals.countsReady.connect(self._updateDocCounts)
+        self._wCounterDoc = BackgroundWordCounter(self)
+        self._wCounterDoc.setAutoDelete(False)
+        self._wCounterDoc.signals.countsReady.connect(self._updateDocCounts)
 
         # Set Up Selection Word Counter
-        self.timerSel = QTimer(self)
-        self.timerSel.timeout.connect(self._runSelCounter)
-        self.timerSel.setInterval(500)
+        self._timerSel = QTimer(self)
+        self._timerSel.timeout.connect(self._runSelCounter)
+        self._timerSel.setInterval(500)
 
-        self.wCounterSel = BackgroundWordCounter(self, forSelection=True)
-        self.wCounterSel.setAutoDelete(False)
-        self.wCounterSel.signals.countsReady.connect(self._updateSelCounts)
+        self._wCounterSel = BackgroundWordCounter(self, forSelection=True)
+        self._wCounterSel.setAutoDelete(False)
+        self._wCounterSel.signals.countsReady.connect(self._updateSelCounts)
 
         # Install Event Filter for Mouse Wheel
         self.wheelEventFilter = WheelEventFilter(self)
@@ -256,8 +259,8 @@ class GuiDocEditor(QPlainTextEdit):
         self._nwDocument = None
         self.setReadOnly(True)
         self.clear()
-        self.timerDoc.stop()
-        self.timerSel.stop()
+        self._timerDoc.stop()
+        self._timerSel.stop()
 
         self._docHandle  = None
         self._lastEdit   = 0.0
@@ -270,6 +273,8 @@ class GuiDocEditor(QPlainTextEdit):
         self.docFooter.setHandle(self._docHandle)
         self.docToolBar.setVisible(False)
 
+        self.itemHandleChanged.emit("")
+
         return
 
     def updateTheme(self) -> None:
@@ -303,28 +308,16 @@ class GuiDocEditor(QPlainTextEdit):
         settings. This function is both called when the editor is
         created, and when the user changes the main editor preferences.
         """
-        # Typography
-        if CONFIG.fmtPadThin:
-            self._typPadChar = nwUnicode.U_THNBSP
-        else:
-            self._typPadChar = nwUnicode.U_NBSP
-
-        self._typSQuoteO = CONFIG.fmtSQuoteOpen
-        self._typSQuoteC = CONFIG.fmtSQuoteClose
-        self._typDQuoteO = CONFIG.fmtDQuoteOpen
-        self._typDQuoteC = CONFIG.fmtDQuoteClose
-        self._typRepDQuote = CONFIG.doReplaceDQuote
-        self._typRepSQuote = CONFIG.doReplaceSQuote
-        self._typRepDash = CONFIG.doReplaceDash
-        self._typRepDots = CONFIG.doReplaceDots
-        self._typPadBefore = CONFIG.fmtPadBefore
-        self._typPadAfter = CONFIG.fmtPadAfter
+        # Auto-Replace
+        self._autoReplace.initSettings()
 
         # Reload spell check and dictionaries
         SHARED.updateSpellCheckLanguage()
 
         # Set the font. See issues #1862 and #1875.
-        self.setFont(CONFIG.textFont)
+        font = fontMatcher(CONFIG.textFont)
+        self.setFont(font)
+        self._qDocument.setDefaultFont(font)
         self.docHeader.updateFont()
         self.docFooter.updateFont()
         self.docSearch.updateFont()
@@ -354,14 +347,14 @@ class GuiDocEditor(QPlainTextEdit):
         # Scrolling
         self.setCenterOnScroll(CONFIG.scrollPastEnd)
         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)
 
         # Refresh the tab stops
         self.setTabStopDistance(CONFIG.getTabWidth())
@@ -388,9 +381,12 @@ class GuiDocEditor(QPlainTextEdit):
         """
         self._nwDocument = SHARED.project.storage.getDocument(tHandle)
         self._nwItem = self._nwDocument.nwItem
+        if not ((nwItem := self._nwItem) and nwItem.itemType == nwItemType.FILE):
+            logger.debug("Requested item '%s' is not a document", tHandle)
+            self.clearEditor()
+            return False
 
-        docText = self._nwDocument.readDocument()
-        if docText is None:
+        if (docText := self._nwDocument.readDocument()) is None:
             # There was an I/O error
             self.clearEditor()
             return False
@@ -406,15 +402,15 @@ class GuiDocEditor(QPlainTextEdit):
         self._lastEdit = time()
         self._lastActive = time()
         self._runDocumentTasks()
-        self.timerDoc.start()
+        self._timerDoc.start()
 
         self.setReadOnly(False)
         self.updateDocMargins()
 
-        if tLine is None and self._nwItem is not None:
-            self.setCursorPosition(self._nwItem.cursorPos)
-        elif isinstance(tLine, int):
+        if isinstance(tLine, int):
             self.setCursorLine(tLine)
+        else:
+            self.setCursorPosition(nwItem.cursorPos)
 
         self.docHeader.setHandle(tHandle)
         self.docFooter.setHandle(tHandle)
@@ -430,11 +426,15 @@ class GuiDocEditor(QPlainTextEdit):
         self._qDocument.clearUndoRedoStacks()
         self.docToolBar.setVisible(CONFIG.showEditToolBar)
 
-        QApplication.restoreOverrideCursor()
+        # Process State Changes
+        SHARED.project.data.setLastHandle(tHandle, "editor")
+        self.itemHandleChanged.emit(tHandle)
 
-        # Update the status bar
-        if self._nwItem is not None:
-            self.statusMessage.emit(self.tr("Opened Document: {0}").format(self._nwItem.itemName))
+        # Finalise
+        QApplication.restoreOverrideCursor()
+        self.updateStatusMessage.emit(
+            self.tr("Opened Document: {0}").format(nwItem.itemName)
+        )
 
         return True
 
@@ -505,7 +505,7 @@ class GuiDocEditor(QPlainTextEdit):
             self.docFooter.updateInfo()
 
         # Update the status bar
-        self.statusMessage.emit(self.tr("Saved Document: {0}").format(self._nwItem.itemName))
+        self.updateStatusMessage.emit(self.tr("Saved Document: {0}").format(self._nwItem.itemName))
 
         return True
 
@@ -700,7 +700,7 @@ class GuiDocEditor(QPlainTextEdit):
         self._qDocument.syntaxHighlighter.rehighlight()
         QApplication.restoreOverrideCursor()
         logger.debug("Document highlighted in %.3f ms", 1000*(time() - start))
-        self.statusMessage.emit(self.tr("Spell check complete"))
+        self.updateStatusMessage.emit(self.tr("Spell check complete"))
         return
 
     ##
@@ -742,9 +742,9 @@ class GuiDocEditor(QPlainTextEdit):
         elif action == nwDocAction.MD_STRIKE:
             self._toggleFormat(2, "~")
         elif action == nwDocAction.S_QUOTE:
-            self._wrapSelection(self._typSQuoteO, self._typSQuoteC)
+            self._wrapSelection(CONFIG.fmtSQuoteOpen, CONFIG.fmtSQuoteClose)
         elif action == nwDocAction.D_QUOTE:
-            self._wrapSelection(self._typDQuoteO, self._typDQuoteC)
+            self._wrapSelection(CONFIG.fmtDQuoteOpen, CONFIG.fmtDQuoteClose)
         elif action == nwDocAction.SEL_ALL:
             self._makeSelection(QTextCursor.SelectionType.Document)
         elif action == nwDocAction.SEL_PARA:
@@ -770,9 +770,9 @@ class GuiDocEditor(QPlainTextEdit):
         elif action == nwDocAction.BLOCK_HSC:
             self._formatBlock(nwDocAction.BLOCK_HSC)
         elif action == nwDocAction.REPL_SNG:
-            self._replaceQuotes("'", self._typSQuoteO, self._typSQuoteC)
+            self._replaceQuotes("'", CONFIG.fmtSQuoteOpen, CONFIG.fmtSQuoteClose)
         elif action == nwDocAction.REPL_DBL:
-            self._replaceQuotes("\"", self._typDQuoteO, self._typDQuoteC)
+            self._replaceQuotes("\"", CONFIG.fmtDQuoteOpen, CONFIG.fmtDQuoteClose)
         elif action == nwDocAction.RM_BREAKS:
             self._removeInParLineBreaks()
         elif action == nwDocAction.ALIGN_L:
@@ -844,13 +844,13 @@ class GuiDocEditor(QPlainTextEdit):
             text = insert
         elif isinstance(insert, nwDocInsert):
             if insert == nwDocInsert.QUOTE_LS:
-                text = self._typSQuoteO
+                text = CONFIG.fmtSQuoteOpen
             elif insert == nwDocInsert.QUOTE_RS:
-                text = self._typSQuoteC
+                text = CONFIG.fmtSQuoteClose
             elif insert == nwDocInsert.QUOTE_LD:
-                text = self._typDQuoteO
+                text = CONFIG.fmtDQuoteOpen
             elif insert == nwDocInsert.QUOTE_RD:
-                text = self._typDQuoteC
+                text = CONFIG.fmtDQuoteClose
             elif insert == nwDocInsert.SYNOPSIS:
                 text = "%Synopsis: "
                 block = True
@@ -877,6 +877,8 @@ class GuiDocEditor(QPlainTextEdit):
                 after = False
             elif insert == nwDocInsert.FOOTNOTE:
                 self._insertCommentStructure(nwComment.FOOTNOTE)
+            elif insert == nwDocInsert.LINE_BRK:
+                text = nwShortcode.BREAK
 
         if text:
             if block:
@@ -965,6 +967,32 @@ class GuiDocEditor(QPlainTextEdit):
 
         return
 
+    def dragEnterEvent(self, event: QDragEnterEvent) -> None:
+        """Overload drag enter event to handle dragged items."""
+        if event.mimeData().hasFormat(nwConst.MIME_HANDLE):
+            event.acceptProposedAction()
+        else:
+            super().dragEnterEvent(event)
+        return
+
+    def dragMoveEvent(self, event: QDragMoveEvent) -> None:
+        """Overload drag move event to handle dragged items."""
+        if event.mimeData().hasFormat(nwConst.MIME_HANDLE):
+            event.acceptProposedAction()
+        else:
+            super().dragMoveEvent(event)
+        return
+
+    def dropEvent(self, event: QDropEvent) -> None:
+        """Overload drop event to handle dragged items."""
+        if event.mimeData().hasFormat(nwConst.MIME_HANDLE):
+            if handles := decodeMimeHandles(event.mimeData()):
+                if SHARED.project.tree.checkType(handles[0], nwItemType.FILE):
+                    self.openDocumentRequest.emit(handles[0], nwDocMode.EDIT, "", True)
+        else:
+            super().dropEvent(event)
+        return
+
     def focusNextPrevChild(self, next: bool) -> bool:
         """Capture the focus request from the tab key on the text
         editor. If the editor has focus, we do not change focus and
@@ -982,8 +1010,13 @@ class GuiDocEditor(QPlainTextEdit):
         pressed, check if we're clicking on a tag, and trigger the
         follow tag function.
         """
-        if QApplication.keyboardModifiers() == QtModCtrl:
-            self._processTag(self.cursorForPosition(event.pos()))
+        if event.modifiers() & QtModCtrl == QtModCtrl:
+            cursor = self.cursorForPosition(event.pos())
+            mData, mType = self._qDocument.metaDataAtPos(cursor.position())
+            if mData and mType == "url":
+                SHARED.openWebsite(mData)
+            else:
+                self._processTag(cursor)
         super().mouseReleaseEvent(event)
         return
 
@@ -999,12 +1032,12 @@ class GuiDocEditor(QPlainTextEdit):
     #  Public Slots
     ##
 
-    @pyqtSlot(str)
-    def updateDocInfo(self, tHandle: str) -> None:
+    @pyqtSlot(str, Enum)
+    def onProjectItemChanged(self, tHandle: str, change: nwChange) -> None:
         """Called when an item label is changed to check if the document
         title bar needs updating,
         """
-        if tHandle and tHandle == self._docHandle:
+        if tHandle == self._docHandle and change == nwChange.UPDATE:
             self.docHeader.setHandle(tHandle)
             self.docFooter.updateInfo()
             self.updateDocMargins()
@@ -1053,8 +1086,8 @@ class GuiDocEditor(QPlainTextEdit):
         if not self._docChanged:
             self.setDocumentChanged(removed != 0 or added != 0)
 
-        if not self.timerDoc.isActive():
-            self.timerDoc.start()
+        if not self._timerDoc.isActive():
+            self._timerDoc.start()
 
         if (block := self._qDocument.findBlock(pos)).isValid():
             text = block.text()
@@ -1071,8 +1104,10 @@ class GuiDocEditor(QPlainTextEdit):
             else:
                 self._completer.setVisible(False)
 
-        if self._doReplace and added == 1:
-            self._docAutoReplace(text)
+            if self._doReplace and added == 1:
+                cursor = self.textCursor()
+                if self._autoReplace.process(text, cursor):
+                    self._qDocument.syntaxHighlighter.rehighlightBlock(cursor.block())
 
         return
 
@@ -1095,6 +1130,12 @@ class GuiDocEditor(QPlainTextEdit):
             self._completer.hide()
         return
 
+    @pyqtSlot()
+    def _openContextFromCursor(self) -> None:
+        """Open the spell check context menu at the cursor."""
+        self._openContextMenu(self.cursorRect().center())
+        return
+
     @pyqtSlot("QPoint")
     def _openContextMenu(self, pos: QPoint) -> None:
         """Open the editor context menu at a given coordinate."""
@@ -1106,41 +1147,48 @@ class GuiDocEditor(QPlainTextEdit):
         ctxMenu.setObjectName("ContextMenu")
         if pBlock.userState() == BLOCK_TITLE:
             action = ctxMenu.addAction(self.tr("Set as Document Name"))
-            action.triggered.connect(lambda: self._emitRenameItem(pBlock))
+            action.triggered.connect(qtLambda(self._emitRenameItem, pBlock))
+
+        # URL
+        (mData, mType) = self._qDocument.metaDataAtPos(pCursor.position())
+        if mData and mType == "url":
+            action = ctxMenu.addAction(self.tr("Open URL"))
+            action.triggered.connect(qtLambda(SHARED.openWebsite, mData))
+            ctxMenu.addSeparator()
 
         # Follow
         status = self._processTag(cursor=pCursor, follow=False)
         if status == nwTrinary.POSITIVE:
             action = ctxMenu.addAction(self.tr("Follow Tag"))
-            action.triggered.connect(lambda: self._processTag(cursor=pCursor, follow=True))
+            action.triggered.connect(qtLambda(self._processTag, cursor=pCursor, follow=True))
             ctxMenu.addSeparator()
         elif status == nwTrinary.NEGATIVE:
             action = ctxMenu.addAction(self.tr("Create Note for Tag"))
-            action.triggered.connect(lambda: self._processTag(cursor=pCursor, create=True))
+            action.triggered.connect(qtLambda(self._processTag, cursor=pCursor, create=True))
             ctxMenu.addSeparator()
 
         # Cut, Copy and Paste
         if uCursor.hasSelection():
             action = ctxMenu.addAction(self.tr("Cut"))
-            action.triggered.connect(lambda: self.docAction(nwDocAction.CUT))
+            action.triggered.connect(qtLambda(self.docAction, nwDocAction.CUT))
             action = ctxMenu.addAction(self.tr("Copy"))
-            action.triggered.connect(lambda: self.docAction(nwDocAction.COPY))
+            action.triggered.connect(qtLambda(self.docAction, nwDocAction.COPY))
 
         action = ctxMenu.addAction(self.tr("Paste"))
-        action.triggered.connect(lambda: self.docAction(nwDocAction.PASTE))
+        action.triggered.connect(qtLambda(self.docAction, nwDocAction.PASTE))
         ctxMenu.addSeparator()
 
         # Selections
         action = ctxMenu.addAction(self.tr("Select All"))
-        action.triggered.connect(lambda: self.docAction(nwDocAction.SEL_ALL))
+        action.triggered.connect(qtLambda(self.docAction, nwDocAction.SEL_ALL))
         action = ctxMenu.addAction(self.tr("Select Word"))
-        action.triggered.connect(
-            lambda: self._makePosSelection(QTextCursor.SelectionType.WordUnderCursor, pos)
-        )
+        action.triggered.connect(qtLambda(
+            self._makePosSelection, QTextCursor.SelectionType.WordUnderCursor, pos,
+        ))
         action = ctxMenu.addAction(self.tr("Select Paragraph"))
-        action.triggered.connect(lambda: self._makePosSelection(
-            QTextCursor.SelectionType.BlockUnderCursor, pos)
-        )
+        action.triggered.connect(qtLambda(
+            self._makePosSelection, QTextCursor.SelectionType.BlockUnderCursor, pos
+        ))
 
         # Spell Checking
         if SHARED.project.data.spellCheck:
@@ -1156,47 +1204,23 @@ class GuiDocEditor(QPlainTextEdit):
                     ctxMenu.addAction(self.tr("Spelling Suggestion(s)"))
                     for option in suggest[:15]:
                         action = ctxMenu.addAction(f"{nwUnicode.U_ENDASH} {option}")
-                        action.triggered.connect(
-                            lambda _, option=option: self._correctWord(sCursor, option)
-                        )
+                        action.triggered.connect(qtLambda(self._correctWord, sCursor, option))
                 else:
                     trNone = self.tr("No Suggestions")
                     ctxMenu.addAction(f"{nwUnicode.U_ENDASH} {trNone}")
 
                 ctxMenu.addSeparator()
+                action = ctxMenu.addAction(self.tr("Ignore Word"))
+                action.triggered.connect(qtLambda(self._addWord, word, block, False))
                 action = ctxMenu.addAction(self.tr("Add Word to Dictionary"))
-                action.triggered.connect(lambda: self._addWord(word, block))
+                action.triggered.connect(qtLambda(self._addWord, word, block, True))
 
         # Execute the context menu
         ctxMenu.exec(self.viewport().mapToGlobal(pos))
-        ctxMenu.deleteLater()
+        ctxMenu.setParent(None)
 
         return
 
-    @pyqtSlot("QTextCursor", str)
-    def _correctWord(self, cursor: QTextCursor, word: str) -> None:
-        """Slot for the spell check context menu triggering the
-        replacement of a word with the word from the dictionary.
-        """
-        pos = cursor.selectionStart()
-        cursor.beginEditBlock()
-        cursor.removeSelectedText()
-        cursor.insertText(word)
-        cursor.endEditBlock()
-        cursor.setPosition(pos)
-        self.setTextCursor(cursor)
-        return
-
-    @pyqtSlot(str, "QTextBlock")
-    def _addWord(self, word: str, block: QTextBlock) -> None:
-        """Slot for the spell check context menu triggered when the user
-        wants to add a word to the project dictionary.
-        """
-        logger.debug("Added '%s' to project dictionary", word)
-        SHARED.spelling.addWord(word)
-        self._qDocument.syntaxHighlighter.rehighlightBlock(block)
-        return
-
     @pyqtSlot()
     def _runDocumentTasks(self) -> None:
         """Run timer document tasks."""
@@ -1205,8 +1229,8 @@ class GuiDocEditor(QPlainTextEdit):
 
         if time() - self._lastEdit < 25.0:
             logger.debug("Running document tasks")
-            if not self.wCounterDoc.isRunning():
-                SHARED.runInThreadPool(self.wCounterDoc)
+            if not self._wCounterDoc.isRunning():
+                SHARED.runInThreadPool(self._wCounterDoc)
 
             self.docHeader.setOutline({
                 block.blockNumber(): block.text()
@@ -1223,11 +1247,15 @@ class GuiDocEditor(QPlainTextEdit):
         """Process the word counter's finished signal."""
         if self._docHandle and self._nwItem:
             logger.debug("Updating word count")
+            needsRefresh = wCount != self._nwItem.wordCount
             self._nwItem.setCharCount(cCount)
             self._nwItem.setWordCount(wCount)
             self._nwItem.setParaCount(pCount)
-            self.docCountsChanged.emit(self._docHandle, cCount, wCount, pCount)
-            self.docFooter.updateWordCount(wCount, False)
+            if needsRefresh:
+                self._nwItem.notifyToRefresh()
+                if not self.textCursor().hasSelection():
+                    # Selection counter should take precedence (#2155)
+                    self.docFooter.updateWordCount(wCount, False)
         return
 
     @pyqtSlot()
@@ -1236,10 +1264,10 @@ class GuiDocEditor(QPlainTextEdit):
         information to the footer, and start the selection word counter.
         """
         if self.textCursor().hasSelection():
-            if not self.timerSel.isActive():
-                self.timerSel.start()
+            if not self._timerSel.isActive():
+                self._timerSel.start()
         else:
-            self.timerSel.stop()
+            self._timerSel.stop()
             self.docFooter.updateWordCount(0, False)
         return
 
@@ -1249,11 +1277,11 @@ class GuiDocEditor(QPlainTextEdit):
         if self._docHandle is None:
             return
 
-        if self.wCounterSel.isRunning():
+        if self._wCounterSel.isRunning():
             logger.debug("Selection word counter is busy")
             return
 
-        SHARED.runInThreadPool(self.wCounterSel)
+        SHARED.runInThreadPool(self._wCounterSel)
 
         return
 
@@ -1263,13 +1291,13 @@ class GuiDocEditor(QPlainTextEdit):
         if self._docHandle and self._nwItem:
             logger.debug("User selected %d words", wCount)
             self.docFooter.updateWordCount(wCount, True)
-            self.timerSel.stop()
+            self._timerSel.stop()
         return
 
     @pyqtSlot()
     def _closeCurrentDocument(self) -> None:
         """Close the document. Forwarded to the main Gui."""
-        self.closeDocumentRequest.emit()
+        self.closeEditorRequest.emit()
         self.docToolBar.setVisible(False)
         return
 
@@ -1875,6 +1903,28 @@ class GuiDocEditor(QPlainTextEdit):
     #  Internal Functions
     ##
 
+    def _correctWord(self, cursor: QTextCursor, word: str) -> None:
+        """Slot for the spell check context menu triggering the
+        replacement of a word with the word from the dictionary.
+        """
+        pos = cursor.selectionStart()
+        cursor.beginEditBlock()
+        cursor.removeSelectedText()
+        cursor.insertText(word)
+        cursor.endEditBlock()
+        cursor.setPosition(pos)
+        self.setTextCursor(cursor)
+        return
+
+    def _addWord(self, word: str, block: QTextBlock, save: bool) -> None:
+        """Slot for the spell check context menu triggered when the user
+        wants to add a word to the project dictionary.
+        """
+        logger.debug("Added '%s' to project dictionary, %s", word, "saved" if save else "unsaved")
+        SHARED.spelling.addWord(word, save=save)
+        self._qDocument.syntaxHighlighter.rehighlightBlock(block)
+        return
+
     def _processTag(self, cursor: QTextCursor | None = None,
                     follow: bool = True, create: bool = False) -> nwTrinary:
         """Activated by Ctrl+Enter. Checks that we're in a block
@@ -1938,119 +1988,6 @@ class GuiDocEditor(QPlainTextEdit):
             self.requestProjectItemRenamed.emit(self._docHandle, text)
         return
 
-    def _openContextFromCursor(self) -> None:
-        """Open the spell check context menu at the cursor."""
-        self._openContextMenu(self.cursorRect().center())
-        return
-
-    def _docAutoReplace(self, text: str) -> None:
-        """Auto-replace text elements based on main configuration."""
-        cursor = self.textCursor()
-        tPos = cursor.positionInBlock()
-        tLen = len(text)
-
-        if tLen < 1 or tPos-1 > tLen:
-            return
-
-        tOne = text[tPos-1:tPos]
-        tTwo = text[tPos-2:tPos]
-        tThree = text[tPos-3:tPos]
-
-        if not tOne:
-            return
-
-        nDelete = 0
-        tInsert = tOne
-
-        if self._typRepDQuote and tTwo[:1].isspace() and tTwo.endswith('"'):
-            nDelete = 1
-            tInsert = self._typDQuoteO
-
-        elif self._typRepDQuote and tOne == '"':
-            nDelete = 1
-            if tPos == 1:
-                tInsert = self._typDQuoteO
-            elif tPos == 2 and tTwo == '>"':
-                tInsert = self._typDQuoteO
-            elif tPos == 3 and tThree == '>>"':
-                tInsert = self._typDQuoteO
-            else:
-                tInsert = self._typDQuoteC
-
-        elif self._typRepSQuote and tTwo[:1].isspace() and tTwo.endswith("'"):
-            nDelete = 1
-            tInsert = self._typSQuoteO
-
-        elif self._typRepSQuote and tOne == "'":
-            nDelete = 1
-            if tPos == 1:
-                tInsert = self._typSQuoteO
-            elif tPos == 2 and tTwo == ">'":
-                tInsert = self._typSQuoteO
-            elif tPos == 3 and tThree == ">>'":
-                tInsert = self._typSQuoteO
-            else:
-                tInsert = self._typSQuoteC
-
-        elif self._typRepDash and tThree == "---":
-            nDelete = 3
-            tInsert = nwUnicode.U_EMDASH
-
-        elif self._typRepDash and tTwo == "--":
-            nDelete = 2
-            tInsert = nwUnicode.U_ENDASH
-
-        elif self._typRepDash and tTwo == nwUnicode.U_ENDASH + "-":
-            nDelete = 2
-            tInsert = nwUnicode.U_EMDASH
-
-        elif self._typRepDots and tThree == "...":
-            nDelete = 3
-            tInsert = nwUnicode.U_HELLIP
-
-        elif tOne == nwUnicode.U_LSEP:
-            # This resolves issue #1150
-            nDelete = 1
-            tInsert = nwUnicode.U_PSEP
-
-        tCheck = tInsert
-        if self._typPadBefore and tCheck in self._typPadBefore:
-            if self._allowSpaceBeforeColon(text, tCheck):
-                nDelete = max(nDelete, 1)
-                chkPos = tPos - nDelete - 1
-                if chkPos >= 0 and text[chkPos].isspace():
-                    # Strip existing space before inserting a new (#1061)
-                    nDelete += 1
-                tInsert = self._typPadChar + tInsert
-
-        if self._typPadAfter and tCheck in self._typPadAfter:
-            if self._allowSpaceBeforeColon(text, tCheck):
-                nDelete = max(nDelete, 1)
-                tInsert = tInsert + self._typPadChar
-
-        if nDelete > 0:
-            cursor.movePosition(QtMoveLeft, QtKeepAnchor, nDelete)
-            cursor.insertText(tInsert)
-
-        # Re-highlight, since the auto-replace sometimes interferes with it
-        self._qDocument.syntaxHighlighter.rehighlightBlock(cursor.block())
-
-        return
-
-    @staticmethod
-    def _allowSpaceBeforeColon(text: str, char: str) -> bool:
-        """Special checker function only used by the insert space
-        feature for French, Spanish, etc, so it doesn't insert a
-        space before colons in meta data lines. See issue #1090.
-        """
-        if char == ":" and len(text) > 1:
-            if text[0] == "@":
-                return False
-            if text[0] == "%":
-                if text[1:].lstrip()[:9].lower() == "synopsis:":
-                    return False
-        return True
-
     def _autoSelect(self) -> QTextCursor:
         """Return a cursor which may or may not have a selection based
         on user settings and document action. The selection will be the
@@ -2173,7 +2110,7 @@ class MetaCompleter(QMenu):
             suffix = ""
             options = list(filter(
                 lambda x: lookup in x.lower(), SHARED.project.index.getClassTags(
-                    nwKeyWords.KEY_CLASS.get(kw.strip(), nwItemClass.NO_CLASS)
+                    nwKeyWords.KEY_CLASS.get(kw.strip())
                 )
             ))[:15]
 
@@ -2183,7 +2120,7 @@ class MetaCompleter(QMenu):
         for value in sorted(options):
             rep = value + suffix
             action = self.addAction(value)
-            action.triggered.connect(lambda _, r=rep: self._emitComplete(offset, length, r))
+            action.triggered.connect(qtLambda(self._emitComplete, offset, length, rep))
 
         return True
 
@@ -2259,6 +2196,131 @@ class BackgroundWordCounterSignals(QObject):
     countsReady = pyqtSignal(int, int, int)
 
 
+class TextAutoReplace:
+
+    __slots__ = (
+        "_quoteSO", "_quoteSC", "_quoteDO", "_quoteDC",
+        "_replaceSQuote", "_replaceDQuote", "_replaceDash", "_replaceDots",
+        "_padChar", "_padBefore", "_padAfter", "_doPadBefore", "_doPadAfter",
+    )
+
+    def __init__(self) -> None:
+        self.initSettings()
+        return
+
+    def initSettings(self) -> None:
+        """Initialise the auto-replace settings from config."""
+        self._quoteSO = CONFIG.fmtSQuoteOpen
+        self._quoteSC = CONFIG.fmtSQuoteClose
+        self._quoteDO = CONFIG.fmtDQuoteOpen
+        self._quoteDC = CONFIG.fmtDQuoteClose
+
+        self._replaceSQuote = CONFIG.doReplaceSQuote
+        self._replaceDQuote = CONFIG.doReplaceDQuote
+        self._replaceDash   = CONFIG.doReplaceDash
+        self._replaceDots   = CONFIG.doReplaceDots
+
+        self._padChar     = nwUnicode.U_THNBSP if CONFIG.fmtPadThin else nwUnicode.U_NBSP
+        self._padBefore   = CONFIG.fmtPadBefore
+        self._padAfter    = CONFIG.fmtPadAfter
+        self._doPadBefore = bool(CONFIG.fmtPadBefore)
+        self._doPadAfter  = bool(CONFIG.fmtPadAfter)
+        return
+
+    def process(self, text: str, cursor: QTextCursor) -> bool:
+        """Auto-replace text elements based on main configuration.
+        Returns True if anything was changed.
+        """
+        pos = cursor.positionInBlock()
+        length = len(text)
+        if length < 1 or pos-1 > length:
+            return False
+
+        delete, insert = self._determine(text, pos)
+        if insert == "":
+            return False
+
+        check = insert
+        if self._doPadBefore and check in self._padBefore:
+            if not (check == ":" and length > 1 and text[0] == "@"):
+                delete = max(delete, 1)
+                chkPos = pos - delete - 1
+                if chkPos >= 0 and text[chkPos].isspace():
+                    # Strip existing space before inserting a new (#1061)
+                    delete += 1
+                insert = self._padChar + insert
+
+        if self._doPadAfter and check in self._padAfter:
+            if not (check == ":" and length > 1 and text[0] == "@"):
+                delete = max(delete, 1)
+                insert = insert + self._padChar
+
+        if delete > 0:
+            cursor.movePosition(QtMoveLeft, QtKeepAnchor, delete)
+            cursor.insertText(insert)
+            return True
+
+        return False
+
+    def _determine(self, text: str, pos: int) -> tuple[int, str]:
+        """Determine what to replace, if anything."""
+        t1 = text[pos-1:pos]
+        t2 = text[pos-2:pos]
+        t3 = text[pos-3:pos]
+        t4 = text[pos-4:pos]
+        if t1 == "":
+            # Return early if there is nothing to check
+            return 0, ""
+
+        leading = t2[:1].isspace()
+        if self._replaceDQuote:
+            if leading and t2.endswith('"'):
+                return 1, self._quoteDO
+            elif t1 == '"':
+                if pos == 1:
+                    return 1, self._quoteDO
+                elif pos == 2 and t2 == '>"':
+                    return 1, self._quoteDO
+                elif pos == 3 and t3 == '>>"':
+                    return 1, self._quoteDO
+                else:
+                    return 1, self._quoteDC
+
+        if self._replaceSQuote:
+            if leading and t2.endswith("'"):
+                return 1, self._quoteSO
+            elif t1 == "'":
+                if pos == 1:
+                    return 1, self._quoteSO
+                elif pos == 2 and t2 == ">'":
+                    return 1, self._quoteSO
+                elif pos == 3 and t3 == ">>'":
+                    return 1, self._quoteSO
+                else:
+                    return 1, self._quoteSC
+
+        if self._replaceDash:
+            if t4 == "----":
+                return 4, "\u2015"  # Horizontal bar
+            elif t3 == "---":
+                return 3, "\u2014"  # Long dash
+            elif t2 == "--":
+                return 2, "\u2013"  # Short dash
+            elif t2 == "\u2013-":
+                return 2, "\u2014"  # Long dash
+            elif t2 == "\u2014-":
+                return 2, "\u2015"  # Horizontal bar
+
+        if self._replaceDots and t3 == "...":
+            return 3, "\u2026"  # Ellipsis
+
+        if t1 == "\u2028":  # Line separator
+            # This resolves issue #1150
+            return 1, "\u2029"  # Paragraph separator
+
+        return 0, t1
+
+
 class GuiDocToolBar(QWidget):
     """The Formatting and Options Fold Out Menu
 
@@ -2283,61 +2345,61 @@ class GuiDocToolBar(QWidget):
         self.tbBoldMD = NIconToolButton(self, iSz)
         self.tbBoldMD.setToolTip(self.tr("Markdown Bold"))
         self.tbBoldMD.clicked.connect(
-            lambda: self.requestDocAction.emit(nwDocAction.MD_BOLD)
+            qtLambda(self.requestDocAction.emit, nwDocAction.MD_BOLD)
         )
 
         self.tbItalicMD = NIconToolButton(self, iSz)
         self.tbItalicMD.setToolTip(self.tr("Markdown Italic"))
         self.tbItalicMD.clicked.connect(
-            lambda: self.requestDocAction.emit(nwDocAction.MD_ITALIC)
+            qtLambda(self.requestDocAction.emit, nwDocAction.MD_ITALIC)
         )
 
         self.tbStrikeMD = NIconToolButton(self, iSz)
         self.tbStrikeMD.setToolTip(self.tr("Markdown Strikethrough"))
         self.tbStrikeMD.clicked.connect(
-            lambda: self.requestDocAction.emit(nwDocAction.MD_STRIKE)
+            qtLambda(self.requestDocAction.emit, nwDocAction.MD_STRIKE)
         )
 
         self.tbBold = NIconToolButton(self, iSz)
         self.tbBold.setToolTip(self.tr("Shortcode Bold"))
         self.tbBold.clicked.connect(
-            lambda: self.requestDocAction.emit(nwDocAction.SC_BOLD)
+            qtLambda(self.requestDocAction.emit, nwDocAction.SC_BOLD)
         )
 
         self.tbItalic = NIconToolButton(self, iSz)
         self.tbItalic.setToolTip(self.tr("Shortcode Italic"))
         self.tbItalic.clicked.connect(
-            lambda: self.requestDocAction.emit(nwDocAction.SC_ITALIC)
+            qtLambda(self.requestDocAction.emit, nwDocAction.SC_ITALIC)
         )
 
         self.tbStrike = NIconToolButton(self, iSz)
         self.tbStrike.setToolTip(self.tr("Shortcode Strikethrough"))
         self.tbStrike.clicked.connect(
-            lambda: self.requestDocAction.emit(nwDocAction.SC_STRIKE)
+            qtLambda(self.requestDocAction.emit, nwDocAction.SC_STRIKE)
         )
 
         self.tbUnderline = NIconToolButton(self, iSz)
         self.tbUnderline.setToolTip(self.tr("Shortcode Underline"))
         self.tbUnderline.clicked.connect(
-            lambda: self.requestDocAction.emit(nwDocAction.SC_ULINE)
+            qtLambda(self.requestDocAction.emit, nwDocAction.SC_ULINE)
         )
 
         self.tbMark = NIconToolButton(self, iSz)
         self.tbMark.setToolTip(self.tr("Shortcode Highlight"))
         self.tbMark.clicked.connect(
-            lambda: self.requestDocAction.emit(nwDocAction.SC_MARK)
+            qtLambda(self.requestDocAction.emit, nwDocAction.SC_MARK)
         )
 
         self.tbSuperscript = NIconToolButton(self, iSz)
         self.tbSuperscript.setToolTip(self.tr("Shortcode Superscript"))
         self.tbSuperscript.clicked.connect(
-            lambda: self.requestDocAction.emit(nwDocAction.SC_SUP)
+            qtLambda(self.requestDocAction.emit, nwDocAction.SC_SUP)
         )
 
         self.tbSubscript = NIconToolButton(self, iSz)
         self.tbSubscript.setToolTip(self.tr("Shortcode Subscript"))
         self.tbSubscript.clicked.connect(
-            lambda: self.requestDocAction.emit(nwDocAction.SC_SUB)
+            qtLambda(self.requestDocAction.emit, nwDocAction.SC_SUB)
         )
 
         # Assemble
@@ -2801,7 +2863,7 @@ class GuiDocEditHeader(QWidget):
         self.tbButton = NIconToolButton(self, iSz)
         self.tbButton.setVisible(False)
         self.tbButton.setToolTip(self.tr("Toggle Tool Bar"))
-        self.tbButton.clicked.connect(lambda: self.toggleToolBarRequest.emit())
+        self.tbButton.clicked.connect(qtLambda(self.toggleToolBarRequest.emit))
 
         self.outlineButton = NIconToolButton(self, iSz)
         self.outlineButton.setVisible(False)
@@ -2816,7 +2878,7 @@ class GuiDocEditHeader(QWidget):
         self.minmaxButton = NIconToolButton(self, iSz)
         self.minmaxButton.setVisible(False)
         self.minmaxButton.setToolTip(self.tr("Toggle Focus Mode"))
-        self.minmaxButton.clicked.connect(lambda: self.docEditor.toggleFocusModeRequest.emit())
+        self.minmaxButton.clicked.connect(qtLambda(self.docEditor.toggleFocusModeRequest.emit))
 
         self.closeButton = NIconToolButton(self, iSz)
         self.closeButton.setVisible(False)
@@ -2879,9 +2941,7 @@ class GuiDocEditHeader(QWidget):
             self.outlineMenu.clear()
             for number, text in data.items():
                 action = self.outlineMenu.addAction(text)
-                action.triggered.connect(
-                    lambda _, number=number: self._gotoBlock(number)
-                )
+                action.triggered.connect(qtLambda(self._gotoBlock, number))
             self._docOutline = data
             logger.debug("Document outline updated in %.3f ms", 1000*(time() - tStart))
         return
@@ -2894,7 +2954,7 @@ class GuiDocEditHeader(QWidget):
 
     def updateTheme(self) -> None:
         """Update theme elements."""
-        self.tbButton.setThemeIcon("menu")
+        self.tbButton.setThemeIcon("toolbar")
         self.outlineButton.setThemeIcon("list")
         self.searchButton.setThemeIcon("search")
         self.minmaxButton.setThemeIcon("maximise")
@@ -2938,7 +2998,7 @@ class GuiDocEditHeader(QWidget):
 
         if CONFIG.showFullPath:
             self.itemTitle.setText(f"  {nwUnicode.U_RSAQUO}  ".join(reversed(
-                [name for name in SHARED.project.tree.getItemPath(tHandle, asName=True)]
+                [name for name in SHARED.project.tree.itemPath(tHandle, asName=True)]
             )))
         else:
             self.itemTitle.setText(i.itemName if (i := SHARED.project.tree[tHandle]) else "")