novelWriter 2.4b1__py3-none-any.whl → 2.4rc1__py3-none-any.whl

novelwriter/gui/doceditor.py

@@ -40,16 +40,15 @@ from typing import TYPE_CHECKING
 
 from PyQt5.QtCore import (
     pyqtSignal, pyqtSlot, QObject, QPoint, QRegExp, QRegularExpression,
-    QRunnable, QSize, Qt, QTimer
+    QRunnable, Qt, QTimer
 )
 from PyQt5.QtGui import (
     QColor, QCursor, QFont, QKeyEvent, QKeySequence, QMouseEvent, QPalette,
     QPixmap, QResizeEvent, QTextBlock, QTextCursor, QTextDocument, QTextOption
 )
 from PyQt5.QtWidgets import (
-    QAction, QFrame, QGridLayout, QHBoxLayout, QLabel, QLineEdit, QMenu,
-    QPlainTextEdit, QPushButton, QShortcut, QToolBar, QToolButton, QVBoxLayout,
-    QWidget, qApp
+    QAction, QApplication, QFrame, QGridLayout, QHBoxLayout, QLabel, QLineEdit,
+    QMenu, QPlainTextEdit, QShortcut, QToolBar, QVBoxLayout, QWidget
 )
 
 from novelwriter import CONFIG, SHARED
@@ -58,12 +57,17 @@ from novelwriter.constants import nwConst, nwKeyWords, nwShortcode, nwUnicode
 from novelwriter.core.document import NWDocument
 from novelwriter.enum import nwDocAction, nwDocInsert, nwDocMode, nwItemClass, nwTrinary
 from novelwriter.extensions.eventfilters import WheelEventFilter
-from novelwriter.extensions.modified import NIconToolButton
+from novelwriter.extensions.modified import NIconToggleButton, NIconToolButton
 from novelwriter.gui.dochighlight import BLOCK_META, BLOCK_TITLE
 from novelwriter.gui.editordocument import GuiTextDocument
 from novelwriter.gui.theme import STYLES_MIN_TOOLBUTTON
 from novelwriter.text.counting import standardCounter
 from novelwriter.tools.lipsum import GuiLipsum
+from novelwriter.types import (
+    QtAlignCenterTop, QtAlignJustify, QtAlignLeft, QtAlignLeftTop,
+    QtAlignRight, QtKeepAnchor, QtModCtrl, QtMouseLeft, QtModeNone, QtModShift,
+    QtMoveAnchor, QtMoveLeft, QtMoveRight
+)
 
 if TYPE_CHECKING:  # pragma: no cover
     from novelwriter.guimain import GuiMain
@@ -92,6 +96,7 @@ class GuiDocEditor(QPlainTextEdit):
     # Custom Signals
     statusMessage = pyqtSignal(str)
     docCountsChanged = pyqtSignal(str, int, int, int)
+    docTextChanged = pyqtSignal(str, float)
     editedStatusChanged = pyqtSignal(bool)
     loadDocumentTagRequest = pyqtSignal(str, Enum)
     novelStructureChanged = pyqtSignal()
@@ -178,12 +183,12 @@ class GuiDocEditor(QPlainTextEdit):
         self.keyContext.activated.connect(self._openContextFromCursor)
 
         self.followTag1 = QShortcut(self)
-        self.followTag1.setKey(Qt.Key.Key_Return | Qt.KeyboardModifier.ControlModifier)
+        self.followTag1.setKey(Qt.Key.Key_Return | QtModCtrl)
         self.followTag1.setContext(Qt.ShortcutContext.WidgetShortcut)
         self.followTag1.activated.connect(self._processTag)
 
         self.followTag2 = QShortcut(self)
-        self.followTag2.setKey(Qt.Key.Key_Enter | Qt.KeyboardModifier.ControlModifier)
+        self.followTag2.setKey(Qt.Key.Key_Enter | QtModCtrl)
         self.followTag2.setContext(Qt.ShortcutContext.WidgetShortcut)
         self.followTag2.activated.connect(self._processTag)
 
@@ -209,6 +214,10 @@ class GuiDocEditor(QPlainTextEdit):
         self.wheelEventFilter = WheelEventFilter(self)
         self.installEventFilter(self.wheelEventFilter)
 
+        # Function Mapping
+        self.closeSearch = self.docSearch.closeSearch
+        self.searchVisible = self.docSearch.isVisible
+
         # Finalise
         self.updateSyntaxColours()
         self.initEditor()
@@ -338,7 +347,7 @@ class GuiDocEditor(QPlainTextEdit):
         options = QTextOption()
 
         if CONFIG.doJustify:
-            options.setAlignment(Qt.AlignmentFlag.AlignJustify)
+            options.setAlignment(QtAlignJustify)
         if CONFIG.showTabsNSpaces:
             options.setFlags(options.flags() | QTextOption.Flag.ShowTabsAndSpaces)
         if CONFIG.showLineEndings:
@@ -390,13 +399,13 @@ class GuiDocEditor(QPlainTextEdit):
             self.clearEditor()
             return False
 
-        qApp.setOverrideCursor(QCursor(Qt.CursorShape.WaitCursor))
+        QApplication.setOverrideCursor(QCursor(Qt.CursorShape.WaitCursor))
         self._docHandle = tHandle
 
         self._allowAutoReplace(False)
         self._qDocument.setTextContent(docText, tHandle)
         self._allowAutoReplace(True)
-        qApp.processEvents()
+        QApplication.processEvents()
 
         self._lastEdit = time()
         self._lastActive = time()
@@ -420,12 +429,12 @@ class GuiDocEditor(QPlainTextEdit):
             self.setPlainText("")
             self.setCursorPosition(0)
 
-        qApp.processEvents()
+        QApplication.processEvents()
         self.setDocumentChanged(False)
         self._qDocument.clearUndoRedoStacks()
         self.docToolBar.setVisible(CONFIG.showEditToolBar)
 
-        qApp.restoreOverrideCursor()
+        QApplication.restoreOverrideCursor()
 
         # Update the status bar
         if self._nwItem is not None:
@@ -442,11 +451,11 @@ class GuiDocEditor(QPlainTextEdit):
         """Replace the text of the current document with the provided
         text. This also clears undo history.
         """
-        qApp.setOverrideCursor(QCursor(Qt.CursorShape.WaitCursor))
+        QApplication.setOverrideCursor(QCursor(Qt.CursorShape.WaitCursor))
         self.setPlainText(text)
         self.updateDocMargins()
         self.setDocumentChanged(True)
-        qApp.restoreOverrideCursor()
+        QApplication.restoreOverrideCursor()
         return
 
     def saveText(self) -> bool:
@@ -533,7 +542,7 @@ class GuiDocEditor(QPlainTextEdit):
             while self.cursorRect().bottom() > vH and count < 100000:
                 vBar.setValue(vBar.value() + 1)
                 count += 1
-        qApp.processEvents()
+        QApplication.processEvents()
         return
 
     def updateDocMargins(self) -> None:
@@ -593,6 +602,15 @@ class GuiDocEditor(QPlainTextEdit):
         text = text.replace(nwUnicode.U_PSEP, "\n")  # Paragraph separators
         return text
 
+    def getSelectedText(self) -> str:
+        """Get currently selected text."""
+        if (cursor := self.textCursor()).hasSelection():
+            text = cursor.selectedText()
+            text = text.replace(nwUnicode.U_LSEP, "\n")  # Line separators
+            text = text.replace(nwUnicode.U_PSEP, "\n")  # Paragraph separators
+            return text
+        return ""
+
     def getCursorPosition(self) -> int:
         """Find the cursor position in the document. If the editor has a
         selection, return the position of the end of the selection.
@@ -639,12 +657,13 @@ class GuiDocEditor(QPlainTextEdit):
                 logger.debug("Cursor moved to line %d", line)
         return
 
-    def setCursorSelection(self, selStart: int, selLength: int) -> None:
+    def setCursorSelection(self, start: int, length: int) -> None:
         """Make a text selection."""
-        cursor = self.textCursor()
-        cursor.setPosition(selStart, QTextCursor.MoveMode.MoveAnchor)
-        cursor.setPosition(selStart + selLength, QTextCursor.MoveMode.KeepAnchor)
-        self.setTextCursor(cursor)
+        if start >= 0 and length > 0:
+            cursor = self.textCursor()
+            cursor.setPosition(start, QtMoveAnchor)
+            cursor.setPosition(start + length, QtKeepAnchor)
+            self.setTextCursor(cursor)
         return
 
     ##
@@ -686,9 +705,9 @@ class GuiDocEditor(QPlainTextEdit):
         """
         logger.debug("Running spell checker")
         start = time()
-        qApp.setOverrideCursor(QCursor(Qt.CursorShape.WaitCursor))
+        QApplication.setOverrideCursor(QCursor(Qt.CursorShape.WaitCursor))
         self._qDocument.syntaxHighlighter.rehighlight()
-        qApp.restoreOverrideCursor()
+        QApplication.restoreOverrideCursor()
         logger.debug("Document highlighted in %.3f ms", 1000*(time() - start))
         self.statusMessage.emit(self.tr("Spell check complete"))
         return
@@ -801,7 +820,7 @@ class GuiDocEditor(QPlainTextEdit):
 
     def anyFocus(self) -> bool:
         """Check if any widget or child widget has focus."""
-        return self.hasFocus() or self.isAncestorOf(qApp.focusWidget())
+        return self.hasFocus() or self.isAncestorOf(QApplication.focusWidget())
 
     def revealLocation(self) -> None:
         """Tell the user where on the file system the file in the editor
@@ -910,11 +929,6 @@ class GuiDocEditor(QPlainTextEdit):
 
         return True
 
-    def closeSearch(self) -> bool:
-        """Close the search box."""
-        self.docSearch.closeSearch()
-        return self.docSearch.isVisible()
-
     ##
     #  Document Events and Maintenance
     ##
@@ -949,7 +963,7 @@ class GuiDocEditor(QPlainTextEdit):
             super().keyPressEvent(event)
             nPos = self.cursorRect().topLeft().y()
             kMod = event.modifiers()
-            okMod = kMod in (Qt.KeyboardModifier.NoModifier, Qt.KeyboardModifier.ShiftModifier)
+            okMod = kMod in (QtModeNone, QtModShift)
             okKey = event.key() not in self.MOVE_KEYS
             if nPos != cPos and okMod and okKey:
                 mPos = CONFIG.autoScrollPos*0.01 * self.viewport().height()
@@ -970,7 +984,7 @@ class GuiDocEditor(QPlainTextEdit):
         if self.hasFocus():
             return False
         elif self.docSearch.isVisible():
-            return self.docSearch.cycleFocus(next)
+            return self.docSearch.cycleFocus()
         return True
 
     def mouseReleaseEvent(self, event: QMouseEvent) -> None:
@@ -978,7 +992,7 @@ class GuiDocEditor(QPlainTextEdit):
         pressed, check if we're clicking on a tag, and trigger the
         follow tag function.
         """
-        if qApp.keyboardModifiers() == Qt.KeyboardModifier.ControlModifier:
+        if QApplication.keyboardModifiers() == QtModCtrl:
             self._processTag(self.cursorForPosition(event.pos()))
         super().mouseReleaseEvent(event)
         return
@@ -1021,8 +1035,8 @@ class GuiDocEditor(QPlainTextEdit):
     @pyqtSlot()
     def toggleSearch(self) -> None:
         """Toggle the visibility of the search box."""
-        if self.docSearch.isVisible():
-            self.docSearch.closeSearch()
+        if self.searchVisible():
+            self.closeSearch()
         else:
             self.beginSearch()
         return
@@ -1078,8 +1092,8 @@ class GuiDocEditor(QPlainTextEdit):
         block = cursor.block()
         if block.isValid():
             pos += block.position()
