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

novelwriter/gui/docviewerpanel.py

@@ -0,0 +1,457 @@
+"""
+novelWriter – GUI Document Viewer Panel
+=======================================
+
+File History:
+Created: 2023-11-14 [2.2rc1] GuiDocViewerPanel
+
+This file is a part of novelWriter
+Copyright 2018–2023, Veronica Berglyd Olsen
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.
+"""
+from __future__ import annotations
+
+import logging
+
+from enum import Enum
+
+from PyQt5.QtCore import QModelIndex, QSize, Qt, pyqtSignal, pyqtSlot
+from PyQt5.QtWidgets import (
+    QAbstractItemView, QFrame, QHeaderView, QTabWidget, QTreeWidget,
+    QTreeWidgetItem, QVBoxLayout, QWidget
+)
+
+from novelwriter import CONFIG, SHARED
+from novelwriter.enum import nwDocMode, nwItemClass
+from novelwriter.common import checkInt
+from novelwriter.constants import nwHeaders, nwLabels, nwLists, trConst
+from novelwriter.core.index import IndexHeading, IndexItem
+
+logger = logging.getLogger(__name__)
+
+
+class GuiDocViewerPanel(QWidget):
+
+    openDocumentRequest = pyqtSignal(str, Enum, str, bool)
+    loadDocumentTagRequest = pyqtSignal(str, Enum)
+
+    def __init__(self, parent: QWidget) -> None:
+        super().__init__(parent=parent)
+
+        logger.debug("Create: GuiDocViewerPanel")
+
+        self._lastHandle = None
+
+        self.tabBackRefs = _ViewPanelBackRefs(self)
+
+        self.mainTabs = QTabWidget(self)
+        self.mainTabs.addTab(self.tabBackRefs, self.tr("Backreferences"))
+
+        self.kwTabs: dict[str, _ViewPanelKeyWords] = {}
+        self.idTabs: dict[str, int] = {}
+        for itemClass in nwLists.USER_CLASSES:
+            cTab = _ViewPanelKeyWords(self, itemClass)
+            tabId = self.mainTabs.addTab(cTab, trConst(nwLabels.CLASS_NAME[itemClass]))
+            self.kwTabs[itemClass.name] = cTab
+            self.idTabs[itemClass.name] = tabId
+
+        # Assemble
+        self.outerBox = QVBoxLayout()
+        self.outerBox.addWidget(self.mainTabs)
+        self.outerBox.setContentsMargins(0, 0, 0, 0)
+
+        self.setLayout(self.outerBox)
+        self.updateTheme()
+
+        logger.debug("Ready: GuiDocViewerPanel")
+
+        return
+
+    ##
+    #  Methods
+    ##
+
+    def updateTheme(self) -> None:
+        """Update theme elements."""
+        vPx = CONFIG.pxInt(4)
+        lPx = CONFIG.pxInt(2)
+        rPx = CONFIG.pxInt(14)
+        hCol = self.palette().highlight().color()
+
+        styleSheet = (
+            "QTabWidget::pane {border: 0;} "
+            "QTabWidget QTabBar::tab {"
+            f"border: 0; padding: {vPx}px {rPx}px {vPx}px {lPx}px;"
+            "} "
+            "QTabWidget QTabBar::tab:selected {"
+            f"color: rgb({hCol.red()}, {hCol.green()}, {hCol.blue()});"
+            "} "
+        )
+        self.mainTabs.setStyleSheet(styleSheet)
+        self.updateHandle(self._lastHandle)
+
+        return
+
+    def openProjectTasks(self) -> None:
+        """Run open project tasks."""
+        widths = SHARED.project.options.getValue("GuiDocViewerPanel", "colWidths", {})
+        if isinstance(widths, dict):
+            for key, value in widths.items():
+                if key in self.kwTabs and isinstance(value, list):
+                    self.kwTabs[key].setColumnWidths(value)
+        return
+
+    def closeProjectTasks(self) -> None:
+        """Run close project tasks."""
+        widths = {}
+        for key, tab in self.kwTabs.items():
+            widths[key] = tab.getColumnWidths()
+        SHARED.project.options.setValue("GuiDocViewerPanel", "colWidths", widths)
+        return
+
+    ##
+    #  Public Slots
+    ##
+
+    @pyqtSlot()
+    def indexWasCleared(self) -> None:
+        """Handle event when the index has been cleared of content."""
+        self.tabBackRefs.clearContent()
+        for cTab in self.kwTabs.values():
+            cTab.clearContent()
+        return
+
+    @pyqtSlot()
+    def indexHasAppeared(self) -> None:
+        """Handle event when the index has appeared."""
+        for key, name, tClass, iItem, hItem in SHARED.project.index.getTagsData():
+            if tClass in self.kwTabs and iItem and hItem:
+                self.kwTabs[tClass].addUpdateEntry(key, name, iItem, hItem)
+        self._updateTabVisibility()
+        self.updateHandle(self._lastHandle)
+        return
+
+    @pyqtSlot(str)
+    def projectItemChanged(self, tHandle: str) -> None:
+        """Update meta data for project item."""
+        self.tabBackRefs.refreshDocument(tHandle)
+        for key in SHARED.project.index.getDocumentTags(tHandle):
+            name, tClass, iItem, hItem = SHARED.project.index.getSingleTag(key)
+            if tClass in self.kwTabs and iItem and hItem:
+                self.kwTabs[tClass].addUpdateEntry(key, name, iItem, hItem)
+        return
+
+    @pyqtSlot(str)
+    def updateHandle(self, tHandle: str | None) -> None:
+        """Update the document handle."""
+        self._lastHandle = tHandle
+        self.tabBackRefs.refreshContent(tHandle or None)
+        return
+
+    @pyqtSlot(list, list)
+    def updateChangedTags(self, updated: list[str], deleted: list[str]) -> None:
+        """Forward tags changes to the lists."""
+        for key in updated:
+            name, tClass, iItem, hItem = SHARED.project.index.getSingleTag(key)
+            if tClass in self.kwTabs and iItem and hItem:
+                self.kwTabs[tClass].addUpdateEntry(key, name, iItem, hItem)
+        for key in deleted:
+            for cTab in self.kwTabs.values():
+                if cTab.removeEntry(key):
+                    break
+            else:
+                logger.warning("Could not remove tag '%s' from view panel", key)
+        self._updateTabVisibility()
+        return
+
+    ##
+    #  Internal Functions
+    ##
+
+    def _updateTabVisibility(self) -> None:
+        """Hide class tabs with no content."""
+        if CONFIG.verQtValue >= 0x050f00:
+            for tClass, cTab in self.kwTabs.items():
+                self.mainTabs.setTabVisible(self.idTabs[tClass], cTab.countEntries() > 0)
+        return
+
+# END Class GuiDocViewerPanel
+
+
+class _ViewPanelBackRefs(QTreeWidget):
+
+    C_DATA  = 0
+    C_DOC   = 0
+    C_EDIT  = 1
+    C_VIEW  = 2
+    C_TITLE = 3
+
+    D_HANDLE = Qt.ItemDataRole.UserRole
+
+    def __init__(self, parent: GuiDocViewerPanel) -> None:
+        super().__init__(parent=parent)
+
+        self._parent = parent
+        self._treeMap: dict[str, QTreeWidgetItem] = {}
+
+        iPx = SHARED.theme.baseIconSize
+        cMg = CONFIG.pxInt(6)
+
+        self.setHeaderLabels([self.tr("Document"), "", "", self.tr("First Heading")])
+        self.setIndentation(0)
+        self.setSelectionMode(QAbstractItemView.SelectionMode.NoSelection)
+        self.setIconSize(QSize(iPx, iPx))
+        self.setFrameStyle(QFrame.Shape.NoFrame)
+
+        # Set Header Sizes
+        treeHeader = self.header()
+        treeHeader.setStretchLastSection(True)
+        treeHeader.setSectionResizeMode(self.C_DOC, QHeaderView.ResizeMode.ResizeToContents)
+        treeHeader.setSectionResizeMode(self.C_EDIT, QHeaderView.ResizeMode.Fixed)
+        treeHeader.setSectionResizeMode(self.C_VIEW, QHeaderView.ResizeMode.Fixed)
+        treeHeader.setSectionResizeMode(self.C_TITLE, QHeaderView.ResizeMode.ResizeToContents)
+        treeHeader.resizeSection(self.C_EDIT, iPx + cMg)
+        treeHeader.resizeSection(self.C_VIEW, iPx + cMg)
+
+        # Cache Icons Locally
+        self._editIcon = SHARED.theme.getIcon("edit")
+        self._viewIcon = SHARED.theme.getIcon("view")
+
+        # Signals
+        self.clicked.connect(self._treeItemClicked)
+        self.doubleClicked.connect(self._treeItemDoubleClicked)
+
+        return
+
+    def clearContent(self) -> None:
+        """Clear the widget."""
+        self.clear()
+        self._treeMap = {}
+        return
+
+    def refreshContent(self, dHandle: str | None) -> None:
+        """Update the content."""
+        self.clearContent()
+        if dHandle:
+            refs = SHARED.project.index.getBackReferenceList(dHandle)
+            for tHandle, (sTitle, hItem) in refs.items():
+                self._setTreeItemValues(tHandle, sTitle, hItem)
+        return
+
+    def refreshDocument(self, tHandle: str) -> None:
+        """Refresh document meta data."""
+        if iItem := SHARED.project.index.getItemData(tHandle):
+            for sTitle, hItem in iItem.items():
+                if f"{tHandle}:{sTitle}" in self._treeMap:
+                    self._setTreeItemValues(tHandle, sTitle, hItem)
+        return
+
+    ##
+    #  Private Slots
+    ##
+
+    @pyqtSlot("QModelIndex")
+    def _treeItemClicked(self, index: QModelIndex) -> None:
+        """Emit document open signal on user click."""
+        tHandle = index.siblingAtColumn(self.C_DATA).data(self.D_HANDLE)
+        if index.column() == self.C_EDIT:
+            self._parent.openDocumentRequest.emit(tHandle, nwDocMode.EDIT, "", True)
+        elif index.column() == self.C_VIEW:
+            self._parent.openDocumentRequest.emit(tHandle, nwDocMode.VIEW, "", True)
+        return
+
+    @pyqtSlot("QModelIndex")
+    def _treeItemDoubleClicked(self, index: QModelIndex) -> None:
+        """Emit follow tag signal on user double click."""
+        tHandle = index.siblingAtColumn(self.C_DATA).data(self.D_HANDLE)
+        if index.column() == self.C_DOC:
+            self._parent.openDocumentRequest.emit(tHandle, nwDocMode.VIEW, "", True)
+        return
+
+    ##
+    #  Internal Functions
+    ##
+
+    def _setTreeItemValues(self, tHandle: str, sTitle: str, hItem: IndexHeading) -> None:
+        """Add or update a tree item."""
+        if nwItem := SHARED.project.tree[tHandle]:
+            docIcon = SHARED.theme.getItemIcon(
+                nwItem.itemType, nwItem.itemClass,
+                nwItem.itemLayout, nwItem.mainHeading
+            )
+            iLevel = nwHeaders.H_LEVEL.get(hItem.level, 0) if nwItem.isDocumentLayout() else 5
+            hDec = SHARED.theme.getHeaderDecorationNarrow(iLevel)
+
+            tKey = f"{tHandle}:{sTitle}"
+            trItem = self._treeMap[tKey] if tKey in self._treeMap else QTreeWidgetItem()
+
+            trItem.setIcon(self.C_DOC, docIcon)
+            trItem.setText(self.C_DOC, nwItem.itemName)
+            trItem.setIcon(self.C_EDIT, self._editIcon)
+            trItem.setIcon(self.C_VIEW, self._viewIcon)
+            trItem.setText(self.C_TITLE, hItem.title)
+            trItem.setData(self.C_TITLE, Qt.ItemDataRole.DecorationRole, hDec)
+            trItem.setData(self.C_DATA, self.D_HANDLE, tHandle)
+
+            if tKey not in self._treeMap:
+                self.addTopLevelItem(trItem)
+                self._treeMap[tKey] = trItem
+
+        return
+
+# END Class _ViewPanelBackRefs
+
+
+class _ViewPanelKeyWords(QTreeWidget):
+
+    C_DATA  = 0
+    C_NAME  = 0
+    C_EDIT  = 1
+    C_VIEW  = 2
+    C_DOC   = 3
+    C_TITLE = 4
+    C_SHORT = 5
+
+    D_TAG = Qt.ItemDataRole.UserRole
+
+    def __init__(self, parent: GuiDocViewerPanel, itemClass: nwItemClass) -> None:
+        super().__init__(parent=parent)
+
+        self._parent = parent
+        self._treeMap: dict[str, QTreeWidgetItem] = {}
+
+        iPx = SHARED.theme.baseIconSize
+        cMg = CONFIG.pxInt(6)
+
+        self.setHeaderLabels([
+            self.tr("Tag"), "", "", self.tr("Document"),
+            self.tr("Heading"), self.tr("Short Description")
+        ])
+        self.setIndentation(0)
+        self.setIconSize(QSize(iPx, iPx))
+        self.setFrameStyle(QFrame.Shape.NoFrame)
+        self.setSelectionMode(QAbstractItemView.SelectionMode.NoSelection)
+        self.setExpandsOnDoubleClick(False)
+        self.setDragEnabled(False)
+        self.setSortingEnabled(True)
+        self.sortByColumn(self.C_NAME, Qt.SortOrder.AscendingOrder)
+
+        # Set Header Sizes
+        treeHeader = self.header()
+        treeHeader.setStretchLastSection(True)
+        treeHeader.setSectionResizeMode(self.C_NAME, QHeaderView.ResizeMode.ResizeToContents)
+        treeHeader.setSectionResizeMode(self.C_EDIT, QHeaderView.ResizeMode.Fixed)
+        treeHeader.setSectionResizeMode(self.C_VIEW, QHeaderView.ResizeMode.Fixed)
+        treeHeader.resizeSection(self.C_EDIT, iPx + cMg)
+        treeHeader.resizeSection(self.C_VIEW, iPx + cMg)
+        treeHeader.setSectionsMovable(False)
+
+        # Cache Icons Locally
+        self._classIcon = SHARED.theme.getIcon(nwLabels.CLASS_ICON[itemClass])
+        self._editIcon = SHARED.theme.getIcon("edit")
+        self._viewIcon = SHARED.theme.getIcon("view")
+
+        # Signals
+        self.clicked.connect(self._treeItemClicked)
+        self.doubleClicked.connect(self._treeItemDoubleClicked)
+
+        return
+
+    def countEntries(self) -> int:
+        """Return the number of items in the list."""
+        return self.topLevelItemCount()
+
+    def clearContent(self) -> None:
+        """Clear the list."""
+        self._treeMap = {}
+        self.clear()
+        return
+
+    def addUpdateEntry(self, tag: str, name: str, iItem: IndexItem, hItem: IndexHeading) -> None:
+        """Add a new entry, or update an existing one."""
+        nwItem = iItem.item
+        docIcon = SHARED.theme.getItemIcon(
+            nwItem.itemType, nwItem.itemClass,
+            nwItem.itemLayout, nwItem.mainHeading
+        )
+        iLevel = nwHeaders.H_LEVEL.get(hItem.level, 0) if nwItem.isDocumentLayout() else 5
+        hDec = SHARED.theme.getHeaderDecorationNarrow(iLevel)
+
+        # This can not use a get call to the dictionary as that creates
+        # some weird issue with Qt, so we need to do this with an if
+        trItem = self._treeMap[tag] if tag in self._treeMap else QTreeWidgetItem()
+
+        trItem.setText(self.C_NAME, name)
+        trItem.setIcon(self.C_NAME, self._classIcon)
+        trItem.setIcon(self.C_EDIT, self._editIcon)
+        trItem.setIcon(self.C_VIEW, self._viewIcon)
+        trItem.setIcon(self.C_DOC, docIcon)
+        trItem.setText(self.C_DOC, nwItem.itemName)
+        trItem.setText(self.C_TITLE, hItem.title)
+        trItem.setData(self.C_TITLE, Qt.ItemDataRole.DecorationRole, hDec)
+        trItem.setText(self.C_SHORT, hItem.synopsis)
+        trItem.setData(self.C_DATA, self.D_TAG, tag)
+
+        if tag not in self._treeMap:
+            self.addTopLevelItem(trItem)
+            self._treeMap[tag] = trItem
+
+        return
+
+    def removeEntry(self, tag: str) -> bool:
+        """Remove a tag from the list."""
+        if tag in self._treeMap:
+            self.takeTopLevelItem(self.indexOfTopLevelItem(self._treeMap[tag]))
+            self._treeMap.pop(tag, None)
+            return True
+        return False
+
+    def setColumnWidths(self, widths: list[int]) -> None:
+        """Set the column widths."""
+        if isinstance(widths, list) and len(widths) >= 2:
+            self.setColumnWidth(self.C_DOC, CONFIG.pxInt(checkInt(widths[0], 100)))
+            self.setColumnWidth(self.C_TITLE, CONFIG.pxInt(checkInt(widths[1], 100)))
+        return
+
+    def getColumnWidths(self) -> list[int]:
+        """Get the widths of the user-adjustable columns."""
+        return [
+            CONFIG.rpxInt(self.columnWidth(self.C_DOC)),
+            CONFIG.rpxInt(self.columnWidth(self.C_TITLE)),
+        ]
+
+    ##
+    #  Private Slots
+    ##
+
+    @pyqtSlot("QModelIndex")
+    def _treeItemClicked(self, index: QModelIndex) -> None:
+        """Emit follow tag signal on user click."""
+        tag = index.siblingAtColumn(self.C_DATA).data(self.D_TAG)
+        if index.column() == self.C_EDIT:
+            self._parent.loadDocumentTagRequest.emit(tag, nwDocMode.EDIT)
+        elif index.column() == self.C_VIEW:
+            self._parent.loadDocumentTagRequest.emit(tag, nwDocMode.VIEW)
+        return
+
+    @pyqtSlot("QModelIndex")
+    def _treeItemDoubleClicked(self, index: QModelIndex) -> None:
+        """Emit follow tag signal on user double click."""
+        tag = index.siblingAtColumn(self.C_DATA).data(self.D_TAG)
+        if index.column() == self.C_NAME:
+            self._parent.loadDocumentTagRequest.emit(tag, nwDocMode.VIEW)
+        return
+
+# END Class _ViewPanelKeyWords

