novelWriter 2.2b1__py3-none-any.whl → 2.2.1__py3-none-any.whl

novelwriter/gui/doceditor.py

@@ -10,9 +10,11 @@ Created:   2020-04-25 [0.4.5] GuiDocEditHeader
 Rewritten: 2020-06-15 [0.9]   GuiDocEditSearch
 Created:   2020-06-27 [0.10]  GuiDocEditFooter
 Rewritten: 2020-10-07 [1.0b3] BackgroundWordCounter
+Created:   2023-11-06 [2.2b1] MetaCompleter
+Created:   2023-11-07 [2.2b1] GuiDocToolBar
 
 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
@@ -46,8 +48,8 @@ from PyQt5.QtGui import (
 )
 from PyQt5.QtWidgets import (
     QAction, QFrame, QGridLayout, QHBoxLayout, QLabel, QLineEdit, QMenu,
-    QPlainTextEdit, QPushButton, QShortcut, QToolBar, QToolButton, QVBoxLayout, QWidget,
-    qApp
+    QPlainTextEdit, QPushButton, QShortcut, QToolBar, QToolButton, QVBoxLayout,
+    QWidget, qApp
 )
 
 from novelwriter import CONFIG, SHARED
@@ -56,10 +58,11 @@ from novelwriter.common import minmax, transferCase
 from novelwriter.constants import nwKeyWords, nwLabels, nwShortcode, nwUnicode, trConst
 from novelwriter.core.item import NWItem
 from novelwriter.core.index import countWords
+from novelwriter.tools.lipsum import GuiLipsum
 from novelwriter.core.document import NWDocument
 from novelwriter.gui.dochighlight import GuiDocHighlighter
 from novelwriter.gui.editordocument import GuiTextDocument
-from novelwriter.extensions.wheeleventfilter import WheelEventFilter
+from novelwriter.extensions.eventfilters import WheelEventFilter
 
 if TYPE_CHECKING:  # pragma: no cover
     from novelwriter.guimain import GuiMain
@@ -67,12 +70,22 @@ if TYPE_CHECKING:  # pragma: no cover
 logger = logging.getLogger(__name__)
 
 
+class _SelectAction(Enum):
+
+    NO_DECISION    = 0
+    KEEP_SELECTION = 1
+    KEEP_POSITION  = 2
+    MOVE_AFTER     = 3
+
+# END Class _SelectAction
+
+
 class GuiDocEditor(QPlainTextEdit):
     """Gui Widget: Main Document Editor"""
 
     MOVE_KEYS = (
-        Qt.Key_Left, Qt.Key_Right, Qt.Key_Up, Qt.Key_Down,
-        Qt.Key_PageUp, Qt.Key_PageDown
+        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
@@ -85,6 +98,8 @@ class GuiDocEditor(QPlainTextEdit):
     spellCheckStateChanged = pyqtSignal(bool)
     closeDocumentRequest = pyqtSignal()
     toggleFocusModeRequest = pyqtSignal()
+    requestProjectItemSelected = pyqtSignal(str, bool)
+    requestProjectItemRenamed = pyqtSignal(str, str)
 
     def __init__(self, mainGui: GuiMain) -> None:
         super().__init__(parent=mainGui)
@@ -145,29 +160,28 @@ class GuiDocEditor(QPlainTextEdit):
         self.docToolBar.requestDocAction.connect(self.docAction)
 
         # Context Menu
-        self.setContextMenuPolicy(Qt.CustomContextMenu)
+        self.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
         self.customContextMenuRequested.connect(self._openContextMenu)
 
         # Editor Settings
         self.setMinimumWidth(CONFIG.pxInt(300))
         self.setAutoFillBackground(True)
-        self.setFrameStyle(QFrame.NoFrame)
-        self.setCenterOnScroll(True)
+        self.setFrameStyle(QFrame.Shape.NoFrame)
 
         # Custom Shortcuts
         self.keyContext = QShortcut(self)
         self.keyContext.setKey("Ctrl+.")
-        self.keyContext.setContext(Qt.WidgetShortcut)
+        self.keyContext.setContext(Qt.ShortcutContext.WidgetShortcut)
         self.keyContext.activated.connect(self._openContextFromCursor)
 
         self.followTag1 = QShortcut(self)
-        self.followTag1.setKey(Qt.Key_Return | Qt.ControlModifier)
-        self.followTag1.setContext(Qt.WidgetShortcut)
+        self.followTag1.setKey(Qt.Key.Key_Return | Qt.KeyboardModifier.ControlModifier)
+        self.followTag1.setContext(Qt.ShortcutContext.WidgetShortcut)
         self.followTag1.activated.connect(self._processTag)
 
         self.followTag2 = QShortcut(self)
-        self.followTag2.setKey(Qt.Key_Enter | Qt.ControlModifier)
-        self.followTag2.setContext(Qt.WidgetShortcut)
+        self.followTag2.setKey(Qt.Key.Key_Enter | Qt.KeyboardModifier.ControlModifier)
+        self.followTag2.setContext(Qt.ShortcutContext.WidgetShortcut)
         self.followTag2.activated.connect(self._processTag)
 
         # Set Up Document Word Counter
@@ -263,14 +277,14 @@ class GuiDocEditor(QPlainTextEdit):
     def updateSyntaxColours(self) -> None:
         """Update the syntax highlighting theme."""
         mainPalette = self.palette()
-        mainPalette.setColor(QPalette.Window, QColor(*SHARED.theme.colBack))
-        mainPalette.setColor(QPalette.Base, QColor(*SHARED.theme.colBack))
-        mainPalette.setColor(QPalette.Text, QColor(*SHARED.theme.colText))
+        mainPalette.setColor(QPalette.ColorRole.Window, QColor(*SHARED.theme.colBack))
+        mainPalette.setColor(QPalette.ColorRole.Base, QColor(*SHARED.theme.colBack))
+        mainPalette.setColor(QPalette.ColorRole.Text, QColor(*SHARED.theme.colText))
         self.setPalette(mainPalette)
 
         docPalette = self.viewport().palette()
-        docPalette.setColor(QPalette.Base, QColor(*SHARED.theme.colBack))
-        docPalette.setColor(QPalette.Text, QColor(*SHARED.theme.colText))
+        docPalette.setColor(QPalette.ColorRole.Base, QColor(*SHARED.theme.colBack))
+        docPalette.setColor(QPalette.ColorRole.Text, QColor(*SHARED.theme.colText))
         self.viewport().setPalette(docPalette)
 
         self.docHeader.matchColours()
@@ -322,24 +336,25 @@ class GuiDocEditor(QPlainTextEdit):
         options = QTextOption()
 
         if CONFIG.doJustify:
-            options.setAlignment(Qt.AlignJustify)
+            options.setAlignment(Qt.AlignmentFlag.AlignJustify)
         if CONFIG.showTabsNSpaces:
-            options.setFlags(options.flags() | QTextOption.ShowTabsAndSpaces)
+            options.setFlags(options.flags() | QTextOption.Flag.ShowTabsAndSpaces)
         if CONFIG.showLineEndings:
-            options.setFlags(options.flags() | QTextOption.ShowLineAndParagraphSeparators)
+            options.setFlags(options.flags() | QTextOption.Flag.ShowLineAndParagraphSeparators)
 
         self._qDocument.setDefaultTextOption(options)
 
-        # Scroll bars
+        # Scrolling
+        self.setCenterOnScroll(CONFIG.scrollPastEnd)
         if CONFIG.hideVScroll:
-            self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
+            self.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
         else:
-            self.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
+            self.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAsNeeded)
 
         if CONFIG.hideHScroll:
