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

novelwriter/gui/mainmenu.py

@@ -132,14 +132,10 @@ class GuiMainMenu(QMenuBar):
         # Project
         self.projMenu = self.addMenu(self.tr("&Project"))
 
-        # Project > New Project
-        self.aNewProject = self.projMenu.addAction(self.tr("New Project"))
-        self.aNewProject.triggered.connect(lambda: self.mainGui.newProject(None))
-
-        # Project > Open Project
-        self.aOpenProject = self.projMenu.addAction(self.tr("Open Project"))
+        # Project > Create or Open Project
+        self.aOpenProject = self.projMenu.addAction(self.tr("Create or Open Project"))
         self.aOpenProject.setShortcut("Ctrl+Shift+O")
-        self.aOpenProject.triggered.connect(lambda: self.mainGui.showProjectLoadDialog())
+        self.aOpenProject.triggered.connect(self.mainGui.showWelcomeDialog)
 
         # Project > Save Project
         self.aSaveProject = self.projMenu.addAction(self.tr("Save Project"))
@@ -159,10 +155,10 @@ class GuiMainMenu(QMenuBar):
         self.aProjectSettings.setShortcut("Ctrl+Shift+,")
         self.aProjectSettings.triggered.connect(self.mainGui.showProjectSettingsDialog)
 
-        # Project > Project Details
-        self.aProjectDetails = self.projMenu.addAction(self.tr("Project Details"))
-        self.aProjectDetails.setShortcut("Shift+F6")
-        self.aProjectDetails.triggered.connect(self.mainGui.showProjectDetailsDialog)
+        # Project > Novel Details
+        self.aNovelDetails = self.projMenu.addAction(self.tr("Novel Details"))
+        self.aNovelDetails.setShortcut("Shift+F6")
+        self.aNovelDetails.triggered.connect(self.mainGui.showNovelDetailsDialog)
 
         # Project > Separator
         self.projMenu.addSeparator()
@@ -785,6 +781,13 @@ class GuiMainMenu(QMenuBar):
             lambda: self.requestDocAction.emit(nwDocAction.BLOCK_COM)
         )
 
+        # Format > Ignore Text
+        self.aFmtIgnore = self.fmtMenu.addAction(self.tr("Toggle Ignore Text"))
+        self.aFmtIgnore.setShortcut("Ctrl+Shift+D")
+        self.aFmtIgnore.triggered.connect(
+            lambda: self.requestDocAction.emit(nwDocAction.BLOCK_IGN)
+        )
+
         # Format > Remove Block Format
         self.aFmtNoFormat = self.fmtMenu.addAction(self.tr("Remove Block Format"))
         self.aFmtNoFormat.setShortcuts(["Ctrl+0", "Ctrl+Shift+/"])
@@ -961,13 +964,6 @@ class GuiMainMenu(QMenuBar):
         self.aWebsite = self.helpMenu.addAction(self.tr("The novelWriter Website"))
         self.aWebsite.triggered.connect(lambda: self._openWebsite(nwConst.URL_WEB))
 
-        # Help > Separator
-        self.helpMenu.addSeparator()
-
-        # Document > Check for Updates
-        self.aUpdates = self.helpMenu.addAction(self.tr("Check for New Release"))
-        self.aUpdates.triggered.connect(self.mainGui.showUpdatesDialog)
-
         return
 
 # END Class GuiMainMenu

novelwriter/gui/noveltree.py

@@ -207,9 +207,10 @@ class GuiNovelToolBar(QWidget):
         # Novel Selector
         selFont = self.font()
         selFont.setWeight(QFont.Weight.Bold)
-        self.novelPrefix = self.tr("Outline of {0}")
+
         self.novelValue = NovelSelector(self)
         self.novelValue.setFont(selFont)
+        self.novelValue.setListFormat(self.tr("Outline of {0}"))
         self.novelValue.setMinimumWidth(CONFIG.pxInt(150))
         self.novelValue.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
         self.novelValue.novelSelectionChanged.connect(self.setCurrentRoot)