-            cursor.setPosition(pos, QTextCursor.MoveMode.MoveAnchor)
-            cursor.setPosition(pos + length, QTextCursor.MoveMode.KeepAnchor)
+            cursor.setPosition(pos, QtMoveAnchor)
+            cursor.setPosition(pos + length, QtKeepAnchor)
             cursor.insertText(text)
             self._completer.hide()
         return
@@ -1139,9 +1153,7 @@ class GuiDocEditor(QPlainTextEdit):
                 block = pCursor.block()
                 sCursor = self.textCursor()
                 sCursor.setPosition(block.position() + cPos)
-                sCursor.movePosition(
-                    QTextCursor.MoveOperation.Right, QTextCursor.MoveMode.KeepAnchor, cLen
-                )
+                sCursor.movePosition(QtMoveRight, QtKeepAnchor, cLen)
                 if suggest:
                     ctxMenu.addSeparator()
                     ctxMenu.addAction(self.tr("Spelling Suggestion(s)"))
@@ -1158,7 +1170,7 @@ class GuiDocEditor(QPlainTextEdit):
                 action.triggered.connect(lambda: self._addWord(word, block))
 
         # Execute the context menu
-        ctxMenu.exec_(self.viewport().mapToGlobal(pos))
+        ctxMenu.exec(self.viewport().mapToGlobal(pos))
         ctxMenu.deleteLater()
 
         return
@@ -1193,18 +1205,19 @@ class GuiDocEditor(QPlainTextEdit):
         if self._docHandle is None:
             return
 
-        if self.wCounterDoc.isRunning():
-            logger.debug("Word counter is busy")
-            return
-
         if time() - self._lastEdit < 25.0:
-            logger.debug("Running word counter")
-            SHARED.runInThreadPool(self.wCounterDoc)
+            logger.debug("Running document tasks")
+            if not self.wCounterDoc.isRunning():
+                SHARED.runInThreadPool(self.wCounterDoc)
+
             self.docHeader.setOutline({
                 block.blockNumber(): block.text()
                 for block in self._qDocument.iterBlockByType(BLOCK_TITLE, maxCount=30)
             })
 
+            if self._docChanged:
+                self.docTextChanged.emit(self._docHandle, self._lastEdit)
+
         return
 
     @pyqtSlot(int, int, int)
@@ -1276,11 +1289,7 @@ class GuiDocEditor(QPlainTextEdit):
 
     def beginSearch(self) -> None:
         """Set the selected text as the search text."""
-        cursor = self.textCursor()
-        if cursor.hasSelection():
-            self.docSearch.setSearchText(cursor.selectedText())
-        else:
-            self.docSearch.setSearchText(None)
+        self.docSearch.setSearchText(self.getSelectedText() or None)
         resS, _ = self.findAllOccurences()
         self.docSearch.setResultCount(None, len(resS))
         return
@@ -1309,9 +1318,9 @@ class GuiDocEditor(QPlainTextEdit):
         if len(resS) == 0 and self._docHandle:
             self.docSearch.setResultCount(0, 0)
             self._lastFind = None
-            if self.docSearch.doNextFile and not goBack:
+            if CONFIG.searchNextFile and not goBack:
                 self.mainGui.openNextDocument(
-                    self._docHandle, wrapAround=self.docSearch.doLoop
+                    self._docHandle, wrapAround=CONFIG.searchLoop
                 )
                 self.beginSearch()
                 self.setFocus()
@@ -1320,7 +1329,7 @@ class GuiDocEditor(QPlainTextEdit):
         cursor = self.textCursor()
         resIdx = bisect.bisect_left(resS, cursor.position())
 
-        doLoop = self.docSearch.doLoop
+        doLoop = CONFIG.searchLoop
         maxIdx = len(resS) - 1
 
         if goBack:
@@ -1330,9 +1339,9 @@ class GuiDocEditor(QPlainTextEdit):
             resIdx = maxIdx if doLoop else 0
 
         if resIdx > maxIdx and self._docHandle:
-            if self.docSearch.doNextFile and not goBack:
+            if CONFIG.searchNextFile and not goBack:
                 self.mainGui.openNextDocument(
-                    self._docHandle, wrapAround=self.docSearch.doLoop
+                    self._docHandle, wrapAround=CONFIG.searchLoop
                 )
                 self.beginSearch()
                 self.setFocus()
@@ -1340,8 +1349,8 @@ class GuiDocEditor(QPlainTextEdit):
             else:
                 resIdx = 0 if doLoop else maxIdx
 
-        cursor.setPosition(resS[resIdx], QTextCursor.MoveMode.MoveAnchor)
-        cursor.setPosition(resE[resIdx], QTextCursor.MoveMode.KeepAnchor)
+        cursor.setPosition(resS[resIdx], QtMoveAnchor)
+        cursor.setPosition(resE[resIdx], QtKeepAnchor)
         self.setTextCursor(cursor)
 
         self.docSearch.setResultCount(resIdx + 1, len(resS))
@@ -1365,9 +1374,9 @@ class GuiDocEditor(QPlainTextEdit):
             origB = cursor.position()
 
         findOpt = QTextDocument.FindFlag(0)
-        if self.docSearch.isCaseSense:
+        if CONFIG.searchCase:
             findOpt |= QTextDocument.FindFlag.FindCaseSensitively
-        if self.docSearch.isWholeWord:
+        if CONFIG.searchWord:
             findOpt |= QTextDocument.FindFlag.FindWholeWords
 
         searchFor = self.docSearch.getSearchObject()
@@ -1387,8 +1396,8 @@ class GuiDocEditor(QPlainTextEdit):
                 break
 
         if hasSelection:
-            cursor.setPosition(origA, QTextCursor.MoveMode.MoveAnchor)
-            cursor.setPosition(origB, QTextCursor.MoveMode.KeepAnchor)
+            cursor.setPosition(origA, QtMoveAnchor)
+            cursor.setPosition(origB, QtKeepAnchor)
         else:
             cursor.setPosition(origA)
 
