Embed ooopy (last version: 1.11)

1 files changed, 1237 insertions, 0 deletions

diff --git a/ooopy/Transforms.py b/ooopy/Transforms.py
new file mode 100644
index 000000000..50a6c0db8
--- /dev/null
+++ b/ooopy/Transforms.py
@@ -0,0 +1,1237 @@
+#!/usr/bin/env python
+# -*- coding: iso-8859-1 -*-
+# Copyright (C) 2005-14 Dr. Ralf Schlatterbeck Open Source Consulting.
+# Reichergasse 131, A-3411 Weidling.
+# Web: http://www.runtux.com Email: office@runtux.com
+# All rights reserved
+# ****************************************************************************
+#
+# This library is free software; you can redistribute it and/or modify
+# it under the terms of the GNU Library General Public License as
+# published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Library General Public License for more details.
+#
+# You should have received a copy of the GNU Library General Public
+# License along with this program; if not, write to the Free Software
+# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+# ****************************************************************************
+
+from __future__              import absolute_import
+
+import time
+import re
+try :
+    from xml.etree.ElementTree   import dump, SubElement, Element, tostring
+except ImportError :
+    from elementtree.ElementTree import dump, SubElement, Element, tostring
+from copy                    import deepcopy
+from ooopy.OOoPy             import OOoPy, autosuper
+from ooopy.Transformer       import files, split_tag, OOo_Tag, Transform
+from ooopy.Transformer       import mimetypes, namespace_by_name
+from ooopy.Version           import VERSION
+
+# counts in meta.xml
+meta_counts = \
+    ( 'character-count', 'image-count', 'object-count', 'page-count'
+    , 'paragraph-count', 'table-count', 'word-count'
+    )
+
+class Access_Attribute (autosuper) :
+    """ For performance reasons we do not specify a separate transform
+        for each attribute-read or -change operation. Instead we define
+        all the attribute accesses we want to perform as objects that
+        follow the attribute access api and apply them all using an
+        Attribute_Access in one go.
+    """
+
+    def __init__ (self, key = None, prefix = None, ** kw) :
+        self.__super.__init__ (key = key, prefix = prefix, **kw)
+        self.key = key
+        if key :
+            if not prefix :
+                prefix   = self.__class__.__name__
+            self.key = ':'.join ((prefix, key))
+    # end def __init__
+
+    def register (self, transformer) :
+        self.transformer = transformer
+    # end def register
+
+    def use_value (self, oldval = None) :
+        """ Can change the given value by returning the new value. If
+            returning None or oldval the attribute stays unchanged.
+        """
+        raise NotImplementedError, "use_value must be defined in derived class"
+    # end def use_value
+
+# end class Access_Attribute
+
+class Get_Attribute (Access_Attribute) :
+    """ An example of not changing an attribute but only storing the
+        value in the transformer
+    """
+
+    def __init__ (self, tag, attr, key, transform = None, ** kw) :
+        self.__super.__init__ (key = key, **kw)
+        self.tag        = tag
+        self.attribute  = attr
+        self.transform  = transform
+    # end def __init__
+
+    def use_value (self, oldval = None) :
+        self.transformer [self.key] = oldval
+        return None
+    # end def use_value
+
+# end def Get_Attribute
+
+class Get_Max (Access_Attribute) :
+    """ Get the maximum value of an attribute """
+
+    def __init__ (self, tag, attr, key, transform = None, ** kw) :
+        self.__super.__init__ (key = key, **kw)
+        self.tag        = tag
+        self.attribute  = attr
+        self.transform  = transform
+    # end def __init__
+
+    def register (self, transformer) :
+        self.__super.register (transformer)
+        self.transformer [self.key] = -1
+    # end def register
+
+    def use_value (self, oldval = None) :
+        if  self.transformer [self.key] < oldval :
+            self.transformer [self.key] = oldval
+        return None
+    # end def use_value
+
+# end def Get_Max
+
+class Renumber (Access_Attribute) :
+    """ Specifies a renumbering transform. OOo has a 'name' attribute
+        for several different tags, e.g., tables, frames, sections etc.
+        These names must be unique in the whole document. OOo itself
+        solves this by appending a unique number to a basename for each
+        element, e.g., sections are named 'Section1', 'Section2', ...
+        Renumber transforms can be applied to correct the numbering
+        after operations that destroy the unique numbering, e.g., after
+        a mailmerge where the same document is repeatedly appended.
+
+        The force parameter specifies if the new renumbered name should
+        be inserted even if the attribute in question does not exist.
+    """
+
+    def __init__ \
+        (self, tag, name = None, attr = None, start = 1, force = False) :
+        self.__super.__init__ ()
+        tag_ns, tag_name = split_tag (tag)
+        self.tag_ns      = tag_ns
+        self.tag         = tag
+        self.name        = name or tag_name [0].upper () + tag_name [1:]
+        self.num         = start
+        self.force       = force
+        self.attribute   = attr
+    # end def __init__
+
+    def register (self, transformer) :
+        self.__super.register (transformer)
+        if not self.attribute :
+            self.attribute = OOo_Tag (self.tag_ns, 'name', transformer.mimetype)
+    # end def register
+
+    def use_value (self, oldval = None) :
+        if oldval is None and not self.force :
+            return
+        name = "%s%d" % (self.name, self.num)
+        self.num += 1
+        return name
+    # end def use_value
+
+# end class Renumber
+
+class Set_Attribute (Access_Attribute) :
+    """
+        Similar to the renumbering transform in that we are assigning
+        new values to some attributes. But in this case we give keys
+        into the Transformer dict to replace some tag attributes.
+    """
+
+    def __init__ \
+        ( self
+        , tag
+        , attr
+        , key       = None
+        , transform = None
+        , value     = None
+        , oldvalue  = None
+        , ** kw
+        ) :
+        self.__super.__init__ (key = key, ** kw)
+        self.tag        = tag
+        self.attribute  = attr
+        self.transform  = transform
+        self.value      = value
+        self.oldvalue   = oldvalue
+    # end def __init__
+
+    def use_value (self, oldval) :
+        if oldval is None :
+            return None
+        if self.oldvalue and oldval != self.oldvalue :
+            return None
+        if self.key and self.transformer.has_key (self.key) :
+            return str (self.transformer [self.key])
+        return self.value
+    # end def use_value
+
+# end class Set_Attribute
+
+def set_attributes_from_dict (tag, attr, d) :
+    """ Convenience function: iterate over a dict and return a list of
+        Set_Attribute objects specifying replacement of attributes in
+        the dictionary
+    """
+    return [Set_Attribute (tag, attr, oldvalue = k, value = v)
+            for k,v in d.iteritems ()
+           ]
+# end def set_attributes_from_dict
+
+class Reanchor (Access_Attribute) :
+    """
+        Similar to the renumbering transform in that we are assigning
+        new values to some attributes. But in this case we want to
+        relocate objects that are anchored to a page.
+    """
+
+    def __init__ (self, offset, tag, attr = None) :
+        self.__super.__init__ ()
+        self.offset     = int (offset)
+        self.tag        = tag
+        self.attribute  = attr
+    # end def __init__
+
+    def register (self, transformer) :
+        self.__super.register (transformer)
+        if not self.attribute :
+            self.attribute = \
+                OOo_Tag ('text', 'anchor-page-number', transformer.mimetype)
+    # end def register
+
+    def use_value (self, oldval) :
+        if oldval is None :
+            return oldval
+        return "%d" % (int (oldval) + self.offset)
+    # end def use_value
+
+# end class Reanchor
+
+#
+# general transforms applicable to several .xml files
+#
+
+class Attribute_Access (Transform) :
+    """
+        Read or Change attributes in an OOo document.
+        Can be used for renumbering, moving anchored objects, etc.
+        Expects a list of attribute changer objects that follow the
+        attribute changer API. This API is very simple:
+
+        - Member function "use_value" returns the new value of an
+          attribute, or if unchanged the old value
+        - The attribute "tag" gives the tag for an element we are
+          searching
+        - The attribute "attribute" gives the name of the attribute we
+          want to read or change.
+        For examples of the attribute changer API, see Renumber and
+        Reanchor above.
+    """
+    filename = 'content.xml'
+    prio     = 110
+
+    def __init__ (self, attrchangers, filename = None, ** kw) :
+        self.filename     = filename or self.filename
+        self.attrchangers = {}
+        # allow several changers for a single tag
+        self.attrchangers [None] = []
+        self.changers = attrchangers
+        self.__super.__init__ (** kw)
+    # end def __init__
+
+    def register (self, transformer) :
+        """ Register transformer with all attrchangers. """
+        self.__super.register (transformer)
+        for r in self.changers :
+            if r.tag not in self.attrchangers :
+                self.attrchangers [r.tag] = []
+            self.attrchangers [r.tag].append (r)
+            r.register (transformer)
+    # end def register
+
+    def apply (self, root) :
+        """ Search for all tags for which we renumber and replace name """
+        for n in [root] + root.findall ('.//*') :
+            changers = \
+                self.attrchangers [None] + self.attrchangers.get (n.tag, [])
+            for r in changers :
+                nval = r.use_value (n.get (r.attribute))
+                if nval is not None :
+                    n.set (r.attribute, nval)
+    # end def apply
+
+# end class Attribute_Access
+
+#
+# META-INF/manifest.xml transforms
+#
+
+class Manifest_Append (Transform) :
+    """
+        The Transformer stores a list of files (and contents) to append.
+        These files are added to the archive later but need to be
+        present in the manifest, too.
+        The file list in the Transformer currently doesn't store a media
+        type (which is one of the parameters in the manifest), the
+        current application of this transform is to add pictures --
+        these don't have a media type in the files that were checked.
+        So for now we add an empty media type.
+    """
+    filename = 'META-INF/manifest.xml'
+    prio     = 1000
+
+    def apply (self, root) :
+        for n, node in enumerate (root) :
+            assert node.tag == self.oootag ('manifest', 'file-entry')
+            path = node.get (self.oootag ('manifest', 'full-path'))
+            assert (path)
+            if path == '/' :
+                break
+        else :
+            assert (not "The manifest needs a '/' entry")
+        for f, _ in self.transformer.appendfiles :
+            e = Element (self.oootag ('manifest', 'file-entry'))
+            e.attrib [self.oootag ('manifest', 'full-path')]  = f
+            e.attrib [self.oootag ('manifest', 'media-type')] = ''
+            root.insert (n + 1, e)
+            n += 1
+    # end def apply
+
+# end class Manifest_Append
+
+#
+# meta.xml transforms
+#
+
+class Editinfo (Transform) :
+    """
+        This is an example of modifying OOo meta info (edit information,
+        author, etc). We set some of the items (program that generated
+        the OOo file, modification time, number of edit cyles and overall
+        edit duration).  It's easy to subclass this transform and replace
+        the "replace" variable (pun intended) in the derived class.
+    """
+    filename = 'meta.xml'
+    prio     = 20
+    repl     = \
+        { ('meta', 'generator')        : 'OOoPy field replacement'
+        , ('dc',   'date')             : time.strftime ('%Y-%m-%dT%H:%M:%S')
+        , ('meta', 'editing-cycles')   : '0'
+        , ('meta', 'editing-duration') : 'PT0M0S'
+        }
+    replace  = {}
+    # iterate over all mimetypes, so this works for all known mimetypes
+    # of OOo documents.
+    for m in mimetypes :
+        for params, value in repl.iteritems () :
+            replace [OOo_Tag (mimetype = m, *params)] = value
+
+    def apply (self, root) :
+        for node in root.findall (self.oootag ('office', 'meta') + '/*') :
+            if self.replace.has_key (node.tag) :
+                node.text = self.replace [node.tag]
+    # end def apply
+# end class Editinfo
+
+#
+# settings.xml transforms
+#
+
+class Autoupdate (Transform) :
+    """
+        This is an example of modifying OOo settings. We set some of the
+        AutoUpdate configuration items in OOo to true. We also specify
+        that links should be updated when reading.
+
+        This was originally intended to make OOo correctly display fields
+        if they were changed with the Field_Replace below
+        (similar to pressing F9 after loading the generated document in
+        OOo). In particular I usually make spaces depend on field
+        contents so that I don't have spurious spaces if a field is
+        empty. Now it would be nice if OOo displayed the spaces correctly
+        after loading a document (It does update the fields before
+        printing, so this is only a cosmetic problem :-). This apparently
+        does not work. If anybody knows how to achieve this, please let
+        me know: mailto:rsc@runtux.com
+    """
+    filename = 'settings.xml'
+    prio     = 20
+
+    def apply (self, root) :
+        config = None
+        for config in root.findall \
+            ( self.oootag ('office', 'settings')
+            + '/'
+            + self.oootag ('config', 'config-item-set')
+            ) :
+            name = config.get (self.oootag ('config', 'name'))
+            if name == 'configuration-settings' :
+                break
+        for node in config.findall (self.oootag ('config', 'config-item')) :
+            name = node.get (self.oootag ('config', 'name'))
+            if name == 'LinkUpdateMode' :  # update when reading
+                node.text = '2'
+            # update fields when reading
+            if name == 'FieldAutoUpdate' or name == 'ChartAutoUpdate' :
+                node.text = 'true'
+    # end def apply
+# end class Autoupdate
+
+#
+# content.xml transforms
+#
+
+class Field_Replace (Transform) :
+    """
+        Takes a dict of replacement key-value pairs. The key is the name
+        of a variable in OOo. Additional replacement key-value pairs may
+        be specified in ** kw. Alternatively a callback mechanism for
+        variable name lookups is provided. The callback function is
+        given the name of a variable in OOo and is expected to return
+        the replacement value or None if the variable value should not
+        be replaced.
+    """
+    filename = 'content.xml'
+    prio     = 100
+
+    def __init__ (self, prio = None, replace = None, ** kw) :
+        """ replace is something behaving like a dict or something
+            callable for name lookups
+        """
+        self.__super.__init__ (prio, ** kw)
+        self.replace  = replace or {}
+        self.dict     = kw
+    # end def __init__
+
+    def apply (self, root) :
+        tbody = self.find_tbody (root)
+        for tag in 'variable-set', 'variable-get', 'variable-input' :
+            for node in tbody.findall ('.//' + self.oootag ('text', tag)) :
+                attr = 'name'
+                if tag == 'text-input' :
+                    attr = 'description'
+                name = node.get (self.oootag ('text', attr))
+                if callable (self.replace) :
+                    replace = self.replace (name)
+                    if replace :
+                        node.text = replace
+                elif name in self.replace :
+                    node.text = self.replace [name]
+                elif name in self.dict :
+                    node.text = self.dict    [name]
+    # end def apply
+# end class Field_Replace
+
+class Addpagebreak_Style (Transform) :
+    """
+        This transformation adds a new ad-hoc paragraph style to the
+        content part of the OOo document. This is needed to be able to
+        add new page breaks to an OOo document. Adding a new page break
+        is then a matter of adding an empty paragraph with the given page
+        break style.
+
+        We first look through all defined paragraph styles for
+        determining a new paragraph style number. Convention is P<num>
+        for paragraph styles. We search the highest number and use this
+        incremented by one for the new style to insert. Then we insert
+        the new style and store the resulting style name in the
+        transformer under the key class_name:stylename where class_name
+        is our own class name.
+    """
+    filename = 'content.xml'
+    prio     = 30
+    para     = re.compile (r'P([0-9]+)')
+
+    def apply (self, root) :
+        max_style = 0
+        styles = root.find (self.oootag ('office', 'automatic-styles'))
+        for s in styles.findall ('./' + self.oootag ('style', 'style')) :
+            m = self.para.match (s.get (self.oootag ('style', 'name'), ''))
+            if m :
+                num = int (m.group (1))
+                if num > max_style :
+                    max_style = num
+        stylename = 'P%d' % (max_style + 1)
+        new = SubElement \
+            ( styles
+            , self.oootag ('style', 'style')
+            , { self.oootag ('style', 'name')              : stylename
+              , self.oootag ('style', 'family')            : 'paragraph'
+              , self.oootag ('style', 'parent-style-name') : 'Standard'
+              }
+            )
+        SubElement \
+            ( new
+            , self.properties_tag
+            , { self.oootag ('fo', 'break-after') : 'page' }
+            )
+        self.set ('stylename', stylename)
+    # end def apply
+# end class Addpagebreak_Style
+
+class Addpagebreak (Transform) :
+    """
+        This transformation adds a page break to the last page of the OOo
+        text. This is needed, e.g., when doing mail-merge: We append a
+        page break to the tbody and then append the next page. This
+        transform needs the name of the paragraph style specifying the
+        page break style. Default is to use
+        'Addpagebreak_Style:stylename' as the key for
+        retrieving the page style. Alternatively the page style or the
+        page style key can be specified in the constructor.
+    """
+    filename = 'content.xml'
+    prio     = 50
+
+    def __init__ (self, stylename = None, stylekey = None, ** kw) :
+        self.__super.__init__ (** kw)
+        self.stylename = stylename
+        self.stylekey  = stylekey or 'Addpagebreak_Style:stylename'
+    # end def __init__
+
+    def apply (self, root) :
+        """append to tbody e.g., <text:p text:style-name="P4"/>"""
+        tbody     = self.find_tbody (root)
+        stylename = self.stylename or self.transformer [self.stylekey]
+        SubElement \
+            ( tbody
+            , self.oootag ('text', 'p')
+            , { self.oootag ('text', 'style-name') : stylename }
+            )
+    # end def apply
+# end class Addpagebreak
+
+class Fix_OOo_Tag (Transform) :
+    """
+        OOo writer conditions are attributes where the *value* is
+        prefixed by an XML namespace. If the ooow namespace declaration
+        is not in scope, all conditions will evaluate to false. I
+        consider this a bug (a violation of the ideas of XML) of OOo.
+        Nevertheless to make conditions work, we insert the ooow
+        namespace declaration into the top-level element.
+    """
+    filename = 'content.xml'
+    prio     = 10000
+
+    def apply (self, root) :
+        if self.mimetype == mimetypes [1] :
+            root.set ('xmlns:ooow', namespace_by_name [self.mimetype]['ooow'])
+    # end def apply
+# end class Fix_OOo_Tag
+
+class _Body_Concat (Transform) :
+    """ Various methods for modifying the tbody split into various pieces
+        that have to keep sequence in order to not confuse OOo.
+    """
+    ooo_sections  = {}
+    for m in mimetypes :
+        ooo_sections [m] = \
+            [ { OOo_Tag ('text', 'variable-decls',   m) : 1
+              , OOo_Tag ('text', 'sequence-decls',   m) : 1
+              , OOo_Tag ('text', 'user-field-decls', m) : 1
+              , OOo_Tag ('office', 'forms',          m) : 1
+              }
+            , { OOo_Tag ('draw', 'frame',            m) : 1
+              , OOo_Tag ('draw', 'rect',             m) : 1
+              , OOo_Tag ('draw', 'text-box',         m) : 1
+              }
+            ]
+
+    def _textbody (self) :
+        """
+            We use the office:body (OOo 1.X)/office:text (OOo 1.X)
+            element as a container for various transforms...
+        """
+        return Element (self.textbody_tag)
+    # end def _textbody
+
+    def _divide (self, textbody) :
+        """ Divide self.copy into parts that must keep their sequence.
+            We use another textbody tag for storing the parts...
+            Side-effect of setting self.copyparts is intended.
+        """
+        self.copyparts = self._textbody ()
+        self.copyparts.append (self._textbody ())
+        l = len (self.ooo_sections [self.mimetype])
+        idx = 0
+        for e in textbody :
+            while idx < l :
+                if e.tag in self.ooo_sections [self.mimetype][idx] :
+                    break
+                else :
+                    self.copyparts.append (self._textbody ())
+                    idx += 1
+            self.copyparts [-1].append (e)
+        declarations = self.copyparts [0]
+        del self.copyparts [0]
+        return declarations
+    # end def _divide
+
+    def divide_body (self, root) :
+        cont       = root
+        if cont.tag != self.oootag ('office', 'document-content') :
+            cont   = root.find  (self.oootag ('office', 'document-content'))
+        tbody      = cont.find  (self.oootag ('office', 'body'))
+        # OOo 2.X has an office:text inside office:body that contains
+        # the real text contents:
+        if self.mimetype == mimetypes [1] :
+            cont   = tbody
+            tbody  = cont.find (self.oootag ('office', 'text'))
+        idx        = cont [:].index (tbody)
+        self.tbody = cont [idx] = self._textbody ()
+        self.declarations = self._divide (tbody)
+        self.bodyparts    = self.copyparts
+    # end def divide_body
+
+    def append_declarations (self) :
+        for e in self.declarations :
+            self.tbody.append (e)
+    # end def append_declarations
+
+    def append_to_body (self, cp) :
+        for i in range (len (self.bodyparts)) :
+            for j in cp [i] :
+                self.bodyparts [i].append (j)
+    # end def append_to_body
+
+    def assemble_body (self) :
+        for p in self.bodyparts :
+            for e in p :
+                self.tbody.append (e)
+    # end def assemble_body
+
+    def _get_meta (self, var, classname = 'Get_Attribute', prefix = "") :
+        """ get page- and paragraph-count etc. meta-info """
+        return int (self.transformer [':'.join ((classname, prefix + var))])
+    # end def _get_meta
+
+    def _set_meta (self, var, value, classname = 'Set_Attribute', prefix = "") :
+        """ set page- and paragraph-count etc. meta-info """
+        self.transformer [':'.join ((classname, prefix + var))] = str (value)
+    # end def _set_meta
+# end class _Body_Concat
+
+class Mailmerge (_Body_Concat) :
+    """
+        This transformation is used to create a mailmerge document using
+        the current document as the template. In the constructor we get
+        an iterator that provides a data set for each item in the
+        iteration. Elements the iterator has to provide are either
+        something that follows the Mapping Type interface (it looks like
+        a dict) or something that is callable and can be used for
+        name-value lookups.
+
+        A precondition for this transform is the application of the
+        Addpagebreak_Style to guarantee that we know the style
+        for adding a page break to the current document. Alternatively
+        the stylename (or the stylekey if a different name should be used
+        for lookup in the current transformer) can be given in the
+        constructor.
+    """
+    filename = 'content.xml'
+    prio     = 60
+
+    def __init__ \
+        (self, iterator, stylename = None, stylekey = None, ** kw) :
+        self.__super.__init__ (** kw)
+        self.iterator  = iterator
+        self.stylename = stylename
+        self.stylekey  = stylekey
+    # end def __init__
+
+    def apply (self, root) :
+        """
+            Copy old tbody, create new empty one and repeatedly append the
+            new tbody.
+        """
+        pb = Addpagebreak \
+            ( stylename   = self.stylename
+            , stylekey    = self.stylekey
+            , transformer = self.transformer
+            )
+        zi = Attribute_Access \
+            ( (Get_Max (None, self.oootag ('draw', 'z-index'), 'z-index'),)
+            , transformer = self.transformer
+            )
+        zi.apply (root)
+
+        pagecount  = self._get_meta ('page-count')
+        z_index    = self._get_meta ('z-index', classname = 'Get_Max') + 1
+        ra         = Attribute_Access \
+            ( ( Reanchor (pagecount, self.oootag ('draw', 'text-box'))
+              , Reanchor (pagecount, self.oootag ('draw', 'rect'))
+              , Reanchor (pagecount, self.oootag ('draw', 'frame'))
+              , Reanchor (z_index, None, self.oootag ('draw', 'z-index'))
+              )
+            , transformer = self.transformer # transformer added
+            )
+        self.divide_body (root)
+        self.bodyparts = [self._textbody () for i in self.copyparts]
+
+        count = 0
+        for i in self.iterator :
+            count += 1
+            fr = Field_Replace (replace = i, transformer = self.transformer)
+            # add page break only to non-empty tbody
+            # reanchor only after the first mailmerge
+            if len (self.tbody) : # tbody non-empty (but existing!)
+                pb.apply (self.bodyparts [-1])
+                ra.apply (self.copyparts)
+            else :
+                self.append_declarations ()
+            cp = deepcopy (self.copyparts)
+            fr.apply (cp)
+            self.append_to_body (cp)
+        # new page-count:
+        for i in meta_counts :
+            self._set_meta (i, count * self._get_meta (i))
+        # we have added count-1 paragraphs, because each page-break is a
+        # paragraph.
+        p = 'paragraph-count'
+        self._set_meta \
+            (p, self._get_meta (p, classname = 'Set_Attribute') + (count - 1))
+        self.assemble_body ()
+    # end def apply
+# end class Mailmerge
+
+def tree_serialise (element, prefix = '', mimetype = mimetypes [1]) :
+    """ Serialise a style-element of an OOo document (e.g., a
+        style:font-decl, style:default-style, etc declaration).
+        We remove the name of the style and return something that is a
+        representation of the style element which can be used as a
+        dictionary key.
+        The serialisation format is a tuple containing the tag as the
+        first item, the attributes (as key,value pairs returned by
+        items()) as the second item and the following items are
+        serialisations of children.
+    """
+    attr = dict (element.attrib)
+    stylename = OOo_Tag ('style', 'name', mimetype)
+    if stylename in attr : del attr [stylename]
+    attr = attr.items ()
+    attr.sort ()
+    attr = tuple (attr)
+    serial = [prefix + element.tag, attr]
+    for e in element :
+        serial.append (tree_serialise (e, prefix, mimetype))
+    return tuple (serial)
+# end def tree_serialise
+
+class Concatenate (_Body_Concat) :
+    """
+        This transformation is used to create a new document from a
+        concatenation of several documents.  In the constructor we get a
+        list of documents to append to the master document.
+    """
+    prio     = 80
+    style_containers = {}
+    ref_attrs        = {}
+    for m in mimetypes :
+        style_containers.update \
+            ({ OOo_Tag ('office', 'font-decls',       m) : 1
+             , OOo_Tag ('office', 'font-face-decls',  m) : 1
+             , OOo_Tag ('office', 'styles',           m) : 1
+             , OOo_Tag ('office', 'automatic-styles', m) : 1
+             , OOo_Tag ('office', 'master-styles',    m) : 1
+            })
+        # Cross-references in OOo document:
+        # 'attribute' references another element with 'tag'.
+        # If attribute names change, we must replace references, too.
+        #     attribute                                :
+        #     tag
+        ref_attrs.update \
+            ({ OOo_Tag ('style', 'parent-style-name', m) :
+               OOo_Tag ('style', 'style',             m)
+             , OOo_Tag ('style', 'master-page-name',  m) :
+               OOo_Tag ('style', 'master-page',       m)
+             , OOo_Tag ('style', 'page-layout-name',  m) : # OOo 2.X
+               OOo_Tag ('style', 'page-layout',       m)
+             , OOo_Tag ('style', 'page-master-name',  m) :
+               OOo_Tag ('style', 'page-master',       m)
+             , OOo_Tag ('table', 'style-name',        m) :
+               OOo_Tag ('style', 'style',             m)
+             , OOo_Tag ('text',  'style-name',        m) :
+               OOo_Tag ('style', 'style',             m)
+             , OOo_Tag ('draw',  'style-name',        m) :
+               OOo_Tag ('style', 'style',             m)
+             , OOo_Tag ('draw',  'text-style-name',   m) :
+               OOo_Tag ('style', 'style',             m)
+            })
+    stylefiles = ['styles.xml', 'content.xml']
+    oofiles    = stylefiles + ['meta.xml']
+
+    body_decl_sections = ['variable-decl', 'sequence-decl']
+
+    def __init__ (self, * docs, ** kw) :
+        self.__super.__init__ (** kw)
+        self.docs = []
+        for doc in docs :
+            self.docs.append (OOoPy (infile = doc))
+            assert (self.docs [-1].mimetype == self.docs [0].mimetype)
+    # end def __init__
+
+    def apply_all (self, trees) :
+        assert (self.docs [0].mimetype == self.transformer.mimetype)
+        self.serialised = {}
+        self.stylenames = {}
+        self.namemaps   = [{}]
+        self.tab_depend = {}
+        for s in self.ref_attrs.itervalues () :
+            self.namemaps [0][s] = {}
+        self.body_decls = {}
+        for s in self.body_decl_sections :
+            self.body_decls [s] = {}
+        self.trees      = {}
+        for f in self.oofiles :
+            self.trees [f] = [trees [f].getroot ()]
+        self.sections   = {}
+        for f in self.stylefiles :
+            self.sections [f] = {}
+            for node in self.trees [f][0] :
+                self.sections [f][node.tag] = node
+        for d in self.docs :
+            self.namemaps.append ({})
+            for s in self.ref_attrs.itervalues () :
+                self.namemaps [-1][s] = {}
+            for f in self.oofiles :
+                self.trees [f].append (d.read (f).getroot ())
+        # append a pagebreak style, will be optimized away if duplicate
+        pbs = Addpagebreak_Style (transformer = self.transformer)
+        pbs.apply (self.trees ['content.xml'][0])
+        get_attr = []
+        for attr in meta_counts :
+            a = self.oootag ('meta', attr)
+            t = self.oootag ('meta', 'document-statistic')
+            get_attr.append (Get_Attribute (t, a, 'concat-' + attr))
+        zi = Attribute_Access \
+            ( (Get_Max (None, self.oootag ('draw', 'z-index'), 'z-index'),)
+            , transformer = self.transformer
+            )
+        zi.apply (self.trees ['content.xml'][0])
+        self.zi = Attribute_Access \
+            ( (Get_Max (None, self.oootag ('draw', 'z-index'), 'concat-z-index')
+              ,
+              )
+            , transformer = self.transformer
+            )
+        self.getmeta = Attribute_Access \
+            (get_attr, filename = 'meta.xml', transformer = self.transformer)
+        self.pbname = self.transformer \
+            [':'.join (('Addpagebreak_Style', 'stylename'))]
+        for s in self.trees ['styles.xml'][0].findall \
+            ('.//' + self.oootag ('style', 'default-style')) :
+            if s.get (self.oootag ('style', 'family')) == 'paragraph' :
+                default_style = s
+                break
+        self.default_properties = default_style.find \
+            ('./' + self.properties_tag)
+        self.set_pagestyle ()
+        for f in 'styles.xml', 'content.xml' :
+            self.style_merge (f)
+        self.body_concat ()
+        self.append_pictures ()
+    # end def apply_all
+
+    def apply_tab_correction (self, node) :
+        """ Check if node depends on a style which has corrected tabs
+            if yes, insert all the default tabs *after* the maximum tab
+            position in that style.
+        """
+        tab_stops = self.oootag ('style', 'tab-stops')
+        tab_stop  = self.oootag ('style', 'tab-stop')
+        tab_pos   = self.oootag ('style', 'position')
+        parent    = node.get (self.oootag ('style', 'parent-style-name'))
+        if parent in self.tab_depend :
+            for prop in node :
+                if prop.tag != self.properties_tag :
+                    continue
+                for sub in prop :
+                    if sub.tag == tab_stops :
+                        self.tab_depend [parent] = 1
+                        max = 0
+                        for ts in sub :
+                            assert (ts.tag == tab_stop)
+                            pos = float (ts.get (tab_pos) [:-2])
+                            if max < pos :
+                                max = pos
+                        self.insert_tabs (sub, max)
+    # end def apply_tab_correction
+
+    def _attr_rename (self, idx) :
+        r = sum \
+            ( [ set_attributes_from_dict (None, k, self.namemaps [idx][v])
+                for k,v in self.ref_attrs.iteritems ()
+              ]
+            , []
+            )
+        return Attribute_Access (r, transformer = self.transformer)
+    # end def _attr_rename
+
+    def body_concat (self) :
+        count = {}
+        for i in meta_counts :
+            count [i] = self._get_meta (i)
+        count ['z-index'] = self._get_meta \
+            ('z-index', classname = 'Get_Max') + 1
+        pb   = Addpagebreak \
+            (stylename = self.pbname, transformer = self.transformer)
+        self.divide_body (self.trees ['content.xml'][0])
+        self.body_decl (self.declarations, append = 0)
+        for idx in range (1, len (self.docs) + 1) :
+            meta    = self.trees ['meta.xml'][idx]
+            content = self.trees ['content.xml'][idx]
+            tbody   = self.find_tbody (content)
+            self.getmeta.apply (meta)
+            self.zi.apply      (tbody)
+
+            ra = Attribute_Access \
+              ( ( Reanchor 
+                    (count ['page-count'], self.oootag ('draw', 'text-box'))
+                , Reanchor
+                    (count ['page-count'], self.oootag ('draw', 'rect'))
+                , Reanchor
+                    (count ['page-count'], self.oootag ('draw', 'frame'))
+                , Reanchor
+                    (count ['z-index'], None, self.oootag ('draw', 'z-index'))
+                )
+              , transformer = self.transformer # transformer added
+              )
+            for i in meta_counts :
+                count [i] += self._get_meta (i, prefix = 'concat-')
+            count ['paragraph-count'] += 1
+            count ['z-index'] += self._get_meta \
+                ('z-index', classname = 'Get_Max', prefix = 'concat-') + 1
+            namemap = self.namemaps [idx][self.oootag ('style', 'style')]
+            tr      = self._attr_rename (idx)
+            pb.apply (self.bodyparts [-1])
+            tr.apply (content)
+            ra.apply (content)
+            declarations = self._divide (tbody)
+            self.body_decl (declarations)
+            self.append_to_body (self.copyparts)
+        self.append_declarations ()
+        self.assemble_body       ()
+        for i in meta_counts :
+            self._set_meta (i, count [i])
+    # end def body_concat
+
+    def body_decl (self, decl_section, append = 1) :
+        for sect in self.body_decl_sections :
+            s = self.declarations.find \
+                ('.//' + self.oootag ('text', sect + 's'))
+            d = self.body_decls [sect]
+            t = self.oootag ('text', sect)
+            for n in decl_section.findall ('.//' + t) :
+                name = n.get (self.oootag ('text', 'name'))
+                if name not in d :
+                    if append and s is not None :
+                        s.append (n)
+                    d [name] = 1
+    # end def body_decl
+
+    def insert_tabs (self, element, max = 0) :
+        """ Insert tab stops into the current element. Optionally after
+            max = the current maximum tab-position
+        """
+        dist_tag = self.oootag ('style', 'tab-stop-distance')
+        for k in range (1, len (self.tab_correct)) :
+            if self.tab_correct [-k].isdigit() :
+                break
+        l    = float (self.tab_correct [:-k])
+        unit = self.tab_correct [-k:]
+        for ts in range (35) :
+            pos = l * (ts + 1)
+            if pos > max :
+                SubElement \
+                    ( element
+                    , self.oootag ('style', 'tab-stop')
+                    , { self.oootag ('style', 'position') : '%s%s' % (pos, unit)
+                      }
+                    )
+    # end def insert_tabs
+
+    def merge_defaultstyle (self, default_style, node) :
+        assert default_style is not None
+        assert node is not None
+        proppath = './' + self.properties_tag
+        defprops = default_style.find (proppath)
+        props    = node.find          (proppath)
+        sn       = self.oootag ('style', 'name')
+        if props is None :
+            props = Element (self.properties_tag)
+        for k, v in defprops.attrib.iteritems () :
+            if self.default_properties.get (k) != v and not props.get (k) :
+                if k == self.oootag ('style', 'tab-stop-distance') :
+                    self.tab_correct = v
+                    self.tab_depend  = {node.get (sn) : 1}
+                    stps = SubElement \
+                        (props, self.oootag ('style', 'tab-stops'))
+                    self.insert_tabs (stps)
+                else :
+                    props.set (k,v)
+        if len (props) or props.attrib :
+            node.append (props)
+    # end def merge_defaultstyle
+
+    def _newname (self, key, oldname) :
+        stylenum = 0
+        if (key, oldname) not in self.stylenames :
+            self.stylenames [(key, oldname)] = 1
+            return oldname
+        newname = basename = 'Concat_%s' % oldname
+        while (key, newname) in self.stylenames :
+            stylenum += 1
+            newname = '%s%d' % (basename, stylenum)
+        self.stylenames [(key, newname)] = 1
+        return newname
+    # end def _newname
+
+    def set_pagestyle (self) :
+        """ For all documents: search for the first paragraph of the tbody
+            and get its style. Modify this style to include a reference
+            to the default page-style if it doesn't contain a reference
+            to a page style. Insert the new style into the list of
+            styles and modify the first paragraph to use the new page
+            style.
+            This procedure is necessary to make appended documents use
+            their page style instead of the master page style of the
+            first document.
+            FIXME: We should search the style hierarchy backwards for
+            the style of the first paragraph to check if there is a
+            reference to a page-style somewhere and not override the
+            page-style in this case. Otherwise appending complex
+            documents that use a different page-style for the first page
+            will not work if the page style is referenced in a style
+            from which the first paragraph style derives.
+        """
+        for idx in range (1, len (self.docs) + 1) :
+            croot  = self.trees  ['content.xml'][idx]
+            sroot  = self.trees  ['styles.xml'] [idx]
+            tbody  = self.find_tbody (croot)
+            para   = tbody.find  ('./' + self.oootag ('text', 'p'))
+            if para is None :
+                para = tbody.find  ('./' + self.oootag ('text', 'list'))
+            tsn    = self.oootag ('text', 'style-name')
+            sname  = para.get    (tsn)
+            styles = croot.find  (self.oootag ('office', 'automatic-styles'))
+            ost    = sroot.find  (self.oootag ('office', 'styles'))
+            mst    = sroot.find  (self.oootag ('office', 'master-styles'))
+            assert mst is not None and len (mst)
+            assert mst [0].tag == self.oootag ('style', 'master-page')
+            sntag  = self.oootag ('style', 'name')
+            master = mst [0].get (sntag)
+            mpn    = self.oootag ('style', 'master-page-name')
+            stytag = self.oootag ('style', 'style')
+            style  = None
+            for s in styles :
+                if s.tag == stytag :
+                    # Explicit references to default style converted to
+                    # explicit references to new page style.
+                    if s.get (mpn) == '' :
+                        s.set (mpn, master)
+                    if s.get (sntag) == sname :
+                        style = s
+            if style is None :
+                for s in ost :
+                    if s.tag == stytag and s.get (sntag) == sname :
+                        style = s
+                        break
+            if style is not None and not style.get (mpn) :
+                newstyle = deepcopy (style)
+                # Don't register with newname: will be rewritten later
+                # when appending. We assume that an original doc does
+                # not already contain a style with _Concat suffix.
+                newname = sname + '_Concat'
+                para.set (tsn, newname)
+                newstyle.set (self.oootag ('style', 'name'), newname)
+                newstyle.set (mpn,                            master)
+                styles.append (newstyle)
+    # end def set_pagestyle
+
+    def style_merge (self, oofile) :
+        """ Loop over all the docs in our document list and look up the
+            styles there. If a style matches an existing style in the
+            original document, register the style name for later
+            transformation if the style name in the original document
+            does not match the style name in the appended document.  If
+            no match is found, append style to master document and add
+            to serialisation. If the style name already exists in the
+            master document, a new style name is created. Names of
+            parent styles are changed when appending -- this means that
+            parent style names already have to be defined earlier in the
+            document.
+
+            If there is a reference to a parent style that is not yet
+            defined, and the parent style is defined later, it is
+            already too late, so an assertion is raised in this case.
+            OOo seems to ensure declaration order of dependent styles,
+            so this should not be a problem.
+        """
+        for idx in range (len (self.trees [oofile])) :
+            namemap = self.namemaps [idx]
+            root    = self.trees    [oofile][idx]
+            delnode = []
+            for nodeidx, node in enumerate (root) :
+                if node.tag not in self.style_containers :
+                    continue
+                prefix = ''
+                # font_decls may have same name in styles.xml and content.xml
+                if node.tag == self.font_decls_tag :
+                    prefix = oofile
+                default_style = None
+                for n in node :
+                    if  (   n.tag == self.oootag ('style', 'default-style')
+                        and (  n.get (self.oootag ('style', 'family'))
+                            == 'paragraph'
+                            )
+                        ) :
+                        default_style = n
+                    name     = n.get (self.oootag ('style', 'name'), None)
+                    if not name : continue
+                    if  (   idx != 0
+                        and name == 'Standard'
+                        and n.get (self.oootag ('style', 'class'))  == 'text'
+                        and (  n.get (self.oootag ('style', 'family'))
+                            == 'paragraph'
+                            )
+                        ) :
+                        self.merge_defaultstyle (default_style, n)
+                    self.apply_tab_correction (n)
+                    key = prefix + n.tag
+                    if key not in namemap : namemap [key] = {}
+                    tr = self._attr_rename (idx)
+                    tr.apply (n)
+                    sn  = tree_serialise (n, prefix, self.mimetype)
+                    if sn in self.serialised :
+                        newname = self.serialised [sn]
+                        if name != newname :
+                            assert \
+                                (  name not in namemap [key]
+                                or namemap [key][name] == newname
+                                )
+                            namemap [key][name] = newname
+                            # optimize original doc: remove duplicate styles
+                            if  not idx and node.tag != self.font_decls_tag :
+                                pass
+                                #delnode.append (nodeidx)
+                    else :
+                        newname = self._newname (key, name)
+                        self.serialised [sn] = newname
+                        if newname != name :
+                            n.set (self.oootag ('style', 'name'), newname)
+                            dn = self.oootag ('style', 'display-name')
+                            disp_name = n.get (dn)
+                            if disp_name :
+                                n.set (dn, 'Concat ' + disp_name)
+                            namemap [key][name] = newname
+                        if idx != 0 :
+                            self.sections [oofile][node.tag].append (n)
+                assert not delnode or not idx
+                delnode.reverse ()
+                for i in delnode :
+                    del node [i]
+    # end style_merge
+
+    def append_pictures (self) :
+        for doc in self.docs :
+            for f in doc.izip.infolist () :
+                if f.filename.startswith ('Pictures/') :
+                    self.transformer.appendfiles.append \
+                        ((f.filename, doc.izip.read (f.filename)))
+    # end def append_pictures
+            
+# end class Concatenate
+
+def renumber_frames (mimetype) :
+    return \
+        [ Renumber (OOo_Tag ('draw',  'text-box', mimetype), 'Frame') # OOo 1.X
+        , Renumber (OOo_Tag ('draw',  'frame',    mimetype), 'Frame') # OOo 2.X
+        ]
+# end def renumber_frames
+
+def renumber_sections (mimetype) :
+    return [Renumber (OOo_Tag ('text',  'section', mimetype))]
+# end def renumber_sections
+
+def renumber_tables (mimetype) :
+    return [Renumber (OOo_Tag ('table', 'table', mimetype))]
+# end def renumber_tables
+
+def renumber_images (mimetype) :
+    return [Renumber (OOo_Tag ('draw', 'image', mimetype))]
+# end def renumber_images
+
+def renumber_xml_id (mimetype) :
+    if mimetype == mimetypes [0] :
+        return []
+    xmlid = OOo_Tag ('xml', 'id', mimetype)
+    return [Renumber (OOo_Tag ('text', 'list', mimetype), 'list', xmlid)]
+# end def renumber_xml_id
+
+def renumber_all (mimetype) :
+    """ Factory function for all renumberings parameterized with
+        mimetype
+    """
+    return Attribute_Access \
+        ( renumber_frames   (mimetype)
+        + renumber_sections (mimetype)
+        + renumber_tables   (mimetype)
+        + renumber_images   (mimetype)
+        + renumber_xml_id   (mimetype)
+        ) 
+# end def renumber_all
+
+# used to have a separate Pagecount transform -- generalized to get
+# some of the meta information using an Attribute_Access transform
+# and set the same information later after possibly being updated by
+# other transforms. We use another naming convention here for storing
+# the info retrieved from the OOo document: We use the attribute name in
+# the meta-information to store (and later retrieve) the information.
+
+def get_meta (mimetype) :
+    """ Factory function for Attribute_Access to get all interesting
+        meta-data
+    """
+    get_attr = []
+    for attr in meta_counts :
+        a = OOo_Tag ('meta', attr, mimetype)
+        t = OOo_Tag ('meta', 'document-statistic', mimetype)
+        get_attr.append (Get_Attribute (t, a, attr))
+    return Attribute_Access (get_attr, prio =  20, filename = 'meta.xml')
+# end def get_meta
+
+def set_meta (mimetype) :
+    """ Factory function for Attribute_Access to set all interesting
+        meta-data
+    """
+    set_attr = []
+    for attr in meta_counts :
+        a = OOo_Tag ('meta', attr, mimetype)
+        t = OOo_Tag ('meta', 'document-statistic', mimetype)
+        set_attr.append (Set_Attribute (t, a, attr))
+    return Attribute_Access (set_attr, prio = 120, filename = 'meta.xml')
+# end def set_meta