novelWriter 2.1.1__py3-none-any.whl → 2.2rc1__py3-none-any.whl

novelwriter/guimain.py

@@ -30,11 +30,11 @@ from time import time
 from pathlib import Path
 from datetime import datetime
 
-from PyQt5.QtCore import Qt, QTimer, QThreadPool, pyqtSlot
-from PyQt5.QtGui import QCloseEvent, QCursor, QIcon, QKeySequence
+from PyQt5.QtCore import Qt, QTimer, pyqtSlot
+from PyQt5.QtGui import QCloseEvent, QCursor, QIcon
 from PyQt5.QtWidgets import (
-    qApp, QDialog, QFileDialog, QMainWindow, QMessageBox, QShortcut, QSplitter,
-    QStackedWidget, QVBoxLayout, QWidget
+    QDialog, QFileDialog, QHBoxLayout, QMainWindow, QMessageBox, QShortcut,
+    QSplitter, QStackedWidget, QVBoxLayout, QWidget, qApp
 )
 
 from novelwriter import CONFIG, SHARED, __hexversion__
@@ -44,10 +44,11 @@ from novelwriter.gui.outline import GuiOutlineView
 from novelwriter.gui.mainmenu import GuiMainMenu
 from novelwriter.gui.projtree import GuiProjectView
 from novelwriter.gui.doceditor import GuiDocEditor
-from novelwriter.gui.docviewer import GuiDocViewDetails, GuiDocViewer
+from novelwriter.gui.docviewer import GuiDocViewer
 from novelwriter.gui.noveltree import GuiNovelView
 from novelwriter.gui.statusbar import GuiMainStatus
 from novelwriter.gui.itemdetails import GuiItemDetails
+from novelwriter.gui.docviewerpanel import GuiDocViewerPanel
 from novelwriter.dialogs.about import GuiAbout
 from novelwriter.dialogs.updates import GuiUpdates
 from novelwriter.dialogs.projload import GuiProjectLoad
@@ -58,11 +59,12 @@ from novelwriter.dialogs.projsettings import GuiProjectSettings
 from novelwriter.tools.lipsum import GuiLipsum
 from novelwriter.tools.manuscript import GuiManuscript
 from novelwriter.tools.projwizard import GuiProjectWizard
+from novelwriter.tools.dictionaries import GuiDictionaries
 from novelwriter.tools.writingstats import GuiWritingStats
 from novelwriter.core.coretools import ProjectBuilder
 
 from novelwriter.enum import (
-    nwDocAction, nwDocMode, nwItemType, nwItemClass, nwWidget, nwView
+    nwDocAction, nwDocInsert, nwDocMode, nwItemType, nwItemClass, nwWidget, nwView
 )
 from novelwriter.common import getGuiItem, hexToInt
 from novelwriter.constants import nwFiles
@@ -95,7 +97,6 @@ class GuiMain(QMainWindow):
 
         logger.debug("Create: GUI")
         self.setObjectName("GuiMain")
-        self.threadPool = QThreadPool()
 
         # System Info
         # ===========
@@ -134,25 +135,25 @@ class GuiMain(QMainWindow):
         hWd = CONFIG.pxInt(4)
 
         # Main GUI Elements
-        self.mainStatus  = GuiMainStatus(self)
-        self.projView    = GuiProjectView(self)
-        self.novelView   = GuiNovelView(self)
-        self.docEditor   = GuiDocEditor(self)
-        self.viewMeta    = GuiDocViewDetails(self)
-        self.docViewer   = GuiDocViewer(self)
-        self.itemDetails = GuiItemDetails(self)
-        self.outlineView = GuiOutlineView(self)
-        self.mainMenu    = GuiMainMenu(self)
-        self.viewsBar    = GuiSideBar(self)
+        self.mainStatus     = GuiMainStatus(self)
+        self.projView       = GuiProjectView(self)
+        self.novelView      = GuiNovelView(self)
+        self.docEditor      = GuiDocEditor(self)
+        self.docViewer      = GuiDocViewer(self)
+        self.docViewerPanel = GuiDocViewerPanel(self)
+        self.itemDetails    = GuiItemDetails(self)
+        self.outlineView    = GuiOutlineView(self)
+        self.mainMenu       = GuiMainMenu(self)
+        self.sideBar        = GuiSideBar(self)
 
         # Project Tree Stack
-        self.projStack = QStackedWidget()
+        self.projStack = QStackedWidget(self)
         self.projStack.addWidget(self.projView)
         self.projStack.addWidget(self.novelView)
         self.projStack.currentChanged.connect(self._projStackChanged)
 
         # Project Tree View
-        self.treePane = QWidget()
+        self.treePane = QWidget(self)
         self.treeBox = QVBoxLayout()
         self.treeBox.setContentsMargins(0, 0, 0, 0)
         self.treeBox.setSpacing(mPx)
@@ -161,15 +162,15 @@ class GuiMain(QMainWindow):
         self.treePane.setLayout(self.treeBox)
 
         # Splitter : Document Viewer / Document Meta