@@ -1436,7 +1445,7 @@ class GuiDocEditor(QPlainTextEdit):
         searchFor = self.docSearch.searchText
         replWith = self.docSearch.replaceText
 
-        if self.docSearch.doMatchCap:
+        if CONFIG.searchMatchCap:
             replWith = transferCase(cursor.selectedText(), replWith)
 
         # Make sure the selected text was selected by an actual find
@@ -1491,8 +1500,8 @@ class GuiDocEditor(QPlainTextEdit):
         if blockS != blockE:
             posE = blockS.position() + blockS.length() - 1
             cursor.clearSelection()
-            cursor.setPosition(posS, QTextCursor.MoveMode.MoveAnchor)
-            cursor.setPosition(posE, QTextCursor.MoveMode.KeepAnchor)
+            cursor.setPosition(posS, QtMoveAnchor)
+            cursor.setPosition(posE, QtKeepAnchor)
             self.setTextCursor(cursor)
 
         numB = 0
@@ -1569,8 +1578,8 @@ class GuiDocEditor(QPlainTextEdit):
         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)
+            cursor.setPosition(posE + len(before), QtMoveAnchor)
+            cursor.setPosition(posS + len(before), QtKeepAnchor)
         elif select == _SelectAction.KEEP_POSITION:
             cursor.setPosition(posO + len(before))
 
@@ -1592,9 +1601,7 @@ class GuiDocEditor(QPlainTextEdit):
         self._allowAutoReplace(False)
         for posC in range(posS, posE+1):
             cursor.setPosition(posC)
-            cursor.movePosition(
-                QTextCursor.MoveOperation.Left, QTextCursor.MoveMode.KeepAnchor, 2
-            )
+            cursor.movePosition(QtMoveLeft, QtKeepAnchor, 2)
             selText = cursor.selectedText()
 
             nS = len(selText)
@@ -1614,16 +1621,12 @@ class GuiDocEditor(QPlainTextEdit):
             cursor.setPosition(posC)
             if pC in closeCheck:
                 cursor.beginEditBlock()
-                cursor.movePosition(
-                    QTextCursor.MoveOperation.Left, QTextCursor.MoveMode.KeepAnchor, 1
-                )
+                cursor.movePosition(QtMoveLeft, QtKeepAnchor, 1)
                 cursor.insertText(oQuote)
                 cursor.endEditBlock()
             else:
                 cursor.beginEditBlock()
-                cursor.movePosition(
-                    QTextCursor.MoveOperation.Left, QTextCursor.MoveMode.KeepAnchor, 1
-                )
+                cursor.movePosition(QtMoveLeft, QtKeepAnchor, 1)
                 cursor.insertText(cQuote)
                 cursor.endEditBlock()
 
@@ -1839,9 +1842,7 @@ class GuiDocEditor(QPlainTextEdit):
         cursor.beginEditBlock()
         cursor.clearSelection()
         cursor.setPosition(rS)
-        cursor.movePosition(
-            QTextCursor.MoveOperation.Right, QTextCursor.MoveMode.KeepAnchor, rE-rS
-        )
+        cursor.movePosition(QtMoveRight, QtKeepAnchor, rE-rS)
         cursor.insertText(cleanText.rstrip() + "\n")
         cursor.endEditBlock()
 
@@ -1902,7 +1903,7 @@ class GuiDocEditor(QPlainTextEdit):
                 ).format(tag)):
                     itemClass = nwKeyWords.KEY_CLASS.get(tBits[0], nwItemClass.NO_CLASS)
                     self.requestNewNoteCreation.emit(tag, itemClass)
-                    qApp.processEvents()
+                    QApplication.processEvents()
                     self._qDocument.syntaxHighlighter.rehighlightBlock(block)
 
             return nwTrinary.POSITIVE if exist else nwTrinary.NEGATIVE
@@ -2007,9 +2008,7 @@ class GuiDocEditor(QPlainTextEdit):
                 tInsert = tInsert + self._typPadChar
 
         if nDelete > 0:
-            cursor.movePosition(
-                QTextCursor.MoveOperation.Left, QTextCursor.MoveMode.KeepAnchor, nDelete
-            )
+            cursor.movePosition(QtMoveLeft, QtKeepAnchor, nDelete)
             cursor.insertText(tInsert)
 
         return
@@ -2065,8 +2064,8 @@ class GuiDocEditor(QPlainTextEdit):
                 return cursor
 
             cursor.clearSelection()
-            cursor.setPosition(sPos, QTextCursor.MoveMode.MoveAnchor)
-            cursor.setPosition(ePos, QTextCursor.MoveMode.KeepAnchor)
+            cursor.setPosition(sPos, QtMoveAnchor)
+            cursor.setPosition(ePos, QtKeepAnchor)
 
             self.setTextCursor(cursor)
 
@@ -2090,8 +2089,8 @@ class GuiDocEditor(QPlainTextEdit):
             posE = cursor.selectionEnd()
             selTxt = cursor.selectedText()
             if selTxt.startswith(nwUnicode.U_PSEP):
-                cursor.setPosition(posS+1, QTextCursor.MoveMode.MoveAnchor)
-                cursor.setPosition(posE, QTextCursor.MoveMode.KeepAnchor)
+                cursor.setPosition(posS+1, QtMoveAnchor)
+                cursor.setPosition(posE, QtKeepAnchor)
 
         self.setTextCursor(cursor)
 