novelwriter/gui/editordocument.py

@@ -64,7 +64,7 @@ class GuiTextDocument(QTextDocument):
         return self._syntax
 
     ##
-    #  Metods
+    #  Methods
     ##
 
     def setTextContent(self, text: str, tHandle: str) -> None:

novelwriter/gui/mainmenu.py

@@ -27,15 +27,14 @@ import logging
 
 from typing import TYPE_CHECKING
 from pathlib import Path
-from urllib.parse import urljoin
-from urllib.request import pathname2url
 
-from PyQt5.QtCore import QUrl, pyqtSignal, pyqtSlot
 from PyQt5.QtGui import QDesktopServices
+from PyQt5.QtCore import QUrl, pyqtSignal, pyqtSlot
 from PyQt5.QtWidgets import QMenuBar, QAction
 
 from novelwriter import CONFIG, SHARED
 from novelwriter.enum import nwDocAction, nwDocInsert, nwWidget
+from novelwriter.common import openExternalPath
 from novelwriter.constants import nwConst, trConst, nwKeyWords, nwLabels, nwUnicode
 
 if TYPE_CHECKING:  # pragma: no cover
@@ -111,9 +110,7 @@ class GuiMainMenu(QMenuBar):
     def _openUserManualFile(self) -> None:
         """Open the documentation in PDF format."""
         if isinstance(CONFIG.pdfDocs, Path):