-        self.splitView = QSplitter(Qt.Vertical)
+        self.splitView = QSplitter(Qt.Vertical, self)
         self.splitView.addWidget(self.docViewer)
-        self.splitView.addWidget(self.viewMeta)
+        self.splitView.addWidget(self.docViewerPanel)
         self.splitView.setHandleWidth(hWd)
         self.splitView.setOpaqueResize(False)
         self.splitView.setSizes(CONFIG.viewPanePos)
 
         # Splitter : Document Editor / Document Viewer
-        self.splitDocs = QSplitter(Qt.Horizontal)
+        self.splitDocs = QSplitter(Qt.Horizontal, self)
         self.splitDocs.addWidget(self.docEditor)
         self.splitDocs.addWidget(self.splitView)
         self.splitDocs.setOpaqueResize(False)
@@ -185,18 +186,18 @@ class GuiMain(QMainWindow):
         self.splitMain.setSizes(CONFIG.mainPanePos)
 
         # Main Stack : Editor / Outline
-        self.mainStack = QStackedWidget()
+        self.mainStack = QStackedWidget(self)
         self.mainStack.addWidget(self.splitMain)
         self.mainStack.addWidget(self.outlineView)
         self.mainStack.currentChanged.connect(self._mainStackChanged)
 
         # Indices of Splitter Widgets
-        self.idxTree     = self.splitMain.indexOf(self.treePane)
-        self.idxMain     = self.splitMain.indexOf(self.splitDocs)
-        self.idxEditor   = self.splitDocs.indexOf(self.docEditor)
-        self.idxViewer   = self.splitDocs.indexOf(self.splitView)
-        self.idxViewDoc  = self.splitView.indexOf(self.docViewer)
-        self.idxViewMeta = self.splitView.indexOf(self.viewMeta)
+        self.idxTree         = self.splitMain.indexOf(self.treePane)
+        self.idxMain         = self.splitMain.indexOf(self.splitDocs)
+        self.idxEditor       = self.splitDocs.indexOf(self.docEditor)
+        self.idxViewer       = self.splitDocs.indexOf(self.splitView)
+        self.idxViewDoc      = self.splitView.indexOf(self.docViewer)
+        self.idxViewDocPanel = self.splitView.indexOf(self.docViewerPanel)
 
         # Indices of Stack Widgets
         self.idxEditorView  = self.mainStack.indexOf(self.splitMain)
@@ -210,7 +211,7 @@ class GuiMain(QMainWindow):
         self.splitDocs.setCollapsible(self.idxEditor, False)
         self.splitDocs.setCollapsible(self.idxViewer, False)
         self.splitView.setCollapsible(self.idxViewDoc, False)
-        self.splitView.setCollapsible(self.idxViewMeta, False)
+        self.splitView.setCollapsible(self.idxViewDocPanel, False)
 
         self.splitMain.setStretchFactor(self.idxTree, 0)
         self.splitMain.setStretchFactor(self.idxMain, 1)
@@ -222,11 +223,19 @@ class GuiMain(QMainWindow):
         # Initialise the Project Tree
         self.rebuildTrees()
 
-        # Set Main Window Elements
+        # Assemble Main Window Elements
+        self.mainBox = QHBoxLayout()
+        self.mainBox.addWidget(self.sideBar)
+        self.mainBox.addWidget(self.mainStack)
+        self.mainBox.setContentsMargins(0, 0, 0, 0)
+        self.mainBox.setSpacing(0)
+
+        self.mainWidget = QWidget(self)
+        self.mainWidget.setLayout(self.mainBox)
+
         self.setMenuBar(self.mainMenu)
-        self.setCentralWidget(self.mainStack)
+        self.setCentralWidget(self.mainWidget)
         self.setStatusBar(self.mainStatus)
-        self.addToolBar(Qt.LeftToolBarArea, self.viewsBar)
         self.setContextMenuPolicy(Qt.NoContextMenu)  # Issue #1147
 
         # Connect Signals
@@ -235,8 +244,20 @@ class GuiMain(QMainWindow):
         SHARED.projectStatusChanged.connect(self.mainStatus.updateProjectStatus)
         SHARED.projectStatusMessage.connect(self.mainStatus.setStatusMessage)
         SHARED.spellLanguageChanged.connect(self.mainStatus.setLanguage)
+        SHARED.indexChangedTags.connect(self.docViewerPanel.updateChangedTags)
+        SHARED.indexScannedText.connect(self.docViewerPanel.projectItemChanged)
+        SHARED.indexScannedText.connect(self.projView.updateItemValues)
+        SHARED.indexScannedText.connect(self.itemDetails.updateViewBox)
+        SHARED.indexCleared.connect(self.docViewerPanel.indexWasCleared)
+        SHARED.indexAvailable.connect(self.docViewerPanel.indexHasAppeared)
 
