mirror of
https://github.com/servo/servo.git
synced 2025-08-03 12:40:06 +01:00
Auto merge of #26852 - servo:layout-2020-independent-kind, r=SimonSapin
Some more boring stuff to change how we compute content sizes
This commit is contained in:
bors-servo
GitHub
commit
24cc72ba85
7 changed files with 343 additions and 335 deletions
|
|
@ -204,7 +204,7 @@ where
|
|||
|
||||
// https://drafts.csswg.org/css-flexbox/#order-modified-document-order
|
||||
children.sort_by_key(|child| match &*child.borrow() {
|
||||
FlexLevelBox::FlexItem(item) => item.style.clone_order(),
|
||||
FlexLevelBox::FlexItem(item) => item.style().clone_order(),
|
||||
|
||||
// “Absolutely-positioned children of a flex container are treated
|
||||
// as having order: 0 for the purpose of determining their painting order
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@ use crate::flow::{BlockContainer, BlockFormattingContext, BlockLevelBox};
|
|||
use crate::formatting_contexts::IndependentFormattingContext;
|
||||
use crate::fragments::Tag;
|
||||
use crate::positioned::AbsolutelyPositionedBox;
|
||||
use crate::sizing::{BoxContentSizes, ContentSizes, ContentSizesRequest};
|
||||
use crate::sizing::{self, BoxContentSizes, ContentSizes, ContentSizesRequest};
|
||||
use crate::style_ext::{ComputedValuesExt, DisplayGeneratingBox, DisplayInside, DisplayOutside};
|
||||
use rayon::iter::{IntoParallelIterator, ParallelIterator};
|
||||
use rayon_croissant::ParallelIteratorExt;
|
||||
|
|
@ -701,10 +701,11 @@ where
|
|||
),
|
||||
);
|
||||
if let Some(to) = max_assign_in_flow_outer_content_sizes_to {
|
||||
to.max_assign(
|
||||
&box_content_sizes
|
||||
.outer_inline(&info.style, not_actually_containing_block_writing_mode),
|
||||
)
|
||||
to.max_assign(&sizing::outer_inline(
|
||||
&info.style,
|
||||
not_actually_containing_block_writing_mode,
|
||||
|| box_content_sizes.expect_inline().clone(),
|
||||
))
|
||||
}
|
||||
let block_level_box = ArcRefCell::new(BlockLevelBox::SameFormattingContextBlock {
|
||||
tag: Tag::from_node_and_style_info(info),
|
||||
|
|
@ -722,7 +723,7 @@ where
|
|||
max_assign_in_flow_outer_content_sizes_to.is_some() &&
|
||||
!info.style.inline_size_is_length(),
|
||||
);
|
||||
let contents = IndependentFormattingContext::construct(
|
||||
let context = IndependentFormattingContext::construct(
|
||||
context,
|
||||
info,
|
||||
display_inside,
|
||||
|
|
@ -731,15 +732,14 @@ where
|
|||
propagated_text_decoration_line,
|
||||
);
|
||||
if let Some(to) = max_assign_in_flow_outer_content_sizes_to {
|
||||
to.max_assign(
|
||||
&contents.content_sizes.outer_inline(
|
||||
&contents.style,
|
||||
to.max_assign(&sizing::outer_inline(
|
||||
&context.style(),
|
||||
not_actually_containing_block_writing_mode,
|
||||
),
|
||||
)
|
||||
|| context.content_sizes(),
|
||||
))
|
||||
}
|
||||
(
|
||||
ArcRefCell::new(BlockLevelBox::Independent(contents)),
|
||||
ArcRefCell::new(BlockLevelBox::Independent(context)),
|
||||
ContainsFloats::No,
|
||||
)
|
||||
},
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@ use crate::positioned::{
|
|||
relative_adjustement, AbsolutelyPositionedBox, HoistedAbsolutelyPositionedBox,
|
||||
PositioningContext,
|
||||
};
|
||||
use crate::sizing::ContentSizes;
|
||||
use crate::sizing::{self, ContentSizes};
|
||||
use crate::style_ext::{ComputedValuesExt, Display, DisplayGeneratingBox, DisplayOutside};
|
||||
use crate::ContainingBlock;
|
||||
use app_units::Au;
|
||||
|
|
@ -155,7 +155,7 @@ impl InlineFormattingContext {
|
|||
impl Computation<'_> {
|
||||
fn traverse(&mut self, inline_level_boxes: &[ArcRefCell<InlineLevelBox>]) {
|
||||
for inline_level_box in inline_level_boxes {
|
||||
match &*inline_level_box.borrow() {
|
||||
match &mut *inline_level_box.borrow_mut() {
|
||||
InlineLevelBox::InlineBox(inline_box) => {
|
||||
let padding =
|
||||
inline_box.style.padding(self.containing_block_writing_mode);
|
||||
|
|
@ -200,9 +200,10 @@ impl InlineFormattingContext {
|
|||
}
|
||||
},
|
||||
InlineLevelBox::Atomic(atomic) => {
|
||||
let (outer, pc) = atomic.content_sizes.outer_inline_and_percentages(
|
||||
&atomic.style,
|
||||
let (outer, pc) = sizing::outer_inline_and_percentages(
|
||||
&atomic.style(),
|
||||
self.containing_block_writing_mode,
|
||||
|| atomic.content_sizes(),
|
||||
);
|
||||
self.current_line.min_content += outer.min_content;
|
||||
self.current_line.max_content += outer.max_content;
|
||||
|
|
@ -294,7 +295,7 @@ impl InlineFormattingContext {
|
|||
InlineLevelBox::TextRun(run) => run.layout(layout_context, &mut ifc),
|
||||
InlineLevelBox::Atomic(a) => layout_atomic(layout_context, &mut ifc, a),
|
||||
InlineLevelBox::OutOfFlowAbsolutelyPositionedBox(box_) => {
|
||||
let style = AtomicRef::map(box_.borrow(), |box_| &box_.contents.style);
|
||||
let style = AtomicRef::map(box_.borrow(), |box_| box_.context.style());
|
||||
let initial_start_corner =
|
||||
match Display::from(style.get_box().original_display) {
|
||||
Display::GeneratingBox(DisplayGeneratingBox::OutsideInside {
|
||||
|
|
@ -544,7 +545,8 @@ fn layout_atomic(
|
|||
ifc: &mut InlineFormattingContextState,
|
||||
atomic: &mut IndependentFormattingContext,
|
||||
) {
|
||||
let pbm = atomic.style.padding_border_margin(&ifc.containing_block);
|
||||
let style = atomic.style();
|
||||
let pbm = style.padding_border_margin(&ifc.containing_block);
|
||||
let margin = pbm.margin.auto_is(Length::zero);
|
||||
let pbm_sums = &(&pbm.padding + &pbm.border) + &margin;
|
||||
ifc.inline_position += pbm_sums.inline_start;
|
||||
|
|
@ -552,19 +554,24 @@ fn layout_atomic(
|
|||
block: pbm_sums.block_start,
|
||||
inline: ifc.inline_position - ifc.current_nesting_level.inline_start,
|
||||
};
|
||||
if atomic.style.clone_position().is_relative() {
|
||||
start_corner += &relative_adjustement(&atomic.style, ifc.containing_block)
|
||||
if style.clone_position().is_relative() {
|
||||
start_corner += &relative_adjustement(&style, ifc.containing_block)
|
||||
}
|
||||
|
||||
let fragment = match atomic.as_replaced() {
|
||||
Ok(replaced) => {
|
||||
let size =
|
||||
replaced.used_size_as_if_inline_element(ifc.containing_block, &atomic.style, &pbm);
|
||||
let fragments = replaced.make_fragments(&atomic.style, size.clone());
|
||||
let fragment = match atomic {
|
||||
IndependentFormattingContext::Replaced(replaced) => {
|
||||
let size = replaced.contents.used_size_as_if_inline_element(
|
||||
ifc.containing_block,
|
||||
&replaced.style,
|
||||
&pbm,
|
||||
);
|
||||
let fragments = replaced
|
||||
.contents
|
||||
.make_fragments(&replaced.style, size.clone());
|
||||
let content_rect = Rect { start_corner, size };
|
||||
BoxFragment::new(
|
||||
atomic.tag,
|
||||
atomic.style.clone(),
|
||||
replaced.tag,
|
||||
replaced.style.clone(),
|
||||
fragments,
|
||||
content_rect,
|
||||
pbm.padding,
|
||||
|
|
@ -573,12 +580,14 @@ fn layout_atomic(
|
|||
CollapsedBlockMargins::zero(),
|
||||
)
|
||||
},
|
||||
Err(non_replaced) => {
|
||||
let box_size = atomic.style.content_box_size(&ifc.containing_block, &pbm);
|
||||
let max_box_size = atomic
|
||||
IndependentFormattingContext::NonReplaced(non_replaced) => {
|
||||
let box_size = non_replaced
|
||||
.style
|
||||
.content_box_size(&ifc.containing_block, &pbm);
|
||||
let max_box_size = non_replaced
|
||||
.style
|
||||
.content_max_box_size(&ifc.containing_block, &pbm);
|
||||
let min_box_size = atomic
|
||||
let min_box_size = non_replaced
|
||||
.style
|
||||
.content_min_box_size(&ifc.containing_block, &pbm)
|
||||
.auto_is(Length::zero);
|
||||
|
|
@ -586,7 +595,7 @@ fn layout_atomic(
|
|||
// https://drafts.csswg.org/css2/visudet.html#inlineblock-width
|
||||
let tentative_inline_size = box_size.inline.auto_is(|| {
|
||||
let available_size = ifc.containing_block.inline_size - pbm_sums.inline_sum();
|
||||
atomic.content_sizes.shrink_to_fit(available_size)
|
||||
non_replaced.content_sizes.shrink_to_fit(available_size)
|
||||
});
|
||||
|
||||
// https://drafts.csswg.org/css2/visudet.html#min-max-widths
|
||||
|
|
@ -598,7 +607,7 @@ fn layout_atomic(
|
|||
let containing_block_for_children = ContainingBlock {
|
||||
inline_size,
|
||||
block_size: box_size.block,
|
||||
style: &atomic.style,
|
||||
style: &non_replaced.style,
|
||||
};
|
||||
assert_eq!(
|
||||
ifc.containing_block.style.writing_mode,
|
||||
|
|
@ -634,8 +643,8 @@ fn layout_atomic(
|
|||
},
|
||||
};
|
||||
BoxFragment::new(
|
||||
atomic.tag,
|
||||
atomic.style.clone(),
|
||||
non_replaced.tag,
|
||||
non_replaced.style.clone(),
|
||||
independent_layout.fragments,
|
||||
content_rect,
|
||||
pbm.padding,
|
||||
|
|
|
|||
|
|
@ -8,7 +8,9 @@ use crate::cell::ArcRefCell;
|
|||
use crate::context::LayoutContext;
|
||||
use crate::flow::float::{FloatBox, FloatContext};
|
||||
use crate::flow::inline::InlineFormattingContext;
|
||||
use crate::formatting_contexts::{IndependentFormattingContext, IndependentLayout, NonReplacedIFC};
|
||||
use crate::formatting_contexts::{
|
||||
IndependentFormattingContext, IndependentLayout, NonReplacedFormattingContext,
|
||||
};
|
||||
use crate::fragments::{
|
||||
AbsoluteOrFixedPositionedFragment, AnonymousFragment, BoxFragment, CollapsedBlockMargins,
|
||||
CollapsedMargin, Fragment, Tag,
|
||||
|
|
@ -288,33 +290,44 @@ impl BlockLevelBox {
|
|||
)
|
||||
},
|
||||
)),
|
||||
BlockLevelBox::Independent(contents) => {
|
||||
BlockLevelBox::Independent(independent) => match independent {
|
||||
IndependentFormattingContext::Replaced(replaced) => {
|
||||
Fragment::Box(positioning_context.layout_maybe_position_relative_fragment(
|
||||
layout_context,
|
||||
containing_block,
|
||||
&contents.style,
|
||||
|positioning_context| match contents.as_replaced() {
|
||||
Ok(replaced) => layout_in_flow_replaced_block_level(
|
||||
&replaced.style,
|
||||
|_positioning_context| {
|
||||
layout_in_flow_replaced_block_level(
|
||||
containing_block,
|
||||
contents.tag,
|
||||
&contents.style,
|
||||
replaced,
|
||||
),
|
||||
Err(non_replaced) => layout_in_flow_non_replaced_block_level(
|
||||
replaced.tag,
|
||||
&replaced.style,
|
||||
&replaced.contents,
|
||||
)
|
||||
},
|
||||
))
|
||||
},
|
||||
IndependentFormattingContext::NonReplaced(non_replaced) => {
|
||||
Fragment::Box(positioning_context.layout_maybe_position_relative_fragment(
|
||||
layout_context,
|
||||
containing_block,
|
||||
&non_replaced.style,
|
||||
|positioning_context| {
|
||||
layout_in_flow_non_replaced_block_level(
|
||||
layout_context,
|
||||
positioning_context,
|
||||
containing_block,
|
||||
contents.tag,
|
||||
&contents.style,
|
||||
non_replaced.tag,
|
||||
&non_replaced.style,
|
||||
NonReplacedContents::EstablishesAnIndependentFormattingContext(
|
||||
non_replaced,
|
||||
),
|
||||
tree_rank,
|
||||
float_context,
|
||||
),
|
||||
)
|
||||
},
|
||||
))
|
||||
},
|
||||
},
|
||||
BlockLevelBox::OutOfFlowAbsolutelyPositionedBox(box_) => {
|
||||
let hoisted_box = AbsolutelyPositionedBox::to_hoisted(
|
||||
box_.clone(),
|
||||
|
|
@ -326,7 +339,7 @@ impl BlockLevelBox {
|
|||
positioning_context.push(hoisted_box);
|
||||
Fragment::AbsoluteOrFixedPositioned(AbsoluteOrFixedPositionedFragment {
|
||||
hoisted_fragment,
|
||||
position: box_.borrow().contents.style.clone_position(),
|
||||
position: box_.borrow().context.style().clone_position(),
|
||||
})
|
||||
},
|
||||
BlockLevelBox::OutOfFlowFloatBox(_box_) => {
|
||||
|
|
@ -341,7 +354,7 @@ impl BlockLevelBox {
|
|||
|
||||
enum NonReplacedContents<'a> {
|
||||
SameFormattingContextBlock(&'a BlockContainer),
|
||||
EstablishesAnIndependentFormattingContext(NonReplacedIFC<'a>),
|
||||
EstablishesAnIndependentFormattingContext(&'a NonReplacedFormattingContext),
|
||||
}
|
||||
|
||||
/// https://drafts.csswg.org/css2/visudet.html#blockwidth
|
||||
|
|
|
|||
|
|
@ -9,7 +9,7 @@ use crate::flow::BlockFormattingContext;
|
|||
use crate::fragments::{Fragment, Tag};
|
||||
use crate::positioned::PositioningContext;
|
||||
use crate::replaced::ReplacedContent;
|
||||
use crate::sizing::{BoxContentSizes, ContentSizesRequest};
|
||||
use crate::sizing::{BoxContentSizes, ContentSizes, ContentSizesRequest};
|
||||
use crate::style_ext::DisplayInside;
|
||||
use crate::ContainingBlock;
|
||||
use servo_arc::Arc;
|
||||
|
|
@ -20,15 +20,36 @@ use style::values::specified::text::TextDecorationLine;
|
|||
|
||||
/// https://drafts.csswg.org/css-display/#independent-formatting-context
|
||||
#[derive(Debug, Serialize)]
|
||||
pub(crate) struct IndependentFormattingContext {
|
||||
pub(crate) enum IndependentFormattingContext {
|
||||
NonReplaced(NonReplacedFormattingContext),
|
||||
Replaced(ReplacedFormattingContext),
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize)]
|
||||
pub(crate) struct NonReplacedFormattingContext {
|
||||
pub tag: Tag,
|
||||
#[serde(skip_serializing)]
|
||||
pub style: Arc<ComputedValues>,
|
||||
|
||||
/// If it was requested during construction
|
||||
pub content_sizes: BoxContentSizes,
|
||||
pub contents: NonReplacedFormattingContextContents,
|
||||
}
|
||||
|
||||
contents: IndependentFormattingContextContents,
|
||||
#[derive(Debug, Serialize)]
|
||||
pub(crate) struct ReplacedFormattingContext {
|
||||
pub tag: Tag,
|
||||
#[serde(skip_serializing)]
|
||||
pub style: Arc<ComputedValues>,
|
||||
pub contents: ReplacedContent,
|
||||
}
|
||||
|
||||
// Private so that code outside of this module cannot match variants.
|
||||
// It should got through methods instead.
|
||||
#[derive(Debug, Serialize)]
|
||||
pub(crate) enum NonReplacedFormattingContextContents {
|
||||
Flow(BlockFormattingContext),
|
||||
Flex(FlexContainer),
|
||||
// Other layout modes go here
|
||||
}
|
||||
|
||||
pub(crate) struct IndependentLayout {
|
||||
|
|
@ -38,25 +59,6 @@ pub(crate) struct IndependentLayout {
|
|||
pub content_block_size: Length,
|
||||
}
|
||||
|
||||
// Private so that code outside of this module cannot match variants.
|
||||
// It should got through methods instead.
|
||||
#[derive(Debug, Serialize)]
|
||||
enum IndependentFormattingContextContents {
|
||||
Flow(BlockFormattingContext),
|
||||
Flex(FlexContainer),
|
||||
|
||||
// Not called FC in specs, but behaves close enough
|
||||
Replaced(ReplacedContent),
|
||||
// Other layout modes go here
|
||||
}
|
||||
|
||||
pub(crate) struct NonReplacedIFC<'a>(NonReplacedIFCKind<'a>);
|
||||
|
||||
enum NonReplacedIFCKind<'a> {
|
||||
Flow(&'a BlockFormattingContext),
|
||||
Flex(&'a FlexContainer),
|
||||
}
|
||||
|
||||
impl IndependentFormattingContext {
|
||||
pub fn construct<'dom>(
|
||||
context: &LayoutContext,
|
||||
|
|
@ -76,12 +78,12 @@ impl IndependentFormattingContext {
|
|||
content_sizes,
|
||||
propagated_text_decoration_line,
|
||||
);
|
||||
Self {
|
||||
Self::NonReplaced(NonReplacedFormattingContext {
|
||||
tag: Tag::from_node_and_style_info(info),
|
||||
style: Arc::clone(&info.style),
|
||||
content_sizes,
|
||||
contents: IndependentFormattingContextContents::Flow(bfc),
|
||||
}
|
||||
contents: NonReplacedFormattingContextContents::Flow(bfc),
|
||||
})
|
||||
},
|
||||
DisplayInside::Flex => {
|
||||
let (fc, content_sizes) = FlexContainer::construct(
|
||||
|
|
@ -91,24 +93,19 @@ impl IndependentFormattingContext {
|
|||
content_sizes,
|
||||
propagated_text_decoration_line,
|
||||
);
|
||||
Self {
|
||||
Self::NonReplaced(NonReplacedFormattingContext {
|
||||
tag: Tag::from_node_and_style_info(info),
|
||||
style: Arc::clone(&info.style),
|
||||
content_sizes,
|
||||
contents: IndependentFormattingContextContents::Flex(fc),
|
||||
}
|
||||
contents: NonReplacedFormattingContextContents::Flex(fc),
|
||||
})
|
||||
},
|
||||
},
|
||||
Err(replaced) => {
|
||||
let content_sizes =
|
||||
content_sizes.compute(|| replaced.inline_content_sizes(&info.style));
|
||||
Self {
|
||||
Err(contents) => Self::Replaced(ReplacedFormattingContext {
|
||||
tag: Tag::from_node_and_style_info(info),
|
||||
style: Arc::clone(&info.style),
|
||||
content_sizes,
|
||||
contents: IndependentFormattingContextContents::Replaced(replaced),
|
||||
}
|
||||
},
|
||||
contents,
|
||||
}),
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -125,27 +122,37 @@ impl IndependentFormattingContext {
|
|||
content_sizes,
|
||||
propagated_text_decoration_line,
|
||||
);
|
||||
Self {
|
||||
Self::NonReplaced(NonReplacedFormattingContext {
|
||||
tag: Tag::from_node_and_style_info(info),
|
||||
style: Arc::clone(&info.style),
|
||||
content_sizes,
|
||||
contents: IndependentFormattingContextContents::Flow(bfc),
|
||||
contents: NonReplacedFormattingContextContents::Flow(bfc),
|
||||
})
|
||||
}
|
||||
|
||||
pub fn style(&self) -> &Arc<ComputedValues> {
|
||||
match self {
|
||||
Self::NonReplaced(inner) => &inner.style,
|
||||
Self::Replaced(inner) => &inner.style,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn as_replaced(&self) -> Result<&ReplacedContent, NonReplacedIFC> {
|
||||
use self::IndependentFormattingContextContents as Contents;
|
||||
use self::NonReplacedIFC as NR;
|
||||
use self::NonReplacedIFCKind as Kind;
|
||||
match &self.contents {
|
||||
Contents::Replaced(r) => Ok(r),
|
||||
Contents::Flow(f) => Err(NR(Kind::Flow(f))),
|
||||
Contents::Flex(f) => Err(NR(Kind::Flex(f))),
|
||||
pub fn tag(&self) -> Tag {
|
||||
match self {
|
||||
Self::NonReplaced(inner) => inner.tag,
|
||||
Self::Replaced(inner) => inner.tag,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn content_sizes(&self) -> ContentSizes {
|
||||
match self {
|
||||
Self::NonReplaced(inner) => inner.content_sizes.expect_inline().clone(),
|
||||
Self::Replaced(inner) => inner.contents.inline_content_sizes(&inner.style),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl NonReplacedIFC<'_> {
|
||||
impl NonReplacedFormattingContext {
|
||||
pub fn layout(
|
||||
&self,
|
||||
layout_context: &LayoutContext,
|
||||
|
|
@ -153,14 +160,14 @@ impl NonReplacedIFC<'_> {
|
|||
containing_block: &ContainingBlock,
|
||||
tree_rank: usize,
|
||||
) -> IndependentLayout {
|
||||
match &self.0 {
|
||||
NonReplacedIFCKind::Flow(bfc) => bfc.layout(
|
||||
match &self.contents {
|
||||
NonReplacedFormattingContextContents::Flow(bfc) => bfc.layout(
|
||||
layout_context,
|
||||
positioning_context,
|
||||
containing_block,
|
||||
tree_rank,
|
||||
),
|
||||
NonReplacedIFCKind::Flex(fc) => fc.layout(
|
||||
NonReplacedFormattingContextContents::Flex(fc) => fc.layout(
|
||||
layout_context,
|
||||
positioning_context,
|
||||
containing_block,
|
||||
|
|
|
|||
|
|
@ -22,7 +22,7 @@ use style::Zero;
|
|||
|
||||
#[derive(Debug, Serialize)]
|
||||
pub(crate) struct AbsolutelyPositionedBox {
|
||||
pub contents: IndependentFormattingContext,
|
||||
pub context: IndependentFormattingContext,
|
||||
}
|
||||
|
||||
pub(crate) struct PositioningContext {
|
||||
|
|
@ -84,7 +84,7 @@ impl AbsolutelyPositionedBox {
|
|||
!node_info.style.inline_box_offsets_are_both_non_auto(),
|
||||
);
|
||||
Self {
|
||||
contents: IndependentFormattingContext::construct(
|
||||
context: IndependentFormattingContext::construct(
|
||||
context,
|
||||
node_info,
|
||||
display_inside,
|
||||
|
|
@ -124,7 +124,7 @@ impl AbsolutelyPositionedBox {
|
|||
|
||||
let box_offsets = {
|
||||
let box_ = self_.borrow();
|
||||
let box_offsets = box_.contents.style.box_offsets(containing_block);
|
||||
let box_offsets = box_.context.style().box_offsets(containing_block);
|
||||
Vec2 {
|
||||
inline: absolute_box_offsets(
|
||||
initial_start_corner.inline,
|
||||
|
|
@ -218,27 +218,6 @@ impl PositioningContext {
|
|||
new_fragment
|
||||
}
|
||||
|
||||
/// Given `fragment_layout_fn`, a closure which lays out a fragment in a provided
|
||||
/// `PositioningContext`, create a positioning context for a positioned fragment and lay out
|
||||
/// the fragment and all its children. Returns the resulting `BoxFragment`.
|
||||
fn create_and_layout_positioned(
|
||||
layout_context: &LayoutContext,
|
||||
style: &ComputedValues,
|
||||
for_nearest_containing_block_for_all_descendants: &mut Vec<HoistedAbsolutelyPositionedBox>,
|
||||
fragment_layout_fn: impl FnOnce(&mut Self) -> BoxFragment,
|
||||
) -> BoxFragment {
|
||||
let mut new_context = match Self::new_for_style(style) {
|
||||
Some(new_context) => new_context,
|
||||
None => unreachable!(),
|
||||
};
|
||||
|
||||
let mut new_fragment = fragment_layout_fn(&mut new_context);
|
||||
new_context.layout_collected_children(layout_context, &mut new_fragment);
|
||||
for_nearest_containing_block_for_all_descendants
|
||||
.extend(new_context.for_nearest_containing_block_for_all_descendants);
|
||||
new_fragment
|
||||
}
|
||||
|
||||
// Lay out the hoisted boxes collected into this `PositioningContext` and add them
|
||||
// to the given `BoxFragment`.
|
||||
pub fn layout_collected_children(
|
||||
|
|
@ -288,8 +267,8 @@ impl PositioningContext {
|
|||
let position = box_
|
||||
.absolutely_positioned_box
|
||||
.borrow()
|
||||
.contents
|
||||
.style
|
||||
.context
|
||||
.style()
|
||||
.clone_position();
|
||||
match position {
|
||||
Position::Fixed => {}, // fall through
|
||||
|
|
@ -416,29 +395,30 @@ impl HoistedAbsolutelyPositionedBox {
|
|||
) -> BoxFragment {
|
||||
let cbis = containing_block.size.inline;
|
||||
let cbbs = containing_block.size.block;
|
||||
let absolutely_positioned_box = self.absolutely_positioned_box.borrow_mut();
|
||||
let style = &absolutely_positioned_box.contents.style;
|
||||
let pbm = style.padding_border_margin(&containing_block.into());
|
||||
let mut absolutely_positioned_box = self.absolutely_positioned_box.borrow_mut();
|
||||
let pbm = absolutely_positioned_box
|
||||
.context
|
||||
.style()
|
||||
.padding_border_margin(&containing_block.into());
|
||||
|
||||
let size;
|
||||
let replaced_used_size;
|
||||
match absolutely_positioned_box.contents.as_replaced() {
|
||||
Ok(replaced) => {
|
||||
let size = match &absolutely_positioned_box.context {
|
||||
IndependentFormattingContext::Replaced(replaced) => {
|
||||
// https://drafts.csswg.org/css2/visudet.html#abs-replaced-width
|
||||
// https://drafts.csswg.org/css2/visudet.html#abs-replaced-height
|
||||
let used_size =
|
||||
replaced.used_size_as_if_inline_element(&containing_block.into(), style, &pbm);
|
||||
size = Vec2 {
|
||||
let used_size = replaced.contents.used_size_as_if_inline_element(
|
||||
&containing_block.into(),
|
||||
&replaced.style,
|
||||
&pbm,
|
||||
);
|
||||
Vec2 {
|
||||
inline: LengthOrAuto::LengthPercentage(used_size.inline),
|
||||
block: LengthOrAuto::LengthPercentage(used_size.block),
|
||||
};
|
||||
replaced_used_size = Some(used_size);
|
||||
},
|
||||
Err(_non_replaced) => {
|
||||
size = style.content_box_size(&containing_block.into(), &pbm);
|
||||
replaced_used_size = None;
|
||||
},
|
||||
}
|
||||
},
|
||||
IndependentFormattingContext::NonReplaced(non_replaced) => non_replaced
|
||||
.style
|
||||
.content_box_size(&containing_block.into(), &pbm),
|
||||
};
|
||||
|
||||
let inline_axis = solve_axis(
|
||||
cbis,
|
||||
|
|
@ -467,22 +447,22 @@ impl HoistedAbsolutelyPositionedBox {
|
|||
block_end: block_axis.margin_end,
|
||||
};
|
||||
|
||||
PositioningContext::create_and_layout_positioned(
|
||||
layout_context,
|
||||
style,
|
||||
for_nearest_containing_block_for_all_descendants,
|
||||
|positioning_context| {
|
||||
let size;
|
||||
let mut positioning_context =
|
||||
PositioningContext::new_for_style(absolutely_positioned_box.context.style()).unwrap();
|
||||
let mut new_fragment = {
|
||||
let content_size;
|
||||
let fragments;
|
||||
match absolutely_positioned_box.contents.as_replaced() {
|
||||
Ok(replaced) => {
|
||||
match &mut absolutely_positioned_box.context {
|
||||
IndependentFormattingContext::Replaced(replaced) => {
|
||||
// https://drafts.csswg.org/css2/visudet.html#abs-replaced-width
|
||||
// https://drafts.csswg.org/css2/visudet.html#abs-replaced-height
|
||||
let style = &absolutely_positioned_box.contents.style;
|
||||
size = replaced_used_size.unwrap();
|
||||
fragments = replaced.make_fragments(style, size.clone());
|
||||
let style = &replaced.style;
|
||||
content_size = size.auto_is(|| unreachable!());
|
||||
fragments = replaced
|
||||
.contents
|
||||
.make_fragments(style, content_size.clone());
|
||||
},
|
||||
Err(non_replaced) => {
|
||||
IndependentFormattingContext::NonReplaced(non_replaced) => {
|
||||
// https://drafts.csswg.org/css2/visudet.html#abs-non-replaced-width
|
||||
// https://drafts.csswg.org/css2/visudet.html#abs-non-replaced-height
|
||||
let inline_size = inline_axis.size.auto_is(|| {
|
||||
|
|
@ -490,20 +470,15 @@ impl HoistedAbsolutelyPositionedBox {
|
|||
Anchor::Start(start) => start,
|
||||
Anchor::End(end) => end,
|
||||
};
|
||||
let available_size = cbis -
|
||||
anchor -
|
||||
pbm.padding_border_sums.inline -
|
||||
margin.inline_sum();
|
||||
absolutely_positioned_box
|
||||
.contents
|
||||
.content_sizes
|
||||
.shrink_to_fit(available_size)
|
||||
let available_size =
|
||||
cbis - anchor - pbm.padding_border_sums.inline - margin.inline_sum();
|
||||
non_replaced.content_sizes.shrink_to_fit(available_size)
|
||||
});
|
||||
|
||||
let containing_block_for_children = ContainingBlock {
|
||||
inline_size,
|
||||
block_size: block_axis.size,
|
||||
style,
|
||||
style: &non_replaced.style,
|
||||
};
|
||||
// https://drafts.csswg.org/css-writing-modes/#orthogonal-flows
|
||||
assert_eq!(
|
||||
|
|
@ -514,12 +489,12 @@ impl HoistedAbsolutelyPositionedBox {
|
|||
let dummy_tree_rank = 0;
|
||||
let independent_layout = non_replaced.layout(
|
||||
layout_context,
|
||||
positioning_context,
|
||||
&mut positioning_context,
|
||||
&containing_block_for_children,
|
||||
dummy_tree_rank,
|
||||
);
|
||||
|
||||
size = Vec2 {
|
||||
content_size = Vec2 {
|
||||
inline: inline_size,
|
||||
block: block_axis
|
||||
.size
|
||||
|
|
@ -533,12 +508,14 @@ impl HoistedAbsolutelyPositionedBox {
|
|||
let inline_start = match inline_axis.anchor {
|
||||
Anchor::Start(start) => start + pb.inline_start + margin.inline_start,
|
||||
Anchor::End(end) => {
|
||||
cbis - end - pb.inline_end - margin.inline_end - size.inline
|
||||
cbis - end - pb.inline_end - margin.inline_end - content_size.inline
|
||||
},
|
||||
};
|
||||
let block_start = match block_axis.anchor {
|
||||
Anchor::Start(start) => start + pb.block_start + margin.block_start,
|
||||
Anchor::End(end) => cbbs - end - pb.block_end - margin.block_end - size.block,
|
||||
Anchor::End(end) => {
|
||||
cbbs - end - pb.block_end - margin.block_end - content_size.block
|
||||
},
|
||||
};
|
||||
|
||||
let content_rect = Rect {
|
||||
|
|
@ -546,12 +523,12 @@ impl HoistedAbsolutelyPositionedBox {
|
|||
inline: inline_start,
|
||||
block: block_start,
|
||||
},
|
||||
size,
|
||||
size: content_size,
|
||||
};
|
||||
|
||||
BoxFragment::new(
|
||||
absolutely_positioned_box.contents.tag,
|
||||
style.clone(),
|
||||
absolutely_positioned_box.context.tag(),
|
||||
absolutely_positioned_box.context.style().clone(),
|
||||
fragments,
|
||||
content_rect,
|
||||
pbm.padding,
|
||||
|
|
@ -559,8 +536,11 @@ impl HoistedAbsolutelyPositionedBox {
|
|||
margin,
|
||||
CollapsedBlockMargins::zero(),
|
||||
)
|
||||
},
|
||||
)
|
||||
};
|
||||
positioning_context.layout_collected_children(layout_context, &mut new_fragment);
|
||||
for_nearest_containing_block_for_all_descendants
|
||||
.extend(positioning_context.for_nearest_containing_block_for_all_descendants);
|
||||
new_fragment
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -64,7 +64,7 @@ impl ContentSizes {
|
|||
}
|
||||
}
|
||||
|
||||
fn map(&self, f: impl Fn(Length) -> Length) -> Self {
|
||||
pub fn map(&self, f: impl Fn(Length) -> Length) -> Self {
|
||||
Self {
|
||||
min_content: f(self.min_content),
|
||||
max_content: f(self.max_content),
|
||||
|
|
@ -98,30 +98,38 @@ pub(crate) enum BoxContentSizes {
|
|||
}
|
||||
|
||||
impl BoxContentSizes {
|
||||
fn expect_inline(&self) -> &ContentSizes {
|
||||
pub fn expect_inline(&self) -> &ContentSizes {
|
||||
match self {
|
||||
Self::NoneWereRequested => panic!("Accessing content size that was not requested"),
|
||||
Self::Inline(s) => s,
|
||||
}
|
||||
}
|
||||
|
||||
/// https://dbaron.org/css/intrinsic/#outer-intrinsic
|
||||
pub fn outer_inline(
|
||||
&self,
|
||||
/// https://drafts.csswg.org/css2/visudet.html#shrink-to-fit-float
|
||||
pub(crate) fn shrink_to_fit(&self, available_size: Length) -> Length {
|
||||
let inline = self.expect_inline();
|
||||
available_size
|
||||
.max(inline.min_content)
|
||||
.min(inline.max_content)
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn outer_inline(
|
||||
style: &ComputedValues,
|
||||
containing_block_writing_mode: WritingMode,
|
||||
) -> ContentSizes {
|
||||
get_content_size: impl FnOnce() -> ContentSizes,
|
||||
) -> ContentSizes {
|
||||
let (mut outer, percentages) =
|
||||
self.outer_inline_and_percentages(style, containing_block_writing_mode);
|
||||
outer_inline_and_percentages(style, containing_block_writing_mode, get_content_size);
|
||||
outer.adjust_for_pbm_percentages(percentages);
|
||||
outer
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn outer_inline_and_percentages(
|
||||
&self,
|
||||
pub(crate) fn outer_inline_and_percentages(
|
||||
style: &ComputedValues,
|
||||
containing_block_writing_mode: WritingMode,
|
||||
) -> (ContentSizes, Percentage) {
|
||||
get_content_size: impl FnOnce() -> ContentSizes,
|
||||
) -> (ContentSizes, Percentage) {
|
||||
let padding = style.padding(containing_block_writing_mode);
|
||||
let border = style.border_width(containing_block_writing_mode);
|
||||
let margin = style.margin(containing_block_writing_mode);
|
||||
|
|
@ -174,7 +182,7 @@ impl BoxContentSizes {
|
|||
max_content: border_box_size,
|
||||
}
|
||||
},
|
||||
None => self.expect_inline().map(|content_box_size| {
|
||||
None => get_content_size().map(|content_box_size| {
|
||||
match box_sizing {
|
||||
// Clamp to 'min-width' and 'max-width', which are sizing the…
|
||||
BoxSizing::ContentBox => clamp(content_box_size) + pb_lengths,
|
||||
|
|
@ -185,13 +193,4 @@ impl BoxContentSizes {
|
|||
|
||||
let outer = border_box_sizes.map(|s| s + m_lengths);
|
||||
(outer, pbm_percentages)
|
||||
}
|
||||
|
||||
/// https://drafts.csswg.org/css2/visudet.html#shrink-to-fit-float
|
||||
pub(crate) fn shrink_to_fit(&self, available_size: Length) -> Length {
|
||||
let inline = self.expect_inline();
|
||||
available_size
|
||||
.max(inline.min_content)
|
||||
.min(inline.max_content)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue