2011-07-22 18:34:32 +04:00
|
|
|
# coding: utf8
|
|
|
|
|
|
|
|
# WeasyPrint converts web documents (HTML, CSS, ...) to PDF.
|
|
|
|
# Copyright (C) 2011 Simon Sapin
|
|
|
|
#
|
|
|
|
# This program is free software: you can redistribute it and/or modify
|
|
|
|
# it under the terms of the GNU Affero General Public License as
|
|
|
|
# published by the Free Software Foundation, either version 3 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 Affero General Public License for more details.
|
|
|
|
#
|
|
|
|
# You should have received a copy of the GNU Affero General Public License
|
|
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
|
2011-08-24 12:25:45 +04:00
|
|
|
"""
|
|
|
|
Functions laying out the block boxes.
|
|
|
|
|
|
|
|
"""
|
2011-07-22 18:34:32 +04:00
|
|
|
|
2012-02-17 21:49:58 +04:00
|
|
|
from __future__ import division, unicode_literals
|
2011-08-20 20:02:04 +04:00
|
|
|
|
2011-10-03 19:55:41 +04:00
|
|
|
from .inlines import get_next_linebox, replaced_box_width, replaced_box_height
|
2011-08-22 17:37:10 +04:00
|
|
|
from .markers import list_marker_layout
|
2011-11-30 17:56:57 +04:00
|
|
|
from .tables import table_layout, fixed_table_layout
|
2011-08-22 17:37:10 +04:00
|
|
|
from .percentages import resolve_percentages
|
|
|
|
from ..formatting_structure import boxes
|
2011-07-22 18:34:32 +04:00
|
|
|
|
2011-08-22 13:38:54 +04:00
|
|
|
|
2011-12-02 18:31:23 +04:00
|
|
|
def block_level_layout(document, box, max_position_y, skip_stack,
|
2012-02-23 22:30:31 +04:00
|
|
|
containing_block, device_size, page_is_empty,
|
|
|
|
adjoining_margins=None):
|
2011-08-24 12:25:45 +04:00
|
|
|
"""Lay out the block-level ``box``.
|
|
|
|
|
2011-08-22 20:14:37 +04:00
|
|
|
:param max_position_y: the absolute vertical position (as in
|
2011-08-24 12:25:45 +04:00
|
|
|
``some_box.position_y``) of the bottom of the
|
|
|
|
content box of the current page area.
|
|
|
|
|
2011-08-22 20:14:37 +04:00
|
|
|
"""
|
2011-11-22 16:06:50 +04:00
|
|
|
if isinstance(box, boxes.TableBox):
|
2011-12-02 18:31:23 +04:00
|
|
|
return table_layout(document, box, max_position_y, containing_block,
|
2011-11-25 20:20:41 +04:00
|
|
|
device_size, page_is_empty)
|
2011-11-22 16:06:50 +04:00
|
|
|
elif isinstance(box, boxes.BlockBox):
|
|
|
|
if box.is_table_wrapper:
|
2011-12-02 18:31:23 +04:00
|
|
|
return block_table_wrapper(document, box, max_position_y,
|
2012-02-23 22:30:31 +04:00
|
|
|
skip_stack, containing_block, device_size, page_is_empty,
|
|
|
|
adjoining_margins)
|
2011-11-22 16:06:50 +04:00
|
|
|
else:
|
2011-12-02 18:31:23 +04:00
|
|
|
return block_box_layout(document, box, max_position_y, skip_stack,
|
2012-02-23 22:30:31 +04:00
|
|
|
containing_block, device_size, page_is_empty,
|
|
|
|
adjoining_margins)
|
2011-12-05 17:24:43 +04:00
|
|
|
elif isinstance(box, boxes.BlockReplacedBox):
|
2012-01-20 14:55:06 +04:00
|
|
|
box = block_replaced_box_layout(
|
|
|
|
box, containing_block, device_size)
|
2012-02-23 15:51:19 +04:00
|
|
|
resume_at = None
|
|
|
|
next_page = 'any'
|
|
|
|
adjoining_margins = []
|
2012-02-28 17:50:35 +04:00
|
|
|
collapsing_through = False
|
|
|
|
return box, resume_at, next_page, adjoining_margins, collapsing_through
|
2011-08-22 13:38:54 +04:00
|
|
|
else:
|
|
|
|
raise TypeError('Layout for %s not handled yet' % type(box).__name__)
|
|
|
|
|
|
|
|
|
2011-12-02 18:31:23 +04:00
|
|
|
def block_box_layout(document, box, max_position_y, skip_stack,
|
2012-02-23 22:30:31 +04:00
|
|
|
containing_block, device_size, page_is_empty,
|
|
|
|
adjoining_margins=None):
|
2011-08-24 12:25:45 +04:00
|
|
|
"""Lay out the block ``box``."""
|
2011-10-06 19:47:04 +04:00
|
|
|
resolve_percentages(box, containing_block)
|
2011-10-06 18:20:03 +04:00
|
|
|
block_level_width(box, containing_block)
|
2012-02-28 17:50:35 +04:00
|
|
|
new_box, resume_at, next_page, adjoining_margins, collapsing_through = \
|
|
|
|
block_level_height(
|
|
|
|
document, box, max_position_y, skip_stack,
|
|
|
|
device_size, page_is_empty, adjoining_margins)
|
2012-02-23 22:30:31 +04:00
|
|
|
list_marker_layout(document, new_box, containing_block)
|
2012-02-28 17:50:35 +04:00
|
|
|
return new_box, resume_at, next_page, adjoining_margins, collapsing_through
|
2011-08-20 17:07:14 +04:00
|
|
|
|
|
|
|
|
2011-10-06 18:20:03 +04:00
|
|
|
def block_replaced_box_layout(box, containing_block, device_size):
|
2011-08-24 12:25:45 +04:00
|
|
|
"""Lay out the block :class:`boxes.ReplacedBox` ``box``."""
|
2011-08-22 17:37:10 +04:00
|
|
|
assert isinstance(box, boxes.ReplacedBox)
|
2011-10-06 19:47:04 +04:00
|
|
|
resolve_percentages(box, containing_block)
|
2011-08-20 20:02:04 +04:00
|
|
|
|
2011-08-26 18:16:40 +04:00
|
|
|
# http://www.w3.org/TR/CSS21/visudet.html#block-replaced-width
|
2011-10-06 17:36:19 +04:00
|
|
|
replaced_box_width(box, device_size)
|
2011-10-06 18:20:03 +04:00
|
|
|
block_level_width(box, containing_block)
|
2011-08-25 19:32:23 +04:00
|
|
|
|
2011-08-26 18:16:40 +04:00
|
|
|
# http://www.w3.org/TR/CSS21/visudet.html#inline-replaced-height
|
2011-10-06 17:36:19 +04:00
|
|
|
replaced_box_height(box, device_size)
|
2011-08-26 18:16:40 +04:00
|
|
|
if box.margin_top == 'auto':
|
|
|
|
box.margin_top = 0
|
|
|
|
if box.margin_bottom == 'auto':
|
|
|
|
box.margin_bottom = 0
|
|
|
|
|
2011-08-22 20:14:37 +04:00
|
|
|
return box
|
2011-07-22 18:34:32 +04:00
|
|
|
|
|
|
|
|
2011-10-06 18:20:03 +04:00
|
|
|
def block_level_width(box, containing_block):
|
2011-08-24 12:25:45 +04:00
|
|
|
"""Set the ``box`` width."""
|
|
|
|
# 'cb' stands for 'containing block'
|
2011-10-06 18:20:03 +04:00
|
|
|
cb_width = containing_block.width
|
2011-07-22 18:34:32 +04:00
|
|
|
|
|
|
|
# http://www.w3.org/TR/CSS21/visudet.html#blockwidth
|
|
|
|
|
|
|
|
# These names are waaay too long
|
|
|
|
margin_l = box.margin_left
|
|
|
|
margin_r = box.margin_right
|
|
|
|
padding_l = box.padding_left
|
|
|
|
padding_r = box.padding_right
|
2011-12-30 20:19:02 +04:00
|
|
|
border_l = box.border_left_width
|
|
|
|
border_r = box.border_right_width
|
2011-07-22 18:34:32 +04:00
|
|
|
width = box.width
|
|
|
|
|
|
|
|
# Only margin-left, margin-right and width can be 'auto'.
|
|
|
|
# We want: width of containing block ==
|
|
|
|
# margin-left + border-left-width + padding-left + width
|
|
|
|
# + padding-right + border-right-width + margin-right
|
|
|
|
|
|
|
|
paddings_plus_borders = padding_l + padding_r + border_l + border_r
|
|
|
|
if box.width != 'auto':
|
|
|
|
total = paddings_plus_borders + width
|
|
|
|
if margin_l != 'auto':
|
|
|
|
total += margin_l
|
|
|
|
if margin_r != 'auto':
|
|
|
|
total += margin_r
|
|
|
|
if total > cb_width:
|
|
|
|
if margin_l == 'auto':
|
|
|
|
margin_l = box.margin_left = 0
|
|
|
|
if margin_r == 'auto':
|
|
|
|
margin_r = box.margin_right = 0
|
|
|
|
if width != 'auto' and margin_l != 'auto' and margin_r != 'auto':
|
|
|
|
# The equation is over-constrained
|
|
|
|
margin_sum = cb_width - paddings_plus_borders - width
|
2012-01-27 14:07:49 +04:00
|
|
|
if containing_block.style.direction == 'ltr':
|
2011-07-22 18:34:32 +04:00
|
|
|
margin_r = box.margin_right = margin_sum - margin_l
|
|
|
|
else:
|
|
|
|
margin_l = box.margin_left = margin_sum - margin_r
|
|
|
|
if width == 'auto':
|
|
|
|
if margin_l == 'auto':
|
|
|
|
margin_l = box.margin_left = 0
|
|
|
|
if margin_r == 'auto':
|
|
|
|
margin_r = box.margin_right = 0
|
|
|
|
width = box.width = cb_width - (
|
|
|
|
paddings_plus_borders + margin_l + margin_r)
|
|
|
|
margin_sum = cb_width - paddings_plus_borders - width
|
|
|
|
if margin_l == 'auto' and margin_r == 'auto':
|
|
|
|
box.margin_left = margin_sum / 2.
|
|
|
|
box.margin_right = margin_sum / 2.
|
|
|
|
elif margin_l == 'auto' and margin_r != 'auto':
|
|
|
|
box.margin_left = margin_sum - margin_r
|
|
|
|
elif margin_l != 'auto' and margin_r == 'auto':
|
|
|
|
box.margin_right = margin_sum - margin_l
|
|
|
|
|
|
|
|
|
2012-01-20 14:55:06 +04:00
|
|
|
# TODO: rename this to block_container_something
|
2011-12-02 18:31:23 +04:00
|
|
|
def block_level_height(document, box, max_position_y, skip_stack,
|
2012-02-23 22:30:31 +04:00
|
|
|
device_size, page_is_empty, adjoining_margins=None):
|
2011-08-24 12:25:45 +04:00
|
|
|
"""Set the ``box`` height."""
|
2011-11-22 16:06:50 +04:00
|
|
|
assert isinstance(box, boxes.BlockContainerBox)
|
2011-08-22 20:14:37 +04:00
|
|
|
|
2012-02-07 19:59:22 +04:00
|
|
|
# TODO: this should make a differenc, but that is currently neglected.
|
|
|
|
# See http://www.w3.org/TR/CSS21/visudet.html#normal-block
|
|
|
|
# http://www.w3.org/TR/CSS21/visudet.html#root-height
|
|
|
|
|
|
|
|
#if box.style.overflow != 'visible':
|
|
|
|
# ...
|
2011-07-22 18:34:32 +04:00
|
|
|
|
|
|
|
if box.margin_top == 'auto':
|
|
|
|
box.margin_top = 0
|
|
|
|
if box.margin_bottom == 'auto':
|
|
|
|
box.margin_bottom = 0
|
|
|
|
|
2012-02-23 22:30:31 +04:00
|
|
|
if adjoining_margins is None:
|
|
|
|
adjoining_margins = []
|
|
|
|
|
|
|
|
adjoining_margins.append(box.margin_top)
|
|
|
|
this_box_adjoining_margins = adjoining_margins
|
|
|
|
|
|
|
|
collapsing_with_children = not (box.border_top_width or box.padding_top
|
2012-02-28 17:50:48 +04:00
|
|
|
or establishes_formatting_context(box) or box.is_for_root_element)
|
2012-02-23 22:30:31 +04:00
|
|
|
if collapsing_with_children:
|
|
|
|
# XXX not counting margins in adjoining_margins, if any
|
|
|
|
position_y = box.position_y
|
|
|
|
else:
|
|
|
|
box.position_y += collapse_margin(adjoining_margins) - box.margin_top
|
|
|
|
adjoining_margins = []
|
|
|
|
position_y = box.content_box_y()
|
|
|
|
|
2011-07-22 18:34:32 +04:00
|
|
|
position_x = box.content_box_x()
|
2011-07-26 19:34:55 +04:00
|
|
|
|
2011-10-03 20:57:26 +04:00
|
|
|
new_children = []
|
2012-01-20 14:55:06 +04:00
|
|
|
next_page = 'any'
|
2011-09-30 21:04:05 +04:00
|
|
|
|
|
|
|
if skip_stack is None:
|
|
|
|
skip = 0
|
|
|
|
else:
|
|
|
|
skip, skip_stack = skip_stack
|
|
|
|
|
2012-02-23 22:30:31 +04:00
|
|
|
first_child_in_flow = None
|
2011-09-30 21:04:05 +04:00
|
|
|
for index, child in box.enumerate_skip(skip):
|
2011-07-22 20:16:31 +04:00
|
|
|
if not child.is_in_normal_flow():
|
|
|
|
continue
|
2012-02-23 22:30:31 +04:00
|
|
|
if first_child_in_flow is None:
|
|
|
|
first_child_in_flow = child
|
|
|
|
|
2011-07-22 18:34:32 +04:00
|
|
|
child.position_x = position_x
|
2012-02-23 22:30:31 +04:00
|
|
|
# XXX does not count margins in adjoining_margins:
|
2011-07-22 18:34:32 +04:00
|
|
|
child.position_y = position_y
|
2012-02-23 22:30:31 +04:00
|
|
|
|
2011-07-26 19:34:55 +04:00
|
|
|
if isinstance(child, boxes.LineBox):
|
2011-10-13 18:25:08 +04:00
|
|
|
assert len(box.children) == 1, (
|
|
|
|
'line box with siblings before layout')
|
2011-10-03 19:55:41 +04:00
|
|
|
is_page_break = False
|
2012-02-23 22:30:31 +04:00
|
|
|
if adjoining_margins:
|
|
|
|
position_y += collapse_margin(adjoining_margins)
|
|
|
|
adjoining_margins = []
|
2011-10-03 19:55:41 +04:00
|
|
|
while 1:
|
2011-10-06 18:22:54 +04:00
|
|
|
new_containing_block = box
|
2011-10-03 19:55:41 +04:00
|
|
|
line, resume_at = get_next_linebox(
|
2011-12-02 18:31:23 +04:00
|
|
|
document, child, position_y, skip_stack,
|
2011-10-06 18:22:54 +04:00
|
|
|
new_containing_block, device_size)
|
2011-10-03 19:55:41 +04:00
|
|
|
if line is None:
|
|
|
|
break
|
|
|
|
new_position_y = position_y + line.height
|
2011-10-21 13:14:38 +04:00
|
|
|
# Allow overflow if the first line of the page is higher
|
|
|
|
# than the page itself so that we put *something* on this
|
|
|
|
# page and can advance in the document.
|
|
|
|
if new_position_y > max_position_y and not page_is_empty:
|
2011-10-13 18:25:08 +04:00
|
|
|
if not new_children:
|
|
|
|
# Page break before any content, cancel the whole box.
|
2012-02-28 17:50:35 +04:00
|
|
|
return None, None, 'any', [], False
|
2011-10-03 19:55:41 +04:00
|
|
|
# Page break here, resume before this line
|
|
|
|
resume_at = (index, skip_stack)
|
|
|
|
is_page_break = True
|
|
|
|
break
|
2011-10-03 20:57:26 +04:00
|
|
|
new_children.append(line)
|
2011-10-21 13:14:38 +04:00
|
|
|
page_is_empty = False
|
2011-10-03 19:55:41 +04:00
|
|
|
position_y = new_position_y
|
|
|
|
if resume_at is None:
|
|
|
|
break
|
|
|
|
skip_stack = resume_at
|
|
|
|
if is_page_break:
|
2011-08-22 20:38:15 +04:00
|
|
|
break
|
2011-07-26 19:34:55 +04:00
|
|
|
else:
|
2012-01-20 14:55:06 +04:00
|
|
|
page_break = child.style.page_break_before
|
|
|
|
if page_break in ('always', 'left', 'right'):
|
|
|
|
next_page = 'any' if page_break == 'always' else page_break
|
|
|
|
resume_at = (index, None)
|
|
|
|
# Force break only once
|
|
|
|
# TODO: refactor to avoid doing this?
|
|
|
|
child.style.page_break_before = 'auto'
|
|
|
|
break
|
|
|
|
|
2011-10-06 18:20:03 +04:00
|
|
|
new_containing_block = box
|
2012-02-28 17:50:35 +04:00
|
|
|
(new_child, resume_at, next_page, next_adjoining_margins,
|
|
|
|
collapsing_through) = block_level_layout(
|
2012-02-23 15:51:19 +04:00
|
|
|
document, child, max_position_y, skip_stack,
|
2012-02-23 22:30:31 +04:00
|
|
|
new_containing_block, device_size, page_is_empty,
|
|
|
|
adjoining_margins)
|
2012-02-22 21:57:56 +04:00
|
|
|
|
2011-09-30 21:04:05 +04:00
|
|
|
skip_stack = None
|
2011-10-13 18:25:08 +04:00
|
|
|
if new_child is None:
|
|
|
|
if new_children:
|
|
|
|
resume_at = (index, None)
|
2011-10-14 18:58:57 +04:00
|
|
|
break
|
2011-10-13 18:25:08 +04:00
|
|
|
else:
|
|
|
|
# This was the first child of this box, cancel the box
|
|
|
|
# completly
|
2012-02-28 17:50:35 +04:00
|
|
|
return None, None, 'any', [], False
|
2012-02-22 21:57:56 +04:00
|
|
|
|
|
|
|
# We need to do this after the child layout to have the used value
|
|
|
|
# for margin_top (eg. it might be a percentage.)
|
2012-02-23 22:30:31 +04:00
|
|
|
if not isinstance(new_child, boxes.BlockBox):
|
|
|
|
adjoining_margins.append(new_child.margin_top)
|
|
|
|
offset_y = (collapse_margin(adjoining_margins)
|
|
|
|
- new_child.margin_top)
|
2012-02-22 21:57:56 +04:00
|
|
|
new_child.translate(0, offset_y)
|
2012-02-23 22:30:31 +04:00
|
|
|
adjoining_margins = []
|
|
|
|
#else: blocks handle that themselves.
|
|
|
|
|
|
|
|
adjoining_margins = next_adjoining_margins
|
|
|
|
adjoining_margins.append(new_child.margin_bottom)
|
2012-02-22 21:57:56 +04:00
|
|
|
|
2012-02-28 17:50:35 +04:00
|
|
|
if not collapsing_through:
|
|
|
|
position_y = new_child.border_box_y() + new_child.border_height()
|
2012-02-22 21:57:56 +04:00
|
|
|
|
2011-10-13 18:25:08 +04:00
|
|
|
# Bottom borders may overflow here
|
|
|
|
# TODO: back-track somehow when all lines fit but not borders
|
2011-10-03 20:57:26 +04:00
|
|
|
new_children.append(new_child)
|
2011-10-21 13:14:38 +04:00
|
|
|
page_is_empty = False
|
2011-09-30 21:04:05 +04:00
|
|
|
if resume_at is not None:
|
|
|
|
resume_at = (index, resume_at)
|
2011-08-22 20:14:37 +04:00
|
|
|
break
|
2012-01-20 14:55:06 +04:00
|
|
|
|
|
|
|
page_break = child.style.page_break_after
|
|
|
|
if page_break in ('always', 'left', 'right'):
|
|
|
|
next_page = 'any' if page_break == 'always' else page_break
|
|
|
|
# Resume after this
|
|
|
|
resume_at = (index + 1, None)
|
|
|
|
break
|
2012-02-22 21:57:56 +04:00
|
|
|
|
2011-09-30 21:04:05 +04:00
|
|
|
else:
|
|
|
|
resume_at = None
|
2011-08-22 20:14:37 +04:00
|
|
|
|
2012-02-23 22:30:31 +04:00
|
|
|
|
|
|
|
if collapsing_with_children:
|
|
|
|
if new_children and not isinstance(
|
|
|
|
# margins are used for something else on line boxes
|
|
|
|
new_children[0], boxes.LineBox):
|
|
|
|
border_box_y = new_children[0].border_box_y()
|
|
|
|
else:
|
|
|
|
# this_adjoining_margins contains box.margin_top
|
|
|
|
border_box_y = box.position_y + collapse_margin(
|
|
|
|
this_box_adjoining_margins)
|
|
|
|
box.position_y = border_box_y - box.margin_top
|
|
|
|
|
2012-02-28 17:50:35 +04:00
|
|
|
collapsing_through = False
|
2012-02-23 22:30:31 +04:00
|
|
|
if new_children:
|
|
|
|
# bottom margin of the last child and bottom margin of this box ...
|
|
|
|
if box.height != 'auto':
|
|
|
|
# not adjoining. (position_y is not used afterwards.)
|
|
|
|
adjoining_margins = []
|
|
|
|
else:
|
|
|
|
# top and bottom margin of this box
|
2012-02-28 17:50:35 +04:00
|
|
|
if box.height in ('auto', 0) and box.min_height == 0:
|
|
|
|
collapsing_through = True
|
|
|
|
else:
|
2012-02-23 22:30:31 +04:00
|
|
|
# not adjoining. (position_y is not used afterwards.)
|
|
|
|
adjoining_margins = []
|
|
|
|
|
|
|
|
if box.border_bottom_width or box.padding_bottom or (
|
2012-02-28 17:50:48 +04:00
|
|
|
establishes_formatting_context(box) or box.is_for_root_element):
|
2012-02-23 22:30:31 +04:00
|
|
|
position_y += collapse_margin(adjoining_margins)
|
|
|
|
adjoining_margins = []
|
|
|
|
|
2011-10-03 20:57:26 +04:00
|
|
|
new_box = box.copy_with_children(new_children)
|
|
|
|
|
2012-02-23 22:30:31 +04:00
|
|
|
# TODO: See corner cases in
|
|
|
|
# http://www.w3.org/TR/CSS21/visudet.html#normal-block
|
2011-08-22 20:14:37 +04:00
|
|
|
if new_box.height == 'auto':
|
2012-02-23 22:30:31 +04:00
|
|
|
new_box.height = position_y - new_box.content_box_y()
|
2011-08-22 20:14:37 +04:00
|
|
|
|
2011-10-13 18:28:26 +04:00
|
|
|
if resume_at is not None:
|
|
|
|
# If there was a list marker, we kept it on `new_box`.
|
|
|
|
# Do not repeat it on `box` on the next page.
|
|
|
|
# TODO: Do this non-destructively
|
|
|
|
box.outside_list_marker = None
|
|
|
|
box.reset_spacing('top')
|
|
|
|
new_box.reset_spacing('bottom')
|
2012-02-23 22:30:31 +04:00
|
|
|
|
2012-02-28 17:50:35 +04:00
|
|
|
return new_box, resume_at, next_page, adjoining_margins, collapsing_through
|
2011-11-22 16:06:50 +04:00
|
|
|
|
|
|
|
|
2011-12-02 18:31:23 +04:00
|
|
|
def block_table_wrapper(document, wrapper, max_position_y, skip_stack,
|
2012-02-23 22:30:31 +04:00
|
|
|
containing_block, device_size, page_is_empty,
|
|
|
|
adjoining_margins):
|
2011-11-22 16:06:50 +04:00
|
|
|
"""Layout for the wrapper of a block-level table wrapper."""
|
2011-11-29 14:22:11 +04:00
|
|
|
for child in wrapper.children:
|
2011-11-22 16:06:50 +04:00
|
|
|
if isinstance(child, boxes.TableBox):
|
|
|
|
table = child
|
|
|
|
break
|
|
|
|
else:
|
|
|
|
raise ValueError('Table wrapper without a table')
|
2011-11-29 14:22:11 +04:00
|
|
|
resolve_percentages(wrapper, containing_block)
|
2011-11-22 16:06:50 +04:00
|
|
|
resolve_percentages(table, containing_block)
|
2011-11-29 14:22:11 +04:00
|
|
|
# Count the wrapper margins in case of `width: auto`
|
|
|
|
table.margin_left = wrapper.margin_left
|
|
|
|
table.margin_right = wrapper.margin_right
|
2011-11-24 20:56:05 +04:00
|
|
|
block_level_width(table, containing_block)
|
2011-11-29 14:22:11 +04:00
|
|
|
# The table margins are on the table wrapper box, not on the table box
|
|
|
|
table.margin_left = 0
|
|
|
|
table.margin_right = 0
|
2011-11-22 16:06:50 +04:00
|
|
|
|
2011-11-30 17:56:57 +04:00
|
|
|
fixed_table_layout(table)
|
2011-11-29 14:22:11 +04:00
|
|
|
wrapper.width = wrapper.style.width = table.border_width()
|
2011-12-02 18:31:23 +04:00
|
|
|
return block_box_layout(document, wrapper, max_position_y, skip_stack,
|
2012-02-23 22:30:31 +04:00
|
|
|
containing_block, device_size, page_is_empty,
|
|
|
|
adjoining_margins)
|
2012-02-23 15:51:19 +04:00
|
|
|
|
|
|
|
|
|
|
|
def collapse_margin(adjoining_margins):
|
|
|
|
"""Return the amount of collapsed margin for a list of adjoining margins.
|
|
|
|
"""
|
|
|
|
# Add 0 to make sure that neither max() or min() get an empty list
|
|
|
|
margins = [0]
|
|
|
|
margins.extend(adjoining_margins)
|
|
|
|
positives = (m for m in margins if m >= 0)
|
|
|
|
negatives = (m for m in margins if m <= 0)
|
|
|
|
return max(positives) + min(negatives)
|
2012-02-23 22:30:31 +04:00
|
|
|
|
|
|
|
|
|
|
|
def establishes_formatting_context(box):
|
|
|
|
"""Return wether a box establishes a block formatting context.
|
|
|
|
|
|
|
|
See http://www.w3.org/TR/CSS2/visuren.html#block-formatting
|
|
|
|
|
|
|
|
"""
|
|
|
|
return box.is_floated() or box.is_absolutely_positioned() or (
|
|
|
|
isinstance(box, boxes.BlockContainerBox)
|
|
|
|
and not isinstance(box, boxes.BlockBox)
|
|
|
|
) or (
|
|
|
|
isinstance(box, boxes.BlockBox) and box.style.overflow != 'visible'
|
|
|
|
)
|