def visit_copyright(self, node):
self.open_moin_page_node(moin_page.table_row())
self.open_moin_page_node(moin_page.table_cell())
self.open_moin_page_node(moin_page.strong())
# TODO: i18n for docutils:
self.open_moin_page_node(u"Copyright:")
self.close_moin_page_node()
self.close_moin_page_node()
self.close_moin_page_node()
self.open_moin_page_node(moin_page.table_cell())
def visit_author(self, node):
self.open_moin_page_node(moin_page.table_row())
self.open_moin_page_node(moin_page.table_cell())
self.open_moin_page_node(moin_page.strong())
# TODO: i18n for docutils:
self.open_moin_page_node(u"Author:")
self.close_moin_page_node()
self.close_moin_page_node()
self.close_moin_page_node()
self.open_moin_page_node(moin_page.table_cell())
def visit_version(self, node):
self.open_moin_page_node(moin_page.table_row())
self.open_moin_page_node(moin_page.table_cell())
self.open_moin_page_node(moin_page.strong())
# TODO: i18n for docutils:
self.open_moin_page_node(u"Version:")
self.close_moin_page_node()
self.close_moin_page_node()
self.close_moin_page_node()
self.open_moin_page_node(moin_page.table_cell())
def build_dom_calendar_table(rows, head=None, caption=None, cls=None):
"""
Build a DOM table with data from <rows>.
"""
table = moin_page.table()
if cls is not None:
table.attrib[moin_page('class')] = cls
if caption is not None:
table_caption = moin_page.caption()
table_caption.append(caption)
table.append(table_caption)
if head is not None:
table_head = moin_page.table_header()
table_row = moin_page.table_row()
for _idx, cell_tuple in enumerate(head):
(cell, cell_class) = cell_tuple
table_cell = moin_page.table_cell(children=[cell])
table_cell.attrib[moin_page('class')] = cell_class
table_row.append(table_cell)
table_head.append(table_row)
table.append(table_head)
table_body = moin_page.table_body()
for row in rows:
table_row = moin_page.table_row()
for cell_tuple in row:
# - cell content
# - href for <a> tag
# - CSS class for <td> tag
(cell, cell_addr, cell_class) = cell_tuple
# empty cell
if not cell_addr:
table_cell = moin_page.table_cell(children=[cell])
table_cell.attrib[moin_page('class')] = cell_class
# cell with link to calendar
else:
table_a = moin_page.a(attrib={xlink.href: Iri(cell_addr)},
children=[cell])
table_cell = moin_page.table_cell(children=[table_a])
table_cell.attrib[moin_page('class')] = cell_class
table_row.append(table_cell)
table_body.append(table_row)
table.append(table_body)
return table
def block_table_repl(self, iter_content, stack, table, table_args=''):
stack.clear()
# TODO: table attributes
elem = moin_page.table()
stack.push(elem)
if table_args:
table_args = _TableArguments()(table_args)
for key, value in table_args.keyword.iteritems():
attrib = elem.attrib
if key in ('class', 'style', 'number-columns-spanned',
'number-rows-spanned'):
attrib[moin_page(key)] = value
element = moin_page.table_body()
stack.push(element)
lines = _Iter(self.block_table_lines(iter_content),
startno=iter_content.lineno)
element = moin_page.table_row()
stack.push(element)
preprocessor_status = []
for line in lines:
m = self.tablerow_re.match(line)
if not m:
return
if m.group('newrow'):
stack.pop_name('table-row')
element = moin_page.table_row()
stack.push(element)
cells = m.group('cells')
if cells:
cells = cells.split('||')
for cell in cells:
if stack.top_check('table-cell'):
stack.pop()
cell = re.split(r'\s*\|\s*', cell)
element = moin_page.table_cell()
if len(cell) > 1:
cell_args = _TableArguments()(cell[0])
for key, value in cell_args.keyword.iteritems():
attrib = element.attrib
if key in ('class', 'style',
'number-columns-spanned',
'number-rows-spanned'):
attrib[moin_page(key)] = value
cell = cell[1]
else:
cell = cell[0]
stack.push(element)
self.preprocessor.push()
self.parse_inline(cell, stack, self.inline_re)
preprocessor_status = self.preprocessor.pop()
elif m.group('text'):
self.preprocessor.push(preprocessor_status)
self.parse_inline('\n{0}'.format(m.group('text')), stack,
self.inline_re)
preprocessor_status = self.preprocessor.pop()
stack.pop_name('table')
def build_dom_table(self, rows, head=None, cls=None):
"""
Build a DOM table with data from <rows>.
"""
table = moin_page.table()
if cls is not None:
table.attrib[moin_page('class')] = cls
if head is not None:
table_head = moin_page.table_header()
table_row = moin_page.table_row()
for idx, cell in enumerate(head):
table_cell = moin_page.table_cell(children=[
cell,
], )
if rows and len(rows[0]) == len(head):
# add "align: right" to heading cell if cell in first data row is numeric
self.add_numeric_class(rows[0][idx], table_cell)
table_row.append(table_cell)
table_head.append(table_row)
table.append(table_head)
table_body = moin_page.table_body()
for row in rows:
table_row = moin_page.table_row()
for cell in row:
if isinstance(cell, ET.Node) and len(cell) and isinstance(cell[0], str) and \
len(cell[0].split()) == 1 and len(cell[0]) > WORDBREAK_LEN:
# avoid destroying table layout by applying special styling to cells with long file name hyperlinks
table_cell = moin_page.table_cell(
children=[
cell,
],
attrib={moin_page.class_: 'moin-wordbreak'})
elif isinstance(cell, ET.Node):
table_cell = moin_page.table_cell(children=[
cell,
])
else:
table_cell = moin_page.table_cell(children=[
cell,
], )
self.add_numeric_class(cell, table_cell)
table_row.append(table_cell)
table_body.append(table_row)
table.append(table_body)
return table
def visit_entry(self, node):
# process a table cell <td> tag
new_element = moin_page.table_cell()
if 'morerows' in node.attributes:
new_element.set(moin_page.number_rows_spanned,
repr(int(node['morerows']) + 1))
if 'morecols' in node.attributes:
new_element.set(moin_page.number_columns_spanned,
repr(int(node['morecols']) + 1))
self.open_moin_page_node(new_element)
def tablerow_cell_repl(self, stack, cell, cell_text, cell_head=None):
"""
Creole has feature that allows table headings to be either row based or column based.
We avoid use of HTML5 row based thead tag and apply CSS styling to any cell marked as a heading.
"""
attrib = {}
if cell_head:
attrib[moin_page.class_] = 'moin-thead'
element = moin_page.table_cell(attrib=attrib)
stack.push(element)
self.parse_inline(cell_text.strip(), stack)
stack.pop_name('table-cell')
def visit_option(self, node):
self.open_moin_page_node(moin_page.table_cell())
def visit_field_name(self, node):
self.open_moin_page_node(moin_page.table_cell())
self.open_moin_page_node(moin_page.strong())
self.open_moin_page_node(u'{0}:'.format(node.astext()))
node.children = []
self.close_moin_page_node()
def visit_field_body(self, node):
self.open_moin_page_node(moin_page.table_cell())
def tablerow_cell_repl(self,
stack,
table,
row,
cell,
cell_marker,
cell_text,
cell_args=None):
def add_attr_to_style(attrib, attr):
attr = attr.strip().decode('unicode-escape')
if not attr.endswith(';'):
attr += ';'
if attrib.get(moin_page('style'), ""):
attrib[moin_page('style')] = attrib.get(
moin_page('style'), "") + " " + attr
else:
attrib[moin_page('style')] = attr
element = moin_page.table_cell()
stack.push(element)
if len(cell_marker) // 2 > 1:
element.set(moin_page.number_columns_spanned,
len(cell_marker) // 2)
if cell_args:
cell_args = _TableArguments()(cell_args)
no_errors = True
# any positional parameters will be errors; retrieved as (key=None, value="some-positional-param");
for key, value in cell_args.items():
if key == 'bgcolor':
if no_errors:
# avoid overriding error highlighting
add_attr_to_style(
element.attrib,
'background-color: {0};'.format(value))
elif key == 'rowbgcolor':
add_attr_to_style(row.attrib,
'background-color: {0};'.format(value))
elif key == 'tablebgcolor':
add_attr_to_style(table.attrib,
'background-color: {0};'.format(value))
elif key == 'width':
add_attr_to_style(element.attrib,
'width: {0};'.format(value))
elif key == 'tablewidth':
add_attr_to_style(table.attrib,
'width: {0};'.format(value))
elif key == 'caption':
table.insert(0, moin_page.caption(children=[
value,
]))
elif key == 'tableclass':
table.attrib[moin_page(
'class')] = value + u' moin-wiki-table'
elif key == 'rowclass':
row.attrib[moin_page('class')] = value
elif key == 'class':
element.attrib[moin_page('class')] = value
elif key == 'tablestyle':
add_attr_to_style(table.attrib, value)
elif key == 'rowstyle':
add_attr_to_style(row.attrib, value)
elif key == 'style':
if no_errors:
add_attr_to_style(element.attrib, value)
elif key == 'tableid':
table.attrib[moin_page('id')] = value
elif key == 'rowid':
row.attrib[moin_page('id')] = value
elif key == 'id':
element.attrib[moin_page('id')] = value
elif key == 'number-columns-spanned':
element.attrib[moin_page(key)] = value
elif key == 'number-rows-spanned':
element.attrib[moin_page(key)] = value
else:
if key == 'error' or key is None:
error = value
else:
error = key
cell_markup = cell.split('>')[0]
cell_markup = cell_markup.split('<')[1]
msg1 = _('Error:')
msg2 = _('is invalid within')
cell_text = '[ {0} "{1}" {2} <{3}> ]<<BR>>{4}'.format(
msg1, error, msg2, cell_markup, cell_text)
if no_errors:
add_attr_to_style(
element.attrib,
'background-color: pink; color: black;')
no_errors = False
self.parse_inline(cell_text, stack, self.inline_re)
stack.pop_name('table-cell')