-            self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
+            self.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
         else:
-            self.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
+            self.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAsNeeded)
 
         # Refresh the tab stops
         self.setTabStopDistance(CONFIG.getTabWidth())
@@ -358,7 +373,7 @@ class GuiDocEditor(QPlainTextEdit):
 
         return
 
-    def loadText(self, tHandle, tLine=None) -> bool:
+    def loadText(self, tHandle: str, tLine=None) -> bool:
         """Load text from a document into the editor. If we have an I/O
         error, we must handle this and clear the editor so that we don't
         risk overwriting the file if it exists. This can for instance
@@ -376,7 +391,7 @@ class GuiDocEditor(QPlainTextEdit):
             self.clearEditor()
             return False
 
-        qApp.setOverrideCursor(QCursor(Qt.WaitCursor))
+        qApp.setOverrideCursor(QCursor(Qt.CursorShape.WaitCursor))
         self._docHandle = tHandle
 
         self._allowAutoReplace(False)
@@ -429,7 +444,7 @@ class GuiDocEditor(QPlainTextEdit):
         """Replace the text of the current document with the provided
         text. This also clears undo history.
         """
-        qApp.setOverrideCursor(QCursor(Qt.WaitCursor))
+        qApp.setOverrideCursor(QCursor(Qt.CursorShape.WaitCursor))
         self.setPlainText(text)
         self.updateDocMargins()
         self.setDocumentChanged(True)
@@ -488,10 +503,7 @@ class GuiDocEditor(QPlainTextEdit):
             else:
                 self.novelStructureChanged.emit()
 
-        # ToDo: This should be a signal
         if oldHeader != newHeader:
-            self.mainGui.projView.setTreeItemValues(tHandle)
-            self.mainGui.itemDetails.updateViewBox(tHandle)
             self.docFooter.updateInfo()
 
         # Update the status bar
@@ -499,6 +511,33 @@ class GuiDocEditor(QPlainTextEdit):
 
         return True
 
+    def cursorIsVisible(self) -> bool:
+        """Check if the cursor is visible in the editor."""
+        return (
+            0 < self.cursorRect().top()
+            and self.cursorRect().bottom() < self.viewport().height()
+        )
+
+    def ensureCursorVisibleNoCentre(self) -> None:
+        """Ensure cursor is visible, but don't force it to centre."""
+        cT = self.cursorRect().top()
+        cB = self.cursorRect().bottom()
+        vH = self.viewport().height()
+        if cT < 0:
+            count = 0
+            vBar = self.verticalScrollBar()
+            while self.cursorRect().top() < 0 and count < 100000:
+                vBar.setValue(vBar.value() - 1)
+                count += 1
+        elif cB > vH:
+            count = 0
+            vBar = self.verticalScrollBar()
+            while self.cursorRect().bottom() > vH and count < 100000:
+                vBar.setValue(vBar.value() + 1)
+                count += 1
+        qApp.processEvents()
+        return
+
     def updateDocMargins(self) -> None:
         """Automatically adjust the margins so the text is centred if
         we have a text width set or we're in Focus Mode. Otherwise, just
@@ -640,7 +679,7 @@ class GuiDocEditor(QPlainTextEdit):
         """
         logger.debug("Running spell checker")
         start = time()
-        qApp.setOverrideCursor(QCursor(Qt.WaitCursor))
+        qApp.setOverrideCursor(QCursor(Qt.CursorShape.WaitCursor))
         self._qDocument.syntaxHighlighter.rehighlight()
         qApp.restoreOverrideCursor()
         logger.debug("Document highlighted in %.3f ms", 1000*(time() - start))
@@ -679,20 +718,20 @@ class GuiDocEditor(QPlainTextEdit):
             self.copy()
         elif action == nwDocAction.PASTE:
             self.paste()
-        elif action == nwDocAction.EMPH:
+        elif action == nwDocAction.MD_ITALIC:
             self._toggleFormat(1, "_")
-        elif action == nwDocAction.STRONG:
+        elif action == nwDocAction.MD_BOLD:
             self._toggleFormat(2, "*")
-        elif action == nwDocAction.STRIKE:
+        elif action == nwDocAction.MD_STRIKE:
             self._toggleFormat(2, "~")
         elif action == nwDocAction.S_QUOTE:
             self._wrapSelection(self._typSQuoteO, self._typSQuoteC)
         elif action == nwDocAction.D_QUOTE:
             self._wrapSelection(self._typDQuoteO, self._typDQuoteC)
         elif action == nwDocAction.SEL_ALL:
-            self._makeSelection(QTextCursor.Document)
+            self._makeSelection(QTextCursor.SelectionType.Document)
         elif action == nwDocAction.SEL_PARA:
-            self._makeSelection(QTextCursor.BlockUnderCursor)
+            self._makeSelection(QTextCursor.SelectionType.BlockUnderCursor)
         elif action == nwDocAction.BLOCK_H1:
             self._formatBlock(nwDocAction.BLOCK_H1)
         elif action == nwDocAction.BLOCK_H2:
@@ -793,7 +832,11 @@ class GuiDocEditor(QPlainTextEdit):
             elif insert == nwDocInsert.QUOTE_RD:
                 text = self._typDQuoteC
             elif insert == nwDocInsert.SYNOPSIS:
-                text = "% Synopsis: "
+                text = "%Synopsis: "
+                newBlock = True
+                goAfter = True
+            elif insert == nwDocInsert.SHORT:
+                text = "%Short: "
                 newBlock = True
                 goAfter = True
             elif insert == nwDocInsert.NEW_PAGE:
@@ -808,18 +851,23 @@ class GuiDocEditor(QPlainTextEdit):
                 text = "[vspace:2]"
                 newBlock = True
                 goAfter = False
+            elif insert == nwDocInsert.LIPSUM:
+                text = GuiLipsum.getLipsum(self)
+                newBlock = True
+                goAfter = False
             else:
                 return False
         else:
             return False
 
-        if newBlock:
-            self.insertNewBlock(text, defaultAfter=goAfter)
-        else:
-            cursor = self.textCursor()
-            cursor.beginEditBlock()
-            cursor.insertText(text)
-            cursor.endEditBlock()
+        if text:
+            if newBlock:
+                self.insertNewBlock(text, defaultAfter=goAfter)
+            else:
+                cursor = self.textCursor()
+                cursor.beginEditBlock()
+                cursor.insertText(text)
+                cursor.endEditBlock()
 
         return True
 