-            QDesktopServices.openUrl(
-                QUrl(urljoin("file:", pathname2url(str(CONFIG.pdfDocs))))
-            )
+            openExternalPath(CONFIG.pdfDocs)
         return
 
     @pyqtSlot(str)
@@ -174,7 +171,7 @@ class GuiMainMenu(QMenuBar):
 
         # Project > Delete
         self.aDeleteItem = self.projMenu.addAction(self.tr("Delete Item"))
-        self.aDeleteItem.setShortcuts(["Ctrl+Del", "Ctrl+Shift+Del"])  # Latter is deprecated
+        self.aDeleteItem.setShortcut("Ctrl+Shift+Del")  # Cannot be Ctrl+Del, see #629
         self.aDeleteItem.triggered.connect(lambda: self.mainGui.projView.requestDeleteItem(None))
 
         # Project > Empty Trash
@@ -567,6 +564,13 @@ class GuiMainMenu(QMenuBar):
             lambda: self.requestDocInsert.emit(nwDocInsert.SYNOPSIS)
         )
 
+        # Insert > Short Description Comment
+        self.aInsShort = self.mInsComments.addAction(self.tr("Short Description Comment"))
+        self.aInsShort.setShortcut("Ctrl+K, U")
+        self.aInsShort.triggered.connect(
+            lambda: self.requestDocInsert.emit(nwDocInsert.SHORT)
+        )
+
         # Insert > Symbols
         self.mInsBreaks = self.insMenu.addMenu(self.tr("Page Break and Space"))
 
@@ -870,6 +874,11 @@ class GuiMainMenu(QMenuBar):
         self.aEditWordList = self.toolsMenu.addAction(self.tr("Project Word List"))
         self.aEditWordList.triggered.connect(lambda: self.mainGui.showProjectWordListDialog())
 
+        # Tools > Add Dictionaries
+        if CONFIG.osWindows or CONFIG.isDebug:
+            self.aAddDicts = self.toolsMenu.addAction(self.tr("Add Dictionaries"))
+            self.aAddDicts.triggered.connect(self.mainGui.showDictionariesDialog)
+
         # Tools > Separator
         self.toolsMenu.addSeparator()
 

novelwriter/gui/outline.py

@@ -377,13 +377,17 @@ class GuiOutlineTree(QTreeWidget):
         fH2 = self.font()
         fH2.setBold(True)
 
+        iType = nwItemType.FILE
+        iClass = nwItemClass.NO_CLASS
+        iLayout = nwItemLayout.DOCUMENT
+
         self._hFonts = [self.font(), fH1, fH2, self.font(), self.font()]
         self._dIcon = {
-            "H0": SHARED.theme.getItemIcon(nwItemType.FILE, None, nwItemLayout.DOCUMENT, "H0"),
-            "H1": SHARED.theme.getItemIcon(nwItemType.FILE, None, nwItemLayout.DOCUMENT, "H1"),
-            "H2": SHARED.theme.getItemIcon(nwItemType.FILE, None, nwItemLayout.DOCUMENT, "H2"),
-            "H3": SHARED.theme.getItemIcon(nwItemType.FILE, None, nwItemLayout.DOCUMENT, "H3"),
-            "H4": SHARED.theme.getItemIcon(nwItemType.FILE, None, nwItemLayout.DOCUMENT, "H4"),
+            "H0": SHARED.theme.getItemIcon(iType, iClass, iLayout, "H0"),
+            "H1": SHARED.theme.getItemIcon(iType, iClass, iLayout, "H1"),
+            "H2": SHARED.theme.getItemIcon(iType, iClass, iLayout, "H2"),
+            "H3": SHARED.theme.getItemIcon(iType, iClass, iLayout, "H3"),
+            "H4": SHARED.theme.getItemIcon(iType, iClass, iLayout, "H4"),
         }
 
         # Internals
@@ -549,7 +553,7 @@ class GuiOutlineTree(QTreeWidget):
         """Load the state of the main tree header, that is, column order
         and column width.
         """
-        # Load whatever we saved last time, regardless of wether it
+        # Load whatever we saved last time, regardless of whether it
         # contains the correct names or number of columns.
         colState = SHARED.project.options.getValue("GuiOutline", "columnState", {})