use super::*;
#[derive(Debug, Clone, Copy, PartialEq)]
pub(in crate::layout) struct UsedEdges {
pub(in crate::layout) top: LayoutLength,
pub(in crate::layout) right: LayoutLength,
pub(in crate::layout) bottom: LayoutLength,
pub(in crate::layout) left: LayoutLength,
}
impl UsedEdges {
pub(in crate::layout) fn from_css_edges(edges: css::Edges) -> Self {
Self {
top: layout_pt(edges.top),
right: layout_pt(edges.right),
bottom: layout_pt(edges.bottom),
left: layout_pt(edges.left),
}
}
pub(in crate::layout) fn to_css_edges(self) -> css::Edges {
css::Edges {
top: self.top.points(),
right: self.right.points(),
bottom: self.bottom.points(),
left: self.left.points(),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub(in crate::layout) struct UsedBoxEdges {
pub(in crate::layout) margin: UsedEdges,
pub(in crate::layout) padding: UsedEdges,
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub(in crate::layout) struct UsedBoxMetrics {
pub(in crate::layout) margin: UsedEdges,
pub(in crate::layout) padding: UsedEdges,
pub(in crate::layout) border: UsedEdges,
}
impl UsedBoxMetrics {
pub(in crate::layout) fn horizontal_non_content_length(self) -> NonContentLength {
non_content_pt(
(self.border.left + self.border.right + self.padding.left + self.padding.right)
.points(),
)
}
pub(in crate::layout) fn vertical_non_content_length(self) -> NonContentLength {
non_content_pt(
(self.border.top + self.border.bottom + self.padding.top + self.padding.bottom)
.points(),
)
}
}
pub(in crate::layout) fn used_padding_edges<Source: Copy>(
style: &ComputedStyle,
inline_basis: PercentageBasis<LayoutLength, Source>,
) -> UsedEdges {
let padding = style.box_values.padding.clone();
UsedEdges {
top: used_padding_edge(padding.top, style.padding.top, inline_basis),
right: used_padding_edge(padding.right, style.padding.right, inline_basis),
bottom: used_padding_edge(padding.bottom, style.padding.bottom, inline_basis),
left: used_padding_edge(padding.left, style.padding.left, inline_basis),
}
}
pub(in crate::layout) fn used_padding_edges_for_logical_inline_basis<Source: Copy>(
style: &ComputedStyle,
inline_basis: LogicalInlinePercentageBasis<Source>,
) -> UsedEdges {
used_padding_edges(
style,
inline_basis.map_value(crate::units::IntoLayoutLength::into_layout_length),
)
}
pub(in crate::layout) fn used_padding_edge<Source>(
value: css::ComputedLengthPercentage,
legacy_length: f32,
basis: PercentageBasis<LayoutLength, Source>,
) -> LayoutLength {
css::clamp_used_layout_length(layout_pt(
value
.length_if_no_percent()
.map(|_| legacy_length)
.unwrap_or_else(|| used_length_percentage(value, basis).points())
.max(0.0),
))
}
pub(in crate::layout) fn used_margin_edges<Source: Copy>(
style: &ComputedStyle,
inline_basis: PercentageBasis<LayoutLength, Source>,
) -> UsedEdges {
let margin = style.box_values.margin.clone();
UsedEdges {
top: used_margin_edge(margin.top, style.margin.top, inline_basis),
right: used_margin_edge(margin.right, style.margin.right, inline_basis),
bottom: used_margin_edge(margin.bottom, style.margin.bottom, inline_basis),
left: used_margin_edge(margin.left, style.margin.left, inline_basis),
}
}
pub(in crate::layout) fn intrinsic_padding_edges(style: &ComputedStyle) -> UsedEdges {
let padding = style.box_values.padding.clone();
UsedEdges {
top: intrinsic_padding_edge(padding.top),
right: intrinsic_padding_edge(padding.right),
bottom: intrinsic_padding_edge(padding.bottom),
left: intrinsic_padding_edge(padding.left),
}
}
pub(in crate::layout) fn intrinsic_padding_edge(
value: css::ComputedLengthPercentage,
) -> LayoutLength {
used_length_percentage(value, PercentageBasis::definite(layout_pt(0.0))).max(layout_pt(0.0))
}
pub(in crate::layout) fn intrinsic_margin_edges(style: &ComputedStyle) -> UsedEdges {
let margin = style.box_values.margin.clone();
UsedEdges {
top: intrinsic_margin_edge(margin.top),
right: intrinsic_margin_edge(margin.right),
bottom: intrinsic_margin_edge(margin.bottom),
left: intrinsic_margin_edge(margin.left),
}
}
pub(in crate::layout) fn intrinsic_margin_edge(
value: css::ComputedLengthPercentageOrAuto,
) -> LayoutLength {
match value {
css::ComputedLengthPercentageOrAuto::LengthPercentage(value) => {
used_length_percentage(value, PercentageBasis::definite(layout_pt(0.0)))
}
css::ComputedLengthPercentageOrAuto::Auto
| css::ComputedLengthPercentageOrAuto::MinContent
| css::ComputedLengthPercentageOrAuto::MaxContent
| css::ComputedLengthPercentageOrAuto::FitContent(_)
| css::ComputedLengthPercentageOrAuto::Stretch
| css::ComputedLengthPercentageOrAuto::CalcSize(_) => layout_pt(0.0),
}
}
pub(in crate::layout) fn used_margin_edge<Source>(
value: css::ComputedLengthPercentageOrAuto,
legacy_length: f32,
basis: PercentageBasis<LayoutLength, Source>,
) -> LayoutLength {
match value {
css::ComputedLengthPercentageOrAuto::Auto => layout_pt(0.0),
css::ComputedLengthPercentageOrAuto::LengthPercentage(value) => value
.length_if_no_percent()
.map(|_| layout_pt(legacy_length))
.unwrap_or_else(|| used_length_percentage(value, basis)),
css::ComputedLengthPercentageOrAuto::MinContent
| css::ComputedLengthPercentageOrAuto::MaxContent
| css::ComputedLengthPercentageOrAuto::FitContent(_)
| css::ComputedLengthPercentageOrAuto::Stretch
| css::ComputedLengthPercentageOrAuto::CalcSize(_) => layout_pt(legacy_length),
}
}
pub(in crate::layout) fn synchronize_resolved_fixed_box_edge_cache(style: &mut ComputedStyle) {
let margin = style.box_values.margin.clone();
let padding = style.box_values.padding.clone();
if let Some(value) = margin.top.length_if_no_percent() {
style.margin.top = value;
}
if let Some(value) = margin.right.length_if_no_percent() {
style.margin.right = value;
}
if let Some(value) = margin.bottom.length_if_no_percent() {
style.margin.bottom = value;
}
if let Some(value) = margin.left.length_if_no_percent() {
style.margin.left = value;
}
if let Some(value) = padding.top.length_if_no_percent() {
style.padding.top = value;
}
if let Some(value) = padding.right.length_if_no_percent() {
style.padding.right = value;
}
if let Some(value) = padding.bottom.length_if_no_percent() {
style.padding.bottom = value;
}
if let Some(value) = padding.left.length_if_no_percent() {
style.padding.left = value;
}
}
pub(in crate::layout) fn suppress_replayed_item_margins(style: &mut ComputedStyle) {
style.margin = css::Edges::ZERO;
style.box_values.margin = css::PhysicalEdges::all(css::ComputedLengthPercentageOrAuto::ZERO);
}
pub(in crate::layout) fn freeze_replayed_item_padding(
style: &mut ComputedStyle,
padding: css::Edges,
) {
style.padding = padding;
style.box_values.padding = css::PhysicalEdges {
top: css::ComputedLengthPercentage::from_points(padding.top),
right: css::ComputedLengthPercentage::from_points(padding.right),
bottom: css::ComputedLengthPercentage::from_points(padding.bottom),
left: css::ComputedLengthPercentage::from_points(padding.left),
};
}
pub(in crate::layout) fn used_box_edges<Source: Copy>(
style: &ComputedStyle,
inline_basis: PercentageBasis<LayoutLength, Source>,
) -> UsedBoxEdges {
UsedBoxEdges {
margin: used_margin_edges(style, inline_basis),
padding: used_padding_edges(style, inline_basis),
}
}
pub(in crate::layout) fn intrinsic_box_edges(style: &ComputedStyle) -> UsedBoxEdges {
UsedBoxEdges {
margin: intrinsic_margin_edges(style),
padding: intrinsic_padding_edges(style),
}
}
pub(in crate::layout) fn used_box_metrics<Source: Copy>(
style: &ComputedStyle,
inline_basis: PercentageBasis<LayoutLength, Source>,
) -> UsedBoxMetrics {
let used_edges = used_box_edges(style, inline_basis);
UsedBoxMetrics {
margin: used_edges.margin,
padding: used_edges.padding,
border: UsedEdges::from_css_edges(used_border_widths(style)),
}
}
pub(in crate::layout) fn used_box_metrics_for_logical_inline_basis<Source: Copy>(
style: &ComputedStyle,
inline_basis: LogicalInlinePercentageBasis<Source>,
) -> UsedBoxMetrics {
used_box_metrics(
style,
inline_basis.map_value(crate::units::IntoLayoutLength::into_layout_length),
)
}
pub(in crate::layout) fn intrinsic_box_metrics(style: &ComputedStyle) -> UsedBoxMetrics {
let intrinsic_edges = intrinsic_box_edges(style);
UsedBoxMetrics {
margin: intrinsic_edges.margin,
padding: intrinsic_edges.padding,
border: UsedEdges::from_css_edges(used_border_widths(style)),
}
}
pub(in crate::layout) fn apply_used_box_metrics(
style: &mut ComputedStyle,
inline_basis: PercentageBasis<LayoutLength>,
) -> UsedBoxMetrics {
let metrics = used_box_metrics(style, inline_basis);
style.margin = metrics.margin.to_css_edges();
style.padding = metrics.padding.to_css_edges();
metrics
}
pub(in crate::layout) fn apply_used_box_metrics_for_logical_inline_basis<Source: Copy>(
style: &mut ComputedStyle,
inline_basis: LogicalInlinePercentageBasis<Source>,
) -> UsedBoxMetrics {
let metrics = used_box_metrics_for_logical_inline_basis(style, inline_basis);
style.margin = metrics.margin.to_css_edges();
style.padding = metrics.padding.to_css_edges();
metrics
}
#[cfg(test)]
mod tests {
use super::super::*;
fn length_auto(value: f32) -> css::ComputedLengthPercentageOrAuto {
css::ComputedLengthPercentageOrAuto::LengthPercentage(
css::ComputedLengthPercentage::from_points(value),
)
}
fn percent_auto(value: f32) -> css::ComputedLengthPercentageOrAuto {
css::ComputedLengthPercentageOrAuto::LengthPercentage(
css::ComputedLengthPercentage::from_percent(value),
)
}
#[test]
fn used_padding_edge_resolves_zero_percent_calc_against_zero_basis() {
let calc_zero_percent =
css::ComputedLengthPercentage::from_affine(layout_pt(50.0), 0.0, true);
assert_eq!(
used_padding_edge(
calc_zero_percent,
0.0,
PercentageBasis::definite(layout_pt(0.0))
),
layout_pt(50.0)
);
assert_eq!(
used_padding_edge(
css::ComputedLengthPercentage::from_points(7.0),
7.0,
PercentageBasis::definite(layout_pt(0.0))
),
layout_pt(7.0)
);
assert_eq!(
used_padding_edge(
css::ComputedLengthPercentage::from_percent(0.25),
0.0,
PercentageBasis::definite(layout_pt(80.0))
),
layout_pt(20.0)
);
}
#[test]
fn used_margin_edge_resolves_zero_percent_calc_against_zero_basis() {
let calc_zero_percent = css::ComputedLengthPercentageOrAuto::LengthPercentage(
css::ComputedLengthPercentage::from_affine(layout_pt(30.0), 0.0, true),
);
assert_eq!(
used_margin_edge(
calc_zero_percent,
0.0,
PercentageBasis::definite(layout_pt(0.0))
),
layout_pt(30.0)
);
assert_eq!(
used_margin_edge(
length_auto(9.0),
9.0,
PercentageBasis::definite(layout_pt(0.0))
),
layout_pt(9.0)
);
assert_eq!(
used_margin_edge(
percent_auto(0.25),
0.0,
PercentageBasis::definite(layout_pt(80.0))
),
layout_pt(20.0)
);
assert_eq!(
used_margin_edge(
css::ComputedLengthPercentageOrAuto::Auto,
42.0,
PercentageBasis::definite(layout_pt(80.0))
),
layout_pt(0.0)
);
}
#[test]
fn intrinsic_margin_edges_resolve_cyclic_percentages_against_zero() {
let mut style = ComputedStyle::initial();
style.box_values.margin.left = css::ComputedLengthPercentageOrAuto::LengthPercentage(
css::ComputedLengthPercentage::from_affine(layout_pt(100.0), 0.10, true),
);
style.box_values.margin.right = percent_auto(0.25);
style.box_values.margin.top = css::ComputedLengthPercentageOrAuto::Auto;
style.margin.left = 999.0;
style.margin.right = 999.0;
let margin = intrinsic_margin_edges(&style).to_css_edges();
assert_eq!(margin.left, 100.0);
assert_eq!(margin.right, 0.0);
assert_eq!(margin.top, 0.0);
}
#[test]
fn intrinsic_padding_edges_resolve_cyclic_percentages_against_zero() {
let mut style = ComputedStyle::initial();
style.box_values.padding.left =
css::ComputedLengthPercentage::from_affine(layout_pt(50.0), 0.20, true);
style.box_values.padding.right = css::ComputedLengthPercentage::from_percent(0.25);
style.box_values.padding.top = css::ComputedLengthPercentage::from_points(-5.0);
style.padding.left = 999.0;
let padding = intrinsic_padding_edges(&style).to_css_edges();
assert_eq!(padding.left, 50.0);
assert_eq!(padding.right, 0.0);
assert_eq!(padding.top, 0.0);
}
#[test]
fn intrinsic_box_metrics_include_zero_basis_edges_and_borders() {
let mut style = ComputedStyle::initial();
style.box_values.margin.left = css::ComputedLengthPercentageOrAuto::LengthPercentage(
css::ComputedLengthPercentage::from_affine(layout_pt(10.0), 0.25, true),
);
style.box_values.padding.left =
css::ComputedLengthPercentage::from_affine(layout_pt(20.0), 0.25, true);
style.border_width_values.left = css::ComputedLengthPercentage::from_points(3.0);
style.border_width_values.right = css::ComputedLengthPercentage::from_points(4.0);
style.border_widths.left = 3.0;
style.border_widths.right = 4.0;
style.border_styles.left = css::BorderStyle::Solid;
style.border_styles.right = css::BorderStyle::Solid;
let metrics = intrinsic_box_metrics(&style);
assert_eq!(metrics.margin.left, layout_pt(10.0));
assert_eq!(metrics.padding.left, layout_pt(20.0));
assert_eq!(metrics.border.left, layout_pt(3.0));
assert_eq!(metrics.border.right, layout_pt(4.0));
assert_eq!(
metrics.horizontal_non_content_length(),
non_content_pt(27.0)
);
}
#[test]
fn applying_used_box_metrics_updates_style_only_at_the_css_edge_boundary() {
let mut style = ComputedStyle::initial();
style.box_values.margin.left = percent_auto(0.25);
style.box_values.padding.right = css::ComputedLengthPercentage::from_percent(0.5);
style.border_width_values.top = css::ComputedLengthPercentage::from_points(3.0);
style.border_widths.top = 3.0;
style.border_styles.top = css::BorderStyle::Solid;
let metrics =
apply_used_box_metrics(&mut style, PercentageBasis::definite(layout_pt(80.0)));
assert_eq!(metrics.margin.left, layout_pt(20.0));
assert_eq!(metrics.padding.right, layout_pt(40.0));
assert_eq!(metrics.border.top, layout_pt(3.0));
assert_eq!(style.margin.left, 20.0);
assert_eq!(style.padding.right, 40.0);
}
#[test]
fn logical_inline_box_metrics_keep_axis_identity_until_resolution() {
let mut style = ComputedStyle::initial();
style.box_values.margin.left = percent_auto(0.1);
style.box_values.padding.left = css::ComputedLengthPercentage::from_percent(0.1);
let metrics = used_box_metrics_for_logical_inline_basis(
&style,
PercentageBasis::definite(LogicalInlineContentSize::new(content_box_pt(100.0))),
);
assert_eq!(metrics.margin.left.points(), 10.0);
assert_eq!(metrics.padding.left.points(), 10.0);
}
}