tags.
Arguments:
pixels -- the amount to indent
"""
self.textLines[0] = ('
{1}'.
format(pixels * self.level, self.textLines[0]))
if not self.siblingPrefix and self.textLines[-1].endswith('
'):
self.textLines[-1] = self.textLines[-1][:-6]
self.textLines[-1] += '
'
def addSiblingPrefix(self):
"""Add the sibling prefix before this output.
"""
if self.siblingPrefix:
self.textLines[0] = self.siblingPrefix + self.textLines[0]
def addSiblingSuffix(self):
"""Add the sibling suffix after this output.
"""
if self.siblingSuffix:
self.textLines[-1] += self.siblingSuffix
def addAnchor(self):
"""Add a link anchor to this item.
"""
self.textLines[0] = '
{1}'.format(self.uId,
self.textLines[0])
def intLinkIds(self):
"""Return a set of uIDs from any internal links in this item.
"""
linkIds = set()
for line in self.textLines:
startPos = 0
while True:
match = _linkRe.search(line, startPos)
if not match:
break
uId = match.group(1)
if uId:
linkIds.add(uId)
startPos = match.start(1)
return linkIds
def numLines(self):
"""Return the number of text lines in the item.
"""
return len(self.textLines)
def equalPrefix(self, otherItem):
"""Return True if sibling prefixes and suffixes are equal.
Arguments:
otherItem -- the item to compare
"""
return (self.siblingPrefix == otherItem.siblingPrefix and
self.siblingSuffix == otherItem.siblingSuffix)
def setDocHeight(self, paintDevice, width, printFont,
replaceDoc=False):
"""Set the height of this item for use in printer output.
Creates an output document if not already created.
Arguments:
paintDevice -- the printer or other device for settings
width -- the width available for the output text
printFont -- the default font for the document
replaceDoc -- if true, re-create the text document
"""
if not self.doc or replaceDoc:
self.doc = QTextDocument()
lines = '\n'.join(self.textLines)
if lines.endswith('
'):
# remove trailing
tag to avoid excess space
lines = lines[:-6]
self.doc.setHtml(lines)
self.doc.setDefaultFont(printFont)
frameFormat = self.doc.rootFrame().frameFormat()
frameFormat.setBorder(0)
frameFormat.setMargin(0)
frameFormat.setPadding(0)
self.doc.rootFrame().setFrameFormat(frameFormat)
layout = self.doc.documentLayout()
layout.setPaintDevice(paintDevice)
self.doc.setTextWidth(width)
self.height = layout.documentSize().height()
def splitDocHeight(self, initHeight, maxHeight, paintDevice, width,
printFont):
"""Split this item into two items and return them.
The first item will fit into initHeight if practical.
Splits at line endings if posible.
Arguments:
initHeight -- the preferred height of the first page
maxheight -- the max height of any pages
paintDevice -- the printer or other device for settings
width -- the width available for the output text
printFont -- the default font for the document
"""
newItem = self.duplicate()
fullHeight = self.height
lines = '\n'.join(self.textLines)
allLines = [line + '
' for line in lines.split('
')]
self.textLines = []
prevHeight = 0
for line in allLines:
self.textLines.append(line)
self.setDocHeight(paintDevice, width, printFont, True)
if ((prevHeight and self.height > initHeight and
fullHeight - prevHeight > maxHeight) or
(prevHeight and self.height > maxHeight)):
self.textLines = self.textLines[:-1]
self.setDocHeight(paintDevice, width, printFont, True)
newItem.textLines = allLines[len(self.textLines):]
newItem.setDocHeight(paintDevice, width, printFont, True)
return (self, newItem)
if self.height > maxHeight:
break
prevHeight = self.height
# no line ending breaks found
text = ' \n'.join(allLines)
allWords = [word + ' ' for word in text.split(' ')]
newWords = []
prevHeight = 0
for word in allWords:
if word.strip() == '
initHeight and
fullHeight - prevHeight < maxHeight) or
(prevHeight and self.height > maxHeight)):
self.textLines = [''.join(newWords[:-1])]
self.setDocHeight(paintDevice, width, printFont, True)
newItem.textLines = [''.join(allWords[len(newWords):])]
newItem.setDocHeight(paintDevice, width, printFont, True)
return (self, newItem)
if self.height > maxHeight:
break
prevHeight = self.height
newItem.setDocHeight(paintDevice, width, printFont, True)
return (newItem, None) # fail to split
class OutputGroup(list):
"""A list of OutputItems that takes TreeNodes as input.
Modifies the output text for use in views, html and printing.
"""
def __init__(self, spotList, includeRoot=True, includeDescend=False,
openOnly=False):
"""Convert the node iter list into a list of output items.
Arguments:
spotList -- a list of spots to convert to output
includeRoot -- if True, include the nodes in nodeList
includeDescend -- if True, include children, grandchildren, etc.
openOnly -- if true, ignore collapsed children in the main treeView
"""
super().__init__()
for spot in spotList:
level = -1
if includeRoot:
level = 0
self.append(OutputItem(spot, level))
if includeDescend:
self.addChildren(spot, level, openOnly)
def addChildren(self, spot, level, openOnly=False):
"""Recursively add OutputItems for descendants of the given spot.
Arguments:
spot -- the parent tree spot
level -- the parent node's original indent level
"""
treeView = globalref.mainControl.activeControl.activeWindow.treeView
if not openOnly or treeView.isSpotExpanded(spot):
for child in spot.childSpots():
self.append(OutputItem(child, level + 1))
self.addChildren(child, level + 1, openOnly)
def addIndents(self):
"""Add nested elements to define indentations in the output.
"""
prevLevel = 0
for item, nextItem in itertools.zip_longest(self, self[1:]):
try:
nextLevel = nextItem.level
except AttributeError:
nextLevel = 0
item.addIndent(prevLevel, nextLevel)
prevLevel = item.level
def addAbsoluteIndents(self, pixels=20):
"""Add tags for individual indentation on each node.
The Qt output view does not fully support nested
tags.
Arguments:
pixels -- the amount to indent
"""
for item in self:
item.addAbsoluteIndent(pixels)
def addBlanksBetween(self):
"""Add blank lines between nodes based on node format's spaceBetween.
"""
for item, nextItem in zip(self, self[1:]):
if item.addSpace or nextItem.addSpace:
item.textLines[-1] += '
'
def addAnchors(self, extraLevels=0):
"""Add anchors to items that are targets and to low level items.
Arguments:
extraLevels -- force adding anchors if level < this
"""
linkIds = set()
for item in self:
linkIds.update(item.intLinkIds())
for item in self:
if item.uId in linkIds or item.level < extraLevels:
item.addAnchor()
def hasPrefixes(self):
"""Return True if sibling prefixes or suffixes are found.
"""
return bool([item for item in self if item.siblingPrefix or
item.siblingSuffix])
def addSiblingPrefixes(self):
"""Add sibling prefixes and suffixes for each node.
"""
if not self.hasPrefixes():
return
addPrefix = True
for item, nextItem in itertools.zip_longest(self, self[1:]):
if addPrefix:
item.addSiblingPrefix()
if (not nextItem or item.level != nextItem.level or
not item.equalPrefix(nextItem)):
item.addSiblingSuffix()
addPrefix = True
else:
addPrefix = False
def combineAllSiblings(self):
"""Group all sibling items with the same prefix into single items.
Also add sibling prefixes and suffixes and spaces in between.
"""
newItems = []
prevItem = None
for item in self:
if prevItem:
if item.level == prevItem.level and item.equalPrefix(prevItem):
if item.addSpace or prevItem.addSpace:
prevItem.textLines[-1] += '
'
prevItem.textLines.extend(item.textLines)
else:
prevItem.addSiblingSuffix()
newItems.append(prevItem)
item.addSiblingPrefix()
prevItem = item
else:
item.addSiblingPrefix()
prevItem = item
prevItem.addSiblingSuffix()
newItems.append(prevItem)
self[:] = newItems
def combineLines(self, addSpacing=True, addPrefixes=True):
"""Return an OutputItem including all of the text from all items.
Arguments:
addPrefixes -- if True, add sibling prefix and suffix to result
addSpacing -- if True, add spacing between items with addSpace True
"""
comboItem = self[0].duplicate()
for item in self[1:]:
if item.addSpace:
comboItem.textLines[-1] += '
'
comboItem.textLines.extend(item.textLines)
if addPrefixes:
comboItem.addSiblingPrefix()
comboItem.addSiblingSuffix()
return comboItem
def splitColumns(self, numColumns):
"""Split output into even length columns using number of lines.
Return a list with a group for each column.
Arguments:
numColumns - the number of columns to split
"""
if numColumns < 2:
return [self]
groupList = []
if len(self) <= numColumns:
for item in self:
groupList.append(OutputGroup([]))
groupList[-1].append(item)
return groupList
numEach = len(self) // numColumns
for colNum in range(numColumns - 1):
groupList.append(OutputGroup([]))
groupList[-1].extend(self[colNum * numEach :
(colNum + 1) * numEach])
groupList.append(OutputGroup([]))
groupList[-1].extend(self[(numColumns - 1) * numEach : ])
numChanges = 1
while numChanges:
numChanges = 0
for colNum in range(numColumns - 1):
if (groupList[colNum].totalNumLines() > groupList[colNum + 1].
totalNumLines() + groupList[colNum][-1].numLines()):
groupList[colNum + 1].insert(0, groupList[colNum][-1])
del groupList[colNum][-1]
numChanges += 1
if (groupList[colNum].totalNumLines() +
groupList[colNum + 1][0].numLines() <=
groupList[colNum + 1].totalNumLines()):
groupList[colNum].append(groupList[colNum + 1][0])
del groupList[colNum + 1][0]
numChanges += 1
return groupList
def getLines(self):
"""Return the full list of text lines from this group.
"""
if not self:
return []
lines = []
for item in self:
lines.extend(item.textLines)
return lines
def totalNumLines(self):
"""Return the total number of lines of all items in this container.
"""
return sum([item.numLines() for item in self])
def loadFamilyRefs(self):
"""Set parentItem and lastChildItem for all items.
Used by the printdata class.
"""
recentParents = [None]
for item in self:
if item.level > 0:
item.parentItem = recentParents[item.level - 1]
item.parentItem.lastChildItem = item
try:
recentParents[item.level] = item
except IndexError:
recentParents.append(item)