@@ -2222,7 +2221,7 @@ class BackgroundWordCounter(QRunnable):
         """
         self._isRunning = True
         if self._forSelection:
-            text = self._docEditor.textCursor().selectedText()
+            text = self._docEditor.getSelectedText()
         else:
             text = self._docEditor.getText()
 
@@ -2258,79 +2257,68 @@ class GuiDocToolBar(QWidget):
 
         logger.debug("Create: GuiDocToolBar")
 
+        iSz = SHARED.theme.baseIconSize
         cM = CONFIG.pxInt(4)
-        tPx = int(0.8*SHARED.theme.fontPixelSize)
-        iconSize = QSize(tPx, tPx)
         self.setContentsMargins(0, 0, 0, 0)
 
         # General Buttons
         # ===============
 
-        self.tbBoldMD = QToolButton(self)
-        self.tbBoldMD.setIconSize(iconSize)
+        self.tbBoldMD = NIconToolButton(self, iSz)
         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 = NIconToolButton(self, iSz)
         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 = NIconToolButton(self, iSz)
         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 = NIconToolButton(self, iSz)
         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 = NIconToolButton(self, iSz)
         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 = NIconToolButton(self, iSz)
         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 = NIconToolButton(self, iSz)
         self.tbUnderline.setToolTip(self.tr("Shortcode Underline"))
         self.tbUnderline.clicked.connect(
             lambda: self.requestDocAction.emit(nwDocAction.SC_ULINE)
         )
 
-        self.tbMark = QToolButton(self)
-        self.tbMark.setIconSize(iconSize)
+        self.tbMark = NIconToolButton(self, iSz)
         self.tbMark.setToolTip(self.tr("Shortcode Highlight"))
         self.tbMark.clicked.connect(
             lambda: self.requestDocAction.emit(nwDocAction.SC_MARK)
         )
 
-        self.tbSuperscript = QToolButton(self)
-        self.tbSuperscript.setIconSize(iconSize)
+        self.tbSuperscript = NIconToolButton(self, iSz)
         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 = NIconToolButton(self, iSz)
         self.tbSubscript.setToolTip(self.tr("Shortcode Subscript"))
         self.tbSubscript.clicked.connect(
             lambda: self.requestDocAction.emit(nwDocAction.SC_SUB)
@@ -2372,16 +2360,16 @@ class GuiDocToolBar(QWidget):
         palette.setColor(QPalette.ColorRole.Text, SHARED.theme.colText)
         self.setPalette(palette)
 
-        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"))
-        self.tbUnderline.setIcon(SHARED.theme.getIcon("fmt_underline"))
-        self.tbMark.setIcon(SHARED.theme.getIcon("fmt_mark"))
-        self.tbSuperscript.setIcon(SHARED.theme.getIcon("fmt_superscript"))
-        self.tbSubscript.setIcon(SHARED.theme.getIcon("fmt_subscript"))
+        self.tbBoldMD.setThemeIcon("fmt_bold-md")
+        self.tbItalicMD.setThemeIcon("fmt_italic-md")
+        self.tbStrikeMD.setThemeIcon("fmt_strike-md")
+        self.tbBold.setThemeIcon("fmt_bold")
+        self.tbItalic.setThemeIcon("fmt_italic")
+        self.tbStrike.setThemeIcon("fmt_strike")
+        self.tbUnderline.setThemeIcon("fmt_underline")
+        self.tbMark.setThemeIcon("fmt_mark")
+        self.tbSuperscript.setThemeIcon("fmt_superscript")
+        self.tbSubscript.setThemeIcon("fmt_subscript")
 
         return
 
@@ -2402,16 +2390,9 @@ class GuiDocEditSearch(QFrame):
 
         self.docEditor = docEditor
 
-        self.repVisible  = False
-        self.isCaseSense = CONFIG.searchCase
-        self.isWholeWord = CONFIG.searchWord
-        self.isRegEx     = CONFIG.searchRegEx
-        self.doLoop      = CONFIG.searchLoop
-        self.doNextFile  = CONFIG.searchNextFile
-        self.doMatchCap  = CONFIG.searchMatchCap
-
+        iSz = SHARED.theme.baseIconSize
         mPx = CONFIG.pxInt(6)
-        tPx = int(0.8*SHARED.theme.fontPixelSize)
+
         self.boxFont = SHARED.theme.guiFont
         self.boxFont.setPointSizeF(0.9*SHARED.theme.fontPointSize)
 
@@ -2437,44 +2418,44 @@ class GuiDocEditSearch(QFrame):
 
         self.searchOpt = QToolBar(self)
         self.searchOpt.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonIconOnly)
-        self.searchOpt.setIconSize(QSize(tPx, tPx))
+        self.searchOpt.setIconSize(iSz)
         self.searchOpt.setContentsMargins(0, 0, 0, 0)
 
-        self.searchLabel = QLabel(self.tr("Search"))
+        self.searchLabel = QLabel(self.tr("Search"), self)
         self.searchLabel.setFont(self.boxFont)
         self.searchLabel.setIndent(CONFIG.pxInt(6))
 
-        self.resultLabel = QLabel("?/?")
+        self.resultLabel = QLabel("?/?", self)
         self.resultLabel.setFont(self.boxFont)
         self.resultLabel.setMinimumWidth(SHARED.theme.getTextWidth("?/?", self.boxFont))
 
         self.toggleCase = QAction(self.tr("Case Sensitive"), self)
         self.toggleCase.setCheckable(True)
-        self.toggleCase.setChecked(self.isCaseSense)
+        self.toggleCase.setChecked(CONFIG.searchCase)
         self.toggleCase.toggled.connect(self._doToggleCase)
         self.searchOpt.addAction(self.toggleCase)
 
         self.toggleWord = QAction(self.tr("Whole Words Only"), self)
         self.toggleWord.setCheckable(True)
-        self.toggleWord.setChecked(self.isWholeWord)
+        self.toggleWord.setChecked(CONFIG.searchWord)
         self.toggleWord.toggled.connect(self._doToggleWord)
         self.searchOpt.addAction(self.toggleWord)
 
         self.toggleRegEx = QAction(self.tr("RegEx Mode"), self)
         self.toggleRegEx.setCheckable(True)
-        self.toggleRegEx.setChecked(self.isRegEx)
+        self.toggleRegEx.setChecked(CONFIG.searchRegEx)
         self.toggleRegEx.toggled.connect(self._doToggleRegEx)
         self.searchOpt.addAction(self.toggleRegEx)
 
         self.toggleLoop = QAction(self.tr("Loop Search"), self)
         self.toggleLoop.setCheckable(True)
-        self.toggleLoop.setChecked(self.doLoop)
+        self.toggleLoop.setChecked(CONFIG.searchLoop)
         self.toggleLoop.toggled.connect(self._doToggleLoop)
         self.searchOpt.addAction(self.toggleLoop)
 
         self.toggleProject = QAction(self.tr("Search Next File"), self)
         self.toggleProject.setCheckable(True)
-        self.toggleProject.setChecked(self.doNextFile)
+        self.toggleProject.setChecked(CONFIG.searchNextFile)
         self.toggleProject.toggled.connect(self._doToggleProject)
         self.searchOpt.addAction(self.toggleProject)
 
@@ -2482,38 +2463,32 @@ class GuiDocEditSearch(QFrame):
 
         self.toggleMatchCap = QAction(self.tr("Preserve Case"), self)
         self.toggleMatchCap.setCheckable(True)
-        self.toggleMatchCap.setChecked(self.doMatchCap)
+        self.toggleMatchCap.setChecked(CONFIG.searchMatchCap)
         self.toggleMatchCap.toggled.connect(self._doToggleMatchCap)
         self.searchOpt.addAction(self.toggleMatchCap)
 
         self.searchOpt.addSeparator()
 
         self.cancelSearch = QAction(self.tr("Close Search"), self)
-        self.cancelSearch.triggered.connect(self._doClose)
+        self.cancelSearch.triggered.connect(self.closeSearch)
         self.searchOpt.addAction(self.cancelSearch)
 
         # Buttons
         # =======
 
-        bPx = self.searchBox.sizeHint().height()
-
-        self.showReplace = QToolButton(self)
-        self.showReplace.setArrowType(Qt.ArrowType.RightArrow)
-        self.showReplace.setCheckable(True)
+        self.showReplace = NIconToggleButton(self, iSz, "unfold")
         self.showReplace.toggled.connect(self._doToggleReplace)
 
-        self.searchButton = QPushButton("")
-        self.searchButton.setFixedSize(QSize(bPx, bPx))
+        self.searchButton = NIconToolButton(self, iSz)
         self.searchButton.setToolTip(self.tr("Find in current document"))
         self.searchButton.clicked.connect(self._doSearch)
 
-        self.replaceButton = QPushButton("")
-        self.replaceButton.setFixedSize(QSize(bPx, bPx))
+        self.replaceButton = NIconToolButton(self, iSz)
         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.AlignmentFlag.AlignLeft)
-        self.mainBox.addWidget(self.searchOpt,     0, 2, 1, 3, Qt.AlignmentFlag.AlignRight)
+        self.mainBox.addWidget(self.searchLabel,   0, 0, 1, 2, QtAlignLeft)
+        self.mainBox.addWidget(self.searchOpt,     0, 2, 1, 3, QtAlignRight)
         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)
@@ -2566,20 +2541,20 @@ class GuiDocEditSearch(QFrame):
         expression object.
         """
         text = self.searchBox.text()