-        self.viewsBar.viewChangeRequested.connect(self._changeView)
+        self.mainMenu.requestDocAction.connect(self._passDocumentAction)
+        self.mainMenu.requestDocInsert.connect(self._passDocumentInsert)
+        self.mainMenu.requestDocInsertText.connect(self._passDocumentInsert)
+        self.mainMenu.requestDocKeyWordInsert.connect(self.docEditor.insertKeyWord)
+        self.mainMenu.requestFocusChange.connect(self.switchFocus)
+
+        self.sideBar.viewChangeRequested.connect(self._changeView)
 
         self.projView.selectedItemChanged.connect(self.itemDetails.updateViewBox)
         self.projView.openDocumentRequest.connect(self._openDocument)
@@ -244,6 +265,7 @@ class GuiMain(QMainWindow):
         self.projView.treeItemChanged.connect(self.docEditor.updateDocInfo)
         self.projView.treeItemChanged.connect(self.docViewer.updateDocInfo)
         self.projView.treeItemChanged.connect(self.itemDetails.updateViewBox)
+        self.projView.treeItemChanged.connect(self.docViewerPanel.projectItemChanged)
         self.projView.rootFolderChanged.connect(self.outlineView.updateRootItem)
         self.projView.rootFolderChanged.connect(self.novelView.updateRootItem)
         self.projView.rootFolderChanged.connect(self.projView.updateRootItem)
@@ -259,8 +281,19 @@ class GuiMain(QMainWindow):
         self.docEditor.novelStructureChanged.connect(self.novelView.refreshTree)
         self.docEditor.novelItemMetaChanged.connect(self.novelView.updateNovelItemMeta)
         self.docEditor.statusMessage.connect(self.mainStatus.setStatusMessage)
+        self.docEditor.spellCheckStateChanged.connect(self.mainMenu.setSpellCheckState)
+        self.docEditor.closeDocumentRequest.connect(self.closeDocEditor)
+        self.docEditor.toggleFocusModeRequest.connect(self.toggleFocusMode)
+        self.docEditor.requestProjectItemSelected.connect(self.projView.setSelectedHandle)
+        self.docEditor.requestProjectItemRenamed.connect(self.projView.renameTreeItem)
 
+        self.docViewer.documentLoaded.connect(self.docViewerPanel.updateHandle)
         self.docViewer.loadDocumentTagRequest.connect(self._followTag)
+        self.docViewer.togglePanelVisibility.connect(self._toggleViewerPanelVisibility)
+        self.docViewer.requestProjectItemSelected.connect(self.projView.setSelectedHandle)
+
+        self.docViewerPanel.loadDocumentTagRequest.connect(self._followTag)
+        self.docViewerPanel.openDocumentRequest.connect(self._openDocument)
 
         self.outlineView.loadDocumentTagRequest.connect(self._followTag)
         self.outlineView.openDocumentRequest.connect(self._openDocument)
@@ -269,15 +302,15 @@ class GuiMain(QMainWindow):
         # =======================
 
         # Set Up Auto-Save Project Timer
-        self.asProjTimer = QTimer()
+        self.asProjTimer = QTimer(self)
         self.asProjTimer.timeout.connect(self._autoSaveProject)
 
         # Set Up Auto-Save Document Timer
-        self.asDocTimer = QTimer()
+        self.asDocTimer = QTimer(self)
         self.asDocTimer.timeout.connect(self._autoSaveDocument)
 
         # Main Clock
-        self.mainTimer = QTimer()
+        self.mainTimer = QTimer(self)
         self.mainTimer.setInterval(1000)
         self.mainTimer.timeout.connect(self._timeTick)
         self.mainTimer.start()
@@ -285,17 +318,17 @@ class GuiMain(QMainWindow):
         # Shortcuts and Actions
         self._connectMenuActions()
 
-        keyReturn = QShortcut(self)
-        keyReturn.setKey(QKeySequence(Qt.Key_Return))
-        keyReturn.activated.connect(self._keyPressReturn)
+        self.keyReturn = QShortcut(self)
+        self.keyReturn.setKey(Qt.Key.Key_Return)
+        self.keyReturn.activated.connect(self._keyPressReturn)
 
-        keyEnter = QShortcut(self)
-        keyEnter.setKey(QKeySequence(Qt.Key_Enter))
-        keyEnter.activated.connect(self._keyPressReturn)
+        self.keyEnter = QShortcut(self)
+        self.keyEnter.setKey(Qt.Key.Key_Enter)
+        self.keyEnter.activated.connect(self._keyPressReturn)
 
-        keyEscape = QShortcut(self)
-        keyEscape.setKey(QKeySequence(Qt.Key_Escape))
-        keyEscape.activated.connect(self._keyPressEscape)
+        self.keyEscape = QShortcut(self)
+        self.keyEscape.setKey(Qt.Key.Key_Escape)
+        self.keyEscape.activated.connect(self._keyPressEscape)
 
         # Check that config loaded fine
         self.reportConfErr()
@@ -311,12 +344,12 @@ class GuiMain(QMainWindow):
 
         logger.debug("Ready: GUI")
 