@@ -294,7 +295,7 @@ class GuiNovelToolBar(QWidget):
             "QComboBox {border-style: none; padding-left: 0;} "
             "QComboBox::drop-down {border-style: none}"
         )
-        self.novelValue.updateList(prefix=self.novelPrefix)
+        self.novelValue.refreshNovelList()
         self.tbNovel.setVisible(self.novelValue.count() > 1)
 
         return
@@ -307,7 +308,7 @@ class GuiNovelToolBar(QWidget):
 
     def buildNovelRootMenu(self) -> None:
         """Build the novel root menu."""
-        self.novelValue.updateList(prefix=self.novelPrefix)
+        self.novelValue.refreshNovelList()
         self.tbNovel.setVisible(self.novelValue.count() > 1)
         return
 
@@ -674,7 +675,7 @@ class GuiNovelTree(QTreeWidget):
         tStart = time()
         logger.debug("Building novel tree for root item '%s'", rootHandle)
 
-        novStruct = SHARED.project.index.novelStructure(rootHandle=rootHandle, skipExcl=True)
+        novStruct = SHARED.project.index.novelStructure(rootHandle=rootHandle, activeOnly=True)
         for tKey, tHandle, sTitle, novIdx in novStruct:
             if novIdx.level == "H0":
                 continue
@@ -725,17 +726,17 @@ class GuiNovelTree(QTreeWidget):
 
         refData = []
         refName = ""
-        theRefs = SHARED.project.index.getReferences(tHandle, sTitle)
+        refs = SHARED.project.index.getReferences(tHandle, sTitle)
         if self._lastCol == NovelTreeColumn.POV:
-            refData = theRefs[nwKeyWords.POV_KEY]
+            refData = refs[nwKeyWords.POV_KEY]
             refName = self._povLabel
 
         elif self._lastCol == NovelTreeColumn.FOCUS:
-            refData = theRefs[nwKeyWords.FOCUS_KEY]
+            refData = refs[nwKeyWords.FOCUS_KEY]
             refName = self._focLabel
 
         elif self._lastCol == NovelTreeColumn.PLOT:
-            refData = theRefs[nwKeyWords.PLOT_KEY]
+            refData = refs[nwKeyWords.PLOT_KEY]
             refName = self._pltLabel
 
         if refData:

novelwriter/gui/outline.py