-        if self.isRegEx:
+        if CONFIG.searchRegEx:
             # Using the Unicode-capable QRegularExpression class was
             # only added in Qt 5.13. Otherwise, 5.3 and up supports
             # only the QRegExp class.
             if CONFIG.verQtValue >= 0x050d00:
                 rxOpt = QRegularExpression.PatternOption.UseUnicodePropertiesOption
-                if not self.isCaseSense:
+                if not CONFIG.searchCase:
                     rxOpt |= QRegularExpression.PatternOption.CaseInsensitiveOption
                 regEx = QRegularExpression(text, rxOpt)
                 self._alertSearchValid(regEx.isValid())
                 return regEx
             else:  # pragma: no cover
                 # >= 50300 to < 51300
-                if self.isCaseSense:
+                if CONFIG.searchCase:
                     rxOpt = Qt.CaseSensitivity.CaseSensitive
                 else:
                     rxOpt = Qt.CaseSensitivity.CaseInsensitive
@@ -2603,7 +2578,7 @@ class GuiDocEditSearch(QFrame):
             self.searchBox.setText(text)
         self.searchBox.setFocus()
         self.searchBox.selectAll()
-        if self.isRegEx:
+        if CONFIG.searchRegEx:
             self._alertSearchValid(True)
         return
 
@@ -2633,7 +2608,7 @@ class GuiDocEditSearch(QFrame):
 
     def updateTheme(self) -> None:
         """Update theme elements."""
-        qPalette = qApp.palette()
+        qPalette = QApplication.palette()
         self.setPalette(qPalette)
         self.searchBox.setPalette(qPalette)
         self.replaceBox.setPalette(qPalette)
@@ -2646,8 +2621,8 @@ class GuiDocEditSearch(QFrame):
         self.toggleProject.setIcon(SHARED.theme.getIcon("search_project"))
         self.toggleMatchCap.setIcon(SHARED.theme.getIcon("search_preserve"))
         self.cancelSearch.setIcon(SHARED.theme.getIcon("search_cancel"))
-        self.searchButton.setIcon(SHARED.theme.getIcon("search"))
-        self.replaceButton.setIcon(SHARED.theme.getIcon("search_replace"))
+        self.searchButton.setThemeIcon("search")
+        self.replaceButton.setThemeIcon("search_replace")
 
         # Set stylesheets
         self.searchOpt.setStyleSheet("QToolBar {padding: 0;}")
@@ -2673,55 +2648,43 @@ class GuiDocEditSearch(QFrame):
 
         return
 
-    def closeSearch(self) -> None:
-        """Close the search box."""
-        CONFIG.searchCase = self.isCaseSense
-        CONFIG.searchWord = self.isWholeWord
-        CONFIG.searchRegEx = self.isRegEx
-        CONFIG.searchLoop = self.doLoop
-        CONFIG.searchNextFile = self.doNextFile
-        CONFIG.searchMatchCap = self.doMatchCap
-
-        self.showReplace.setChecked(False)
-        self.setVisible(False)
-        self.docEditor.updateDocMargins()
-        self.docEditor.setFocus()
-
-        return
-
-    def cycleFocus(self, next: bool) -> bool:
+    def cycleFocus(self) -> bool:
         """The tab key just alternates focus between the two input
         boxes, if the replace box is visible.
         """
