\n')
return html
class TitleOutput(object):
"Return the HTML title tag"
pdftitle = None
title = None
def gethtml(self, container):
"Return the title tag"
return ['
' + self.gettitle() + '\n']
def gettitle(self):
"Return the correct title from the option or the PDF title"
if Options.title:
return Options.title
if TitleOutput.title:
return TitleOutput.title
if TitleOutput.pdftitle:
return TitleOutput.pdftitle
return 'Converted document'
class FooterOutput(object):
"Return the HTML code for the footer"
author = None
def gethtml(self, container):
"Footer HTML"
html = []
html.append('\n\n')
if FooterOutput.author and not Options.nocopy:
html.append('
\n')
year = datetime.date.today().year
html.append('
Copyright (C) ' + unicode(year) + ' ' + FooterOutput.author
+ '
\n')
html.append('
\n'
return indent
def closeindent(self, times):
"Close the indenting div a few times."
indent = ''
for i in range(times):
indent += '
\n'
return indent
class TOCTree(object):
"A tree that contains the full TOC."
def __init__(self):
self.tree = []
self.branches = []
def store(self, entry):
"Place the entry in a tree of entries."
while len(self.tree) < entry.depth:
self.tree.append(None)
if len(self.tree) > entry.depth:
self.tree = self.tree[:entry.depth]
stem = self.findstem()
if len(self.tree) == 0:
self.branches.append(entry)
self.tree.append(entry)
if stem:
entry.stem = stem
stem.branches.append(entry)
def findstem(self):
"Find the stem where our next element will be inserted."
for element in reversed(self.tree):
if element:
return element
return None
class TOCConverter(object):
"A converter from containers to TOC entries."
cache = dict()
tree = TOCTree()
def __init__(self):
self.indenter = Indenter()
def translate(self, container):
"Translate a container to TOC entry + indentation."
entry = self.convert(container)
if not entry:
return []
indent = self.indenter.getindent(entry.depth)
return [indent, entry]
def convert(self, container):
"Convert a container to a TOC entry."
if container.__class__ in [LyXHeader, LyXFooter]:
return TOCEntry().header(container)
if not hasattr(container, 'partkey'):
return None
if container.partkey in self.cache:
return TOCConverter.cache[container.partkey]
if container.level > LyXHeader.tocdepth:
return None
entry = TOCEntry().create(container)
TOCConverter.cache[container.partkey] = entry
TOCConverter.tree.store(entry)
return entry
import os.path
class Basket(object):
"A basket to place a set of containers. Can write them, store them..."
def setwriter(self, writer):
self.writer = writer
return self
class WriterBasket(Basket):
"A writer of containers. Just writes them out to a writer."
def write(self, container):
"Write a container to the line writer."
self.writer.write(container.gethtml())
def finish(self):
"Mark as finished."
self.writer.close()
class KeeperBasket(Basket):
"Keeps all containers stored."
def __init__(self):
self.contents = []
def write(self, container):
"Keep the container."
self.contents.append(container)
def finish(self):
"Finish the basket by flushing to disk."
self.flush()
def flush(self):
"Flush the contents to the writer."
for container in self.contents:
self.writer.write(container.gethtml())
class TOCBasket(Basket):
"A basket to place the TOC of a document."
def __init__(self):
self.converter = TOCConverter()
def setwriter(self, writer):
Basket.setwriter(self, writer)
Options.nocopy = True
self.writer.write(LyXHeader().gethtml())
return self
def write(self, container):
"Write the table of contents for a container."
entries = self.converter.translate(container)
for entry in entries:
self.writer.write(entry.gethtml())
def finish(self):
"Mark as finished."
self.writer.write(LyXFooter().gethtml())
class IntegralProcessor(object):
"A processor for an integral document."
def __init__(self):
"Create the processor for the integral contents."
self.storage = []
def locate(self, container):
"Locate only containers of the processed type."
return isinstance(container, self.processedtype)
def store(self, container):
"Store a new container."
self.storage.append(container)
def process(self):
"Process the whole storage."
for container in self.storage:
self.processeach(container)
class IntegralLayout(IntegralProcessor):
"A processor for layouts that will appear in the TOC."
processedtype = Layout
tocentries = []
def processeach(self, layout):
"Keep only layouts that have an entry."
if not hasattr(layout, 'entry'):
return
IntegralLayout.tocentries.append(layout)
class IntegralTOC(IntegralProcessor):
"A processor for an integral TOC."
processedtype = TableOfContents
def processeach(self, toc):
"Fill in a Table of Contents."
toc.output = TaggedOutput().settag('div class="fulltoc"', True)
converter = TOCConverter()
for container in IntegralLayout.tocentries:
toc.contents += converter.translate(container)
# finish off with the footer to align indents
toc.contents += converter.translate(LyXFooter())
def writetotoc(self, entries, toc):
"Write some entries to the TOC."
for entry in entries:
toc.contents.append(entry)
class IntegralBiblioEntry(IntegralProcessor):
"A processor for an integral bibliography entry."
processedtype = BiblioEntry
def processeach(self, entry):
"Process each entry."
number = NumberGenerator.instance.generateunique('integralbib')
link = Link().complete(number, 'biblio-' + number, type='biblioentry')
entry.contents = [Constant('['), link, Constant('] ')]
if entry.key in BiblioCite.cites:
for cite in BiblioCite.cites[entry.key]:
cite.complete(number, anchor = 'cite-' + number)
cite.destination = link
class IntegralFloat(IntegralProcessor):
"Store all floats in the document by type."
processedtype = Float
bytype = dict()
def processeach(self, float):
"Store each float by type."
if not float.type in IntegralFloat.bytype:
IntegralFloat.bytype[float.type] = []
IntegralFloat.bytype[float.type].append(float)
class IntegralListOf(IntegralProcessor):
"A processor for an integral list of floats."
processedtype = ListOf
def processeach(self, listof):
"Fill in a list of floats."
listof.output = TaggedOutput().settag('div class="fulltoc"', True)
if not listof.type in IntegralFloat.bytype:
Trace.message('No floats of type ' + listof.type)
return
for float in IntegralFloat.bytype[listof.type]:
entry = self.processfloat(float)
if entry:
listof.contents.append(entry)
def processfloat(self, float):
"Get an entry for the list of floats."
if float.parentfloat:
return None
link = self.createlink(float)
if not link:
return None
return TaggedText().complete([link], 'div class="toc"', True)
def createlink(self, float):
"Create the link to the float label."
captions = float.searchinside(float.contents, Caption)
if len(captions) == 0:
return None
labels = float.searchinside(float.contents, Label)
if len(labels) > 0:
label = labels[0]
else:
label = Label().create(' ', float.entry.replace(' ', '-'))
float.contents.insert(0, label)
labels.append(label)
if len(labels) > 1:
Trace.error('More than one label in ' + float.entry)
link = Link().complete(float.entry + u': ')
for caption in captions:
link.contents += caption.contents[1:]
link.destination = label
return link
class IntegralReference(IntegralProcessor):
"A processor for a reference to a label."
processedtype = Reference
def processeach(self, reference):
"Extract the text of the original label."
text = self.extracttext(reference.destination)
if text:
reference.contents.insert(0, Constant(text))
def extracttext(self, container):
"Extract the final text for the label."
while not hasattr(container, 'number'):
if not hasattr(container, 'parent'):
# no number; label must be in some unnumbered element
return None
container = container.parent
return container.number
class MemoryBasket(KeeperBasket):
"A basket which stores everything in memory, processes it and writes it."
def __init__(self):
"Create all processors in one go."
KeeperBasket.__init__(self)
self.processors = [
IntegralLayout(), IntegralTOC(), IntegralBiblioEntry(),
IntegralFloat(), IntegralListOf(), IntegralReference()
]
def finish(self):
"Process everything which cannot be done in one pass and write to disk."
self.process()
self.flush()
def process(self):
"Process everything with the integral processors."
self.searchintegral()
for processor in self.processors:
processor.process()
def searchintegral(self):
"Search for all containers for all integral processors."
for container in self.contents:
# container.tree()
if self.integrallocate(container):
self.integralstore(container)
container.locateprocess(self.integrallocate, self.integralstore)
def integrallocate(self, container):
"Locate all integrals."
for processor in self.processors:
if processor.locate(container):
return True
return False
def integralstore(self, container):
"Store a container in one or more processors."
for processor in self.processors:
if processor.locate(container):
processor.store(container)
class IntegralLink(IntegralProcessor):
"Integral link processing for multi-page output."
processedtype = Link
def processeach(self, link):
"Process each link and add the current page."
link.page = self.page
class SplittingBasket(Basket):
"A basket used to split the output in different files."
baskets = []
def setwriter(self, writer):
if not hasattr(writer, 'filename') or not writer.filename:
Trace.error('Cannot use standard output for split output; ' +
'please supply an output filename.')
exit()
self.writer = writer
self.base, self.extension = os.path.splitext(writer.filename)
self.converter = TOCConverter()
self.basket = MemoryBasket()
return self
def write(self, container):
"Write a container, possibly splitting the file."
self.basket.write(container)
def finish(self):
"Process the whole basket, create page baskets and flush all of them."
self.basket.process()
basket = self.addbasket(self.writer)
for container in self.basket.contents:
if self.mustsplit(container):
filename = self.getfilename(container)
Trace.debug('New page ' + filename)
basket.write(LyXFooter())
basket = self.addbasket(LineWriter(filename))
basket.write(LyXHeader())
basket.write(container)
for basket in self.baskets:
basket.process()
for basket in self.baskets:
basket.flush()
def addbasket(self, writer):
"Add a new basket."
basket = MemoryBasket()
basket.setwriter(writer)
self.baskets.append(basket)
# set the page name everywhere
basket.page = writer.filename
integrallink = IntegralLink()
integrallink.page = os.path.basename(basket.page)
basket.processors = [integrallink]
return basket
def mustsplit(self, container):
"Find out if the oputput file has to be split at this entry."
if self.splitalone(container):
return True
if not hasattr(container, 'entry'):
return False
entry = self.converter.convert(container)
if not entry:
return False
if hasattr(entry, 'split'):
return True
return entry.depth <= Options.splitpart
def splitalone(self, container):
"Find out if the container must be split in its own page."
found = []
container.locateprocess(
lambda container: container.__class__ in [PrintNomenclature, PrintIndex],
lambda container: found.append(container.__class__.__name__))
if not found:
return False
container.depth = 0
container.split = found[0].lower().replace('print', '')
return True
def getfilename(self, container):
"Get the new file name for a given container."
if hasattr(container, 'split'):
partname = '-' + container.split
else:
entry = self.converter.convert(container)
if entry.depth == Options.splitpart:
partname = '-' + container.number
else:
partname = '-' + container.type + '-' + container.number
return self.base + partname + self.extension
class PendingList(object):
"A pending list"
def __init__(self):
self.contents = []
self.type = None
def additem(self, item):
"Add a list item"
self.contents += item.contents
if not self.type:
self.type = item.type
def adddeeper(self, deeper):
"Add a deeper list item"
if self.empty():
self.insertfake()
item = self.contents[-1]
self.contents[-1].contents += deeper.contents
def generate(self):
"Get the resulting list"
if not self.type:
tag = 'ul'
else:
tag = TagConfig.listitems[self.type]
text = TaggedText().complete(self.contents, tag, True)
self.__init__()
return text
def isduewithitem(self, item):
"Decide whether the pending list must be generated before the given item"
if not self.type:
return False
if self.type != item.type:
return True
return False
def isduewithnext(self, next):
"Applies only if the list is finished with next item."
if not next:
return True
if not isinstance(next, ListItem) and not isinstance(next, DeeperList):
return True
return False
def empty(self):
return len(self.contents) == 0
def insertfake(self):
"Insert a fake item"
item = TaggedText().constant('', 'li class="nested"', True)
self.contents = [item]
self.type = 'Itemize'
def __unicode__(self):
result = 'pending ' + unicode(self.type) + ': ['
for element in self.contents:
result += unicode(element) + ', '
if len(self.contents) > 0:
result = result[:-2]
return result + ']'
class PostListItem(object):
"Postprocess a list item"
processedclass = ListItem
def postprocess(self, last, item, next):
"Add the item to pending and return an empty item"
if not hasattr(self.postprocessor, 'list'):
self.postprocessor.list = PendingList()
self.postprocessor.list.additem(item)
if self.postprocessor.list.isduewithnext(next):
return self.postprocessor.list.generate()
if isinstance(next, ListItem) and self.postprocessor.list.isduewithitem(next):
return self.postprocessor.list.generate()
return BlackBox()
class PostDeeperList(object):
"Postprocess a deeper list"
processedclass = DeeperList
def postprocess(self, last, deeper, next):
"Append to the list in the postprocessor"
if not hasattr(self.postprocessor, 'list'):
self.postprocessor.list = PendingList()
self.postprocessor.list.adddeeper(deeper)
if self.postprocessor.list.isduewithnext(next):
return self.postprocessor.list.generate()
return BlackBox()
Postprocessor.stages += [PostListItem, PostDeeperList]
class PostTable(object):
"Postprocess a table"
processedclass = Table
def postprocess(self, last, table, next):
"Postprocess a table: long table, multicolumn rows"
self.longtable(table)
for row in table.contents:
index = 0
while index < len(row.contents):
self.checkmulticolumn(row, index)
index += 1
return table
def longtable(self, table):
"Postprocess a long table, removing unwanted rows"
if not 'features' in table.parameters:
return
features = table.parameters['features']
if not 'islongtable' in features:
return
if features['islongtable'] != 'true':
return
if self.hasrow(table, 'endfirsthead'):
self.removerows(table, 'endhead')
if self.hasrow(table, 'endlastfoot'):
self.removerows(table, 'endfoot')
def hasrow(self, table, attrname):
"Find out if the table has a row of first heads"
for row in table.contents:
if attrname in row.parameters:
return True
return False
def removerows(self, table, attrname):
"Remove the head rows, since the table has first head rows."
for row in table.contents:
if attrname in row.parameters:
row.output = EmptyOutput()
def checkmulticolumn(self, row, index):
"Process a multicolumn attribute"
cell = row.contents[index]
if not hasattr(cell, 'parameters') or not 'multicolumn' in cell.parameters:
return
mc = cell.parameters['multicolumn']
if mc != '1':
Trace.error('Unprocessed multicolumn=' + unicode(multicolumn) +
' cell ' + unicode(cell))
return
total = 1
index += 1
while self.checkbounds(row, index):
del row.contents[index]
total += 1
cell.setmulticolumn(total)
def checkbounds(self, row, index):
"Check if the index is within bounds for the row"
if index >= len(row.contents):
return False
if not 'multicolumn' in row.contents[index].parameters:
return False
if row.contents[index].parameters['multicolumn'] != '2':
return False
return True
Postprocessor.stages.append(PostTable)
class PostFormula(object):
"Postprocess a formula"
processedclass = Formula
def postprocess(self, last, formula, next):
"Postprocess any formulae"
self.postnumbering(formula)
self.postcontents(formula.contents)
self.posttraverse(formula)
return formula
def postnumbering(self, formula):
"Check if it's a numbered equation, insert number."
if formula.header[0] != 'numbered':
return
formula.number = NumberGenerator.instance.generatechaptered('formula')
formula.entry = '(' + formula.number + ')'
functions = formula.searchremove(LabelFunction)
if len(functions) > 1:
Trace.error('More than one label in ' + unicode(formula))
return
if len(functions) == 0:
label = Label()
label.create(formula.entry + ' ', 'eq-' + formula.number, type="eqnumber")
else:
label = functions[0].label
label.complete(formula.entry + ' ')
label.parent = formula
formula.contents.insert(0, label)
def postcontents(self, contents):
"Search for sum or integral"
for index, bit in enumerate(contents):
self.checklimited(contents, index)
if isinstance(bit, FormulaBit):
self.postcontents(bit.contents)
def checklimited(self, contents, index):
"Check for a command with limits"
bit = contents[index]
if not isinstance(bit, EmptyCommand):
return
if not bit.command in FormulaConfig.limits['commands']:
return
limits = self.findlimits(contents, index + 1)
limits.reverse()
if len(limits) == 0:
return
tagged = TaggedBit().complete(limits, 'span class="limits"')
contents.insert(index + 1, tagged)
def findlimits(self, contents, index):
"Find the limits for the command"
limits = []
while index < len(contents):
if not self.checklimits(contents, index):
return limits
limits.append(contents[index])
del contents[index]
return limits
def checklimits(self, contents, index):
"Check for a command making the limits"
bit = contents[index]
if not isinstance(bit, SymbolFunction):
return False
if not bit.command in FormulaConfig.limits['operands']:
return False
bit.output.tag += ' class="bigsymbol"'
return True
def posttraverse(self, formula):
"Traverse over the contents to alter variables and space units."
flat = self.flatten(formula)
last = None
for bit, contents in self.traverse(flat):
if bit.type == 'alpha':
self.italicize(bit, contents)
elif bit.type == 'font' and last and last.type == 'number':
bit.contents.insert(0, FormulaConstant(u' '))
# last.contents.append(FormulaConstant(u' '))
last = bit
def flatten(self, bit):
"Return all bits as a single list of (bit, list) pairs."
flat = []
for element in bit.contents:
if element.type:
flat.append((element, bit.contents))
elif isinstance(element, FormulaBit):
flat += self.flatten(element)
return flat
def traverse(self, flattened):
"Traverse each (bit, list) pairs of the formula."
for element in flattened:
yield element
def italicize(self, bit, contents):
"Italicize the given bit of text."
index = contents.index(bit)
contents[index] = TaggedBit().complete([bit], 'i')
Postprocessor.stages.append(PostFormula)
class eLyXerConverter(object):
"Converter for a document in a lyx file. Places all output in a given basket."
def __init__(self):
self.filtering = False
def setio(self, ioparser):
"Set the InOutParser"
self.reader = ioparser.getreader()
self.basket = self.getbasket()
self.basket.setwriter(ioparser.getwriter())
return self
def getbasket(self):
"Get the appropriate basket for the current options."
if Options.toc:
return TOCBasket()
if Options.splitpart:
return SplittingBasket()
if Options.memory:
return MemoryBasket()
return WriterBasket()
def embed(self, reader):
"Embed the results from a reader into a memory basket."
"Header and footer are ignored. Useful for embedding one document inside another."
self.filtering = True
self.reader = reader
self.basket = MemoryBasket()
self.writer = NullWriter()
return self
def convert(self):
"Perform the conversion for the document"
try:
self.processcontents()
except (Exception):
Trace.error('Conversion failed at ' + self.reader.currentline())
raise
def processcontents(self):
"Parse the contents and write it by containers"
factory = ContainerFactory()
self.postproc = Postprocessor()
while not self.reader.finished():
container = factory.createcontainer(self.reader)
if container and not self.filtered(container):
result = self.postproc.postprocess(container)
if result:
self.basket.write(result)
# last round: clear the pipeline
result = self.postproc.postprocess(None)
if result:
self.basket.write(result)
if not self.filtering:
self.basket.finish()
def filtered(self, container):
"Find out if the container is a header or footer and must be filtered."
if not self.filtering:
return False
if container.__class__ in [LyXHeader, LyXFooter]:
return True
return False
def getcontents(self):
"Return the contents of the basket."
return self.basket.contents
def __unicode__(self):
"Printable representation."
string = 'Converter with filtering ' + unicode(self.filtering)
string += ' and basket ' + unicode(self.basket)
return string
class InOutParser(object):
"Parse in and out arguments"
def __init__(self):
self.filein = sys.stdin
self.fileout = sys.stdout
def parse(self, args):
"Parse command line arguments"
self.filein = sys.stdin
self.fileout = sys.stdout
if len(args) < 2:
Trace.quietmode = True
if len(args) > 0:
self.filein = args[0]
del args[0]
self.readdir(self.filein, 'directory')
else:
Options.directory = '.'
if len(args) > 0:
self.fileout = args[0]
del args[0]
self.readdir(self.fileout, 'destdirectory')
else:
Options.destdirectory = '.'
if len(args) > 0:
raise Exception('Unused arguments: ' + unicode(args))
return self
def getreader(self):
"Get the resulting reader."
return LineReader(self.filein)
def getwriter(self):
"Get the resulting writer."
return LineWriter(self.fileout)
def readdir(self, filename, diroption):
"Read the current directory if needed"
if getattr(Options, diroption) != None:
return
setattr(Options, diroption, os.path.dirname(filename))
if getattr(Options, diroption) == '':
setattr(Options, diroption, '.')
class NullWriter(object):
"A writer that goes nowhere."
def write(self, list):
"Do nothing."
pass
class ConverterFactory(object):
"Create a converter fit for converting a filename and embedding the result."
def create(self, container):
"Create a converter for a given container, with filename"
" and possibly other parameters."
fullname = os.path.join(Options.directory, container.filename)
reader = LineReader(fullname)
if 'firstline' in container.parameters:
reader.setstart(int(container.parameters['firstline']))
if 'lastline' in container.parameters:
reader.setend(int(container.parameters['lastline']))
return eLyXerConverter().embed(reader)
IncludeInset.converterfactory = ConverterFactory()
def convertdoc(args):
"Read a whole document and write it"
Options().parseoptions(args)
ioparser = InOutParser().parse(args)
converter = eLyXerConverter().setio(ioparser)
converter.convert()
def main():
"Main function, called if invoked from the command line"
convertdoc(list(sys.argv))
if __name__ == '__main__':
main()