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

novelwriter/gui/dochighlight.py

@@ -25,10 +25,11 @@ along with this program. If not, see <https://www.gnu.org/licenses/>.
 from __future__ import annotations
 
 import logging
+import re
 
 from time import time
 
-from PyQt5.QtCore import QRegularExpression, Qt
+from PyQt5.QtCore import Qt
 from PyQt5.QtGui import (
     QBrush, QColor, QFont, QSyntaxHighlighter, QTextBlockUserData,
     QTextCharFormat, QTextDocument
@@ -36,20 +37,17 @@ from PyQt5.QtGui import (
 
 from novelwriter import CONFIG, SHARED
 from novelwriter.common import checkInt
-from novelwriter.constants import nwHeaders, nwRegEx, nwUnicode
+from novelwriter.constants import nwStyles, nwUnicode
 from novelwriter.core.index import processComment
 from novelwriter.enum import nwComment
-from novelwriter.text.patterns import REGEX_PATTERNS
-from novelwriter.types import QRegExUnicode
+from novelwriter.text.patterns import REGEX_PATTERNS, DialogParser
 
 logger = logging.getLogger(__name__)
 
-SPELLRX = QRegularExpression(r"\b[^\s\-\+\/–—\[\]:]+\b")
-SPELLRX.setPatternOptions(QRegExUnicode)
-SPELLSC = QRegularExpression(nwRegEx.FMT_SC)
-SPELLSC.setPatternOptions(QRegExUnicode)
-SPELLSV = QRegularExpression(nwRegEx.FMT_SV)
-SPELLSV.setPatternOptions(QRegExUnicode)
+RX_URL = REGEX_PATTERNS.url
+RX_WORDS = REGEX_PATTERNS.wordSplit
+RX_FMT_SC = REGEX_PATTERNS.shortcodePlain
+RX_FMT_SV = REGEX_PATTERNS.shortcodeValue
 
 BLOCK_NONE  = 0
 BLOCK_TEXT  = 1
@@ -61,7 +59,7 @@ class GuiDocHighlighter(QSyntaxHighlighter):
 
     __slots__ = (
         "_tHandle", "_isNovel", "_isInactive", "_spellCheck", "_spellErr",
-        "_hStyles", "_minRules", "_txtRules", "_cmnRules",
+        "_hStyles", "_minRules", "_txtRules", "_cmnRules", "_dialogParser",
     )
 
     def __init__(self, document: QTextDocument) -> None:
@@ -76,9 +74,11 @@ class GuiDocHighlighter(QSyntaxHighlighter):
         self._spellErr = QTextCharFormat()
 
         self._hStyles: dict[str, QTextCharFormat] = {}
-        self._minRules: list[tuple[QRegularExpression, dict[int, QTextCharFormat]]] = []
-        self._txtRules: list[tuple[QRegularExpression, dict[int, QTextCharFormat]]] = []
-        self._cmnRules: list[tuple[QRegularExpression, dict[int, QTextCharFormat]]] = []
+        self._minRules: list[tuple[re.Pattern, dict[int, QTextCharFormat]]] = []
+        self._txtRules: list[tuple[re.Pattern, dict[int, QTextCharFormat]]] = []
+        self._cmnRules: list[tuple[re.Pattern, dict[int, QTextCharFormat]]] = []
+
+        self._dialogParser = DialogParser()
 
         self.initHighlighter()
 
@@ -98,14 +98,14 @@ class GuiDocHighlighter(QSyntaxHighlighter):
 
         # Create Character Formats
         self._addCharFormat("text",      SHARED.theme.colText)
-        self._addCharFormat("header1",   SHARED.theme.colHead, "b", nwHeaders.H_SIZES[1])
-        self._addCharFormat("header2",   SHARED.theme.colHead, "b", nwHeaders.H_SIZES[2])
-        self._addCharFormat("header3",   SHARED.theme.colHead, "b", nwHeaders.H_SIZES[3])
-        self._addCharFormat("header4",   SHARED.theme.colHead, "b", nwHeaders.H_SIZES[4])
-        self._addCharFormat("head1h",    SHARED.theme.colHeadH, "b", nwHeaders.H_SIZES[1])
-        self._addCharFormat("head2h",    SHARED.theme.colHeadH, "b", nwHeaders.H_SIZES[2])
-        self._addCharFormat("head3h",    SHARED.theme.colHeadH, "b", nwHeaders.H_SIZES[3])
-        self._addCharFormat("head4h",    SHARED.theme.colHeadH, "b", nwHeaders.H_SIZES[4])
+        self._addCharFormat("header1",   SHARED.theme.colHead, "b", nwStyles.H_SIZES[1])
+        self._addCharFormat("header2",   SHARED.theme.colHead, "b", nwStyles.H_SIZES[2])
+        self._addCharFormat("header3",   SHARED.theme.colHead, "b", nwStyles.H_SIZES[3])
+        self._addCharFormat("header4",   SHARED.theme.colHead, "b", nwStyles.H_SIZES[4])
+        self._addCharFormat("head1h",    SHARED.theme.colHeadH, "b", nwStyles.H_SIZES[1])
+        self._addCharFormat("head2h",    SHARED.theme.colHeadH, "b", nwStyles.H_SIZES[2])
+        self._addCharFormat("head3h",    SHARED.theme.colHeadH, "b", nwStyles.H_SIZES[3])
+        self._addCharFormat("head4h",    SHARED.theme.colHeadH, "b", nwStyles.H_SIZES[4])
         self._addCharFormat("bold",      colEmph, "b")
         self._addCharFormat("italic",    colEmph, "i")
         self._addCharFormat("strike",    SHARED.theme.colHidden, "s")
@@ -116,10 +116,11 @@ class GuiDocHighlighter(QSyntaxHighlighter):
         self._addCharFormat("replace",   SHARED.theme.colRepTag)
         self._addCharFormat("hidden",    SHARED.theme.colHidden)
         self._addCharFormat("markup",    SHARED.theme.colHidden)
+        self._addCharFormat("link",      SHARED.theme.colLink, "u")
         self._addCharFormat("note",      SHARED.theme.colNote)
         self._addCharFormat("code",      SHARED.theme.colCode)
         self._addCharFormat("keyword",   SHARED.theme.colKey)
-        self._addCharFormat("tag",       SHARED.theme.colTag)
+        self._addCharFormat("tag",       SHARED.theme.colTag, "u")
         self._addCharFormat("modifier",  SHARED.theme.colMod)
         self._addCharFormat("value",     SHARED.theme.colVal)
         self._addCharFormat("optional",  SHARED.theme.colOpt)
@@ -133,10 +134,11 @@ class GuiDocHighlighter(QSyntaxHighlighter):
         self._txtRules.clear()
         self._cmnRules.clear()
 
+        self._dialogParser.initParser()
+
         # Multiple or Trailing Spaces
         if CONFIG.showMultiSpaces:
-            rxRule = QRegularExpression(r"[ ]{2,}|[ ]*$")
-            rxRule.setPatternOptions(QRegExUnicode)
+            rxRule = re.compile(r"[ ]{2,}|[ ]*$", re.UNICODE)
             hlRule = {
                 0: self._hStyles["mspaces"],
             }
@@ -145,8 +147,7 @@ class GuiDocHighlighter(QSyntaxHighlighter):
             self._cmnRules.append((rxRule, hlRule))
 
         # Non-Breaking Spaces
-        rxRule = QRegularExpression(f"[{nwUnicode.U_NBSP}{nwUnicode.U_THNBSP}]+")
-        rxRule.setPatternOptions(QRegExUnicode)
+        rxRule = re.compile(f"[{nwUnicode.U_NBSP}{nwUnicode.U_THNBSP}]+", re.UNICODE)
         hlRule = {
             0: self._hStyles["nobreak"],
         }
@@ -154,30 +155,8 @@ class GuiDocHighlighter(QSyntaxHighlighter):
         self._txtRules.append((rxRule, hlRule))
         self._cmnRules.append((rxRule, hlRule))
 
-        # Dialogue
-        if CONFIG.dialogStyle > 0:
-            rxRule = REGEX_PATTERNS.dialogStyle
-            hlRule = {
-                0: self._hStyles["dialog"],
-            }
-            self._txtRules.append((rxRule, hlRule))
-
-        if CONFIG.dialogLine:
-            rxRule = REGEX_PATTERNS.dialogLine
-            hlRule = {
-                0: self._hStyles["dialog"],
-            }
-            self._txtRules.append((rxRule, hlRule))
-
-        if CONFIG.narratorBreak:
-            rxRule = REGEX_PATTERNS.narratorBreak
-            hlRule = {
-                0: self._hStyles["text"],
-            }
-            self._txtRules.append((rxRule, hlRule))
-
-        if CONFIG.altDialogOpen and CONFIG.altDialogClose:
-            rxRule = REGEX_PATTERNS.altDialogStyle
+        # Alt Dialogue
+        if rxRule := REGEX_PATTERNS.altDialogStyle:
             hlRule = {
                 0: self._hStyles["altdialog"],
             }
@@ -236,9 +215,17 @@ class GuiDocHighlighter(QSyntaxHighlighter):
         self._txtRules.append((rxRule, hlRule))
         self._cmnRules.append((rxRule, hlRule))
 
+        # URLs
+        rxRule = REGEX_PATTERNS.url
+        hlRule = {
+            0: self._hStyles["link"],
+        }
+        self._minRules.append((rxRule, hlRule))
+        self._txtRules.append((rxRule, hlRule))
+        self._cmnRules.append((rxRule, hlRule))
+
         # Alignment Tags
-        rxRule = QRegularExpression(r"(^>{1,2}|<{1,2}$)")
-        rxRule.setPatternOptions(QRegExUnicode)
+        rxRule = re.compile(r"(^>{1,2}|<{1,2}$)", re.UNICODE)
         hlRule = {
             1: self._hStyles["markup"],
         }
@@ -246,8 +233,7 @@ class GuiDocHighlighter(QSyntaxHighlighter):
         self._txtRules.append((rxRule, hlRule))
 
         # Auto-Replace Tags
-        rxRule = QRegularExpression(r"<(\S+?)>")
-        rxRule.setPatternOptions(QRegExUnicode)
+        rxRule = re.compile(r"<(\S+?)>", re.UNICODE)
         hlRule = {
             0: self._hStyles["replace"],
         }
@@ -406,15 +392,17 @@ class GuiDocHighlighter(QSyntaxHighlighter):
         else:  # Text Paragraph
             self.setCurrentBlockState(BLOCK_TEXT)
             hRules = self._txtRules if self._isNovel else self._minRules
+            if self._dialogParser.enabled:
+                for pos, end in self._dialogParser(text):
+                    length = end - pos
+                    self.setFormat(pos, length, self._hStyles["dialog"])
 
         if hRules:
             for rX, hRule in hRules:
-                rxItt = rX.globalMatch(text, xOff)
-                while rxItt.hasNext():
-                    rxMatch = rxItt.next()
+                for res in re.finditer(rX, text[xOff:]):
                     for xM, hFmt in hRule.items():
-                        xPos = rxMatch.capturedStart(xM)
-                        xEnd = rxMatch.capturedEnd(xM)
+                        xPos = res.start(xM) + xOff
+                        xEnd = res.end(xM) + xOff
                         for x in range(xPos, xEnd):
                             cFmt = self.format(x)
                             if cFmt.fontStyleName() != "markup":
@@ -426,9 +414,10 @@ class GuiDocHighlighter(QSyntaxHighlighter):
             data = TextBlockData()
             self.setCurrentBlockUserData(data)
 
+        data.processText(text, xOff)
         if self._spellCheck:
-            for xPos, xLen in data.spellCheck(text, xOff):
-                for x in range(xPos, xPos+xLen):
+            for xPos, xEnd in data.spellCheck():
+                for x in range(xPos, xEnd):
                     cFmt = self.format(x)
                     cFmt.merge(self._spellErr)
                     self.setFormat(x, 1, cFmt)
@@ -456,6 +445,8 @@ class GuiDocHighlighter(QSyntaxHighlighter):
                 charFormat.setFontWeight(QFont.Weight.Bold)
             if "i" in styles:
                 charFormat.setFontItalic(True)
+            if "u" in styles:
+                charFormat.setFontUnderline(True)
             if "s" in styles:
                 charFormat.setFontStrikeOut(True)
             if "err" in styles:
@@ -474,40 +465,61 @@ class GuiDocHighlighter(QSyntaxHighlighter):
 
 class TextBlockData(QTextBlockUserData):
 
-    __slots__ = ("_spellErrors")
+    __slots__ = ("_text", "_offset", "_metaData", "_spellErrors")
 
     def __init__(self) -> None:
         super().__init__()
-        self._spellErrors: list[tuple[int, int]] = []
+        self._text = ""
+        self._offset = 0
+        self._metaData: list[tuple[int, int, str, str]] = []
+        self._spellErrors: list[tuple[int, int,]] = []
         return
 
+    @property
+    def metaData(self) -> list[tuple[int, int, str, str]]:
+        """Return meta data from last check."""
+        return self._metaData
+
     @property
     def spellErrors(self) -> list[tuple[int, int]]:
         """Return spell error data from last check."""
         return self._spellErrors
 
-    def spellCheck(self, text: str, offset: int) -> list[tuple[int, int]]:
-        """Run the spell checker and cache the result, and return the
-        list of spell check errors.
-        """
+    def processText(self, text: str, offset: int) -> None:
+        """Extract meta data from the text."""
+        self._metaData = []
         if "[" in text:
             # Strip shortcodes
-            for rX in [SPELLSC, SPELLSV]:
-                rxItt = rX.globalMatch(text, offset)
-                while rxItt.hasNext():
-                    rxMatch = rxItt.next()
-                    xPos = rxMatch.capturedStart(0)
-                    xLen = rxMatch.capturedLength(0)
-                    xEnd = rxMatch.capturedEnd(0)
-                    text = text[:xPos] + " "*xLen + text[xEnd:]
+            for regEx in [RX_FMT_SC, RX_FMT_SV]:
+                for res in regEx.finditer(text, offset):
+                    if (s := res.start(0)) >= 0 and (e := res.end(0)) >= 0:
+                        pad = " "*(e - s)
+                        text = f"{text[:s]}{pad}{text[e:]}"
+
+        if "http" in text:
+            # Strip URLs
+            for res in RX_URL.finditer(text, offset):
+                if (s := res.start(0)) >= 0 and (e := res.end(0)) >= 0:
+                    pad = " "*(e - s)
+                    text = f"{text[:s]}{pad}{text[e:]}"
+                    self._metaData.append((s, e, res.group(0), "url"))
+
+        self._text = text
+        self._offset = offset
+
+        return
 
+    def spellCheck(self) -> list[tuple[int, int]]:
+        """Run the spell checker and cache the result, and return the
+        list of spell check errors.
+        """
         self._spellErrors = []
-        rxSpell = SPELLRX.globalMatch(text.replace("_", " "), offset)
-        while rxSpell.hasNext():
-            rxMatch = rxSpell.next()
-            if not SHARED.spelling.checkWord(rxMatch.captured(0)):
-                if not rxMatch.captured(0).isnumeric() and not rxMatch.captured(0).isupper():
-                    self._spellErrors.append(
-                        (rxMatch.capturedStart(0), rxMatch.capturedLength(0))
-                    )
+        checker = SHARED.spelling
+        for res in RX_WORDS.finditer(self._text.replace("_", " "), self._offset):
+            if (
+                (word := res.group(0))
+                and not (word.isnumeric() or word.isupper() or checker.checkWord(word))
+            ):
+                self._spellErrors.append((res.start(0), res.end(0)))
+
         return self._spellErrors

novelwriter/gui/docviewer.py

@@ -31,34 +31,43 @@ import logging
 from enum import Enum
 
 from PyQt5.QtCore import QPoint, Qt, QUrl, pyqtSignal, pyqtSlot
-from PyQt5.QtGui import QCursor, QMouseEvent, QPalette, QResizeEvent, QTextCursor
+from PyQt5.QtGui import (
+    QCursor, QDesktopServices, QDragEnterEvent, QDragMoveEvent, QDropEvent,
+    QMouseEvent, QPalette, QResizeEvent, QTextCursor
+)
 from PyQt5.QtWidgets import (
     QAction, QApplication, QFrame, QHBoxLayout, QMenu, QTextBrowser,
     QToolButton, QWidget
 )
 
 from novelwriter import CONFIG, SHARED
-from novelwriter.constants import nwHeaders, nwUnicode
-from novelwriter.core.toqdoc import TextDocumentTheme, ToQTextDocument
-from novelwriter.enum import nwDocAction, nwDocMode, nwItemType
+from novelwriter.common import decodeMimeHandles, qtLambda
+from novelwriter.constants import nwConst, nwStyles, nwUnicode
+from novelwriter.enum import nwChange, nwDocAction, nwDocMode, nwItemType
 from novelwriter.error import logException
 from novelwriter.extensions.configlayout import NColourLabel
 from novelwriter.extensions.eventfilters import WheelEventFilter
 from novelwriter.extensions.modified import NIconToolButton
+from novelwriter.formats.shared import TextDocumentTheme
+from novelwriter.formats.toqdoc import ToQTextDocument
 from novelwriter.gui.theme import STYLES_MIN_TOOLBUTTON
-from novelwriter.types import QtAlignCenterTop, QtKeepAnchor, QtMouseLeft, QtMoveAnchor
+from novelwriter.types import (
+    QtAlignCenterTop, QtKeepAnchor, QtMouseLeft, QtMoveAnchor,
+    QtScrollAlwaysOff, QtScrollAsNeeded
+)
 
 logger = logging.getLogger(__name__)
 
 
 class GuiDocViewer(QTextBrowser):
 
+    closeDocumentRequest = pyqtSignal()
     documentLoaded = pyqtSignal(str)
     loadDocumentTagRequest = pyqtSignal(str, Enum)
-    closeDocumentRequest = pyqtSignal()
+    openDocumentRequest = pyqtSignal(str, Enum, str, bool)
     reloadDocumentRequest = pyqtSignal()
-    togglePanelVisibility = pyqtSignal()
     requestProjectItemSelected = pyqtSignal(str, bool)
+    togglePanelVisibility = pyqtSignal()
 
     def __init__(self, parent: QWidget) -> None:
         super().__init__(parent=parent)
@@ -72,6 +81,7 @@ class GuiDocViewer(QTextBrowser):
         # Settings
         self.setMinimumWidth(CONFIG.pxInt(300))
         self.setAutoFillBackground(True)
+        self.setOpenLinks(False)
         self.setOpenExternalLinks(False)
         self.setFocusPolicy(Qt.FocusPolicy.StrongFocus)
         self.setFrameStyle(QFrame.Shape.NoFrame)
@@ -162,6 +172,7 @@ class GuiDocViewer(QTextBrowser):
         self._docTheme.text      = SHARED.theme.colText
         self._docTheme.highlight = SHARED.theme.colMark
         self._docTheme.head      = SHARED.theme.colHead
+        self._docTheme.link      = SHARED.theme.colLink
         self._docTheme.comment   = SHARED.theme.colHidden
         self._docTheme.note      = SHARED.theme.colNote
         self._docTheme.code      = SHARED.theme.colCode
@@ -177,14 +188,14 @@ class GuiDocViewer(QTextBrowser):
 
         # Scroll bars
         if CONFIG.hideVScroll:
-            self.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
+            self.setVerticalScrollBarPolicy(QtScrollAlwaysOff)
         else:
-            self.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAsNeeded)
+            self.setVerticalScrollBarPolicy(QtScrollAsNeeded)
 
         if CONFIG.hideHScroll:
-            self.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
+            self.setHorizontalScrollBarPolicy(QtScrollAlwaysOff)
         else:
-            self.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAsNeeded)
+            self.setHorizontalScrollBarPolicy(QtScrollAsNeeded)
 
         # Refresh the tab stops
         self.setTabStopDistance(CONFIG.getTabWidth())
