Veronica Berglyd Olsen
543 lines
16 KiB
Python
543 lines
16 KiB
Python
"""
|
||
novelWriter – Project Item Class
|
||
================================
|
||
Data class for a project tree item
|
||
|
||
File History:
|
||
Created: 2018-10-27 [0.0.1]
|
||
|
||
This file is a part of novelWriter
|
||
Copyright 2018–2022, 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/>.
|
||
"""
|
||
|
||
import logging
|
||
|
||
from lxml import etree
|
||
|
||
from novelwriter.enum import nwItemType, nwItemClass, nwItemLayout
|
||
from novelwriter.common import (
|
||
checkInt, isHandle, isItemClass, isItemLayout, isItemType, simplified
|
||
)
|
||
from novelwriter.constants import nwLabels, trConst
|
||
|
||
logger = logging.getLogger(__name__)
|
||
|
||
|
||
class NWItem():
|
||
|
||
def __init__(self, theProject):
|
||
|
||
self.theProject = theProject
|
||
|
||
self._name = ""
|
||
self._handle = None
|
||
self._parent = None
|
||
self._root = None
|
||
self._order = 0
|
||
self._type = nwItemType.NO_TYPE
|
||
self._class = nwItemClass.NO_CLASS
|
||
self._layout = nwItemLayout.NO_LAYOUT
|
||
self._status = None
|
||
self._import = None
|
||
self._expanded = False
|
||
self._exported = True
|
||
|
||
# Document Meta Data
|
||
self._charCount = 0 # Current character count
|
||
self._wordCount = 0 # Current word count
|
||
self._paraCount = 0 # Current paragraph count
|
||
self._cursorPos = 0 # Last cursor position
|
||
self._initCount = 0 # Initial word count
|
||
|
||
return
|
||
|
||
def __repr__(self):
|
||
return f"<NWItem handle={self._handle}, parent={self._parent}, name='{self._name}'>"
|
||
|
||
def __bool__(self):
|
||
return self._handle is not None
|
||
|
||
##
|
||
# Properties
|
||
##
|
||
|
||
@property
|
||
def itemName(self):
|
||
return self._name
|
||
|
||
@property
|
||
def itemHandle(self):
|
||
return self._handle
|
||
|
||
@property
|
||
def itemParent(self):
|
||
return self._parent
|
||
|
||
@property
|
||
def itemRoot(self):
|
||
return self._root
|
||
|
||
@property
|
||
def itemOrder(self):
|
||
return self._order
|
||
|
||
@property
|
||
def itemType(self):
|
||
return self._type
|
||
|
||
@property
|
||
def itemClass(self):
|
||
return self._class
|
||
|
||
@property
|
||
def itemLayout(self):
|
||
return self._layout
|
||
|
||
@property
|
||
def itemStatus(self):
|
||
return self._status
|
||
|
||
@property
|
||
def itemImport(self):
|
||
return self._import
|
||
|
||
@property
|
||
def isExpanded(self):
|
||
return self._expanded
|
||
|
||
@property
|
||
def isExported(self):
|
||
return self._exported
|
||
|
||
@property
|
||
def charCount(self):
|
||
return self._charCount
|
||
|
||
@property
|
||
def wordCount(self):
|
||
return self._wordCount
|
||
|
||
@property
|
||
def paraCount(self):
|
||
return self._paraCount
|
||
|
||
@property
|
||
def initCount(self):
|
||
return self._initCount
|
||
|
||
@property
|
||
def cursorPos(self):
|
||
return self._cursorPos
|
||
|
||
##
|
||
# XML Pack/Unpack
|
||
##
|
||
|
||
def packXML(self, xParent):
|
||
"""Pack all the data in the class instance into an XML object.
|
||
"""
|
||
itemAttrib = {}
|
||
itemAttrib["handle"] = str(self._handle)
|
||
itemAttrib["parent"] = str(self._parent)
|
||
itemAttrib["root"] = str(self._root)
|
||
itemAttrib["order"] = str(self._order)
|
||
itemAttrib["type"] = str(self._type.name)
|
||
itemAttrib["class"] = str(self._class.name)
|
||
if self._type == nwItemType.FILE:
|
||
itemAttrib["layout"] = str(self._layout.name)
|
||
|
||
metaAttrib = {}
|
||
metaAttrib["expanded"] = str(self._expanded)
|
||
if self._type == nwItemType.FILE:
|
||
metaAttrib["charCount"] = str(self._charCount)
|
||
metaAttrib["wordCount"] = str(self._wordCount)
|
||
metaAttrib["paraCount"] = str(self._paraCount)
|
||
metaAttrib["cursorPos"] = str(self._cursorPos)
|
||
|
||
nameAttrib = {}
|
||
nameAttrib["status"] = str(self._status)
|
||
nameAttrib["import"] = str(self._import)
|
||
if self._type == nwItemType.FILE:
|
||
nameAttrib["exported"] = str(self._exported)
|
||
|
||
xPack = etree.SubElement(xParent, "item", attrib=itemAttrib)
|
||
self._subPack(xPack, "meta", attrib=metaAttrib)
|
||
self._subPack(xPack, "name", text=str(self._name), attrib=nameAttrib)
|
||
|
||
return
|
||
|
||
def unpackXML(self, xItem):
|
||
"""Set the values from an XML entry of type 'item'.
|
||
"""
|
||
if xItem.tag != "item":
|
||
logger.error("XML entry is not an NWItem")
|
||
return False
|
||
|
||
if "handle" in xItem.attrib:
|
||
self.setHandle(xItem.attrib["handle"])
|
||
else:
|
||
logger.error("XML item entry does not have a handle")
|
||
return False
|
||
|
||
self.setParent(xItem.attrib.get("parent", None))
|
||
self.setRoot(xItem.attrib.get("root", None))
|
||
self.setOrder(xItem.attrib.get("order", 0))
|
||
self.setType(xItem.attrib.get("type", nwItemType.NO_TYPE))
|
||
self.setClass(xItem.attrib.get("class", nwItemClass.NO_CLASS))
|
||
self.setLayout(xItem.attrib.get("layout", nwItemLayout.NO_LAYOUT))
|
||
|
||
for xValue in xItem:
|
||
if xValue.tag == "meta":
|
||
self.setExpanded(xValue.attrib.get("expanded", False))
|
||
self.setCharCount(xValue.attrib.get("charCount", 0))
|
||
self.setWordCount(xValue.attrib.get("wordCount", 0))
|
||
self.setParaCount(xValue.attrib.get("paraCount", 0))
|
||
self.setCursorPos(xValue.attrib.get("cursorPos", 0))
|
||
elif xValue.tag == "name":
|
||
self.setName(xValue.text)
|
||
self.setStatus(xValue.attrib.get("status", None))
|
||
self.setImport(xValue.attrib.get("import", None))
|
||
self.setExported(xValue.attrib.get("exported", True))
|
||
|
||
# Legacy Format (1.3 and earlier)
|
||
elif xValue.tag == "status":
|
||
self.setImportStatus(xValue.text)
|
||
elif xValue.tag == "type":
|
||
self.setType(xValue.text)
|
||
elif xValue.tag == "class":
|
||
self.setClass(xValue.text)
|
||
elif xValue.tag == "layout":
|
||
self.setLayout(xValue.text)
|
||
elif xValue.tag == "expanded":
|
||
self.setExpanded(xValue.text)
|
||
elif xValue.tag == "exported":
|
||
self.setExported(xValue.text)
|
||
elif xValue.tag == "charCount":
|
||
self.setCharCount(xValue.text)
|
||
elif xValue.tag == "wordCount":
|
||
self.setWordCount(xValue.text)
|
||
elif xValue.tag == "paraCount":
|
||
self.setParaCount(xValue.text)
|
||
elif xValue.tag == "cursorPos":
|
||
self.setCursorPos(xValue.text)
|
||
else:
|
||
# Sliently skip as we may otherwise cause orphaned
|
||
# items if an otherwise valid file is opened by a
|
||
# version of novelWriter that doesn't know the tag
|
||
logger.error("Unknown tag '%s'", xValue.tag)
|
||
|
||
# Make some checks to ensure consistency
|
||
if self._type == nwItemType.ROOT:
|
||
self._root = self._handle # Root items are their own ancestor
|
||
self._parent = None # Root items cannot have a parent
|
||
|
||
if self._type != nwItemType.FILE:
|
||
self._charCount = 0 # Only set for files
|
||
self._wordCount = 0 # Only set for files
|
||
self._paraCount = 0 # Only set for files
|
||
self._cursorPos = 0 # Only set for files
|
||
|
||
return True
|
||
|
||
@staticmethod
|
||
def _subPack(xParent, name, attrib=None, text=None, none=True):
|
||
"""Pack the values into an XML element.
|
||
"""
|
||
if not none and (text is None or text == "None"):
|
||
return None
|
||
xAttr = {} if attrib is None else attrib
|
||
xSub = etree.SubElement(xParent, name, attrib=xAttr)
|
||
if text is not None:
|
||
xSub.text = text
|
||
|
||
return
|
||
|
||
##
|
||
# Lookup Methods
|
||
##
|
||
|
||
def describeMe(self, hLevel=None):
|
||
"""Return a string description of the item.
|
||
"""
|
||
descKey = "none"
|
||
if self._type == nwItemType.ROOT:
|
||
descKey = "root"
|
||
elif self._type == nwItemType.FOLDER:
|
||
descKey = "folder"
|
||
elif self._type == nwItemType.FILE:
|
||
if self._layout == nwItemLayout.DOCUMENT:
|
||
if hLevel == "H1":
|
||
descKey = "doc_h1"
|
||
elif hLevel == "H2":
|
||
descKey = "doc_h2"
|
||
elif hLevel == "H3":
|
||
descKey = "doc_h3"
|
||
else:
|
||
descKey = "document"
|
||
elif self._layout == nwItemLayout.NOTE:
|
||
descKey = "note"
|
||
|
||
return trConst(nwLabels.ITEM_DESCRIPTION.get(descKey, ""))
|
||
|
||
def getImportStatus(self):
|
||
"""Return the relevant importance or status label and icon for
|
||
the current item based on its class.
|
||
"""
|
||
if self.isNovelLike():
|
||
stName = self.theProject.statusItems.name(self._status)
|
||
stIcon = self.theProject.statusItems.icon(self._status)
|
||
else:
|
||
stName = self.theProject.importItems.name(self._import)
|
||
stIcon = self.theProject.importItems.icon(self._import)
|
||
return stName, stIcon
|
||
|
||
##
|
||
# Checker Methods
|
||
##
|
||
|
||
def isNovelLike(self):
|
||
"""Returns true if the item is of a novel-like class.
|
||
"""
|
||
return self._class in (nwItemClass.NOVEL, nwItemClass.ARCHIVE)
|
||
|
||
def documentAllowed(self):
|
||
"""Returns true if the item is allowed to be of document layout.
|
||
"""
|
||
return self._class in (nwItemClass.NOVEL, nwItemClass.ARCHIVE, nwItemClass.TRASH)
|
||
|
||
def isInactive(self):
|
||
"""Returns true if the item is in an inactive class.
|
||
"""
|
||
return self._class in (nwItemClass.NO_CLASS, nwItemClass.ARCHIVE, nwItemClass.TRASH)
|
||
|
||
def isRootType(self):
|
||
return self._type == nwItemType.ROOT
|
||
|
||
def isFolderType(self):
|
||
return self._type == nwItemType.FOLDER
|
||
|
||
def isFileType(self):
|
||
return self._type == nwItemType.FILE
|
||
|
||
def isNoteLayout(self):
|
||
return self._layout == nwItemLayout.NOTE
|
||
|
||
def isDocumentLayout(self):
|
||
return self._layout == nwItemLayout.DOCUMENT
|
||
|
||
##
|
||
# Special Setters
|
||
##
|
||
|
||
def setImportStatus(self, value):
|
||
"""Update the importance or status value based on class. This is
|
||
a wrapper setter for setStatus and setImport.
|
||
"""
|
||
if self.isNovelLike():
|
||
self.setStatus(value)
|
||
else:
|
||
self.setImport(value)
|
||
return
|
||
|
||
def setClassDefaults(self, itemClass):
|
||
"""Set the default values based on the item's class and the
|
||
project settings.
|
||
"""
|
||
if self._parent is not None:
|
||
# Only update for child items
|
||
self.setClass(itemClass)
|
||
|
||
if self._layout == nwItemLayout.NO_LAYOUT:
|
||
# If no layout is set, pick one
|
||
if self.isNovelLike():
|
||
self._layout = nwItemLayout.DOCUMENT
|
||
else:
|
||
self._layout = nwItemLayout.NOTE
|
||
elif not self.documentAllowed():
|
||
# Change layout to note if it is not in an allowed folder
|
||
self._layout = nwItemLayout.NOTE
|
||
|
||
if self._status is None:
|
||
self.setStatus("New") # This forces a default value lookup
|
||
|
||
if self._import is None:
|
||
self.setImport("New") # This forces a default value lookup
|
||
|
||
return
|
||
|
||
##
|
||
# Set Item Values
|
||
##
|
||
|
||
def setName(self, name):
|
||
"""Set the item name.
|
||
"""
|
||
if isinstance(name, str):
|
||
self._name = simplified(name)
|
||
else:
|
||
self._name = ""
|
||
return
|
||
|
||
def setHandle(self, handle):
|
||
"""Set the item handle, and ensure it is valid.
|
||
"""
|
||
if isHandle(handle):
|
||
self._handle = handle
|
||
else:
|
||
self._handle = None
|
||
return
|
||
|
||
def setParent(self, handle):
|
||
"""Set the parent handle, and ensure it is valid.
|
||
"""
|
||
if handle is None:
|
||
self._parent = None
|
||
elif isHandle(handle):
|
||
self._parent = handle
|
||
else:
|
||
self._parent = None
|
||
return
|
||
|
||
def setRoot(self, handle):
|
||
"""Set the root handle, and ensure it is valid.
|
||
"""
|
||
if handle is None:
|
||
self._root = None
|
||
elif isHandle(handle):
|
||
self._root = handle
|
||
else:
|
||
self._root = None
|
||
return
|
||
|
||
def setOrder(self, order):
|
||
"""Set the item order, and ensure that it is valid. This value
|
||
is purely a meta value, and not actually used by novelWriter at
|
||
the moment.
|
||
"""
|
||
self._order = checkInt(order, 0)
|
||
return
|
||
|
||
def setType(self, value):
|
||
"""Set the item type from either a proper nwItemType, or set it
|
||
from a string representing an nwItemType.
|
||
"""
|
||
if isinstance(value, nwItemType):
|
||
self._type = value
|
||
elif isItemType(value):
|
||
self._type = nwItemType[value]
|
||
elif value == "TRASH":
|
||
self._type = nwItemType.ROOT
|
||
else:
|
||
logger.error("Unrecognised item type '%s'", value)
|
||
self._type = nwItemType.NO_TYPE
|
||
return
|
||
|
||
def setClass(self, value):
|
||
"""Set the item class from either a proper nwItemClass, or set
|
||
it from a string representing an nwItemClass.
|
||
"""
|
||
if isinstance(value, nwItemClass):
|
||
self._class = value
|
||
elif isItemClass(value):
|
||
self._class = nwItemClass[value]
|
||
else:
|
||
logger.error("Unrecognised item class '%s'", value)
|
||
self._class = nwItemClass.NO_CLASS
|
||
return
|
||
|
||
def setLayout(self, value):
|
||
"""Set the item layout from either a proper nwItemLayout, or set
|
||
it from a string representing an nwItemLayout.
|
||
"""
|
||
if isinstance(value, nwItemLayout):
|
||
self._layout = value
|
||
elif isItemLayout(value):
|
||
self._layout = nwItemLayout[value]
|
||
elif value in ("TITLE", "PAGE", "BOOK", "PARTITION", "UNNUMBERED", "CHAPTER", "SCENE"):
|
||
self._layout = nwItemLayout.DOCUMENT
|
||
else:
|
||
logger.error("Unrecognised item layout '%s'", value)
|
||
self._layout = nwItemLayout.NO_LAYOUT
|
||
return
|
||
|
||
def setStatus(self, value):
|
||
"""Set the item status by looking it up in the valid status
|
||
items of the current project.
|
||
"""
|
||
self._status = self.theProject.statusItems.check(value)
|
||
return
|
||
|
||
def setImport(self, value):
|
||
"""Set the item importance by looking it up in the valid import
|
||
items of the current project.
|
||
"""
|
||
self._import = self.theProject.importItems.check(value)
|
||
return
|
||
|
||
def setExpanded(self, state):
|
||
"""Set the expanded status of an item in the project tree.
|
||
"""
|
||
if isinstance(state, str):
|
||
self._expanded = (state == str(True))
|
||
else:
|
||
self._expanded = (state is True)
|
||
return
|
||
|
||
def setExported(self, state):
|
||
"""Set the export flag.
|
||
"""
|
||
if isinstance(state, str):
|
||
self._exported = (state == str(True))
|
||
else:
|
||
self._exported = (state is True)
|
||
return
|
||
|
||
##
|
||
# Set Document Meta Data
|
||
##
|
||
|
||
def setCharCount(self, count):
|
||
"""Set the character count, and ensure that it is an integer.
|
||
"""
|
||
self._charCount = max(0, checkInt(count, 0))
|
||
return
|
||
|
||
def setWordCount(self, count):
|
||
"""Set the word count, and ensure that it is an integer.
|
||
"""
|
||
self._wordCount = max(0, checkInt(count, 0))
|
||
return
|
||
|
||
def setParaCount(self, count):
|
||
"""Set the paragraph count, and ensure that it is an integer.
|
||
"""
|
||
self._paraCount = max(0, checkInt(count, 0))
|
||
return
|
||
|
||
def setCursorPos(self, position):
|
||
"""Set the cursor position, and ensure that it is an integer.
|
||
"""
|
||
self._cursorPos = max(0, checkInt(position, 0))
|
||
return
|
||
|
||
def saveInitialCount(self):
|
||
"""Save the initial word count.
|
||
"""
|
||
self._initCount = self._wordCount
|
||
return
|
||
|
||
# END Class NWItem
|