@@ -27,18 +27,17 @@ along with this program. If not, see <https://www.gnu.org/licenses/>.
 """
 from __future__ import annotations
 
+import csv
 import logging
 
 from time import time
 from enum import Enum
 
-from PyQt5.QtCore import (
-    Qt, pyqtSignal, pyqtSlot, QSize, QT_TRANSLATE_NOOP
-)
+from PyQt5.QtCore import Qt, pyqtSignal, pyqtSlot, QSize, QT_TRANSLATE_NOOP
 from PyQt5.QtWidgets import (
-    QAbstractItemView, QAction, QFrame, QGridLayout, QGroupBox, QHBoxLayout,
-    QLabel, QMenu, QScrollArea, QSizePolicy, QSplitter, QToolBar, QToolButton,
-    QTreeWidget, QTreeWidgetItem, QVBoxLayout, QWidget
+    QAbstractItemView, QAction, QFileDialog, QFrame, QGridLayout, QGroupBox,
+    QHBoxLayout, QLabel, QMenu, QScrollArea, QSizePolicy, QSplitter, QToolBar,
+    QToolButton, QTreeWidget, QTreeWidgetItem, QVBoxLayout, QWidget
 )
 
 from novelwriter import CONFIG, SHARED
@@ -46,7 +45,7 @@ from novelwriter.enum import (
     nwDocMode, nwItemClass, nwItemLayout, nwItemType, nwOutline
 )
 from novelwriter.error import logException
-from novelwriter.common import checkInt
+from novelwriter.common import checkInt, formatFileFilter, makeFileNameSafe
 from novelwriter.constants import nwHeaders, trConst, nwKeyWords, nwLabels
 from novelwriter.extensions.novelselector import NovelSelector
 
@@ -88,6 +87,7 @@ class GuiOutlineView(QWidget):
         self.outlineData.itemTagClicked.connect(self._tagClicked)
         self.outlineBar.loadNovelRootRequest.connect(self._rootItemChanged)
         self.outlineBar.viewColumnToggled.connect(self.outlineTree.menuColumnToggled)
+        self.outlineBar.outlineExportRequest.connect(self.outlineTree.exportOutline)
 
         # Function Mappings
         self.getSelectedHandle = self.outlineTree.getSelectedHandle
@@ -124,7 +124,7 @@ class GuiOutlineView(QWidget):
     def openProjectTasks(self) -> None:
         """Run open project tasks."""
         lastOutline = SHARED.project.data.getLastHandle("outline")
-        if not (lastOutline is None or lastOutline in SHARED.project.tree):
+        if not lastOutline or lastOutline not in SHARED.project.tree:
             lastOutline = SHARED.project.tree.findRoot(nwItemClass.NOVEL)
 
         logger.debug("Setting outline tree to root item '%s'", lastOutline)
@@ -198,6 +198,7 @@ class GuiOutlineView(QWidget):
 class GuiOutlineToolBar(QToolBar):
 
     loadNovelRootRequest = pyqtSignal(str)
+    outlineExportRequest = pyqtSignal()
     viewColumnToggled = pyqtSignal(bool, Enum)
 
     def __init__(self, outlineView: GuiOutlineView) -> None:
@@ -220,6 +221,7 @@ class GuiOutlineToolBar(QToolBar):
         self.novelLabel.setContentsMargins(0, 0, mPx, 0)
 
         self.novelValue = NovelSelector(self)
+        self.novelValue.setIncludeAll(True)
         self.novelValue.setMinimumWidth(CONFIG.pxInt(200))
         self.novelValue.novelSelectionChanged.connect(self._novelValueChanged)
 
@@ -227,6 +229,9 @@ class GuiOutlineToolBar(QToolBar):
         self.aRefresh = QAction(self.tr("Refresh"), self)
         self.aRefresh.triggered.connect(self._refreshRequested)
 
+        self.aExport = QAction(self.tr("Export CSV"), self)
+        self.aExport.triggered.connect(self._exportRequested)
+
         # Column Menu
         self.mColumns = GuiOutlineHeaderMenu(self)
         self.mColumns.columnToggled.connect(
@@ -242,6 +247,7 @@ class GuiOutlineToolBar(QToolBar):
         self.addWidget(self.novelValue)
         self.addSeparator()
         self.addAction(self.aRefresh)
+        self.addAction(self.aExport)
         self.addWidget(self.tbColumns)
         self.addWidget(stretch)
 
@@ -258,15 +264,16 @@ class GuiOutlineToolBar(QToolBar):
     def updateTheme(self) -> None:
         """Update theme elements."""
         self.setStyleSheet("QToolBar {border: 0px;}")
-        self.novelValue.updateList(includeAll=True)
+        self.novelValue.refreshNovelList()
         self.aRefresh.setIcon(SHARED.theme.getIcon("refresh"))
+        self.aExport.setIcon(SHARED.theme.getIcon("export"))
         self.tbColumns.setIcon(SHARED.theme.getIcon("menu"))
         self.tbColumns.setStyleSheet("QToolButton::menu-indicator {image: none;}")
         return
 
     def populateNovelList(self) -> None:
         """Reload the content of the novel list."""
-        self.novelValue.updateList(includeAll=True)
+        self.novelValue.refreshNovelList()
         return
 
     def setCurrentRoot(self, rootHandle: str | None) -> None:
@@ -295,6 +302,12 @@ class GuiOutlineToolBar(QToolBar):
         self.loadNovelRootRequest.emit(self.novelValue.handle)
         return
 
+    @pyqtSlot()
+    def _exportRequested(self) -> None:
+        """Emit a signal that an export of the outline was requested."""
+        self.outlineExportRequest.emit()
+        return
+
 # END Class GuiOutlineToolBar
 
 
@@ -491,15 +504,48 @@ class GuiOutlineTree(QTreeWidget):
         """Get the currently selected handle. If multiple items are
         selected, return the first.
         """
-        selItem = self.selectedItems()
-        if selItem:
-            tHandle = selItem[0].data(self._colIdx[nwOutline.TITLE], self.D_HANDLE)
-            sTitle = selItem[0].data(self._colIdx[nwOutline.TITLE], self.D_TITLE)
+        if item := self.selectedItems():
+            tHandle = item[0].data(self._colIdx[nwOutline.TITLE], self.D_HANDLE)
+            sTitle = item[0].data(self._colIdx[nwOutline.TITLE], self.D_TITLE)
             return tHandle, sTitle
         return None, None
 
     ##
-    #  Slots
+    #  Public Slots
+    ##
+
+    @pyqtSlot(bool, Enum)
+    def menuColumnToggled(self, isChecked: bool, hItem: nwOutline) -> None:
+        """Receive the changes to column visibility forwarded by the
+        column selection menu.
+        """
+        if hItem in self._colIdx:
+            self.setColumnHidden(self._colIdx[hItem], not isChecked)
+            self._saveHeaderState()
+        return
+
+    @pyqtSlot()
+    def exportOutline(self) -> None:
+        """Export the outline as a CSV file."""
+        path = CONFIG.lastPath() / f"{makeFileNameSafe(SHARED.project.data.name)}.csv"
+        path, _ = QFileDialog.getSaveFileName(
+            self, self.tr("Save Outline As"), str(path), formatFileFilter(["*.csv", "*"])
+        )
+        if path:
+            CONFIG.setLastPath(path)
+            logger.info("Writing CSV file: %s", path)
+            cols = [col for col in self._treeOrder if not self._colHidden[col]]
+            order = [self._colIdx[col] for col in cols]
+            with open(path, mode="w", newline="") as csvFile:
+                writer = csv.writer(csvFile, dialect="excel", quoting=csv.QUOTE_ALL)
+                writer.writerow([trConst(nwLabels.OUTLINE_COLS[col]) for col in cols])
+                for i in range(self.topLevelItemCount()):
+                    if item := self.topLevelItem(i):
+                        writer.writerow(item.text(i) for i in order)
+        return
+
+    ##
+    #  Private Slots
     ##
 
     @pyqtSlot("QTreeWidgetItem*", int)
@@ -509,9 +555,8 @@ class GuiOutlineTree(QTreeWidget):
         document editor.
         """
         tHandle, sTitle = self.getSelectedHandle()