-        if self.replaceBox.isVisible():
-            if self.searchBox.hasFocus():
-                self.replaceBox.setFocus()
-                return True
-            elif self.replaceBox.hasFocus():
-                self.searchBox.setFocus()
-                return True
+        if self.searchBox.hasFocus():
+            self.replaceBox.setFocus()
+            return True
+        elif self.replaceBox.hasFocus():
+            self.searchBox.setFocus()
+            return True
         return False
 
     def anyFocus(self) -> bool:
         """Return True if any of the input boxes have focus."""
-        return self.searchBox.hasFocus() | self.replaceBox.hasFocus()
+        return self.searchBox.hasFocus() or self.replaceBox.hasFocus()
 
     ##
-    #  Private Slots
+    #  Public Slots
     ##
 
     @pyqtSlot()
-    def _doClose(self) -> None:
-        """Hide the search/replace bar."""
-        self.closeSearch()
+    def closeSearch(self) -> None:
+        """Close the search box."""
+        self.showReplace.setChecked(False)
+        self.setVisible(False)
+        self.docEditor.updateDocMargins()
+        self.docEditor.setFocus()
         return
 
+    ##
+    #  Private Slots
+    ##
+
     @pyqtSlot()
     def _doSearch(self) -> None:
         """Call the search action function for the document editor."""
-        self.docEditor.findNext(goBack=(
-            qApp.keyboardModifiers() == Qt.KeyboardModifier.ShiftModifier)
-        )
+        self.docEditor.findNext(goBack=(QApplication.keyboardModifiers() == QtModShift))
         return
 
     @pyqtSlot()
@@ -2733,13 +2696,8 @@ class GuiDocEditSearch(QFrame):
     @pyqtSlot(bool)
     def _doToggleReplace(self, state: bool) -> None:
         """Toggle the show/hide of the replace box."""
-        if state:
-            self.showReplace.setArrowType(Qt.ArrowType.DownArrow)
-        else:
-            self.showReplace.setArrowType(Qt.ArrowType.RightArrow)
         self.replaceBox.setVisible(state)
         self.replaceButton.setVisible(state)
-        self.repVisible = state
         self.adjustSize()
         self.docEditor.updateDocMargins()
         return
@@ -2747,37 +2705,37 @@ class GuiDocEditSearch(QFrame):
     @pyqtSlot(bool)
     def _doToggleCase(self, state: bool) -> None:
         """Enable/disable case sensitive mode."""
-        self.isCaseSense = state
+        CONFIG.searchCase = state
         return
 
     @pyqtSlot(bool)
     def _doToggleWord(self, state: bool) -> None:
         """Enable/disable whole word search mode."""
-        self.isWholeWord = state
+        CONFIG.searchWord = state
         return
 
     @pyqtSlot(bool)
     def _doToggleRegEx(self, state: bool) -> None:
         """Enable/disable regular expression search mode."""
-        self.isRegEx = state
+        CONFIG.searchRegEx = state
         return
 
     @pyqtSlot(bool)
     def _doToggleLoop(self, state: bool) -> None:
         """Enable/disable looping the search."""
-        self.doLoop = state
+        CONFIG.searchLoop = state
         return
 
     @pyqtSlot(bool)
     def _doToggleProject(self, state: bool) -> None:
         """Enable/disable continuing search in next project file."""
-        self.doNextFile = state
+        CONFIG.searchNextFile = state
         return
 
     @pyqtSlot(bool)
     def _doToggleMatchCap(self, state: bool) -> None:
         """Enable/disable preserving capitalisation when replacing."""
-        self.doMatchCap = state
+        CONFIG.searchMatchCap = state
         return
 
     ##
@@ -2816,7 +2774,8 @@ class GuiDocEditHeader(QWidget):
         self._docHandle = None
         self._docOutline: dict[int, str] = {}
 
-        iPx = SHARED.theme.baseIconSize
+        iPx = SHARED.theme.baseIconHeight
+        iSz = SHARED.theme.baseIconSize
         mPx = CONFIG.pxInt(4)
 
         # Main Widget Settings
@@ -2828,7 +2787,7 @@ class GuiDocEditHeader(QWidget):
         self.itemTitle.setMargin(0)
         self.itemTitle.setContentsMargins(0, 0, 0, 0)
         self.itemTitle.setAutoFillBackground(True)
-        self.itemTitle.setAlignment(Qt.AlignmentFlag.AlignHCenter | Qt.AlignmentFlag.AlignTop)
+        self.itemTitle.setAlignment(QtAlignCenterTop)
         self.itemTitle.setFixedHeight(iPx)
 
         lblFont = self.itemTitle.font()
@@ -2839,27 +2798,27 @@ class GuiDocEditHeader(QWidget):
         self.outlineMenu = QMenu(self)
 
         # Buttons
-        self.tbButton = NIconToolButton(self, iPx)
+        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.outlineButton = NIconToolButton(self, iPx)
+        self.outlineButton = NIconToolButton(self, iSz)
         self.outlineButton.setVisible(False)
         self.outlineButton.setToolTip(self.tr("Outline"))
         self.outlineButton.setMenu(self.outlineMenu)
 
-        self.searchButton = NIconToolButton(self, iPx)
+        self.searchButton = NIconToolButton(self, iSz)
         self.searchButton.setVisible(False)
         self.searchButton.setToolTip(self.tr("Search"))
         self.searchButton.clicked.connect(self.docEditor.toggleSearch)
 
-        self.minmaxButton = NIconToolButton(self, iPx)
+        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.closeButton = NIconToolButton(self, iPx)
+        self.closeButton = NIconToolButton(self, iSz)
         self.closeButton.setVisible(False)
         self.closeButton.setToolTip(self.tr("Close"))
         self.closeButton.clicked.connect(self._closeDocument)
@@ -2928,11 +2887,11 @@ class GuiDocEditHeader(QWidget):
 
     def updateTheme(self) -> None:
         """Update theme elements."""
-        self.tbButton.setIcon(SHARED.theme.getIcon("menu"))
-        self.outlineButton.setIcon(SHARED.theme.getIcon("list"))
-        self.searchButton.setIcon(SHARED.theme.getIcon("search"))
-        self.minmaxButton.setIcon(SHARED.theme.getIcon("maximise"))
-        self.closeButton.setIcon(SHARED.theme.getIcon("close"))
+        self.tbButton.setThemeIcon("menu")
+        self.outlineButton.setThemeIcon("list")
+        self.searchButton.setThemeIcon("search")
+        self.minmaxButton.setThemeIcon("maximise")
+        self.closeButton.setThemeIcon("close")
 
         buttonStyle = SHARED.theme.getStyleSheet(STYLES_MIN_TOOLBUTTON)
         self.tbButton.setStyleSheet(buttonStyle)
@@ -3000,7 +2959,7 @@ class GuiDocEditHeader(QWidget):
     @pyqtSlot(bool)
     def _focusModeChanged(self, focusMode: bool) -> None:
         """Update minimise/maximise icon of the Focus Mode button."""
-        self.minmaxButton.setIcon(SHARED.theme.getIcon("minimise" if focusMode else "maximise"))
+        self.minmaxButton.setThemeIcon("minimise" if focusMode else "maximise")
         return
 
     ##
@@ -3011,7 +2970,7 @@ class GuiDocEditHeader(QWidget):
         """Capture a click on the title and ensure that the item is
         selected in the project tree.
         """
-        if event.button() == Qt.MouseButton.LeftButton:
+        if event.button() == QtMouseLeft:
             self.docEditor.requestProjectItemSelected.emit(self._docHandle or "", True)
         return
 
@@ -3033,7 +2992,7 @@ class GuiDocEditFooter(QWidget):
         self._tItem = None
         self._docHandle = None
 
-        iPx = round(0.9*SHARED.theme.baseIconSize)
+        iPx = round(0.9*SHARED.theme.baseIconHeight)
         fPx = int(0.9*SHARED.theme.fontPixelSize)
         mPx = CONFIG.pxInt(8)
         bSp = CONFIG.pxInt(4)
@@ -3051,28 +3010,26 @@ class GuiDocEditFooter(QWidget):
         self.setContentsMargins(0, 0, 0, 0)
         self.setAutoFillBackground(True)
 
-        alLeftTop = Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignTop
-
         # Status
         self.statusIcon = QLabel("", self)
         self.statusIcon.setContentsMargins(0, 0, 0, 0)
         self.statusIcon.setFixedHeight(iPx)
-        self.statusIcon.setAlignment(alLeftTop)
+        self.statusIcon.setAlignment(QtAlignLeftTop)
 
-        self.statusText = QLabel(self.tr("Status"))
+        self.statusText = QLabel(self.tr("Status"), self)
         self.statusText.setIndent(0)
         self.statusText.setMargin(0)
         self.statusText.setContentsMargins(0, 0, 0, 0)
         self.statusText.setAutoFillBackground(True)
         self.statusText.setFixedHeight(fPx)
-        self.statusText.setAlignment(alLeftTop)
+        self.statusText.setAlignment(QtAlignLeftTop)
         self.statusText.setFont(lblFont)
 
         # Lines
         self.linesIcon = QLabel("", self)
         self.linesIcon.setContentsMargins(0, 0, 0, 0)
         self.linesIcon.setFixedHeight(iPx)
-        self.linesIcon.setAlignment(alLeftTop)
+        self.linesIcon.setAlignment(QtAlignLeftTop)
 
         self.linesText = QLabel("", self)
         self.linesText.setIndent(0)
@@ -3080,14 +3037,14 @@ class GuiDocEditFooter(QWidget):
         self.linesText.setContentsMargins(0, 0, 0, 0)
         self.linesText.setAutoFillBackground(True)
         self.linesText.setFixedHeight(fPx)
-        self.linesText.setAlignment(alLeftTop)
+        self.linesText.setAlignment(QtAlignLeftTop)
         self.linesText.setFont(lblFont)
 
         # Words
         self.wordsIcon = QLabel("", self)
         self.wordsIcon.setContentsMargins(0, 0, 0, 0)
         self.wordsIcon.setFixedHeight(iPx)
-        self.wordsIcon.setAlignment(alLeftTop)
+        self.wordsIcon.setAlignment(QtAlignLeftTop)
 
         self.wordsText = QLabel("", self)
         self.wordsText.setIndent(0)
@@ -3095,7 +3052,7 @@ class GuiDocEditFooter(QWidget):
         self.wordsText.setContentsMargins(0, 0, 0, 0)
         self.wordsText.setAutoFillBackground(True)
         self.wordsText.setFixedHeight(fPx)
-        self.wordsText.setAlignment(alLeftTop)
+        self.wordsText.setAlignment(QtAlignLeftTop)
         self.wordsText.setFont(lblFont)
 
         # Assemble Layout
@@ -3134,7 +3091,7 @@ class GuiDocEditFooter(QWidget):
 
     def updateTheme(self) -> None:
         """Update theme elements."""
-        iPx = round(0.9*SHARED.theme.baseIconSize)
+        iPx = round(0.9*SHARED.theme.baseIconHeight)
         self.linesIcon.setPixmap(SHARED.theme.getPixmap("status_lines", (iPx, iPx)))
         self.wordsIcon.setPixmap(SHARED.theme.getPixmap("status_stats", (iPx, iPx)))
         self.matchColours()
@@ -3176,7 +3133,7 @@ class GuiDocEditFooter(QWidget):
             sIcon = QPixmap()
             sText = ""
         else:
-            iPx = round(0.9*SHARED.theme.baseIconSize)
+            iPx = round(0.9*SHARED.theme.baseIconHeight)
             status, icon = self._tItem.getImportStatus(incIcon=True)
             sIcon = icon.pixmap(iPx, iPx)
             sText = f"{status} / {self._tItem.describeMe()}"