Handle contextual spacing for paragraphs

Author: botzill

pydocx/export/base.py

@@ -31,6 +31,7 @@ def __init__(self, path):
         self.footnote_tracker = []
 
         self.captured_runs = None
+        self.paragraphs = []
         self.complex_field_runs = []
 
         self.node_type_to_export_func_map = {
@@ -299,6 +300,11 @@ def yield_body_children(self, body):
         return self.yield_numbering_spans(body.children)
 
     def export_paragraph(self, paragraph):
+        if self.first_pass:
+            # To properly handle contextual spacing we need to know what is the style
+            # of the previous and next paragraphs. So, we save all the paragraphs here.
+            self.paragraphs.append(paragraph)
+
         children = self.yield_paragraph_children(paragraph)
         results = self.yield_nested(children, self.export_node)
         if paragraph.effective_properties:

pydocx/export/html.py

@@ -5,7 +5,6 @@
     print_function,
     unicode_literals,
 )
-
 import base64
 import posixpath
 from itertools import chain
@@ -187,8 +186,8 @@ def style(self):
                 'margin': '0px auto',
             },
             'p': {
-                'margin-top': '0px',
-                'margin-bottom': '0px'
+                'margin-top': '0',
+                'margin-bottom': '0'
             }
         }
 
@@ -259,7 +258,10 @@ def export_footnote(self, footnote):
         return tag.apply(results, allow_empty=False)
 
     def get_paragraph_tag(self, paragraph):
-        if paragraph.is_empty:
+        if self.in_table_cell and paragraph.parent.properties.is_continue_vertical_merge:
+            # We ignore such paragraphs here because are added via rowspan
+            return
+        elif paragraph.is_empty:
             return HtmlTag('p', custom_text=HTML_WHITE_SPACE)
 
         heading_style = paragraph.heading_style
@@ -340,13 +342,78 @@ def export_paragraph_property_indentation(self, paragraph, results):
 
     def get_paragraph_property_spacing(self, paragraph):
         style = {}
+        if self.first_pass:
+            return style
+
+        previous_paragraph = None
+        next_paragraph = None
+        previous_paragraph_spacing = None
+        next_paragraph_spacing = None
+        spacing_after = None
+        spacing_before = None
+
+        current_paragraph_spacing = paragraph.get_spacing()
+        current_par_index = self.paragraphs.index(paragraph)
+
+        if current_par_index > 0:
+            previous_paragraph = self.paragraphs[current_par_index - 1]
+            previous_paragraph_spacing = previous_paragraph.get_spacing()
+        if current_par_index < len(self.paragraphs) - 1:
+            next_paragraph = self.paragraphs[current_par_index + 1]
+            next_paragraph_spacing = next_paragraph.get_spacing()
+
+        if next_paragraph:
+            current_after = current_paragraph_spacing['after'] or 0
+            next_before = next_paragraph_spacing['before'] or 0
+
+            same_style = current_paragraph_spacing['parent_style'] == \
+                         next_paragraph_spacing['parent_style']
+
+            if same_style:
+                if not current_paragraph_spacing['contextual_spacing']:
+                    if next_paragraph_spacing['contextual_spacing']:
+                        spacing_after = current_after
+                    else:
+                        if current_after > next_before:
+                            spacing_after = current_after
+            else:
+                if current_after > next_before:
+                    spacing_after = current_after
+        else:
+            spacing_after = current_paragraph_spacing['after']
+
+        if previous_paragraph:
+            current_before = current_paragraph_spacing['before'] or 0
+            prev_after = previous_paragraph_spacing['after'] or 0
+
+            same_style = current_paragraph_spacing['parent_style'] == \
+                         previous_paragraph_spacing['parent_style']
+
+            if same_style:
+                if not current_paragraph_spacing['contextual_spacing']:
+                    if previous_paragraph_spacing['contextual_spacing']:
+                        if current_before > prev_after:
+                            spacing_before = current_before - prev_after
+                        else:
+                            spacing_before = 0
+                    else:
+                        if current_before > prev_after:
+                            spacing_before = current_before
+            else:
+                if current_before > prev_after:
+                    spacing_before = current_before
+        else:
+            spacing_before = current_paragraph_spacing['before']
+
+        if current_paragraph_spacing['line']:
+            style['line-height'] = '{0}%'.format(current_paragraph_spacing['line'] * 100)
+
+        if spacing_after:
+            style['margin-bottom'] = '{0:.2f}em'.format(convert_twips_to_ems(spacing_after))
 
-        spacing = paragraph.get_spacing()
+        if spacing_before:
+            style['margin-top'] = '{0:.2f}em'.format(convert_twips_to_ems(spacing_before))
 
-        if spacing['line']:
-            style['line-height'] = '%s%%' % (spacing['line'] * 100)
-        if spacing['after']:
-            style['margin-bottom'] = '{0:.2f}em'.format(convert_twips_to_ems(spacing['after']))
         if style:
             style = {
                 'style': convert_dictionary_to_style_fragment(style)

pydocx/openxml/wordprocessing/paragraph.py

@@ -6,17 +6,18 @@
 )
 
 from pydocx.models import XmlModel, XmlCollection, XmlChild
+from pydocx.openxml.wordprocessing.bookmark import Bookmark
+from pydocx.openxml.wordprocessing.deleted_run import DeletedRun
 from pydocx.openxml.wordprocessing.hyperlink import Hyperlink
+from pydocx.openxml.wordprocessing.inserted_run import InsertedRun
 from pydocx.openxml.wordprocessing.paragraph_properties import ParagraphProperties  # noqa
 from pydocx.openxml.wordprocessing.run import Run
-from pydocx.openxml.wordprocessing.tab_char import TabChar
-from pydocx.openxml.wordprocessing.text import Text
-from pydocx.openxml.wordprocessing.smart_tag_run import SmartTagRun
-from pydocx.openxml.wordprocessing.inserted_run import InsertedRun
-from pydocx.openxml.wordprocessing.deleted_run import DeletedRun
 from pydocx.openxml.wordprocessing.sdt_run import SdtRun
 from pydocx.openxml.wordprocessing.simple_field import SimpleField
-from pydocx.openxml.wordprocessing.bookmark import Bookmark
+from pydocx.openxml.wordprocessing.smart_tag_run import SmartTagRun
+from pydocx.openxml.wordprocessing.tab_char import TabChar
+from pydocx.openxml.wordprocessing.text import Text
+from pydocx.openxml.wordprocessing.table_cell import TableCell
 from pydocx.util.memoize import memoized
 
 
@@ -231,27 +232,62 @@ def get_spacing(self):
         """
         results = {
             'line': None,
-            'after': None
+            'after': None,
+            'before': None,
+            'contextual_spacing': False,
+            'parent_style': None
         }
 
-        default_properties_spacing = self.default_doc_styles.paragraph.properties
-        no_spacing_properties = not self.properties or self.properties.no_spacing
+        # Get the paragraph_properties from the parent styles
+        style_paragraph_properties = None
+        for style in self.get_style_chain_stack():
+            if style.paragraph_properties:
+                style_paragraph_properties = style.paragraph_properties
+                break
+
+        if style_paragraph_properties:
+            results['contextual_spacing'] = bool(style_paragraph_properties.contextual_spacing)
+
+        default_paragraph_properties = None
+        if self.default_doc_styles and self.default_doc_styles.paragraph:
+            default_paragraph_properties = self.default_doc_styles.paragraph.properties
 
-        if not default_properties_spacing and no_spacing_properties:
+        # Spacing properties can be defined in multiple places and we need to get some
+        # kind of order of check
+        properties_order = [None, None, None]
+        if self.properties:
+            properties_order[0] = self.properties
+        if isinstance(self.parent, TableCell):
+            properties_order[1] = self.parent.parent_table.get_paragraph_properties()
+        if not self.properties or not self.properties.spacing_properties:
+            properties_order[2] = default_paragraph_properties
+
+        spacing_properties = None
+        contextual_spacing = None
+
+        for properties in properties_order:
+            if spacing_properties is None:
+                spacing_properties = getattr(properties, 'spacing_properties', None)
+            if contextual_spacing is None:
+                contextual_spacing = getattr(properties, 'contextual_spacing', None)
+
+        if not spacing_properties:
             return results
 
-        if no_spacing_properties:
-            properties = default_properties_spacing
-        else:
-            properties = self.properties
+        if contextual_spacing is not None:
+            results['contextual_spacing'] = bool(contextual_spacing)
 
-        spacing_line = properties.to_int('spacing_line')
-        spacing_after = properties.to_int('spacing_after')
+        if self.properties:
+            results['parent_style'] = self.properties.parent_style
 
-        if default_properties_spacing and spacing_line is None \
-                and bool(properties.spacing_after_auto_spacing):
+        spacing_line = spacing_properties.to_int('line')
+        spacing_after = spacing_properties.to_int('after')
+        spacing_before = spacing_properties.to_int('before')
+
+        if default_paragraph_properties and spacing_line is None \
+                and bool(spacing_properties.after_auto_spacing):
             # get the spacing_line from the default definition
-            spacing_line = default_properties_spacing.to_int('spacing_line')
+            spacing_line = default_paragraph_properties.spacing_properties.to_int('line')
 
         if spacing_line:
             line = spacing_line / 240.0
@@ -262,4 +298,7 @@ def get_spacing(self):
         if spacing_after is not None:
             results['after'] = spacing_after
 
+        if spacing_before is not None:
+            results['before'] = spacing_before
+
         return results

pydocx/openxml/wordprocessing/paragraph_properties.py

@@ -7,6 +7,7 @@
 
 from pydocx.models import XmlModel, XmlChild
 from pydocx.openxml.wordprocessing.numbering_properties import NumberingProperties  # noqa
+from pydocx.openxml.wordprocessing.paragraph_spacing import ParagraphSpacing
 from pydocx.types import OnOff
 
 
@@ -26,11 +27,9 @@ class ParagraphProperties(XmlModel):
     indentation_first_line = XmlChild(name='ind', attrname='firstLine')
     indentation_hanging = XmlChild(name='ind', attrname='hanging')
 
+    contextual_spacing = XmlChild(type=OnOff, name='contextualSpacing', attrname='val')
     # paragraph spacing
-    spacing_after = XmlChild(name='spacing', attrname='after')
-    spacing_line = XmlChild(name='spacing', attrname='line')
-    spacing_line_rule = XmlChild(name='spacing', attrname='lineRule')
-    spacing_after_auto_spacing = XmlChild(type=OnOff, name='spacing', attrname='afterAutospacing')
+    spacing_properties = XmlChild(type=ParagraphSpacing)
 
     @property
     def start_margin_position(self):
@@ -70,13 +69,4 @@ def no_indentation(self):
             self.indentation_hanging,
             self.indentation_right,
             self.indentation_first_line,
-        ))
-
-    @property
-    def no_spacing(self):
-        return not any((
-            self.spacing_line,
-            self.spacing_after,
-            self.spacing_after_auto_spacing,
-            self.spacing_line_rule,
-        ))
+        ))

pydocx/openxml/wordprocessing/paragraph_spacing.py

@@ -0,0 +1,27 @@
+# coding: utf-8
+from __future__ import (
+    absolute_import,
+    print_function,
+    unicode_literals,
+)
+
+from pydocx.models import XmlModel, XmlAttribute
+from pydocx.types import OnOff
+
+
+class ParagraphSpacing(XmlModel):
+    XML_TAG = 'spacing'
+
+    after = XmlAttribute(name='after')
+    before = XmlAttribute(name='before')
+    line = XmlAttribute(name='line')
+    line_rule = XmlAttribute(name='lineRule')
+    after_auto_spacing = XmlAttribute(type=OnOff, name='afterAutospacing')
+
+    def to_int(self, attribute, default=None):
+        # TODO would be nice if this integer conversion was handled
+        # implicitly by the model somehow
+        try:
+            return int(getattr(self, attribute, default))
+        except (ValueError, TypeError):
+            return default

pydocx/openxml/wordprocessing/style.py

@@ -7,6 +7,7 @@
 
 from pydocx.models import XmlModel, XmlChild, XmlAttribute
 from pydocx.openxml.wordprocessing.run_properties import RunProperties
+from pydocx.openxml.wordprocessing.paragraph_properties import ParagraphProperties
 
 
 class Style(XmlModel):
@@ -16,6 +17,7 @@ class Style(XmlModel):
     style_id = XmlAttribute(name='styleId', default='')
     name = XmlChild(attrname='val', default='')
     run_properties = XmlChild(type=RunProperties)
+    paragraph_properties = XmlChild(type=ParagraphProperties)
     parent_style = XmlChild(name='basedOn', attrname='val')
 
     def is_a_heading(self):

pydocx/openxml/wordprocessing/table.py

@@ -7,13 +7,16 @@
 
 from collections import defaultdict
 
-from pydocx.models import XmlModel, XmlCollection
+from pydocx.models import XmlModel, XmlCollection, XmlChild
 from pydocx.openxml.wordprocessing.table_row import TableRow
+from pydocx.openxml.wordprocessing.table_properties import TableProperties
 
 
 class Table(XmlModel):
     XML_TAG = 'tbl'
 
+    properties = XmlChild(type=TableProperties)
+
     rows = XmlCollection(
         TableRow,
     )
@@ -45,3 +48,28 @@ def calculate_table_cell_spans(self):
                         if active_rowspan_for_column:
                             cell_to_rowspan_count[active_rowspan_for_column] += 1  # noqa
         return dict(cell_to_rowspan_count)
+
+    def get_style_chain_stack(self):
+        if not self.properties:
+            return
+
+        parent_style = self.properties.parent_style
+        if not parent_style:
+            return
+
+        part = getattr(self.container, 'style_definitions_part', None)
+        if part:
+            style_stack = part.get_style_chain_stack('table', parent_style)
+            for result in style_stack:
+                yield result
+
+    def get_paragraph_properties(self):
+        """Get default style paragraph properties for table"""
+
+        paragraph_properties = None
+        for style in self.get_style_chain_stack():
+            if style.paragraph_properties:
+                paragraph_properties = style.paragraph_properties
+                break
+
+        return paragraph_properties

pydocx/openxml/wordprocessing/table_cell.py

@@ -6,7 +6,6 @@
 )
 
 from pydocx.models import XmlModel, XmlCollection, XmlChild
-from pydocx.openxml.wordprocessing.paragraph import Paragraph
 from pydocx.openxml.wordprocessing.table_cell_properties import TableCellProperties  # noqa
 
 
@@ -16,6 +15,14 @@ class TableCell(XmlModel):
     properties = XmlChild(type=TableCellProperties)
 
     children = XmlCollection(
-        Paragraph,
+        'wordprocessing.Paragraph',
         'wordprocessing.Table',
     )
+
+    @property
+    def parent_table(self):
+        return self.parent.parent
+
+    @property
+    def table_properties(self):
+        return self.parent_table.properties