-        if tHandle is None:
-            return
-        self.outlineView.openDocumentRequest.emit(tHandle, nwDocMode.EDIT, sTitle or "", True)
+        if tHandle:
+            self.outlineView.openDocumentRequest.emit(tHandle, nwDocMode.EDIT, sTitle or "", True)
         return
 
     @pyqtSlot()
@@ -535,16 +580,6 @@ class GuiOutlineTree(QTreeWidget):
         self._saveHeaderState()
         return
 
-    @pyqtSlot(bool, Enum)
-    def menuColumnToggled(self, isChecked: bool, hItem: nwOutline) -> None:
-        """Receive the changes to column visibility forwarded by the
-        column selection menu.
-        """
-        if hItem in self._colIdx:
-            self.setColumnHidden(self._colIdx[hItem], not isChecked)
-            self._saveHeaderState()
-        return
-
     ##
     #  Internal Functions
     ##
@@ -624,12 +659,12 @@ class GuiOutlineTree(QTreeWidget):
         self.clear()
 
         if self._firstView:
-            theLabels = []
+            labels = []
             for i, hItem in enumerate(self._treeOrder):
-                theLabels.append(trConst(nwLabels.OUTLINE_COLS[hItem]))
+                labels.append(trConst(nwLabels.OUTLINE_COLS[hItem]))
                 self._colIdx[hItem] = i
 