@@ -207,8 +218,10 @@ class GuiDocViewer(QTextBrowser):
         sPos = self.verticalScrollBar().value()
         qDoc = ToQTextDocument(SHARED.project)
         qDoc.setJustify(CONFIG.doJustify)
-        qDoc.setDialogueHighlight(True)
-        qDoc.initDocument(CONFIG.textFont, self._docTheme)
+        qDoc.setDialogHighlight(True)
+        qDoc.setTextFont(CONFIG.textFont)
+        qDoc.setTheme(self._docTheme)
+        qDoc.initDocument()
         qDoc.setKeywords(True)
         qDoc.setComments(CONFIG.viewComments)
         qDoc.setSynopsis(CONFIG.viewSynopsis)
@@ -221,7 +234,7 @@ class GuiDocViewer(QTextBrowser):
             qDoc.doPreProcessing()
             qDoc.tokenizeText()
             qDoc.doConvert()
-            qDoc.appendFootnotes()
+            qDoc.closeDocument()
         except Exception:
             logger.error("Failed to generate preview for document with handle '%s'", tHandle)
             logException()
@@ -245,7 +258,7 @@ class GuiDocViewer(QTextBrowser):
         SHARED.project.data.setLastHandle(tHandle, "viewer")
         self.docHeader.setHandle(tHandle)
         self.docHeader.setOutline({
-            sTitle: (hItem.title, nwHeaders.H_LEVEL.get(hItem.level, 0))
+            sTitle: (hItem.title, nwStyles.H_LEVEL.get(hItem.level, 0))
             for sTitle, hItem in SHARED.project.index.iterItemHeadings(tHandle)
         })
         self.updateDocMargins()