@@ -873,17 +921,17 @@ class GuiDocEditor(QPlainTextEdit):
           * We also handle automatic scrolling here.
         """
         self._lastActive = time()
-        isReturn  = event.key() == Qt.Key_Return
-        isReturn |= event.key() == Qt.Key_Enter
+        isReturn  = event.key() == Qt.Key.Key_Return
+        isReturn |= event.key() == Qt.Key.Key_Enter
         if isReturn and self.docSearch.anyFocus():
             return
-        elif event == QKeySequence.Redo:
+        elif event == QKeySequence.StandardKey.Redo:
             self.docAction(nwDocAction.REDO)
             return
-        elif event == QKeySequence.Undo:
+        elif event == QKeySequence.StandardKey.Undo:
             self.docAction(nwDocAction.UNDO)
             return
-        elif event == QKeySequence.SelectAll:
+        elif event == QKeySequence.StandardKey.SelectAll:
             self.docAction(nwDocAction.SEL_ALL)
             return
 
@@ -892,7 +940,7 @@ class GuiDocEditor(QPlainTextEdit):
             super().keyPressEvent(event)
             nPos = self.cursorRect().topLeft().y()
             kMod = event.modifiers()
-            okMod = kMod == Qt.NoModifier or kMod == Qt.ShiftModifier
+            okMod = kMod in (Qt.KeyboardModifier.NoModifier, Qt.KeyboardModifier.ShiftModifier)
             okKey = event.key() not in self.MOVE_KEYS
             if nPos != cPos and okMod and okKey:
                 mPos = CONFIG.autoScrollPos*0.01 * self.viewport().height()
@@ -923,7 +971,7 @@ class GuiDocEditor(QPlainTextEdit):
         pressed, check if we're clicking on a tag, and trigger the
         follow tag function.
         """
-        if qApp.keyboardModifiers() == Qt.ControlModifier:
+        if qApp.keyboardModifiers() == Qt.KeyboardModifier.ControlModifier:
             self._processTag(self.cursorForPosition(event.pos()))
         super().mouseReleaseEvent(event)
         self.docFooter.updateLineCount()
@@ -996,7 +1044,9 @@ class GuiDocEditor(QPlainTextEdit):
             return
 
         text = block.text()
-        if text.startswith("@"):
+        if text.startswith("@") and added + removed == 1:
+            # Only run on single keypresses, otherwise it will trigger
+            # at unwanted times when other changes are made to the document
             cursor = self.textCursor()
             bPos = cursor.positionInBlock()
             if bPos > 0:
@@ -1004,8 +1054,10 @@ class GuiDocEditor(QPlainTextEdit):
                 point = self.cursorRect().bottomRight()
                 self._completer.move(self.viewport().mapToGlobal(point))
                 self._completer.setVisible(show)
+        else:
+            self._completer.setVisible(False)
 
-        elif self._doReplace and added == 1:
+        if self._doReplace and added == 1:
             self._docAutoReplace(text)
 
         return
@@ -1025,43 +1077,50 @@ class GuiDocEditor(QPlainTextEdit):
 
     @pyqtSlot("QPoint")
     def _openContextMenu(self, pos: QPoint) -> None:
-        """Triggered by right click to open the context menu. Also
-        triggered by the Ctrl+. shortcut.
-        """
+        """Open the editor context menu at a given coordinate."""
         uCursor = self.textCursor()
         pCursor = self.cursorForPosition(pos)
+        pBlock = pCursor.block()
 
         ctxMenu = QMenu(self)
+        ctxMenu.setObjectName("ContextMenu")
+        if pBlock.userState() == GuiDocHighlighter.BLOCK_TITLE:
+            action = ctxMenu.addAction(self.tr("Set as Document Name"))
+            action.triggered.connect(lambda: self._emitRenameItem(pBlock))
 
         # Follow
         status = self._processTag(cursor=pCursor, follow=False)
         if status == nwTrinary.POSITIVE:
-            aTag = ctxMenu.addAction(self.tr("Follow Tag"))
-            aTag.triggered.connect(lambda: self._processTag(cursor=pCursor, follow=True))
+            action = ctxMenu.addAction(self.tr("Follow Tag"))
+            action.triggered.connect(lambda: self._processTag(cursor=pCursor, follow=True))
             ctxMenu.addSeparator()
         elif status == nwTrinary.NEGATIVE:
-            aTag = ctxMenu.addAction(self.tr("Create Note for Tag"))
-            aTag.triggered.connect(lambda: self._processTag(cursor=pCursor, create=True))
+            action = ctxMenu.addAction(self.tr("Create Note for Tag"))
+            action.triggered.connect(lambda: self._processTag(cursor=pCursor, create=True))
             ctxMenu.addSeparator()
 
         # Cut, Copy and Paste
         if uCursor.hasSelection():
-            aCut = ctxMenu.addAction(self.tr("Cut"))
-            aCut.triggered.connect(lambda: self.docAction(nwDocAction.CUT))
-            aCopy = ctxMenu.addAction(self.tr("Copy"))
-            aCopy.triggered.connect(lambda: self.docAction(nwDocAction.COPY))
+            action = ctxMenu.addAction(self.tr("Cut"))
+            action.triggered.connect(lambda: self.docAction(nwDocAction.CUT))
+            action = ctxMenu.addAction(self.tr("Copy"))
+            action.triggered.connect(lambda: self.docAction(nwDocAction.COPY))
 
-        aPaste = ctxMenu.addAction(self.tr("Paste"))
-        aPaste.triggered.connect(lambda: self.docAction(nwDocAction.PASTE))
+        action = ctxMenu.addAction(self.tr("Paste"))
+        action.triggered.connect(lambda: self.docAction(nwDocAction.PASTE))
         ctxMenu.addSeparator()
 
         # Selections
-        aSAll = ctxMenu.addAction(self.tr("Select All"))
-        aSAll.triggered.connect(lambda: self.docAction(nwDocAction.SEL_ALL))
-        aSWrd = ctxMenu.addAction(self.tr("Select Word"))
-        aSWrd.triggered.connect(lambda: self._makePosSelection(QTextCursor.WordUnderCursor, pos))
-        aSPar = ctxMenu.addAction(self.tr("Select Paragraph"))
-        aSPar.triggered.connect(lambda: self._makePosSelection(QTextCursor.BlockUnderCursor, pos))
+        action = ctxMenu.addAction(self.tr("Select All"))
+        action.triggered.connect(lambda: self.docAction(nwDocAction.SEL_ALL))
+        action = ctxMenu.addAction(self.tr("Select Word"))
+        action.triggered.connect(
+            lambda: self._makePosSelection(QTextCursor.SelectionType.WordUnderCursor, pos)
+        )
+        action = ctxMenu.addAction(self.tr("Select Paragraph"))
+        action.triggered.connect(lambda: self._makePosSelection(
+            QTextCursor.SelectionType.BlockUnderCursor, pos)
+        )
 
         # Spell Checking
         if SHARED.project.data.spellCheck:
@@ -1071,24 +1130,27 @@ class GuiDocEditor(QPlainTextEdit):
                 block = pCursor.block()
                 sCursor = self.textCursor()
                 sCursor.setPosition(block.position() + cPos)
-                sCursor.movePosition(QTextCursor.Right, QTextCursor.KeepAnchor, cLen)
+                sCursor.movePosition(
+                    QTextCursor.MoveOperation.Right, QTextCursor.MoveMode.KeepAnchor, cLen
+                )
                 if suggest:
                     ctxMenu.addSeparator()
                     ctxMenu.addAction(self.tr("Spelling Suggestion(s)"))
                     for option in suggest[:15]:
-                        aFix = ctxMenu.addAction(f"{nwUnicode.U_ENDASH} {option}")
-                        aFix.triggered.connect(
+                        action = ctxMenu.addAction(f"{nwUnicode.U_ENDASH} {option}")
+                        action.triggered.connect(
                             lambda _, option=option: self._correctWord(sCursor, option)
                         )
                 else:
                     ctxMenu.addAction("%s %s" % (nwUnicode.U_ENDASH, self.tr("No Suggestions")))
 
                 ctxMenu.addSeparator()
-                aAdd = ctxMenu.addAction(self.tr("Add Word to Dictionary"))
-                aAdd.triggered.connect(lambda: self._addWord(word, block))
+                action = ctxMenu.addAction(self.tr("Add Word to Dictionary"))
+                action.triggered.connect(lambda: self._addWord(word, block))
 
         # Execute the context menu
         ctxMenu.exec_(self.viewport().mapToGlobal(pos))
+        ctxMenu.deleteLater()
 
         return
 
@@ -1276,8 +1338,8 @@ class GuiDocEditor(QPlainTextEdit):
             else:
                 resIdx = 0 if doLoop else maxIdx
 
-        cursor.setPosition(resS[resIdx], QTextCursor.MoveAnchor)
-        cursor.setPosition(resE[resIdx], QTextCursor.KeepAnchor)
+        cursor.setPosition(resS[resIdx], QTextCursor.MoveMode.MoveAnchor)
+        cursor.setPosition(resE[resIdx], QTextCursor.MoveMode.KeepAnchor)
         self.setTextCursor(cursor)
 
         self.docFooter.updateLineCount()
@@ -1303,9 +1365,9 @@ class GuiDocEditor(QPlainTextEdit):
 
         findOpt = QTextDocument.FindFlag(0)
         if self.docSearch.isCaseSense:
-            findOpt |= QTextDocument.FindCaseSensitively
+            findOpt |= QTextDocument.FindFlag.FindCaseSensitively
         if self.docSearch.isWholeWord:
-            findOpt |= QTextDocument.FindWholeWords
+            findOpt |= QTextDocument.FindFlag.FindWholeWords
 
         searchFor = self.docSearch.getSearchObject()
         cursor.setPosition(0)
@@ -1323,8 +1385,8 @@ class GuiDocEditor(QPlainTextEdit):
                 break
 
         if hasSelection:
-            cursor.setPosition(origA, QTextCursor.MoveAnchor)
-            cursor.setPosition(origB, QTextCursor.KeepAnchor)
+            cursor.setPosition(origA, QTextCursor.MoveMode.MoveAnchor)
+            cursor.setPosition(origB, QTextCursor.MoveMode.KeepAnchor)
         else:
             cursor.setPosition(origA)
 
@@ -1410,22 +1472,33 @@ class GuiDocEditor(QPlainTextEdit):
         If more than one block is selected, the formatting is applied to
         the first block.
         """
-        cursor = self._autoSelect()
-        if not cursor.hasSelection():
-            logger.warning("No selection made, nothing to do")
-            return False
+        cursor = self.textCursor()
+        posO = cursor.position()
+        if cursor.hasSelection():
+            select = _SelectAction.KEEP_SELECTION
+        else:
+            cursor = self._autoSelect()
+            if cursor.hasSelection() and posO == cursor.selectionEnd():
+                select = _SelectAction.MOVE_AFTER
+            else:
+                select = _SelectAction.KEEP_POSITION
 
         posS = cursor.selectionStart()
         posE = cursor.selectionEnd()
+        if self._qDocument.characterAt(posO - 1) == fChar:
+            logger.warning("Format repetition, cancelling action")
+            cursor.clearSelection()
+            cursor.setPosition(posO)
+            self.setTextCursor(cursor)
+            return False
 
         blockS = self._qDocument.findBlock(posS)
         blockE = self._qDocument.findBlock(posE)
-
         if blockS != blockE:
             posE = blockS.position() + blockS.length() - 1
             cursor.clearSelection()
-            cursor.setPosition(posS, QTextCursor.MoveAnchor)
-            cursor.setPosition(posE, QTextCursor.KeepAnchor)
+            cursor.setPosition(posS, QTextCursor.MoveMode.MoveAnchor)
+            cursor.setPosition(posE, QTextCursor.MoveMode.KeepAnchor)
             self.setTextCursor(cursor)
 
         numB = 0
@@ -1443,34 +1516,26 @@ class GuiDocEditor(QPlainTextEdit):
                 break
 
         if fLen == min(numA, numB):
-            self._clearSurrounding(cursor, fLen)
-        else:
-            self._wrapSelection(fChar*fLen)
-
-        return True
-
-    def _clearSurrounding(self, cursor: QTextCursor, nChars: int) -> bool:
-        """Clear n characters before and after the cursor."""
-        if not cursor.hasSelection():
-            logger.warning("No selection made, nothing to do")
-            return False
+            cursor.clearSelection()
+            cursor.beginEditBlock()
+            cursor.setPosition(posS)
+            for i in range(fLen):
+                cursor.deletePreviousChar()
+            cursor.setPosition(posE)
+            for i in range(fLen):
+                cursor.deletePreviousChar()
+            cursor.endEditBlock()
+            cursor.clearSelection()
+            cursor.setPosition(posO - fLen)
+            self.setTextCursor(cursor)
 
-        posS = cursor.selectionStart()
-        posE = cursor.selectionEnd()
-        cursor.clearSelection()
-        cursor.beginEditBlock()
-        cursor.setPosition(posS)
-        for i in range(nChars):
-            cursor.deletePreviousChar()
-        cursor.setPosition(posE)
-        for i in range(nChars):
-            cursor.deletePreviousChar()
-        cursor.endEditBlock()
-        cursor.clearSelection()
+        else:
+            self._wrapSelection(fChar*fLen, pos=posO, select=select)
 
         return True
 
-    def _wrapSelection(self, before: str, after: str | None = None) -> bool:
+    def _wrapSelection(self, before: str, after: str | None = None, pos: int | None = None,
+                       select: _SelectAction = _SelectAction.NO_DECISION) -> bool:
         """Wrap the selected text in whatever is in tBefore and tAfter.
         If there is no selection, the autoSelect setting decides the
         action. AutoSelect will select the word under the cursor before
@@ -1479,10 +1544,17 @@ class GuiDocEditor(QPlainTextEdit):
         if after is None:
             after = before
 
-        cursor = self._autoSelect()
-        if not cursor.hasSelection():
-            logger.warning("No selection made, nothing to do")
-            return False
+        cursor = self.textCursor()
+        posO = pos if isinstance(pos, int) else cursor.position()
+        if select == _SelectAction.NO_DECISION:
+            if cursor.hasSelection():
+                select = _SelectAction.KEEP_SELECTION
+            else:
+                cursor = self._autoSelect()
+                if cursor.hasSelection() and posO == cursor.selectionEnd():
+                    select = _SelectAction.MOVE_AFTER
+                else:
+                    select = _SelectAction.KEEP_POSITION
 
         posS = cursor.selectionStart()
         posE = cursor.selectionEnd()
@@ -1500,8 +1572,14 @@ class GuiDocEditor(QPlainTextEdit):
         cursor.insertText(before)
         cursor.endEditBlock()
 
-        cursor.setPosition(posE + len(before), QTextCursor.MoveAnchor)
-        cursor.setPosition(posS + len(before), QTextCursor.KeepAnchor)
+        if select == _SelectAction.MOVE_AFTER:
+            cursor.setPosition(posE + len(before + after))
+        elif select == _SelectAction.KEEP_SELECTION:
+            cursor.setPosition(posE + len(before), QTextCursor.MoveMode.MoveAnchor)
+            cursor.setPosition(posS + len(before), QTextCursor.MoveMode.KeepAnchor)
+        elif select == _SelectAction.KEEP_POSITION:
+            cursor.setPosition(posO + len(before))
+
         self.setTextCursor(cursor)
 
         return True
@@ -1522,7 +1600,9 @@ class GuiDocEditor(QPlainTextEdit):
         self._allowAutoReplace(False)
         for posC in range(posS, posE+1):
             cursor.setPosition(posC)
-            cursor.movePosition(QTextCursor.Left, QTextCursor.KeepAnchor, 2)
+            cursor.movePosition(
+                QTextCursor.MoveOperation.Left, QTextCursor.MoveMode.KeepAnchor, 2
+            )
             selText = cursor.selectedText()
 
             nS = len(selText)
@@ -1542,12 +1622,16 @@ class GuiDocEditor(QPlainTextEdit):
             cursor.setPosition(posC)
             if pC in closeCheck:
                 cursor.beginEditBlock()
-                cursor.movePosition(QTextCursor.Left, QTextCursor.KeepAnchor, 1)
+                cursor.movePosition(
+                    QTextCursor.MoveOperation.Left, QTextCursor.MoveMode.KeepAnchor, 1
+                )
                 cursor.insertText(oQuote)
                 cursor.endEditBlock()
             else:
                 cursor.beginEditBlock()
-                cursor.movePosition(QTextCursor.Left, QTextCursor.KeepAnchor, 1)
+                cursor.movePosition(
+                    QTextCursor.MoveOperation.Left, QTextCursor.MoveMode.KeepAnchor, 1
+                )
                 cursor.insertText(cQuote)
                 cursor.endEditBlock()
 
@@ -1667,7 +1751,7 @@ class GuiDocEditor(QPlainTextEdit):
         # Replace the block text
         cursor.beginEditBlock()
         posO = cursor.position()
-        cursor.select(QTextCursor.BlockUnderCursor)
+        cursor.select(QTextCursor.SelectionType.BlockUnderCursor)
         posS = cursor.selectionStart()
         cursor.removeSelectedText()
         cursor.setPosition(posS)
@@ -1727,7 +1811,9 @@ class GuiDocEditor(QPlainTextEdit):
         cursor.beginEditBlock()
         cursor.clearSelection()
         cursor.setPosition(rS)
-        cursor.movePosition(QTextCursor.Right, QTextCursor.KeepAnchor, rE-rS)
+        cursor.movePosition(
+            QTextCursor.MoveOperation.Right, QTextCursor.MoveMode.KeepAnchor, rE-rS
+        )
         cursor.insertText(cleanText.rstrip() + "\n")
         cursor.endEditBlock()
 
@@ -1751,13 +1837,13 @@ class GuiDocEditor(QPlainTextEdit):
         block = cursor.block()
         text = block.text()
         if len(text) == 0:
-            return nwTrinary.UNKNOWN
+            return nwTrinary.NEUTRAL
 
         if text.startswith("@") and isinstance(self._nwItem, NWItem):
 
             isGood, tBits, tPos = SHARED.project.index.scanThis(text)
             if not isGood:
-                return nwTrinary.UNKNOWN
+                return nwTrinary.NEUTRAL
 
             tag = ""
             exist = False
@@ -1774,7 +1860,7 @@ class GuiDocEditor(QPlainTextEdit):
 
             if not tag or tag.startswith("@"):
                 # The keyword cannot be looked up, so we ignore that
-                return nwTrinary.UNKNOWN
+                return nwTrinary.NEUTRAL
 
             if follow and exist:
                 logger.debug("Attempting to follow tag '%s'", tag)
@@ -1794,7 +1880,14 @@ class GuiDocEditor(QPlainTextEdit):
 
             return nwTrinary.POSITIVE if exist else nwTrinary.NEGATIVE
 
-        return nwTrinary.UNKNOWN
+        return nwTrinary.NEUTRAL
+
+    def _emitRenameItem(self, block: QTextBlock) -> None:
+        """Emit a signal to request an item be renamed."""
+        if self._docHandle:
+            text = block.text().lstrip("#").lstrip("!").strip()
+            self.requestProjectItemRenamed.emit(self._docHandle, text)
+        return
 
     def _openContextFromCursor(self) -> None:
         """Open the spell check context menu at the cursor."""
@@ -1887,7 +1980,9 @@ class GuiDocEditor(QPlainTextEdit):
                 tInsert = tInsert + self._typPadChar
 
         if nDelete > 0:
-            cursor.movePosition(QTextCursor.Left, QTextCursor.KeepAnchor, nDelete)
+            cursor.movePosition(
+                QTextCursor.MoveOperation.Left, QTextCursor.MoveMode.KeepAnchor, nDelete
+            )
             cursor.insertText(tInsert)
 
         return
@@ -1908,27 +2003,43 @@ class GuiDocEditor(QPlainTextEdit):
 
     def _autoSelect(self) -> QTextCursor:
         """Return a cursor which may or may not have a selection based
-        on user settings and document action.
+        on user settings and document action. The selection will be the
+        word closest to the cursor consisting of alphanumerical unicode
+        characters.
         """
         cursor = self.textCursor()
         if CONFIG.autoSelect and not cursor.hasSelection():
-            cursor.select(QTextCursor.WordUnderCursor)
-            posS = cursor.selectionStart()
-            posE = cursor.selectionEnd()
+            cPos = cursor.position()
+            bPos = cursor.block().position()
+            bLen = cursor.block().length()
+            apos = nwUnicode.U_APOS + nwUnicode.U_RSQUO
+
+            # Scan backward
+            sPos = cPos
+            for i in range(cPos - bPos):
+                sPos = cPos - i - 1
+                cOne = self._qDocument.characterAt(sPos)
+                cTwo = self._qDocument.characterAt(sPos - 1)
+                if not (cOne.isalnum() or cOne in apos and cTwo.isalnum()):
+                    sPos += 1
+                    break
 
-            # Underscore counts as a part of the word, so check that the
-            # selection isn't wrapped in italics markers.
-            reSelect = False
-            if self._qDocument.characterAt(posS) == "_":
-                posS += 1
-                reSelect = True
-            if self._qDocument.characterAt(posE) == "_":
-                posE -= 1
-                reSelect = True
-            if reSelect:
-                cursor.clearSelection()
-                cursor.setPosition(posS, QTextCursor.MoveAnchor)
-                cursor.setPosition(posE-1, QTextCursor.KeepAnchor)
+            # Scan forward
+            ePos = cPos
+            for i in range(bPos + bLen - cPos):
+                ePos = cPos + i
+                cOne = self._qDocument.characterAt(ePos)
+                cTwo = self._qDocument.characterAt(ePos + 1)
+                if not (cOne.isalnum() or cOne in apos and cTwo.isalnum()):
+                    break
+
+            if ePos - sPos <= 0:
+                # No selection possible
+                return cursor
+
+            cursor.clearSelection()
+            cursor.setPosition(sPos, QTextCursor.MoveMode.MoveAnchor)
+            cursor.setPosition(ePos, QTextCursor.MoveMode.KeepAnchor)
 
             self.setTextCursor(cursor)
 
@@ -1940,18 +2051,18 @@ class GuiDocEditor(QPlainTextEdit):
         cursor.clearSelection()
         cursor.select(mode)
 
-        if mode == QTextCursor.WordUnderCursor:
+        if mode == QTextCursor.SelectionType.WordUnderCursor:
             cursor = self._autoSelect()
 
-        elif mode == QTextCursor.BlockUnderCursor:
+        elif mode == QTextCursor.SelectionType.BlockUnderCursor:
             # This selection mode also selects the preceding paragraph
             # separator, which we want to avoid.
             posS = cursor.selectionStart()
             posE = cursor.selectionEnd()
             selTxt = cursor.selectedText()
             if selTxt.startswith(nwUnicode.U_PSEP):
-                cursor.setPosition(posS+1, QTextCursor.MoveAnchor)
-                cursor.setPosition(posE, QTextCursor.KeepAnchor)
+                cursor.setPosition(posS+1, QTextCursor.MoveMode.MoveAnchor)
+                cursor.setPosition(posE, QTextCursor.MoveMode.KeepAnchor)
 
         self.setTextCursor(cursor)
 
@@ -2011,7 +2122,7 @@ class MetaCompleter(QMenu):
             length = len(lookup)
             suffix = ""
             options = list(filter(
-                lambda x: lookup in x.lower(), SHARED.project.index.getTags(
+                lambda x: lookup in x.lower(), SHARED.project.index.getClassTags(
                     nwKeyWords.KEY_CLASS.get(kw.strip(), nwItemClass.NO_CLASS)
                 )
             ))[:15]
@@ -2033,7 +2144,10 @@ class MetaCompleter(QMenu):
     def keyPressEvent(self, event: QKeyEvent) -> None:
         """Capture keypresses and forward most of them to the editor."""
         parent = self.parent()
-        if event.key() in (Qt.Key_Up, Qt.Key_Down, Qt.Key_Return, Qt.Key_Enter, Qt.Key_Escape):
+        if event.key() in (
+            Qt.Key.Key_Up, Qt.Key.Key_Down, Qt.Key.Key_Return,
+            Qt.Key.Key_Enter, Qt.Key.Key_Escape
+        ):
             super().keyPressEvent(event)
         elif isinstance(parent, GuiDocEditor):
             parent.keyPressEvent(event)
@@ -2123,39 +2237,65 @@ class GuiDocToolBar(QWidget):
         # General Buttons
         # ===============
 
-        self.tbMode = QToolButton(self)
-        self.tbMode.setToolTip(self.tr("Toggle Markdown or Shortcodes Mode"))
-        self.tbMode.setIconSize(iconSize)
-        self.tbMode.setCheckable(True)
-        self.tbMode.setChecked(CONFIG.useShortcodes)
-        self.tbMode.toggled.connect(self._toggleFormatMode)
+        self.tbBoldMD = QToolButton(self)
+        self.tbBoldMD.setIconSize(iconSize)
+        self.tbBoldMD.setToolTip(self.tr("Markdown Bold"))
+        self.tbBoldMD.clicked.connect(
+            lambda: self.requestDocAction.emit(nwDocAction.MD_BOLD)
+        )
+
+        self.tbItalicMD = QToolButton(self)
+        self.tbItalicMD.setIconSize(iconSize)
+        self.tbItalicMD.setToolTip(self.tr("Markdown Italic"))
+        self.tbItalicMD.clicked.connect(
+            lambda: self.requestDocAction.emit(nwDocAction.MD_ITALIC)
+        )
+
+        self.tbStrikeMD = QToolButton(self)
+        self.tbStrikeMD.setIconSize(iconSize)
+        self.tbStrikeMD.setToolTip(self.tr("Markdown Strikethrough"))
+        self.tbStrikeMD.clicked.connect(
+            lambda: self.requestDocAction.emit(nwDocAction.MD_STRIKE)
+        )
 
         self.tbBold = QToolButton(self)
         self.tbBold.setIconSize(iconSize)
-        self.tbBold.clicked.connect(self._formatBold)
+        self.tbBold.setToolTip(self.tr("Shortcode Bold"))
+        self.tbBold.clicked.connect(
+            lambda: self.requestDocAction.emit(nwDocAction.SC_BOLD)
+        )
 
         self.tbItalic = QToolButton(self)
         self.tbItalic.setIconSize(iconSize)
-        self.tbItalic.clicked.connect(self._formatItalic)
+        self.tbItalic.setToolTip(self.tr("Shortcode Italic"))
+        self.tbItalic.clicked.connect(
+            lambda: self.requestDocAction.emit(nwDocAction.SC_ITALIC)
+        )
 
         self.tbStrike = QToolButton(self)
         self.tbStrike.setIconSize(iconSize)
-        self.tbStrike.clicked.connect(self._formatStrike)
+        self.tbStrike.setToolTip(self.tr("Shortcode Strikethrough"))
+        self.tbStrike.clicked.connect(
+            lambda: self.requestDocAction.emit(nwDocAction.SC_STRIKE)
+        )
 
         self.tbUnderline = QToolButton(self)
         self.tbUnderline.setIconSize(iconSize)
+        self.tbUnderline.setToolTip(self.tr("Shortcode Underline"))
         self.tbUnderline.clicked.connect(
             lambda: self.requestDocAction.emit(nwDocAction.SC_ULINE)
         )
 
         self.tbSuperscript = QToolButton(self)
         self.tbSuperscript.setIconSize(iconSize)
+        self.tbSuperscript.setToolTip(self.tr("Shortcode Superscript"))
         self.tbSuperscript.clicked.connect(
             lambda: self.requestDocAction.emit(nwDocAction.SC_SUP)
         )
 
         self.tbSubscript = QToolButton(self)
         self.tbSubscript.setIconSize(iconSize)
+        self.tbSubscript.setToolTip(self.tr("Shortcode Subscript"))
         self.tbSubscript.clicked.connect(
             lambda: self.requestDocAction.emit(nwDocAction.SC_SUB)
         )
@@ -2164,7 +2304,10 @@ class GuiDocToolBar(QWidget):
         # ========
 
         self.outerBox = QVBoxLayout()
-        self.outerBox.addWidget(self.tbMode)
+        self.outerBox.addWidget(self.tbBoldMD)
+        self.outerBox.addWidget(self.tbItalicMD)
+        self.outerBox.addWidget(self.tbStrikeMD)
+        self.outerBox.addSpacing(cM)
         self.outerBox.addWidget(self.tbBold)
         self.outerBox.addWidget(self.tbItalic)
         self.outerBox.addWidget(self.tbStrike)
@@ -2187,13 +2330,14 @@ class GuiDocToolBar(QWidget):
     def updateTheme(self) -> None:
         """Initialise GUI elements that depend on specific settings."""
         palette = QPalette()
-        palette.setColor(QPalette.Window, QColor(*SHARED.theme.colBack))
-        palette.setColor(QPalette.WindowText, QColor(*SHARED.theme.colText))
-        palette.setColor(QPalette.Text, QColor(*SHARED.theme.colText))
+        palette.setColor(QPalette.ColorRole.Window, QColor(*SHARED.theme.colBack))
+        palette.setColor(QPalette.ColorRole.WindowText, QColor(*SHARED.theme.colText))
+        palette.setColor(QPalette.ColorRole.Text, QColor(*SHARED.theme.colText))
         self.setPalette(palette)
 
-        tPx = int(0.8*SHARED.theme.fontPixelSize)
-        self.tbMode.setIcon(SHARED.theme.getToggleIcon("fmt_mode", (tPx, tPx)))
+        self.tbBoldMD.setIcon(SHARED.theme.getIcon("fmt_bold-md"))
+        self.tbItalicMD.setIcon(SHARED.theme.getIcon("fmt_italic-md"))
+        self.tbStrikeMD.setIcon(SHARED.theme.getIcon("fmt_strike-md"))
         self.tbBold.setIcon(SHARED.theme.getIcon("fmt_bold"))
         self.tbItalic.setIcon(SHARED.theme.getIcon("fmt_italic"))
         self.tbStrike.setIcon(SHARED.theme.getIcon("fmt_strike"))
@@ -2203,40 +2347,6 @@ class GuiDocToolBar(QWidget):
 
         return
 
-    ##
-    #  Private Slots
-    ##
-
-    @pyqtSlot(bool)
-    def _toggleFormatMode(self, checked: bool) -> None:
-        """Toggle the formatting mode."""
-        CONFIG.useShortcodes = checked
-        return
-
-    @pyqtSlot()
-    def _formatBold(self):
-        """Call the bold format action."""
-        self.requestDocAction.emit(
-            nwDocAction.SC_BOLD if self.tbMode.isChecked() else nwDocAction.STRONG
-        )
-        return
-
-    @pyqtSlot()
-    def _formatItalic(self):
-        """Call the italic format action."""
-        self.requestDocAction.emit(
-            nwDocAction.SC_ITALIC if self.tbMode.isChecked() else nwDocAction.EMPH
-        )
-        return
-
-    @pyqtSlot()
-    def _formatStrike(self):
-        """Call the strikethrough format action."""
-        self.requestDocAction.emit(
-            nwDocAction.SC_STRIKE if self.tbMode.isChecked() else nwDocAction.STRIKE
-        )
-        return
-
 # END Class GuiDocToolBar
 
 
@@ -2269,7 +2379,7 @@ class GuiDocEditSearch(QFrame):
 
         self.setContentsMargins(0, 0, 0, 0)
         self.setAutoFillBackground(True)
-        self.setFrameStyle(QFrame.StyledPanel | QFrame.Plain)
+        self.setFrameStyle(QFrame.Shape.StyledPanel | QFrame.Shadow.Plain)
 
         self.mainBox = QGridLayout(self)
         self.setLayout(self.mainBox)
@@ -2288,7 +2398,7 @@ class GuiDocEditSearch(QFrame):
         self.replaceBox.returnPressed.connect(self._doReplace)
 
         self.searchOpt = QToolBar(self)
-        self.searchOpt.setToolButtonStyle(Qt.ToolButtonIconOnly)
+        self.searchOpt.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonIconOnly)
         self.searchOpt.setIconSize(QSize(tPx, tPx))
         self.searchOpt.setContentsMargins(0, 0, 0, 0)
 
@@ -2350,7 +2460,7 @@ class GuiDocEditSearch(QFrame):
         bPx = self.searchBox.sizeHint().height()
 
         self.showReplace = QToolButton(self)
-        self.showReplace.setArrowType(Qt.RightArrow)
+        self.showReplace.setArrowType(Qt.ArrowType.RightArrow)
         self.showReplace.setCheckable(True)
         self.showReplace.toggled.connect(self._doToggleReplace)
 
@@ -2364,8 +2474,8 @@ class GuiDocEditSearch(QFrame):
         self.replaceButton.setToolTip(self.tr("Find and replace in current document"))
         self.replaceButton.clicked.connect(self._doReplace)
 
-        self.mainBox.addWidget(self.searchLabel,   0, 0, 1, 2, Qt.AlignLeft)
-        self.mainBox.addWidget(self.searchOpt,     0, 2, 1, 3, Qt.AlignRight)
+        self.mainBox.addWidget(self.searchLabel,   0, 0, 1, 2, Qt.AlignmentFlag.AlignLeft)
+        self.mainBox.addWidget(self.searchOpt,     0, 2, 1, 3, Qt.AlignmentFlag.AlignRight)
         self.mainBox.addWidget(self.showReplace,   1, 0, 1, 1)
         self.mainBox.addWidget(self.searchBox,     1, 1, 1, 2)
         self.mainBox.addWidget(self.searchButton,  1, 3, 1, 1)
@@ -2423,18 +2533,18 @@ class GuiDocEditSearch(QFrame):
             # only added in Qt 5.13. Otherwise, 5.3 and up supports
             # only the QRegExp class.
             if CONFIG.verQtValue >= 0x050d00:
-                rxOpt = QRegularExpression.UseUnicodePropertiesOption
+                rxOpt = QRegularExpression.PatternOption.UseUnicodePropertiesOption
                 if not self.isCaseSense:
-                    rxOpt |= QRegularExpression.CaseInsensitiveOption
+                    rxOpt |= QRegularExpression.PatternOption.CaseInsensitiveOption
                 regEx = QRegularExpression(text, rxOpt)
                 self._alertSearchValid(regEx.isValid())
                 return regEx
             else:  # pragma: no cover
                 # >= 50300 to < 51300
                 if self.isCaseSense:
-                    rxOpt = Qt.CaseSensitive
+                    rxOpt = Qt.CaseSensitivity.CaseSensitive
                 else:
-                    rxOpt = Qt.CaseInsensitive
+                    rxOpt = Qt.CaseSensitivity.CaseInsensitive
                 regEx = QRegExp(text, rxOpt)
                 self._alertSearchValid(regEx.isValid())
                 return regEx
@@ -2570,7 +2680,7 @@ class GuiDocEditSearch(QFrame):
     def _doSearch(self) -> None:
         """Call the search action function for the document editor."""
         modKey = qApp.keyboardModifiers()
-        if modKey == Qt.ShiftModifier:
+        if modKey == Qt.KeyboardModifier.ShiftModifier:
             self.docEditor.findNext(goBack=True)
         else:
             self.docEditor.findNext()
@@ -2586,9 +2696,9 @@ class GuiDocEditSearch(QFrame):
     def _doToggleReplace(self, state: bool) -> None:
         """Toggle the show/hide of the replace box."""
         if state:
-            self.showReplace.setArrowType(Qt.DownArrow)
+            self.showReplace.setArrowType(Qt.ArrowType.DownArrow)
         else:
-            self.showReplace.setArrowType(Qt.RightArrow)
+            self.showReplace.setArrowType(Qt.ArrowType.RightArrow)
         self.replaceBox.setVisible(state)
         self.replaceButton.setVisible(state)
         self.repVisible = state
@@ -2641,7 +2751,7 @@ class GuiDocEditSearch(QFrame):
         isn't valid. Take the colour from the replace box.
         """
         qPalette = self.replaceBox.palette()
-        qPalette.setColor(QPalette.Base, self.rxCol[isValid])
+        qPalette.setColor(QPalette.ColorRole.Base, self.rxCol[isValid])
         self.searchBox.setPalette(qPalette)
         return
 
@@ -2682,7 +2792,7 @@ class GuiDocEditHeader(QWidget):
         self.itemTitle.setMargin(0)
         self.itemTitle.setContentsMargins(0, 0, 0, 0)
         self.itemTitle.setAutoFillBackground(True)
-        self.itemTitle.setAlignment(Qt.AlignHCenter | Qt.AlignTop)
+        self.itemTitle.setAlignment(Qt.AlignmentFlag.AlignHCenter | Qt.AlignmentFlag.AlignTop)
         self.itemTitle.setFixedHeight(fPx)
 
         lblFont = self.itemTitle.font()
@@ -2694,7 +2804,7 @@ class GuiDocEditHeader(QWidget):
         self.tbButton.setContentsMargins(0, 0, 0, 0)
         self.tbButton.setIconSize(iconSize)
         self.tbButton.setFixedSize(fPx, fPx)
-        self.tbButton.setToolButtonStyle(Qt.ToolButtonIconOnly)
+        self.tbButton.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonIconOnly)
         self.tbButton.setVisible(False)
         self.tbButton.setToolTip(self.tr("Toggle Tool Bar"))
         self.tbButton.clicked.connect(lambda: self.toggleToolBarRequest.emit())
@@ -2703,7 +2813,7 @@ class GuiDocEditHeader(QWidget):
         self.searchButton.setContentsMargins(0, 0, 0, 0)
         self.searchButton.setIconSize(iconSize)
         self.searchButton.setFixedSize(fPx, fPx)
-        self.searchButton.setToolButtonStyle(Qt.ToolButtonIconOnly)
+        self.searchButton.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonIconOnly)
         self.searchButton.setVisible(False)
         self.searchButton.setToolTip(self.tr("Search"))
         self.searchButton.clicked.connect(self.docEditor.toggleSearch)
@@ -2712,7 +2822,7 @@ class GuiDocEditHeader(QWidget):
         self.minmaxButton.setContentsMargins(0, 0, 0, 0)
         self.minmaxButton.setIconSize(iconSize)
         self.minmaxButton.setFixedSize(fPx, fPx)
-        self.minmaxButton.setToolButtonStyle(Qt.ToolButtonIconOnly)
+        self.minmaxButton.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonIconOnly)
         self.minmaxButton.setVisible(False)
         self.minmaxButton.setToolTip(self.tr("Toggle Focus Mode"))
         self.minmaxButton.clicked.connect(lambda: self.docEditor.toggleFocusModeRequest.emit())
@@ -2721,7 +2831,7 @@ class GuiDocEditHeader(QWidget):
         self.closeButton.setContentsMargins(0, 0, 0, 0)
         self.closeButton.setIconSize(iconSize)
         self.closeButton.setFixedSize(fPx, fPx)
-        self.closeButton.setToolButtonStyle(Qt.ToolButtonIconOnly)
+        self.closeButton.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonIconOnly)
         self.closeButton.setVisible(False)
         self.closeButton.setToolTip(self.tr("Close"))
         self.closeButton.clicked.connect(self._closeDocument)
@@ -2779,9 +2889,9 @@ class GuiDocEditHeader(QWidget):
         theme rather than the main GUI.
         """
         palette = QPalette()
-        palette.setColor(QPalette.Window, QColor(*SHARED.theme.colBack))
-        palette.setColor(QPalette.WindowText, QColor(*SHARED.theme.colText))
-        palette.setColor(QPalette.Text, QColor(*SHARED.theme.colText))
+        palette.setColor(QPalette.ColorRole.Window, QColor(*SHARED.theme.colBack))
+        palette.setColor(QPalette.ColorRole.WindowText, QColor(*SHARED.theme.colText))
+        palette.setColor(QPalette.ColorRole.Text, QColor(*SHARED.theme.colText))
 
         self.setPalette(palette)
         self.itemTitle.setPalette(palette)
@@ -2857,7 +2967,8 @@ class GuiDocEditHeader(QWidget):
         """Capture a click on the title and ensure that the item is
         selected in the project tree.
         """
-        self.mainGui.projView.setSelectedHandle(self._docHandle, doScroll=True)
+        if event.button() == Qt.MouseButton.LeftButton:
+            self.docEditor.requestProjectItemSelected.emit(self._docHandle, True)
         return
 
 # END Class GuiDocEditHeader
@@ -2894,11 +3005,13 @@ class GuiDocEditFooter(QWidget):
         self.setContentsMargins(0, 0, 0, 0)
         self.setAutoFillBackground(True)
 
+        alLeftTop = Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignTop
+
         # Status
         self.statusIcon = QLabel("")
         self.statusIcon.setContentsMargins(0, 0, 0, 0)
         self.statusIcon.setFixedHeight(self.sPx)
-        self.statusIcon.setAlignment(Qt.AlignLeft | Qt.AlignTop)
+        self.statusIcon.setAlignment(alLeftTop)
 
         self.statusText = QLabel(self.tr("Status"))
         self.statusText.setIndent(0)
@@ -2906,14 +3019,14 @@ class GuiDocEditFooter(QWidget):
         self.statusText.setContentsMargins(0, 0, 0, 0)
         self.statusText.setAutoFillBackground(True)
         self.statusText.setFixedHeight(fPx)
-        self.statusText.setAlignment(Qt.AlignLeft | Qt.AlignTop)
+        self.statusText.setAlignment(alLeftTop)
         self.statusText.setFont(lblFont)
 
         # Lines
         self.linesIcon = QLabel("")
         self.linesIcon.setContentsMargins(0, 0, 0, 0)
         self.linesIcon.setFixedHeight(self.sPx)
-        self.linesIcon.setAlignment(Qt.AlignLeft | Qt.AlignTop)
+        self.linesIcon.setAlignment(alLeftTop)
 
         self.linesText = QLabel("")
         self.linesText.setIndent(0)
@@ -2921,14 +3034,14 @@ class GuiDocEditFooter(QWidget):
         self.linesText.setContentsMargins(0, 0, 0, 0)
         self.linesText.setAutoFillBackground(True)
         self.linesText.setFixedHeight(fPx)
-        self.linesText.setAlignment(Qt.AlignLeft | Qt.AlignTop)
+        self.linesText.setAlignment(alLeftTop)
         self.linesText.setFont(lblFont)
 
         # Words
         self.wordsIcon = QLabel("")
         self.wordsIcon.setContentsMargins(0, 0, 0, 0)
         self.wordsIcon.setFixedHeight(self.sPx)
-        self.wordsIcon.setAlignment(Qt.AlignLeft | Qt.AlignTop)
+        self.wordsIcon.setAlignment(alLeftTop)
 
         self.wordsText = QLabel("")
         self.wordsText.setIndent(0)
@@ -2936,7 +3049,7 @@ class GuiDocEditFooter(QWidget):
         self.wordsText.setContentsMargins(0, 0, 0, 0)
         self.wordsText.setAutoFillBackground(True)
         self.wordsText.setFixedHeight(fPx)
-        self.wordsText.setAlignment(Qt.AlignLeft | Qt.AlignTop)
+        self.wordsText.setAlignment(alLeftTop)
         self.wordsText.setFont(lblFont)
 
         # Assemble Layout
@@ -2984,9 +3097,9 @@ class GuiDocEditFooter(QWidget):
         theme rather than the main GUI.
         """
         palette = QPalette()
-        palette.setColor(QPalette.Window, QColor(*SHARED.theme.colBack))
-        palette.setColor(QPalette.WindowText, QColor(*SHARED.theme.colText))
-        palette.setColor(QPalette.Text, QColor(*SHARED.theme.colText))
+        palette.setColor(QPalette.ColorRole.Window, QColor(*SHARED.theme.colBack))
+        palette.setColor(QPalette.ColorRole.WindowText, QColor(*SHARED.theme.colText))
+        palette.setColor(QPalette.ColorRole.Text, QColor(*SHARED.theme.colText))
 
         self.setPalette(palette)
         self.statusText.setPalette(palette)