-        if __hexversion__[-2] == "a" and logger.getEffectiveLevel() > logging.DEBUG:
-            SHARED.warn(self.tr(
+        if __hexversion__[-2] == "a" and not CONFIG.isDebug:
+            SHARED.warn(
                 "You are running an untested development version of novelWriter. "
-                "Please be careful when working on a live project "
+                "Please be careful when you are working on live projects "
                 "and make sure you take regular backups."
-            ))
+            )
 
         logger.info("novelWriter is ready ...")
         self.mainStatus.setStatusMessage(self.tr("novelWriter is ready ..."))
@@ -332,6 +365,7 @@ class GuiMain(QMainWindow):
     def postLaunchTasks(self, cmdOpen: str | None) -> None:
         """Process tasks after the main window has been created."""
         if cmdOpen:
+            qApp.processEvents()
             logger.info("Command line path: %s", cmdOpen)
             self.openProject(cmdOpen)
 
@@ -420,6 +454,7 @@ class GuiMain(QMainWindow):
             self.docViewer.clearNavHistory()
             self.closeDocViewer(byUser=False)
 
+            self.docViewerPanel.closeProjectTasks()
             self.outlineView.closeProjectTasks()
             self.novelView.closeProjectTasks()
             self.projView.clearProjectView()
@@ -493,6 +528,7 @@ class GuiMain(QMainWindow):
         self.projView.openProjectTasks()
         self.novelView.openProjectTasks()
         self.outlineView.openProjectTasks()
+        self.docViewerPanel.openProjectTasks()
         self._updateStatusWordCount()
 
         # Restore previously open documents, if any
@@ -505,10 +541,12 @@ class GuiMain(QMainWindow):
                     break
 
         if lastEdited is not None:
+            qApp.processEvents()
             self.openDocument(lastEdited, doScroll=True)
 
         lastViewed = SHARED.project.data.getLastHandle("viewer")
         if lastViewed is not None:
+            qApp.processEvents()
             self.viewDocument(lastViewed)
 
         # Check if we need to rebuild the index
@@ -610,10 +648,10 @@ class GuiMain(QMainWindow):
                 break
 
         if nHandle is not None:
-            self.openDocument(nHandle, tLine=0, doScroll=True)
+            self.openDocument(nHandle, tLine=1, doScroll=True)
             return True
         elif wrapAround:
-            self.openDocument(fHandle, tLine=0, doScroll=True)
+            self.openDocument(fHandle, tLine=1, doScroll=True)
             return False
 
         return False
@@ -656,13 +694,19 @@ class GuiMain(QMainWindow):
         logger.debug("Viewing document with handle '%s'", tHandle)
         if self.docViewer.loadText(tHandle):
             if not self.splitView.isVisible():
+                cursorVisible = self.docEditor.cursorIsVisible()
                 bPos = self.splitMain.sizes()
                 self.splitView.setVisible(True)
                 vPos = [0, 0]
                 vPos[0] = int(bPos[1]/2)
                 vPos[1] = bPos[1] - vPos[0]
                 self.splitDocs.setSizes(vPos)
-                self.viewMeta.setVisible(CONFIG.showRefPanel)
+                self.docViewerPanel.setVisible(CONFIG.showViewerPanel)
+
+                # Since editor width changes, we need to make sure we
+                # restore cursor visibility in the editor. See #1302
+                if cursorVisible:
+                    self.docEditor.ensureCursorVisibleNoCentre()
 
             if sTitle:
                 self.docViewer.navigateTo(f"#{sTitle}")
@@ -722,20 +766,6 @@ class GuiMain(QMainWindow):
 
         return True
 
-    def passDocumentAction(self, action: nwDocAction) -> None:
-        """Pass on document action to the document viewer if it has
-        focus, or pass it to the document editor if it or any of
-        its child widgets have focus. If neither has focus, ignore the
-        action.
-        """
-        if self.docViewer.hasFocus():
-            self.docViewer.docAction(action)
-        elif self.docEditor.hasFocus():
-            self.docEditor.docAction(action)
-        else:
-            logger.debug("Action cancelled as neither editor nor viewer has focus")
-        return
-
     ##
     #  Tree Item Actions
     ##
@@ -777,11 +807,9 @@ class GuiMain(QMainWindow):
         if not SHARED.hasProject:
             logger.error("No project open")
             return False
-
         if tHandle is None and (self.docEditor.anyFocus() or self.isFocusMode):
             tHandle = self.docEditor.docHandle
         self.projView.renameTreeItem(tHandle)
-
         return True
 
     def rebuildTrees(self) -> None:
@@ -872,7 +900,8 @@ class GuiMain(QMainWindow):
                 SHARED.theme.loadTheme()
                 self.docEditor.updateTheme()
                 self.docViewer.updateTheme()
-                self.viewsBar.updateTheme()
+                self.docViewerPanel.updateTheme()
+                self.sideBar.updateTheme()
                 self.projView.updateTheme()
                 self.novelView.updateTheme()
                 self.outlineView.updateTheme()
@@ -1023,7 +1052,7 @@ class GuiMain(QMainWindow):
 
     def showAboutQtDialog(self) -> None:
         """Show the about dialog for Qt."""
-        msgBox = QMessageBox()
+        msgBox = QMessageBox(self)
         msgBox.aboutQt(self, "About Qt")
         return
 
@@ -1042,6 +1071,20 @@ class GuiMain(QMainWindow):
 
         return
 
+    @pyqtSlot()
+    def showDictionariesDialog(self) -> None:
+        """Show the download dictionaries dialog."""
+        dlgDicts = GuiDictionaries(self)
+        dlgDicts.setModal(True)
+        dlgDicts.show()
+        dlgDicts.raise_()
+        qApp.processEvents()
+        if not dlgDicts.initDialog():
+            dlgDicts.close()
+            SHARED.error(self.tr("Could not initialise the dialog."))
+
+        return
+
     def reportConfErr(self) -> bool:
         """Checks if the Config module has any errors to report, and let
         the user know if this is the case. The Config module caches
@@ -1071,10 +1114,10 @@ class GuiMain(QMainWindow):
         if not self.isFocusMode:
             CONFIG.setMainPanePos(self.splitMain.sizes())
             CONFIG.setOutlinePanePos(self.outlineView.splitSizes())
-            if self.viewMeta.isVisible():
+            if self.docViewerPanel.isVisible():
                 CONFIG.setViewPanePos(self.splitView.sizes())
 
-        CONFIG.showRefPanel = self.viewMeta.isVisible()
+        CONFIG.showViewerPanel = self.docViewerPanel.isVisible()
         if self.windowState() & Qt.WindowFullScreen != Qt.WindowFullScreen:
             # Ignore window size if in full screen mode
             CONFIG.setMainWinSize(self.width(), self.height())
@@ -1089,31 +1132,6 @@ class GuiMain(QMainWindow):
 
         return True
 
-    def switchFocus(self, paneNo: nwWidget) -> None:
-        """Switch focus between main GUI views."""
-        if paneNo == nwWidget.TREE:
-            tabIdx = self.projStack.currentIndex()
-            if tabIdx == self.idxProjView:
-                self.projView.setFocus()
-            elif tabIdx == self.idxNovelView:
-                self.novelView.setTreeFocus()
-        elif paneNo == nwWidget.EDITOR:
-            self._changeView(nwView.EDITOR)
-            self.docEditor.setFocus()
-        elif paneNo == nwWidget.VIEWER:
-            self._changeView(nwView.EDITOR)
-            self.docViewer.setFocus()
-        elif paneNo == nwWidget.OUTLINE:
-            self._changeView(nwView.OUTLINE)
-            self.outlineView.setTreeFocus()
-        return
-
-    def closeDocEditor(self) -> None:
-        """Close the document editor. This does not hide the editor."""
-        self.closeDocument()
-        SHARED.project.data.setLastHandle(None, "editor")
-        return
-
     def closeDocViewer(self, byUser: bool = True) -> bool:
         """Close the document view panel."""
         self.docViewer.clearViewer()
@@ -1121,20 +1139,55 @@ class GuiMain(QMainWindow):
             # Only reset the last handle if the user called this
             SHARED.project.data.setLastHandle(None, "viewer")
 
+        cursorVisible = self.docEditor.cursorIsVisible()
+
         # Hide the panel
         bPos = self.splitMain.sizes()
         self.splitView.setVisible(False)
         self.splitDocs.setSizes([bPos[1], 0])
 
+        # Since editor width changes, we need to make sure we restore
+        # cursor visibility in the editor. See #1302
+        if cursorVisible:
+            self.docEditor.ensureCursorVisibleNoCentre()
+
         return not self.splitView.isVisible()
 
-    def toggleFocusMode(self) -> bool:
+    def toggleFullScreenMode(self) -> None:
+        """Toggle full screen mode"""
+        self.setWindowState(self.windowState() ^ Qt.WindowFullScreen)
+        return
+
+    ##
+    #  Events
+    ##
+
+    def closeEvent(self, event: QCloseEvent):
+        """Capture the closing event of the GUI and call the close
+        function to handle all the close process steps.
+        """
+        event.accept() if self.closeMain() else event.ignore()
+        return
+
+    ##
+    #  Public Slots
+    ##
+
+    @pyqtSlot()
+    def closeDocEditor(self) -> None:
+        """Close the document editor. This does not hide the editor."""
+        self.closeDocument()
+        SHARED.project.data.setLastHandle(None, "editor")
+        return
+
+    @pyqtSlot()
+    def toggleFocusMode(self) -> None:
         """Handle toggle focus mode. The Main GUI Focus Mode hides tree,
         view, statusbar and menu.
         """
         if self.docEditor.docHandle is None:
             logger.error("No document open, so not activating Focus Mode")
-            return False
+            return
 
         self.isFocusMode = not self.isFocusMode
         if self.isFocusMode:
@@ -1143,11 +1196,12 @@ class GuiMain(QMainWindow):
         else:
             logger.debug("Deactivating Focus Mode")
 
+        cursorVisible = self.docEditor.cursorIsVisible()
         isVisible = not self.isFocusMode
         self.treePane.setVisible(isVisible)
         self.mainStatus.setVisible(isVisible)
         self.mainMenu.setVisible(isVisible)
-        self.viewsBar.setVisible(isVisible)
+        self.sideBar.setVisible(isVisible)
 
         hideDocFooter = self.isFocusMode and CONFIG.hideFocusFooter
         self.docEditor.docFooter.setVisible(not hideDocFooter)
@@ -1158,11 +1212,198 @@ class GuiMain(QMainWindow):
         elif self.docViewer.docHandle is not None:
             self.splitView.setVisible(True)
 
-        return True
+        if cursorVisible:
+            self.docEditor.ensureCursorVisibleNoCentre()
+
+        return
+
+    @pyqtSlot(nwWidget)
+    def switchFocus(self, paneNo: nwWidget) -> None:
+        """Switch focus between main GUI views."""
+        if paneNo == nwWidget.TREE:
+            if self.projStack.currentWidget() is self.projView:
+                if self.projView.treeHasFocus():
+                    self._changeView(nwView.NOVEL)
+                    self.novelView.setTreeFocus()
+                else:
+                    self.projView.setTreeFocus()
+            else:
+                if self.novelView.treeHasFocus():
+                    self._changeView(nwView.PROJECT)
+                    self.projView.setTreeFocus()
+                else:
+                    self.novelView.setTreeFocus()
+        elif paneNo == nwWidget.EDITOR:
+            self._changeView(nwView.EDITOR)
+            self.docEditor.setFocus()
+        elif paneNo == nwWidget.VIEWER:
+            self._changeView(nwView.EDITOR)
+            self.docViewer.setFocus()
+        elif paneNo == nwWidget.OUTLINE:
+            self._changeView(nwView.OUTLINE)
+            self.outlineView.setTreeFocus()
+        return
+
+    ##
+    #  Private Slots
+    ##
+
+    @pyqtSlot(str, nwDocMode)
+    def _followTag(self, tag: str, mode: nwDocMode) -> None:
+        """Follow a tag after user interaction with a link."""
+        tHandle, sTitle = self._getTagSource(tag)
+        if tHandle is not None:
+            if mode == nwDocMode.EDIT:
+                self.openDocument(tHandle)
+            elif mode == nwDocMode.VIEW:
+                self.viewDocument(tHandle=tHandle, sTitle=sTitle)
+        return
+
+    @pyqtSlot(str, nwDocMode, str, bool)
+    def _openDocument(self, tHandle: str, mode: nwDocMode, sTitle: str, setFocus: bool) -> None:
+        """Handle an open document request."""
+        if tHandle is not None:
+            if mode == nwDocMode.EDIT:
+                tLine = None
+                hItem = SHARED.project.index.getItemHeader(tHandle, sTitle)
+                if hItem is not None:
+                    tLine = hItem.line
+                self.openDocument(tHandle, tLine=tLine, changeFocus=setFocus)
+            elif mode == nwDocMode.VIEW:
+                self.viewDocument(tHandle=tHandle, sTitle=sTitle)
+        return
+
+    @pyqtSlot(nwView)
+    def _changeView(self, view: nwView) -> None:
+        """Handle the requested change of view from the GuiViewBar."""
+        if view == nwView.EDITOR:
+            # Only change the main stack, but not the project stack
+            self.mainStack.setCurrentWidget(self.splitMain)
+        elif view == nwView.PROJECT:
+            self.mainStack.setCurrentWidget(self.splitMain)
+            self.projStack.setCurrentWidget(self.projView)
+        elif view == nwView.NOVEL:
+            self.mainStack.setCurrentWidget(self.splitMain)
+            self.projStack.setCurrentWidget(self.novelView)
+        elif view == nwView.OUTLINE:
+            self.mainStack.setCurrentWidget(self.outlineView)
+        return
+
+    @pyqtSlot(nwDocAction)
+    def _passDocumentAction(self, action: nwDocAction) -> None:
+        """Pass on a document action to the document viewer if it has
+        focus, or pass it to the document editor if it or any of its
+        child widgets have focus. If neither has focus, ignore it.
+        """
+        if self.docViewer.hasFocus():
+            self.docViewer.docAction(action)
+        elif self.docEditor.hasFocus():
+            self.docEditor.docAction(action)
+        else:
+            logger.debug("Action cancelled as neither editor nor viewer has focus")
+        return
+
+    @pyqtSlot(str)
+    @pyqtSlot(nwDocInsert)
+    def _passDocumentInsert(self, content: str | nwDocInsert) -> None:
+        """Pass on a document insert action to the document editor if it
+        has focus. If not, ignore it.
+        """
+        if self.docEditor.hasFocus():
+            self.docEditor.insertText(content)
+        return
+
+    @pyqtSlot()
+    def _toggleViewerPanelVisibility(self):
+        """Toggle the visibility of the document viewer panel."""
+        CONFIG.showViewerPanel = not CONFIG.showViewerPanel
+        self.docViewerPanel.setVisible(CONFIG.showViewerPanel)
+        return
+
+    @pyqtSlot()
+    def _timeTick(self) -> None:
+        """Process time tick of the main timer."""
+        if not SHARED.hasProject:
+            return
+        currTime = time()
+        editIdle = currTime - self.docEditor.lastActive > CONFIG.userIdleTime
+        userIdle = qApp.applicationState() != Qt.ApplicationActive
+        self.mainStatus.setUserIdle(editIdle or userIdle)
+        SHARED.updateIdleTime(currTime, editIdle or userIdle)
+        self.mainStatus.updateTime(idleTime=SHARED.projectIdleTime)
+        return
+
+    @pyqtSlot()
+    def _autoSaveProject(self) -> None:
+        """Autosave of the project. This is a timer-activated slot."""
+        doSave  = SHARED.hasProject
+        doSave &= SHARED.project.projChanged
+        doSave &= SHARED.project.storage.isOpen()
+        if doSave:
+            logger.debug("Autosaving project")
+            self.saveProject(autoSave=True)
+        return
+
+    @pyqtSlot()
+    def _autoSaveDocument(self) -> None:
+        """Autosave of the document. This is a timer-activated slot."""
+        if SHARED.hasProject and self.docEditor.docChanged:
+            logger.debug("Autosaving document")
+            self.saveDocument()
+        return
+
+    @pyqtSlot()
+    def _updateStatusWordCount(self) -> None:
+        """Update the word count on the status bar."""
+        if not SHARED.hasProject:
+            self.mainStatus.setProjectStats(0, 0)
+
+        SHARED.project.updateWordCounts()
+        if CONFIG.incNotesWCount:
+            iTotal = sum(SHARED.project.data.initCounts)
+            cTotal = sum(SHARED.project.data.currCounts)
+            self.mainStatus.setProjectStats(cTotal, cTotal - iTotal)
+        else:
+            iNovel, _ = SHARED.project.data.initCounts
+            cNovel, _ = SHARED.project.data.currCounts
+            self.mainStatus.setProjectStats(cNovel, cNovel - iNovel)
 
-    def toggleFullScreenMode(self) -> None:
-        """Toggle full screen mode"""
-        self.setWindowState(self.windowState() ^ Qt.WindowFullScreen)
+        return
+
+    @pyqtSlot()
+    def _keyPressReturn(self) -> None:
+        """Forward the return/enter keypress to the function that opens
+        the currently selected item.
+        """
+        self.openSelectedItem()
+        return
+
+    @pyqtSlot()
+    def _keyPressEscape(self) -> None:
+        """Process escape keypress in the main window."""
+        if self.docEditor.docSearch.isVisible():
+            self.docEditor.closeSearch()
+        elif self.isFocusMode:
+            self.toggleFocusMode()
+        return
+
+    @pyqtSlot(int)
+    def _mainStackChanged(self, index: int) -> None:
+        """Process main window tab change."""
+        if index == self.idxOutlineView:
+            if SHARED.hasProject:
+                self.outlineView.refreshTree()
+        return
+
+    @pyqtSlot(int)
+    def _projStackChanged(self, index: int) -> None:
+        """Process project view tab change."""
+        sHandle = None
+        if index == self.idxProjView:
+            sHandle = self.projView.getSelectedHandle()
+        elif index == self.idxNovelView:
+            sHandle, _ = self.novelView.getSelectedHandle()
+        self.itemDetails.updateViewBox(sHandle)
         return
 
     ##
@@ -1220,6 +1461,7 @@ class GuiMain(QMainWindow):
         self.addAction(self.mainMenu.aInsTimes)
         self.addAction(self.mainMenu.aInsDivide)
         self.addAction(self.mainMenu.aInsSynopsis)
+        self.addAction(self.mainMenu.aInsShort)
 
         for mAction, _ in self.mainMenu.mInsKWItems.values():
             self.addAction(mAction)
@@ -1299,6 +1541,12 @@ class GuiMain(QMainWindow):
             projData["numChapters"] = newProj.field("numChapters")
             projData["numScenes"] = newProj.field("numScenes")
 
+        try:
+            langIdx = newProj.field("projLang")
+            projData["projLang"] = CONFIG.listLanguages(CONFIG.LANG_PROJ)[langIdx][0]
+        except Exception:
+            projData["projLang"] = "en_GB"
+
         return projData
 
     def _getTagSource(self, tag: str) -> tuple[str | None, str | None]:
@@ -1317,153 +1565,4 @@ class GuiMain(QMainWindow):
             return None, None
         return tHandle, sTitle
 
-    ##
-    #  Events
-    ##
-
-    def closeEvent(self, event: QCloseEvent):
-        """Capture the closing event of the GUI and call the close
-        function to handle all the close process steps.
-        """
-        if self.closeMain():
-            event.accept()
-        else:
-            event.ignore()
-        return
-
-    ##
-    #  Private Slots
-    ##
-
-    @pyqtSlot(str, nwDocMode)
-    def _followTag(self, tag: str, mode: nwDocMode) -> None:
-        """Follow a tag after user interaction with a link."""
-        tHandle, sTitle = self._getTagSource(tag)
-        if tHandle is not None:
-            if mode == nwDocMode.EDIT:
-                self.openDocument(tHandle)
-            elif mode == nwDocMode.VIEW:
-                self.viewDocument(tHandle=tHandle, sTitle=sTitle)
-        return
-
-    @pyqtSlot(str, nwDocMode, str, bool)
-    def _openDocument(self, tHandle: str, mode: nwDocMode, sTitle: str, setFocus: bool) -> None:
-        """Handle an open document request."""
-        if tHandle is not None:
-            if mode == nwDocMode.EDIT:
-                tLine = None
-                hItem = SHARED.project.index.getItemHeader(tHandle, sTitle)
-                if hItem is not None:
-                    tLine = hItem.line
-                self.openDocument(tHandle, tLine=tLine, changeFocus=setFocus)
-            elif mode == nwDocMode.VIEW:
-                self.viewDocument(tHandle=tHandle, sTitle=sTitle)
-        return
-
-    @pyqtSlot(nwView)
-    def _changeView(self, view: nwView) -> None:
-        """Handle the requested change of view from the GuiViewBar."""
-        if view == nwView.EDITOR:
-            # Only change the main stack, but not the project stack
-            self.mainStack.setCurrentWidget(self.splitMain)
-
-        elif view == nwView.PROJECT:
-            self.mainStack.setCurrentWidget(self.splitMain)
-            self.projStack.setCurrentWidget(self.projView)
-
-        elif view == nwView.NOVEL:
-            self.mainStack.setCurrentWidget(self.splitMain)
-            self.projStack.setCurrentWidget(self.novelView)
-
-        elif view == nwView.OUTLINE:
-            self.mainStack.setCurrentWidget(self.outlineView)
-
-        return
-
-    @pyqtSlot()
-    def _timeTick(self) -> None:
-        """Process time tick of the main timer."""
-        if not SHARED.hasProject:
-            return
-        currTime = time()
-        editIdle = currTime - self.docEditor.lastActive > CONFIG.userIdleTime
-        userIdle = qApp.applicationState() != Qt.ApplicationActive
-        self.mainStatus.setUserIdle(editIdle or userIdle)
-        SHARED.updateIdleTime(currTime, editIdle or userIdle)
-        self.mainStatus.updateTime(idleTime=SHARED.projectIdleTime)
-        return
-
-    @pyqtSlot()
-    def _autoSaveProject(self) -> None:
-        """Autosave of the project. This is a timer-activated slot."""
-        doSave  = SHARED.hasProject
-        doSave &= SHARED.project.projChanged
-        doSave &= SHARED.project.storage.isOpen()
-        if doSave:
-            logger.debug("Autosaving project")
-            self.saveProject(autoSave=True)
-        return
-
-    @pyqtSlot()
-    def _autoSaveDocument(self) -> None:
-        """Autosave of the document. This is a timer-activated slot."""
-        if SHARED.hasProject and self.docEditor.docChanged:
-            logger.debug("Autosaving document")
-            self.saveDocument()
-        return
-
-    @pyqtSlot()
-    def _updateStatusWordCount(self) -> None:
-        """Update the word count on the status bar."""
-        if not SHARED.hasProject:
-            self.mainStatus.setProjectStats(0, 0)
-
-        SHARED.project.updateWordCounts()
-        if CONFIG.incNotesWCount:
-            iTotal = sum(SHARED.project.data.initCounts)
-            cTotal = sum(SHARED.project.data.currCounts)
-            self.mainStatus.setProjectStats(cTotal, cTotal - iTotal)
-        else:
-            iNovel, _ = SHARED.project.data.initCounts
-            cNovel, _ = SHARED.project.data.currCounts
-            self.mainStatus.setProjectStats(cNovel, cNovel - iNovel)
-
-        return
-
-    @pyqtSlot()
-    def _keyPressReturn(self) -> None:
-        """Forward the return/enter keypress to the function that opens
-        the currently selected item.
-        """
-        self.openSelectedItem()
-        return
-
-    @pyqtSlot()
-    def _keyPressEscape(self) -> None:
-        """Process escape keypress in the main window."""
-        if self.docEditor.docSearch.isVisible():
-            self.docEditor.closeSearch()
-        elif self.isFocusMode:
-            self.toggleFocusMode()
-        return
-
-    @pyqtSlot(int)
-    def _mainStackChanged(self, index: int) -> None:
-        """Process main window tab change."""
-        if index == self.idxOutlineView:
-            if SHARED.hasProject:
-                self.outlineView.refreshTree()
-        return
-
-    @pyqtSlot(int)
-    def _projStackChanged(self, index: int) -> None:
-        """Process project view tab change."""
-        sHandle = None
-        if index == self.idxProjView:
-            sHandle = self.projView.getSelectedHandle()
-        elif index == self.idxNovelView:
-            sHandle, _ = self.novelView.getSelectedHandle()
-        self.itemDetails.updateViewBox(sHandle)
-        return
-
 # END Class GuiMain