@@ -333,10 +346,10 @@ class GuiDocViewer(QTextBrowser):
     #  Public Slots
     ##
 
-    @pyqtSlot(str)
-    def updateDocInfo(self, tHandle: str) -> None:
+    @pyqtSlot(str, Enum)
+    def onProjectItemChanged(self, tHandle: str, change: nwChange) -> None:
         """Update the header title bar if needed."""
-        if tHandle and tHandle == self._docHandle:
+        if tHandle == self._docHandle and change == nwChange.UPDATE:
             self.docHeader.setHandle(tHandle)
             self.updateDocMargins()
         return
@@ -372,8 +385,10 @@ class GuiDocViewer(QTextBrowser):
             logger.debug("Clicked link: '%s'", link)
             if (bits := link.partition("_")) and bits[0] == "#tag" and bits[2]:
                 self.loadDocumentTagRequest.emit(bits[2], nwDocMode.VIEW)
-            else:
+            elif link.startswith("#"):
                 self.navigateTo(link)
+            elif link.startswith("http"):
+                QDesktopServices.openUrl(QUrl(url))
         return
 
     @pyqtSlot("QPoint")
@@ -386,25 +401,25 @@ class GuiDocViewer(QTextBrowser):
 
         if userSelection:
             mnuCopy = QAction(self.tr("Copy"), ctxMenu)
-            mnuCopy.triggered.connect(lambda: self.docAction(nwDocAction.COPY))
+            mnuCopy.triggered.connect(qtLambda(self.docAction, nwDocAction.COPY))
             ctxMenu.addAction(mnuCopy)
 
             ctxMenu.addSeparator()
 
         mnuSelAll = QAction(self.tr("Select All"), ctxMenu)
-        mnuSelAll.triggered.connect(lambda: self.docAction(nwDocAction.SEL_ALL))
+        mnuSelAll.triggered.connect(qtLambda(self.docAction, nwDocAction.SEL_ALL))
         ctxMenu.addAction(mnuSelAll)
 
         mnuSelWord = QAction(self.tr("Select Word"), ctxMenu)
-        mnuSelWord.triggered.connect(
-            lambda: self._makePosSelection(QTextCursor.SelectionType.WordUnderCursor, point)
-        )
+        mnuSelWord.triggered.connect(qtLambda(
+            self._makePosSelection, QTextCursor.SelectionType.WordUnderCursor, point
+        ))
         ctxMenu.addAction(mnuSelWord)
 
         mnuSelPara = QAction(self.tr("Select Paragraph"), ctxMenu)
-        mnuSelPara.triggered.connect(
-            lambda: self._makePosSelection(QTextCursor.SelectionType.BlockUnderCursor, point)
-        )
+        mnuSelPara.triggered.connect(qtLambda(
+            self._makePosSelection, QTextCursor.SelectionType.BlockUnderCursor, point
+        ))
         ctxMenu.addAction(mnuSelPara)
 
         # Open the context menu
@@ -433,6 +448,32 @@ class GuiDocViewer(QTextBrowser):
             super().mouseReleaseEvent(event)
         return
 
+    def dragEnterEvent(self, event: QDragEnterEvent) -> None:
+        """Overload drag enter event to handle dragged items."""
+        if event.mimeData().hasFormat(nwConst.MIME_HANDLE):
+            event.acceptProposedAction()
+        else:
+            super().dragEnterEvent(event)
+        return
+
+    def dragMoveEvent(self, event: QDragMoveEvent) -> None:
+        """Overload drag move event to handle dragged items."""
+        if event.mimeData().hasFormat(nwConst.MIME_HANDLE):
+            event.acceptProposedAction()
+        else:
+            super().dragMoveEvent(event)
+        return
+
+    def dropEvent(self, event: QDropEvent) -> None:
+        """Overload drop event to handle dragged items."""
+        if event.mimeData().hasFormat(nwConst.MIME_HANDLE):
+            if handles := decodeMimeHandles(event.mimeData()):
+                if SHARED.project.tree.checkType(handles[0], nwItemType.FILE):
+                    self.openDocumentRequest.emit(handles[0], nwDocMode.VIEW, "", True)
+        else:
+            super().dropEvent(event)
+        return
+
     ##
     #  Internal Functions
     ##
@@ -629,6 +670,11 @@ class GuiDocViewHeader(QWidget):
         self.forwardButton.setToolTip(self.tr("Go Forward"))
         self.forwardButton.clicked.connect(self.docViewer.navForward)
 
+        self.editButton = NIconToolButton(self, iSz)
+        self.editButton.setVisible(False)
+        self.editButton.setToolTip(self.tr("Open in Editor"))
+        self.editButton.clicked.connect(self._editDocument)
+
         self.refreshButton = NIconToolButton(self, iSz)
         self.refreshButton.setVisible(False)
         self.refreshButton.setToolTip(self.tr("Reload"))
@@ -647,7 +693,7 @@ class GuiDocViewHeader(QWidget):
         self.outerBox.addSpacing(mPx)
         self.outerBox.addWidget(self.itemTitle, 1)
         self.outerBox.addSpacing(mPx)
-        self.outerBox.addSpacing(iPx)
+        self.outerBox.addWidget(self.editButton, 0)
         self.outerBox.addWidget(self.refreshButton, 0)
         self.outerBox.addWidget(self.closeButton, 0)
         self.outerBox.setSpacing(0)
@@ -681,8 +727,9 @@ class GuiDocViewHeader(QWidget):
         self.outlineButton.setVisible(False)
         self.backButton.setVisible(False)
         self.forwardButton.setVisible(False)
