Add partial support for column-span property.

[grewn0uille]

Related to #719.

[JohannesMunk]

Hey liZe!

This new balancing algorithm is the cause of quite a big slowdown in document generation in our projects. We have several documents with colspans>=2 that span multiple pages and contain complex block stuff. Rendering all columns content on every pixel the height is increased was getting to slow. 90mins for 230 pages..

While keeping the basic idea alive instead of a linear scan to find the smallest columns height for a "balanced" layout I implemented a simple binary search.

    # Balance.
    #
    # The current algorithm starts from the ideal height (the total height
    # divided by the number of columns). We then iterate until the last column
    # is not the highest one. At the end of each loop, we add the minimal
    # height needed to make one direct child at the top of one column go to the
    # end of the previous column.
    #
    # We rely on a real rendering for each loop, and with a scanning algorithm
    # like this it can last minutes…

    adjoining_margins = []
    current_position_y = box.content_box_y()
    new_children = []
    for column_children_or_block in columns_and_blocks:
        if not isinstance(column_children_or_block, list):
            # We get a spanning block, we display it like other blocks.
            block = column_children_or_block
            resolve_percentages(block, containing_block)
            block.position_x = box.content_box_x()
            block.position_y = current_position_y
            new_child, _, _, adjoining_margins, _ = block_level_layout(
                context, block, original_max_position_y, skip_stack,
                containing_block, page_is_empty, absolute_boxes, fixed_boxes,
                adjoining_margins)
            new_children.append(new_child)
            current_position_y = (
                new_child.border_height() + new_child.border_box_y())
            adjoining_margins.append(new_child.margin_bottom)
            continue

        excluded_shapes = context.excluded_shapes[:]

        # We have a list of children that we have to balance between columns.
        column_children = column_children_or_block

        # Find the total height of the content
        current_position_y += collapse_margin(adjoining_margins)
        adjoining_margins = []
        column_box = create_column_box(column_children)
        new_child, _, _, _, _ = block_box_layout(
            context, column_box, float('inf'), skip_stack, containing_block,
            page_is_empty, [], [], [])
        height = new_child.margin_height()
        total_height = height
        if style['column_fill'] == 'balance':
            height /= count

        # Try to render columns until the content fits, increase the column
        # height step by step by binary search limits.

        # helper to derive the step_size
        def step_size_calc(value):
            return max(1, value)
            # coercing to power of 2 has no benefit, but increases number of steps..
            # result = round(value).bit_length()
            # return 1 if result == 0 else 1 << result-1

        # difference between upper and lower height is the current search step size
        # start value is arbitrary height / 4
        step_size = step_size_calc((height)/4)
        lower_height = height
        upper_height = 0
        # while the right height has not been found
        while True:
            column_skip_stack = skip_stack
            # Remove extra excluded shapes introduced during previous loop
            new_excluded_shapes = (
                len(context.excluded_shapes) - len(excluded_shapes))
            for i in range(new_excluded_shapes):
                context.excluded_shapes.pop()

            # through all columns
            for i in range(count):
                # render the column.
                new_box, resume_at, next_page, _, _ = block_box_layout(
                    context, column_box, box.content_box_y() + height,
                    column_skip_stack, containing_block, page_is_empty,
                    [], [], [])

                # did we render anything?
                if new_box is None:
                    # Give up and use the total content height.
                    height = total_height
                    break

                # render of the next column shall pickup where this one left
                column_skip_stack = resume_at

                # Stop if we already rendered the whole content
                if resume_at is None:
                    break

            # gave up or reached the total_height of all content combined?
            if height >= total_height:
                break

            # rendered the whole content?
            if column_skip_stack is None:
                if step_size == 1:
                    break
                else:
                    # found a working height, but our binary step is still to big.
                    # need to continue and check if height is lowest acceptable
                    upper_height = height
                    # we need to step backwards until our stepsize is 1.
                    step_size = step_size_calc((upper_height-lower_height)/2)
                    height -= step_size
            else:
                # overall height was not enough to fit the whole content =>

                # height value itself is not acceptable - height+1 might be
                lower_height = height+1
                
                # if a real upper limit is not known. we do not half the stepsize
                # Increase the columns heights and render them once again
                if not upper_height == 0:
                    step_size = step_size_calc((upper_height-lower_height)/2)
                    height = min(height+step_size, upper_height)
                    # optimization: avoid last block_box_layout if we already know that our new height is acceptable
                    if step_size == 1 and height == upper_height:
                        break
                else:
                    height = height+step_size
                

My question is: Why is the height information of each child - as is used to determine the total content height - not enough to fill the children into columns as they fit? Why call block_box_layout in every iteration of the height scan?

Hope your pdf-backend migration is progressing well!

Johannes