8000 layout: Unify layout logic for replaced and non-replaced floats&atomics · servo/servo@00bd360 · GitHub
[go: up one dir, main page]
Skip to content

Commit 00bd360

Browse files
LoirooriolLoirooriol
committed
layout: Unify layout logic for replaced and non-replaced floats&atomics
Laying out a replaced element which is a float or atomic inline will now use the same logic as for non-replaced floats and atomic inlines. This reduces the amount of code, but should have no observable effect. Signed-off-by: Oriol Brufau <obrufau@igalia.com>
1 parent 864c877 commit 00bd360

File tree

4 files changed

+88
-140
lines changed

4 files changed

+88
-140
lines changed

‎components/layout/flow/inline/mod.rs‎

Lines changed: 2 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -2076,11 +2076,8 @@ impl IndependentFormattingContext {
20762076
.content_rect
20772077
.translate(pbm_physical_offset.to_vector());
20782078

2079-
// Apply baselines if necessary.
2080-
let mut fragment = match baselines {
2081-
Some(baselines) => fragment.with_baselines(baselines),
2082-
None => fragment,
2083-
};
2079+
// Apply baselines.
2080+
fragment = fragment.with_baselines(baselines);
20842081

20852082
// Lay out absolutely positioned children if this new atomic establishes a containing block
20862083
// for absolutes.

‎components/layout/flow/mod.rs‎

Lines changed: 84 additions & 101 deletions
Original file line numberDiff line numberDiff line change
@@ -2221,7 +2221,7 @@ fn block_size_is_zero_or_intrinsic(size: &StyleSize, containing_block: &Containi
22212221

22222222
pub(crate) struct IndependentFloatOrAtomicLayoutResult {
22232223
pub fragment: BoxFragment,
2224-
pub baselines: Option<Baselines>,
2224+
pub baselines: Baselines,
22252225
pub pbm_sums: LogicalSides<Au>,
22262226
}
22272227

@@ -2233,120 +2233,103 @@ impl IndependentFormattingContext {
22332233
containing_block: &ContainingBlock,
22342234
) -> IndependentFloatOrAtomicLayoutResult {
22352235
let style = self.style();
2236+
let writing_mode = style.writing_mode;
22362237
let container_writing_mode = containing_block.style.writing_mode;
22372238
let layout_style = self.layout_style();
22382239
let content_box_sizes_and_pbm =
22392240
layout_style.content_box_sizes_and_padding_border_margin(&containing_block.into());
22402241
let pbm = &content_box_sizes_and_pbm.pbm;
22412242
let margin = pbm.margin.auto_is(Au::zero);
22422243
let pbm_sums = pbm.padding + pbm.border + margin;
2244+
let preferred_aspect_ratio = self.preferred_aspect_ratio(&pbm.padding_border_sums);
2245+
let is_table = self.is_table();
22432246

2244-
let (fragments, content_rect, baselines) = match &self.contents {
2245-
IndependentFormattingContextContents::Replaced(replaced) => {
2246-
// Floats and atomic inlines can't collapse margins with their parent,
2247-
// so don't ignore block margins when resolving a stretch block size.
2248-
// https://drafts.csswg.org/css-sizing-4/#stretch-fit-sizing
2249-
let ignore_block_margins_for_stretch = LogicalSides1D::new(false, false);
2250-
2251-
// https://drafts.csswg.org/css2/visudet.html#float-replaced-width
2252-
// https://drafts.csswg.org/css2/visudet.html#inline-replaced-height
2253-
let content_size = replaced
2254-
.used_size_as_if_inline_element(
2255-
containing_block,
2256-
style,
2257-
&content_box_sizes_and_pbm,
2258-
ignore_block_margins_for_stretch,
2259-
)
2260-
.to_physical_size(container_writing_mode);
2261-
let fragments = replaced.make_fragments(layout_context, style, content_size);
2247+
let available_inline_size =
2248+
Au::zero().max(containing_block.size.inline - pbm_sums.inline_sum());
2249+
let available_block_size = containing_block
2250+
.size
2251+
.block
2252+
.to_definite()
2253+
.map(|block_size| Au::zero().max(block_size - pbm_sums.block_sum()));
22622254

2263-
let content_rect = PhysicalRect::new(PhysicalPoint::zero(), content_size);
2264-
(fragments, content_rect, None)
2265-
},
2266-
IndependentFormattingContextContents::NonReplaced(non_replaced) => {
2267-
let writing_mode = self.style().writing_mode;
2268-
let available_inline_size =
2269-
Au::zero().max(containing_block.size.inline - pbm_sums.inline_sum());
2270-
let available_block_size = containing_block
2271-
.size
2272-
.block
2273-
.to_definite()
2274-
.map(|block_size| Au::zero().max(block_size - pbm_sums.block_sum()));
2275-
let tentative_block_size = content_box_sizes_and_pbm
2276-
.content_box_sizes
2277-
.block
2278-
.resolve_extrinsic(Size::FitContent, Au::zero(), available_block_size);
2279-
2280-
let get_content_size = || {
2281-
let constraint_space = ConstraintSpace::new(
2282-
tentative_block_size,
2283-
writing_mode,
2284-
non_replaced.preferred_aspect_ratio(),
2285-
);
2286-
self.inline_content_sizes(layout_context, &constraint_space)
2287-
.sizes
2288-
};
2255+
let tentative_block_content_size =
2256+
self.tentative_block_content_size(preferred_aspect_ratio);
2257+
let tentative_block_size = if let Some(block_content_size) = tentative_block_content_size {
2258+
SizeConstraint::Definite(content_box_sizes_and_pbm.content_box_sizes.block.resolve(
2259+
Direction::Block,
2260+
Size::FitContent,
2261+
Au::zero,
2262+
available_block_size,
2263+
|| block_content_size,
2264+
is_table,
2265+
))
2266+
} else {
2267+
content_box_sizes_and_pbm
2268+
.content_box_sizes
2269+
.block
2270+
.resolve_extrinsic(Size::FitContent, Au::zero(), available_block_size)
2271+
};
22892272

2290-
let is_table = layout_style.is_table();
2291-
let inline_size = content_box_sizes_and_pbm.content_box_sizes.inline.resolve(
2292-
Direction::Inline,
2293-
Size::FitContent,
2294-
Au::zero,
2295-
Some(available_inline_size),
2296-
get_content_size,
2297-
is_table,
2298-
);
2273+
let get_content_size = || {
2274+
let constraint_space =
2275+
ConstraintSpace::new(tentative_block_size, writing_mode, preferred_aspect_ratio);
2276+
self.inline_content_sizes(layout_context, &constraint_space)
2277+
.sizes
2278+
};
22992279

2300-
let containing_block_for_children = ContainingBlock {
2301-
size: ContainingBlockSize {
2302-
inline: inline_size,
2303-
block: tentative_block_size,
2304 6D3F -
},
2305-
style: self.style(),
2306-
};
2307-
assert_eq!(
2308-
container_writing_mode.is_horizontal(),
2309-
writing_mode.is_horizontal(),
2310-
"Mixed horizontal and vertical writing modes are not supported yet"
2311-
);
2280+
let inline_size = content_box_sizes_and_pbm.content_box_sizes.inline.resolve(
2281+
Direction::Inline,
2282+
Size::FitContent,
2283+
Au::zero,
2284+
Some(available_inline_size),
2285+
get_content_size,
2286+
is_table,
2287+
);
23122288

2313-
let lazy_block_size = LazySize::new(
2314-
&content_box_sizes_and_pbm.content_box_sizes.block,
2315-
Direction::Block,
2316-
Size::FitContent,
2317-
Au::zero,
2318-
available_block_size,
2319-
is_table,
2320-
);
2289+
let containing_block_for_children = ContainingBlock {
2290+
size: ContainingBlockSize {
2291+
inline: inline_size,
2292+
block: tentative_block_size,
2293+
},
2294+
style,
2295+
};
2296+
assert_eq!(
2297+
container_writing_mode.is_horizontal(),
2298+
writing_mode.is_horizontal(),
2299+
"Mixed horizontal and vertical writing modes are not supported yet"
2300+
);
23212301

2322-
let independent_layout = non_replaced.layout(
2323-
layout_context,
2324-
child_positioning_context,
2325-
&containing_block_for_children,
2326-
containing_block,
2327-
&self.base,
2328-
false, /* depends_on_block_constraints */
2329-
&lazy_block_size,
2330-
);
2331-
let inline_size = independent_layout
2332-
.content_inline_size_for_table
2333-
.unwrap_or(inline_size);
2334-
let block_size = lazy_block_size.resolve(|| independent_layout.content_block_size);
2302+
let lazy_block_size = LazySize::new(
2303+
&content_box_sizes_and_pbm.content_box_sizes.block,
2304+
Direction::Block,
2305+
Size::FitContent,
2306+
Au::zero,
2307+
available_block_size,
2308+
is_table,
2309+
);
23352310

2336-
let content_size = LogicalVec2 {
2337-
block: block_size,
2338-
inline: inline_size,
2339-
}
2340-
.to_physical_size(container_writing_mode);
2341-
let content_rect = PhysicalRect::new(PhysicalPoint::zero(), content_size);
2311+
let CacheableLayoutResult {
2312+
content_inline_size_for_table,
2313+
content_block_size,
2314+
fragments,
2315+
baselines,
2316+
..
2317+
} = self.layout(
2318+
layout_context,
2319+
child_positioning_context,
2320+
&containing_block_for_children,
2321+
containing_block,
2322+
preferred_aspect_ratio,
2323+
false, /* depends_on_block_constraints */
2324+
&lazy_block_size,
2325+
);
23422326

2343-
(
2344-
independent_layout.fragments,
2345-
content_rect,
2346-
Some(independent_layout.baselines),
2347-
)
2348-
},
2349-
};
2327+
let content_size = LogicalVec2 {
2328+
inline: content_inline_size_for_table.unwrap_or(inline_size),
2329+
block: lazy_block_size.resolve(|| content_block_size),
2330+
}
2331+
.to_physical_size(container_writing_mode);
2332+
let content_rect = PhysicalRect::new(PhysicalPoint::zero(), content_size);
23502333

23512334
let mut base_fragment_info = self.base_fragment_info();
23522335
if content_box_sizes_and_pbm.depends_on_block_constraints {
@@ -2357,7 +2340,7 @@ impl IndependentFormattingContext {
23572340

23582341
let fragment = BoxFragment::new(
23592342
base_fragment_info,
2360-
self.style().clone(),
2343+
style.clone(),
23612344
fragments,
23622345
content_rect,
23632346
pbm.padding.to_physical(container_writing_mode),

‎components/layout/geom.rs‎

Lines changed: 0 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -85,13 +85,6 @@ impl<T: Copy> From<T> for LogicalVec2<T> {
8585
}
8686

8787
impl<T> LogicalVec2<T> {
88-
pub(crate) fn as_ref(&self) -> LogicalVec2<&T> {
89-
LogicalVec2 {
90-
inline: &self.inline,
91-
block: &self.block,
92-
}
93-
}
94-
9588
pub fn map_inline_and_block_axes<U>(
9689
&self,
9790
inline_f: impl FnOnce(&T) -> U,

‎components/layout/replaced.rs‎

Lines changed: 2 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -29,12 +29,10 @@ use crate::dom::NodeExt;
2929
use crate::fragment_tree::{
3030
BaseFragmentInfo, CollapsedBlockMargins, Fragment, IFrameFragment, ImageFragment,
3131
};
32-
use crate::geom::{
33-
LazySize, LogicalSides1D, LogicalVec2, PhysicalPoint, PhysicalRect, PhysicalSize, Size, Sizes,
34-
};
32+
use crate::geom::{LazySize, LogicalVec2, PhysicalPoint, PhysicalRect, PhysicalSize, Size, Sizes};
3533
use crate::layout_box_base::{CacheableLayoutResult, LayoutBoxBase};
3634
use crate::sizing::{ComputeInlineContentSizes, ContentSizes, InlineContentSizesResult};
37-
use crate::style_ext::{AspectRatio, Clamp, ComputedValuesExt, ContentBoxSizesAndPBM, LayoutStyle};
35+
use crate::style_ext::{AspectRatio, Clamp, ComputedValuesExt, LayoutStyle};
3836
use crate::{ConstraintSpace, ContainingBlock, SizeConstraint};
3937

4038
#[derive(Debug, MallocSizeOf)]
@@ -410,29 +408,6 @@ impl ReplacedContents {
410408
})
411409
}
412410

413-
/// <https://drafts.csswg.org/css2/visudet.html#inline-replaced-width>
414-
/// <https://drafts.csswg.org/css2/visudet.html#inline-replaced-height>
415-
///
416-
/// Also used in other cases, for example
417-
/// <https://drafts.csswg.org/css2/visudet.html#block-replaced-width>
418-
pub(crate) fn used_size_as_if_inline_element(
419-
&self,
420-
containing_block: &ContainingBlock,
421-
style: &ComputedValues,
422-
content_box_sizes_and_pbm: &ContentBoxSizesAndPBM,
423-
ignore_block_margins_for_stretch: LogicalSides1D<bool>,
424-
) -> LogicalVec2<Au> {
425-
let pbm = &content_box_sizes_and_pbm.pbm;
426-
self.used_size_as_if_inline_element_from_content_box_sizes(
427-
containing_block,
428-
style,
429-
self.preferred_aspect_ratio(style, &pbm.padding_border_sums),
430-
content_box_sizes_and_pbm.content_box_sizes.as_ref(),
431-
Size::FitContent.into(),
432-
pbm.sums_auto_is_zero(ignore_block_margins_for_stretch),
433-
)
434-
}
435-
436411
/// The aspect ratio of the default object sizes.
437412
/// <https://drafts.csswg.org/css-images-3/#default-object-size>
438413
pub(crate) fn default_aspect_ratio() -> AspectRatio {

0 commit comments

Comments
 (0)
0