-        self.closeButton.setVisible(False)
+        self.editButton.setVisible(False)
         self.refreshButton.setVisible(False)
+        self.closeButton.setVisible(False)
         return
 
     def setOutline(self, data: dict[str, tuple[str, int]]) -> None:
@@ -716,6 +763,7 @@ class GuiDocViewHeader(QWidget):
         self.outlineButton.setThemeIcon("list")
         self.backButton.setThemeIcon("backward")
         self.forwardButton.setThemeIcon("forward")
+        self.editButton.setThemeIcon("edit")
         self.refreshButton.setThemeIcon("refresh")
         self.closeButton.setThemeIcon("close")
 
@@ -723,6 +771,7 @@ class GuiDocViewHeader(QWidget):
         self.outlineButton.setStyleSheet(buttonStyle)
         self.backButton.setStyleSheet(buttonStyle)
         self.forwardButton.setStyleSheet(buttonStyle)
+        self.editButton.setStyleSheet(buttonStyle)
         self.refreshButton.setStyleSheet(buttonStyle)
         self.closeButton.setStyleSheet(buttonStyle)
 
@@ -757,7 +806,7 @@ class GuiDocViewHeader(QWidget):
 
         if CONFIG.showFullPath:
             self.itemTitle.setText(f"  {nwUnicode.U_RSAQUO}  ".join(reversed(
-                [name for name in SHARED.project.tree.getItemPath(tHandle, asName=True)]
+                [name for name in SHARED.project.tree.itemPath(tHandle, asName=True)]
             )))
         else:
             self.itemTitle.setText(i.itemName if (i := SHARED.project.tree[tHandle]) else "")
@@ -765,8 +814,9 @@ class GuiDocViewHeader(QWidget):
         self.backButton.setVisible(True)
         self.forwardButton.setVisible(True)
         self.outlineButton.setVisible(True)
-        self.closeButton.setVisible(True)
+        self.editButton.setVisible(True)
         self.refreshButton.setVisible(True)
+        self.closeButton.setVisible(True)
 
         return
 
@@ -793,6 +843,13 @@ class GuiDocViewHeader(QWidget):
         self.docViewer.reloadDocumentRequest.emit()
         return
 
+    @pyqtSlot()
+    def _editDocument(self) -> None:
+        """Open the document in the editor."""
+        if tHandle := self._docHandle:
+            self.docViewer.openDocumentRequest.emit(tHandle, nwDocMode.EDIT, "", True)
+        return
+
     ##
     #  Events
     ##