\n'
return comm
elif issubclass(self.__class__, Par):
start = self.name + '@start'
end = self.name + '@end'
if start in jinja.elements and end in jinja.elements:
if self.parend:
comm += self.render_jinja_spec(jinja.elements[end], jinja)
if self.parstart:
comm += '\n' + self.render_jinja_spec(jinja.elements[start], jinja)
return comm
else:
print('ERROR: no start and and definition for Par object in jinja specification')
if self.name in jinja.elements:
comm = self.render_jinja_spec(jinja.elements[self.name], jinja)
return comm
else:
# catch all other commands that have a jinja specification
if self.name in jinja.elements:
comm = self.render_jinja_spec(jinja.elements[self.name], jinja)
return comm
# or use default rendering
# NEEDS TO BE IMPLEMENTED on the basis of jinja spec for @default
# THIS IS JUST A PRELIMINARY VERSION :::::
#
else:
# comm += f'\n'
# i = 0
# for optarg in self.optargs:
# i += 1
# comm += f'{optarg.content.render(jinja)}'
# i = 0
# for reqarg in self.reqargs:
# i += 1
# comm += f'{reqarg.content.render(jinja)}'
# comm += '\n'
return comm
def expand(self):
if issubclass(self.__class__, Table):
return self.expand_table()
optargs = ''
for arg in self.optargs: optargs += f'[{arg.content.expand()}]'
reqargs = ''
for arg in self.reqargs: reqargs += f'{{{arg.content.expand()}}}'
if optargs or reqargs:
if self.name == 'math': # AD HOC FIX FOR WEIRD BEHAVIOR IN FORMULAS
return f'{optargs}{reqargs}'
else:
return f'\\{self.name}{optargs}{reqargs}'
else:
return f'\\{self.name} '
def normalize(self, jinja):
if issubclass(self.__class__, Lineend): return '\n'
elif issubclass(self.__class__, NoLineend): return ' '
elif issubclass(self.__class__, TextMacro) and jinja.elements[self.name].normaltext:
return jinja.elements[self.name].normaltext
elif issubclass(self.__class__, Table): return '[TABLE]'
elif issubclass(self.__class__, Formula): return '[FORMULA]'
elif not issubclass(self.__class__, Ignore):
if self.reqargs:
arg = self.reqargs[-1]
return arg.content.normalize(jinja)
return ''
def expand_table(self):
str = ''
for row in self.rows:
str += ' ROW: '
for cell in row:
expand = cell.expand()
str += f'CELL: {expand}\n'
return str
def expand_formula(self):
optargs = ''
for arg in self.optargs: optargs += f'[{arg.content.expand()}]'
reqargs = ''
if len(self.reqargs) > 1:
for arg in self.reqargs[0:-1]:
reqargs += f'{{{arg.content.expand()}}}'
if len(self.reqargs) > 0: reqargs += self.reqargs[-1].content.expand()
return f'{optargs}{reqargs}'
# this is a marker for all commands and environments that create divisions
# where in the self.reqarg[-1].content paragraphs might be contained
# IS NEEDED IN DocNode.adjust_paragraphs()
class Division():
pass
# this class is intended as a marker for all objects that do not interrupt the flow of a paragraph
class Inline():
pass
# is not exactly inline but can be taken as if it where:
class SystemCommand(Command, Inline):
pass
class UnknownCommand(Command, Inline):
pass
# any command that specifies format for the text in the argument such as:
# italics, underlined, deletion, insertion, editor addition, etc. etc.
# WARNING: Format objects may not contain several paragraphs!!
class Format(Command):
args = 'self'
class usepackage(SystemCommand):
args = '[ opt ] self'
class input(SystemCommand):
args = 'self'
class include(SystemCommand):
args = 'self'
# indicates for a subclass not to be included in the normalize process of a document:
class Ignore():
pass
class Environment(Command):
pass
class FormatEnv(Environment):
args = ''
class UnknownEnvironment(Environment, Inline):
pass
class document(Environment, Division):
args = ''
class Formula(Environment):
pass
class Math(Command):
pass
# This is important for dynamically switching from and to math mode:
class EnsureMath(Format):
args = 'self'
class ensuremath(EnsureMath):
pass
class math(Formula):
args = ''
class displaymath(Formula):
args = ''
class equation(Formula):
args = ''
class equation_(Formula):
args = ''
class eqnarray(Formula):
args = ''
class eqnarray_(Formula):
args = ''
# each column of a table is characterized by a Coldef
# here top_style and bottom_style may change from row to row
class Coldef():
def __init__(self):
# style-options: none, solid, double
self.align = 'l'
self.style = ''
self.left_style = 'solid'
self.right_style = 'solid'
self.top_style = 'solid'
self.bottom_style = 'solid'
class Cell(Command):
args = 'content'
def __init__(self, name):
super().__init__(name)
self.align = 'l'
self.left_style = 'none'
self.right_style = 'none'
self.top_style = 'none'
self.bottom_style = 'none'
self.colspan = 1
self.rowspan = 1
self.hidden = False
class Table(Environment):
args = '[ opt ] def'
def __init__(self, name):
super().__init__(name)
self.coldef = list()
self.rows = list()
self.rowspans = dict()
class tabular(Table):
pass
class tabular_(tabular):
args = 'width [opt] def'
class longtable(tabular):
args = 'width [opt] def'
class twocols(tabular):
args = ''
def __init__(self, name):
super().__init__(name)
n = 2
for i in range(n):
coll = Coldef()
coll.left_style = 'none'
coll.right_style = 'none'
coll.top_style = 'none'
coll.bottom_style = 'none'
self.coldef.append(coll)
class transcols(tabular):
args = ''
def __init__(self, name):
super().__init__(name)
n = 2
for i in range(n):
coll = Coldef()
coll.left_style = 'none'
coll.right_style = 'none'
coll.top_style = 'none'
coll.bottom_style = 'none'
self.coldef.append(coll)
class mytabular(tabular):
pass
class tabbing(Table):
args = ''
class Section(Command):
args = '[ opt ] self'
level = 1 # options: int, range:
# -10
#
# part, -1
# chapter, 0
# section, 1
# subsection, 2
# subsubsection, 3
# subsubsection, 4
# subsubsubsection, 5
#
# paragraph, 10
# subparagraph 11
#
# 16 16-20: no resetting of counters
#
# 20
def __init__(self,name):
super().__init__(name)
self.countervalue = {}
def setcounter(self,stack):
level = self.level
i = 0
# store current counter and reset values of all subcounters
if f'section@{level}' in stack.counters:
stack.counters[f'section@{level}'].increment()
self.countervalue
self.countervalue[level] = stack.counters[f'section@{level}'].getvalue()
n = level + 1
while n < 10:
if f'section@{n}' in stack.counters:
stack.counters[f'section@{n}'].reset()
n += 1
# store values for all parent counters
j = -10
while j < level:
if f'section@{j}' in stack.counters:
self.countervalue[j] = stack.counters[f'section@{j}'].getvalue()
j += 1
# reset Note counters and other counters, if applicable:
def get_sub_classes(cls):
subclasses = []
for subclass in cls.__subclasses__():
subclasses.append(subclass)
subclasses.extend(get_sub_classes(subclass))
return subclasses
if level == 0 or level == 16:
# notes: each instance of Note
classes = get_sub_classes(Note)
for cls in classes:
if cls.__name__ in stack.counters: stack.counters[cls.__name__].reset()
return stack
# any footnote, marginnote, endnote etc.
class Note(Format):
args = 'self'
def __init__(self,name):
super().__init__(name)
self.countervalue = 0
self.notetype = 'solo'
self.markednote = 0
if name[-4:] == 'mark':
self.notetype = 'label'
#self.name = name[:-4]
elif name[-4:] == 'text':
self.notetype = 'text'
#self.name = name[:-4]
def setcounter(self,stack):
#name = self.name + 'mark'
if self.notetype == 'solo':
stack.counters[self.name].increment()
self.countervalue = stack.counters[self.name].getvalue()
elif self.notetype == 'label':
name = self.name[:-4]
stack.counters[self.name].increment()
stack.counters[name].increment()
if stack.firstdoc:
stack.counters['MarkedNotes'].decrement()
stack.firstdoc = False
stack.counters['MarkedNotes'].increment()
self.markednote = stack.counters['MarkedNotes'].getvalue()
self.countervalue = stack.counters[name].getvalue()
elif self.notetype == 'text':
name = self.name[:-4]
if stack.counters[name + 'mark'].getvalue() > 0:
stack.counters[name].addtocounter(- stack.counters[name + 'mark'].getvalue())
stack.counters[name].increment()
stack.counters[name + 'mark'].reset()
self.countervalue = stack.counters[name].getvalue()
else:
stack.counters[name].increment()
self.countervalue = stack.counters[name].getvalue()
return stack
class footnote(Note):
args = '[ number ] text'
class marginpar(Note):
args = '[ lefttext ] righttext'
class marginnote(Note):
args = 'self [ length ]'
# counters must be created with newcounter, this is only for refering to counter values:
class Counter(SystemCommand):
args = 'self'
def __init__(self,name):
super().__init__(name)
self.countervalue = 0
def stepcounter(self,stack):
if self.reqargs: name = self.reqargs[0]
else: name = ''
if name in stack.counters:
stack.counters[name].increment()
self.countervalue = stack.counters[name].getvalue()
return stack
def setcounter(self,value,stack):
if self.reqargs: name = self.reqargs[0]
else: name = ''
i = 0
if not isinstance(value, int): value = 0
if name in stack.counters:
stack.counters[name].setvalue(value)
self.countervalue = stack.counters[name].getvalue()
return stack
def addtocounter(self,value,stack):
if self.reqargs: name = self.reqargs[0]
else: name = ''
i = 0
if not isinstance(value, int): value = 0
if name in stack.counters:
stack.counters[name].addtocounter(value)
self.countervalue = stack.counters[name].getvalue()
return stack
class setcounter(Counter):
args = 'name value'
class addtocounter(Counter):
args = 'name value'
class stepcounter(Counter):
args = 'name'
class refstepcounter(Counter):
args = 'name'
class LaTeXList(Environment):
args = ''
class List(LaTeXList):
args = 'label parameter'
# BETTER Enumerate and enumerate only as a subclass !!!!
class enumerate(LaTeXList):
args = ''
class itemize(LaTeXList):
args = ''
class description(LaTeXList):
args = ''
class Item(Command):
args = '[ label ] content'
# normal item commands that do not deliver the content as a reqarg
class ItemWithoutContent(Item):
args = '[ label ]'
class item(ItemWithoutContent):
args = '[ description ]'
class iitem(item):
pass
# nonstandard item commands that deliver the content as a reqarg
class ItemWithContent(Item):
pass
# Bibliographies
class Bibliography(LaTeXList):
pass
# some Commands for internal use only:
class Whitespace(Format):
args = ''
# any whitespace that does not include a line shift:
class NoLineend(Whitespace):
args = ''
class Lineend(Whitespace):
pass
class VALEPThinSpace(NoLineend):
args = ''
class VALEPnbsp(NoLineend):
args = ''
# ANY TEXTMACRO that produces just (formatted or unformatted) text
class TextMacro(Format):
args = ''
# this class is essential for identifying paragraphs in the document:
class Par(Command):
args = ''
def __init__(self,name):
super().__init__(name)
self.parend = True
self.parstart = True
class par(Par):
pass
class newline(Lineend):
args = '[ opt ]'
class VALEPlb(Lineend):
args = '[ space ]'
class VALEPlb_(Lineend):
args = '[ space ]'
# further important standard LaTeX macros:
# character > (treat with care in xml and html)
class gt(TextMacro):
args = ''
# character < (treat with care in xml and html)
class lt(TextMacro):
args = ''
# soft hyphen: replaces \-
class VALEPshy(Format):
args = ''
class Verbatim(Command):
pass
class VerbatimEnvironment(Environment,Verbatim):
pass
class VerbatimCommand(Verbatim, Inline):
args = 'self'
class verbatim(VerbatimEnvironment):
args = ''
class htmlcode(VerbatimCommand):
args = 'self'
class rawhtml(VerbatimEnvironment):
args = ''
class htmlonly(Command, Inline):
args = 'self'
class LaTeXOnly(VerbatimCommand):
args = 'self'
class latexonly(LaTeXOnly):
args = 'self'
# any reference
# varieties include: Index, Label, Ref, Link
class Reference(Command, Ignore, Inline):
args = 'self'
# any index entry
class Index(Reference):
pass
class Label(Reference):
pass
class Ref(Reference):
pass
class Link(Reference):
args = 'link text'
class Graphic(Reference):
args = 'src'
class includegraphics(Graphic):
args = '[ argll ] [ argur ] self'