-            self.setHeaderLabels(theLabels)
+            self.setHeaderLabels(labels)
             for hItem in self._treeOrder:
                 self.setColumnWidth(self._colIdx[hItem], self._colWidth[hItem])
                 self.setColumnHidden(self._colIdx[hItem], self._colHidden[hItem])
@@ -646,7 +681,7 @@ class GuiOutlineTree(QTreeWidget):
                 headItem.setTextAlignment(
                     self._colIdx[nwOutline.PCOUNT], Qt.AlignmentFlag.AlignRight)
 
-        novStruct = SHARED.project.index.novelStructure(rootHandle=rootHandle, skipExcl=True)
+        novStruct = SHARED.project.index.novelStructure(rootHandle=rootHandle, activeOnly=True)
         for _, tHandle, sTitle, novIdx in novStruct:
 
             iLevel = nwHeaders.H_LEVEL.get(novIdx.level, 0)
@@ -842,18 +877,15 @@ class GuiOutlineDetails(QScrollArea):
         self.entKeyValue.setWordWrap(True)
         self.cstKeyValue.setWordWrap(True)
 
-        def tagClicked(link):
-            self.itemTagClicked.emit(link)
-
-        self.povKeyValue.linkActivated.connect(tagClicked)
-        self.focKeyValue.linkActivated.connect(tagClicked)
-        self.chrKeyValue.linkActivated.connect(tagClicked)
-        self.pltKeyValue.linkActivated.connect(tagClicked)
-        self.timKeyValue.linkActivated.connect(tagClicked)
-        self.wldKeyValue.linkActivated.connect(tagClicked)
-        self.objKeyValue.linkActivated.connect(tagClicked)
-        self.entKeyValue.linkActivated.connect(tagClicked)
-        self.cstKeyValue.linkActivated.connect(tagClicked)
+        self.povKeyValue.linkActivated.connect(lambda x: self.itemTagClicked.emit(x))
+        self.focKeyValue.linkActivated.connect(lambda x: self.itemTagClicked.emit(x))
+        self.chrKeyValue.linkActivated.connect(lambda x: self.itemTagClicked.emit(x))
+        self.pltKeyValue.linkActivated.connect(lambda x: self.itemTagClicked.emit(x))
+        self.timKeyValue.linkActivated.connect(lambda x: self.itemTagClicked.emit(x))
+        self.wldKeyValue.linkActivated.connect(lambda x: self.itemTagClicked.emit(x))
+        self.objKeyValue.linkActivated.connect(lambda x: self.itemTagClicked.emit(x))
+        self.entKeyValue.linkActivated.connect(lambda x: self.itemTagClicked.emit(x))
+        self.cstKeyValue.linkActivated.connect(lambda x: self.itemTagClicked.emit(x))
 
         self.povKeyLWrap.addWidget(self.povKeyValue, 1)
         self.focKeyLWrap.addWidget(self.focKeyValue, 1)
@@ -982,49 +1014,40 @@ class GuiOutlineDetails(QScrollArea):
     ##
 
     @pyqtSlot(str, str)
-    def showItem(self, tHandle: str, sTitle: str) -> bool:
+    def showItem(self, tHandle: str, sTitle: str) -> None:
         """Update the content of the tree with the given handle and line
         number pointing to a header.
         """
         pIndex = SHARED.project.index
         nwItem = SHARED.project.tree[tHandle]
         novIdx = pIndex.getItemHeader(tHandle, sTitle)
-        theRefs = pIndex.getReferences(tHandle, sTitle)
-        if nwItem is None or novIdx is None:
-            return False
-
-        if novIdx.level in self.LVL_MAP:
-            self.titleLabel.setText("<b>%s</b>" % self.tr(self.LVL_MAP[novIdx.level]))
-        else:
-            self.titleLabel.setText("<b>%s</b>" % self.tr("Title"))
-        self.titleValue.setText(novIdx.title)
+        novRefs = pIndex.getReferences(tHandle, sTitle)
+        if nwItem and novIdx:
+            self.titleLabel.setText("<b>%s</b>" % self.tr(self.LVL_MAP.get(novIdx.level, "H1")))
+            self.titleValue.setText(novIdx.title)
 
-        itemStatus, _ = nwItem.getImportStatus(incIcon=False)
+            itemStatus, _ = nwItem.getImportStatus(incIcon=False)
 
-        self.fileValue.setText(nwItem.itemName)
-        self.itemValue.setText(itemStatus)
+            self.fileValue.setText(nwItem.itemName)
+            self.itemValue.setText(itemStatus)
 
-        cC = checkInt(novIdx.charCount, 0)
-        wC = checkInt(novIdx.wordCount, 0)
-        pC = checkInt(novIdx.paraCount, 0)
+            self.cCValue.setText(f"{checkInt(novIdx.charCount, 0):n}")
+            self.wCValue.setText(f"{checkInt(novIdx.wordCount, 0):n}")
+            self.pCValue.setText(f"{checkInt(novIdx.paraCount, 0):n}")
 
-        self.cCValue.setText(f"{cC:n}")
-        self.wCValue.setText(f"{wC:n}")
-        self.pCValue.setText(f"{pC:n}")
+            self.synopValue.setText(novIdx.synopsis)
 
-        self.synopValue.setText(novIdx.synopsis)
+            self.povKeyValue.setText(self._formatTags(novRefs, nwKeyWords.POV_KEY))
+            self.focKeyValue.setText(self._formatTags(novRefs, nwKeyWords.FOCUS_KEY))
+            self.chrKeyValue.setText(self._formatTags(novRefs, nwKeyWords.CHAR_KEY))
+            self.pltKeyValue.setText(self._formatTags(novRefs, nwKeyWords.PLOT_KEY))
+            self.timKeyValue.setText(self._formatTags(novRefs, nwKeyWords.TIME_KEY))
+            self.wldKeyValue.setText(self._formatTags(novRefs, nwKeyWords.WORLD_KEY))
+            self.objKeyValue.setText(self._formatTags(novRefs, nwKeyWords.OBJECT_KEY))
+            self.entKeyValue.setText(self._formatTags(novRefs, nwKeyWords.ENTITY_KEY))
+            self.cstKeyValue.setText(self._formatTags(novRefs, nwKeyWords.CUSTOM_KEY))
 
-        self.povKeyValue.setText(self._formatTags(theRefs, nwKeyWords.POV_KEY))
-        self.focKeyValue.setText(self._formatTags(theRefs, nwKeyWords.FOCUS_KEY))
-        self.chrKeyValue.setText(self._formatTags(theRefs, nwKeyWords.CHAR_KEY))
-        self.pltKeyValue.setText(self._formatTags(theRefs, nwKeyWords.PLOT_KEY))
-        self.timKeyValue.setText(self._formatTags(theRefs, nwKeyWords.TIME_KEY))
-        self.wldKeyValue.setText(self._formatTags(theRefs, nwKeyWords.WORLD_KEY))
-        self.objKeyValue.setText(self._formatTags(theRefs, nwKeyWords.OBJECT_KEY))
-        self.entKeyValue.setText(self._formatTags(theRefs, nwKeyWords.ENTITY_KEY))
-        self.cstKeyValue.setText(self._formatTags(theRefs, nwKeyWords.CUSTOM_KEY))
-
-        return True
+        return
 
     @pyqtSlot()
     def updateClasses(self) -> None: