Changeset 95:1f15abe2f51a

Timestamp:

01/21/09 07:18:37 (19 months ago)

Author:

Ga?tan de Menten <ged@…>

Branch:

default

Message:

- add support for column looping over several rows (rowspan > 1)
- factorized a method to wrap the nodes between two existing nodes in a new

node (removing the boundary nodes in the process)

- the factorization also fixed a small bug which led to bad column width when

repeating several columns

Files:

• relatorio/templates/opendocument.py (modified) (8 diffs)

relatorio/templates/opendocument.py

@@ -121 +121 @@
 
 
+def wrap_nodes_between(first, last, new_parent):
+    old_parent = first.getparent()
+    for node in first.itersiblings():
+        if node is last:
+            break
+        # appending a node to a new parent also
+        # remove it from its previous parent
+        new_parent.append(node)
+    old_parent.replace(first, new_parent)
+    old_parent.remove(last)
+
+
 class Template(MarkupTemplate):
 
@@ -262 +274 @@
         table_row_tag = '{%s}table-row' % table_namespace
         table_cell_tag = '{%s}table-cell' % table_namespace
+        table_cov_cell_tag = '{%s}covered-table-cell' % table_namespace
         table_num_col_attr = '{%s}number-columns-repeated' % table_namespace
         table_name_attr = '{%s}name' % table_namespace
+        table_rowspan_attr = '{%s}number-rows-spanned' % table_namespace
 
         office_name = '{%s}value' % self.namespaces['office']
@@ -298 +312 @@
                         break
                     except ValueError:
+                        # c_ancestors.index(node) raise ValueError if node is
+                        # not a child of c_ancestors
                         pass
                     o_ancestors.append(node)
@@ -327 +343 @@
                     #    the first cell node after the opening (cell node)
                     #    ancestor
-                    enclosed_cell = outermost_o_ancestor.itersiblings().next()
+                    enclosed_cell = outermost_o_ancestor.getnext()
                     assert enclosed_cell.tag == table_cell_tag
                     attr_value = "__inc_col_count(%d)" % loop_id
@@ -343 +359 @@
                     # find the position in the row of the cells holding the
                     # <for> and </for> instructions
+                    #XXX: count cells only instead of *
                     position_xpath_expr = 'count(preceding-sibling::*)'
                     opening_pos = \
@@ -351 +368 @@
                                                    namespaces=self.namespaces))
 
-                    # check if this table was already processed
+                    # check whether or not the opening tag spans several rows
+                    o_node_attrs = outermost_o_ancestor.attrib
+                    if table_rowspan_attr in o_node_attrs:
+                        rows_spanned = int(o_node_attrs[table_rowspan_attr])
+                        # if so, we need to replace the corresponding cell on
+                        # the next line (a covered-table-cell) by a duplicate
+                        # py:for node, delete the covered-table-cell
+                        # corresponding to the /for, and move all cells between
+                        # them into the py:for node
+                        row_node = outermost_o_ancestor.getparent()
+                        assert row_node.tag == table_row_tag
+                        next_rows = row_node.itersiblings(table_row_tag)
+                        for row_idx in range(rows_spanned-1):
+                            next_row_node = next_rows.next()
+                            first = next_row_node[opening_pos]
+                            last = next_row_node[closing_pos]
+                            assert first.tag == table_cov_cell_tag
+                            assert last.tag == table_cov_cell_tag
+
+                            # execute moves (add a <py:for> node around
+                            # the column definitions nodes)
+                            tag = '{%s}%s' % (py_namespace, directive)
+                            for_node = EtreeElement(tag,
+                                                    attrib={attr: a_val},
+                                                    nsmap=self.namespaces)
+                            wrap_nodes_between(first, last, for_node)
+
+                    # check if this table's headers were already processed
                     repeat_node = table_node.find(repeat_tag)
                     if repeat_node is not None:
@@ -391 +435 @@
                         # need to be moved to inside the "repeat" tag (which
                         # is to be created later).
-                        to_remove = []
-                        to_move = []
-                        coldefs = table_node.iterchildren(table_col_tag)
-                        for idx, tag in enumerate(coldefs):
-                            if idx in (opening_pos, closing_pos):
-                                to_remove.append(tag)
-                            if opening_pos < idx < closing_pos:
-                                to_move.append(tag)
-                            elif idx > closing_pos:
-                                break
-                        assert len(to_remove) == 2, "failed %d %d" \
-                               % (opening_pos, closing_pos)
-                        assert to_move
-
-                        # execute deletes
-                        for node in to_remove:
-                            table_node.remove(node)
+                        coldefs = list(table_node.iterchildren(table_col_tag))
+                        first = table_node[opening_pos]
+                        last = table_node[closing_pos]
 
                         # execute moves (add a <relatorio:repeat> node around
                         # the column definitions nodes)
-                        o_pos, c_pos = str(opening_pos), str(closing_pos)
-                        repeat_node = EtreeElement(repeat_tag,
-                                                   attrib={
-                                                       "opening": o_pos,
-                                                       "closing": c_pos,
-                                                       "table": table_name},
+                        attribs = {
+                           "opening": str(opening_pos),
+                           "closing": str(closing_pos),
+                           "table": table_name
+                        }
+                        repeat_node = EtreeElement(repeat_tag, attrib=attribs,
                                                    nsmap=self.namespaces)
-
-                        for node in to_move[1:]:
-                            table_node.remove(node)
-                            repeat_node.append(node)
-                        table_node.replace(to_move[0], repeat_node)
-                        repeat_node.append(to_move[0])
+                        wrap_nodes_between(first, last, repeat_node)
 
                 # - we create a <py:xxx> node
@@ -431 +456 @@
                                            nsmap=self.namespaces)
 
-                # - we add all the nodes between the opening and closing
-                #   statements to this new node
-                for node in outermost_o_ancestor.itersiblings():
-                    if node is outermost_c_ancestor:
-                        break
-                    genshi_node.append(node)
-
+                # - we move all the nodes between the opening and closing
+                #   statements to this new node (append also removes from old
+                #   parent)
                 # - we replace the opening statement by the <py:xxx> node
-                ancestor.replace(outermost_o_ancestor, genshi_node)
-
                 # - we delete the closing statement (and its ancestors)
-                ancestor.remove(outermost_c_ancestor)
+                wrap_nodes_between(outermost_o_ancestor, outermost_c_ancestor,
+                                   genshi_node)
             else:
                 # It's not a genshi statement it's a python expression