use std::num::NonZeroUsize;
use super::*;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum GridLanesAxis {
Columns,
Rows,
}
#[derive(Debug, Clone, Copy)]
enum GridLanesLineEdge {
Start,
End,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(super) enum GridLanesItemPlacement {
Definite { grid_axis: GridAxis },
Automatic { grid_axis: GridAxis, span: usize },
}
impl GridLanesItemPlacement {
pub(super) fn grid_axis(self) -> GridAxis {
match self {
Self::Definite { grid_axis } | Self::Automatic { grid_axis, .. } => grid_axis,
}
}
pub(super) fn is_automatic(self) -> bool {
matches!(self, Self::Automatic { .. })
}
}
pub(super) fn grid_lanes_stacking_axis_is_block(style: &ComputedStyle) -> bool {
matches!(GridLanesAxis::from_style(style), GridLanesAxis::Columns)
}
pub(super) fn grid_lanes_item_placement(
parent_style: &ComputedStyle,
child: &GridChild<'_>,
) -> Option<GridLanesItemPlacement> {
parent_style.display.is_grid_lanes().then(|| {
let axis = GridLanesAxis::from_style(parent_style);
let (start, end) = axis.placements(child);
let grid_axis = match axis {
GridLanesAxis::Columns => GridAxis::Column,
GridLanesAxis::Rows => GridAxis::Row,
};
if matches!(start, css::GridPlacement::Line(_))
|| matches!(end, css::GridPlacement::Line(_))
{
GridLanesItemPlacement::Definite { grid_axis }
} else {
GridLanesItemPlacement::Automatic {
grid_axis,
span: grid_lanes_span(axis, child, usize::MAX),
}
}
})
}
type GridLanesPercentageBasis = PercentageBasis<LayoutLength>;
#[derive(Debug, Clone, Copy)]
struct GridLanesTrackBreadth(LayoutLength);
impl GridLanesTrackBreadth {
fn from_points(value: f32) -> Self {
Self(layout_pt(value.max(0.0)))
}
fn points(self) -> f32 {
self.0.points()
}
}
#[derive(Debug, Clone, Copy)]
struct GridLanesGutterBreadth(LayoutLength);
impl GridLanesGutterBreadth {
fn from_points(value: f32) -> Self {
Self(layout_pt(value.max(0.0)))
}
fn points(self) -> f32 {
self.0.points()
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct GridLanesTrackRange {
start: usize,
span: NonZeroUsize,
}
#[derive(Debug, Clone, Copy)]
struct GridLanesStackingRange(LayoutLength);
impl GridLanesStackingRange {
fn from_lane_ends(lane_ends: &[f32], stacking_gap: f32) -> Self {
let end = lane_ends.iter().cloned().fold(0.0_f32, f32::max);
Self(layout_pt((end - stacking_gap).max(0.0)))
}
fn end_points(self) -> f32 {
self.0.points()
}
}
impl GridLanesTrackRange {
fn new(start: usize, span: usize) -> Option<Self> {
Some(Self {
start,
span: NonZeroUsize::new(span)?,
})
}
fn end(self) -> usize {
self.start + self.span.get()
}
fn indices(self) -> std::ops::Range<usize> {
self.start..self.end()
}
fn span(self) -> usize {
self.span.get()
}
}
pub(super) struct GridLanesLayoutContext<'a> {
pub(super) width: PhysicalContentWidth,
pub(super) block_percentage_basis: GridLanesPercentageBasis,
pub(super) subgrid_context: Option<&'a ResolvedSubgridContext>,
}
struct GridLanesItemMeasurementContext<'a> {
stylesheets: &'a Stylesheets<'a>,
parent_style: &'a ComputedStyle,
parent_layout: &'a GridLayout,
area: GridItemArea,
placement: GridLanesItemPlacement,
inline_percentage_basis: GridLanesPercentageBasis,
axis: GridLanesAxis,
}
fn grid_lanes_basis_points(basis: GridLanesPercentageBasis) -> f32 {
basis.points().unwrap_or(0.0)
}
fn grid_lanes_repeat_count_constraint(
style: &ComputedStyle,
axis: GridLanesAxis,
basis: GridLanesPercentageBasis,
) -> GridLanesRepeatCountConstraint {
let (preferred, minimum, maximum) = match axis {
GridLanesAxis::Columns => (
style.box_values.width.clone(),
style.box_values.min_width.clone(),
style.box_values.max_width.clone(),
),
GridLanesAxis::Rows => (
style.box_values.height.value().clone(),
style.box_values.min_height.clone(),
style.box_values.max_height.clone(),
),
};
let resolve = |value| {
used_length_percentage_or_auto(value, basis)
.map(|value| GridLanesTrackBreadth::from_points(value.points()))
};
resolve(preferred)
.map(GridLanesRepeatCountConstraint::DefinitePreferred)
.or_else(|| resolve(maximum).map(GridLanesRepeatCountConstraint::DefiniteMaximum))
.or_else(|| resolve(minimum).map(GridLanesRepeatCountConstraint::DefiniteMinimum))
.or_else(|| {
basis.value().map(|value| {
GridLanesRepeatCountConstraint::DefinitePreferred(
GridLanesTrackBreadth::from_points(value.points()),
)
})
})
.unwrap_or(GridLanesRepeatCountConstraint::Indefinite)
}
fn grid_lanes_intrinsic_auto_repeat_count(
constraint: GridLanesRepeatCountConstraint,
first_repetition_size: f32,
additional_repetition_size: f32,
) -> usize {
let additional_repetition_size = additional_repetition_size.max(css::CSS_PX_TO_PT);
match constraint {
GridLanesRepeatCountConstraint::DefinitePreferred(available)
| GridLanesRepeatCountConstraint::DefiniteMaximum(available) => {
let available = available.points();
if first_repetition_size > available {
1
} else {
((available - first_repetition_size) / additional_repetition_size)
.floor()
.max(0.0) as usize
+ 1
}
}
GridLanesRepeatCountConstraint::DefiniteMinimum(minimum) => {
let minimum = minimum.points();
if first_repetition_size >= minimum {
1
} else {
((minimum - first_repetition_size) / additional_repetition_size)
.ceil()
.max(0.0) as usize
+ 1
}
}
GridLanesRepeatCountConstraint::Indefinite => 1,
}
}
#[allow(dead_code)]
#[derive(Debug, Clone)]
enum GridLanesIntrinsicAutoRepeatTrack {
Auto,
MinContent,
MaxContent,
FitContent(css::ComputedLengthPercentage),
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum GridLanesAutoRepeatKind {
Fill,
Fit,
}
#[derive(Debug, Clone, Copy)]
enum GridLanesRepeatCountConstraint {
DefinitePreferred(GridLanesTrackBreadth),
DefiniteMaximum(GridLanesTrackBreadth),
DefiniteMinimum(GridLanesTrackBreadth),
Indefinite,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum GridLanesAutoRepeatTrackSource {
FixedPrefix,
Repeated { repetition: usize, slot: usize },
FixedSuffix,
ImplicitEnd,
}
#[derive(Debug, Clone)]
struct GridLanesResolvedAutoRepeatTrack {
source: GridLanesAutoRepeatTrackSource,
used_size: GridLanesTrackBreadth,
auto_sized: bool,
collapsed: bool,
}
#[derive(Clone)]
struct GridLanesAutoRepeatResolution {
tracks: Vec<GridLanesResolvedAutoRepeatTrack>,
explicit_line_count: usize,
line_names: Vec<Vec<String>>,
repeat_range: std::ops::Range<usize>,
gap: GridLanesGutterBreadth,
final_geometry: Option<GridLanesTrackGeometry>,
}
impl GridLanesAutoRepeatResolution {
fn active_track_count(&self) -> usize {
self.tracks.iter().filter(|track| !track.collapsed).count()
}
fn active_repeated_track_count(&self) -> usize {
self.repeat_range
.clone()
.filter(|&index| !self.tracks[index].collapsed)
.count()
}
fn active_line(&self, source_line: usize) -> usize {
source_line
- self.tracks[..source_line.min(self.tracks.len())]
.iter()
.filter(|track| track.collapsed)
.count()
}
fn expand_active_geometry(
&self,
active_geometry: &GridLanesTrackGeometry,
) -> Option<GridLanesTrackGeometry> {
if active_geometry.track_count() != self.active_track_count() {
return None;
}
let mut starts = Vec::with_capacity(self.tracks.len());
let mut ends = Vec::with_capacity(self.tracks.len());
let mut active_index = 0;
let mut collapsed_offset = active_geometry
.topology
.track(0)
.map_or(0.0, |track| track.start());
for track in &self.tracks {
if track.collapsed {
starts.push(collapsed_offset);
ends.push(collapsed_offset);
continue;
}
let geometry = active_geometry.topology.track(active_index)?;
let start = geometry.start();
let end = geometry.end();
starts.push(start);
ends.push(end);
collapsed_offset = end;
active_index += 1;
}
(active_index == active_geometry.track_count())
.then(|| {
GridAxisTopology::from_track_bounds(
&starts,
&ends,
self.tracks.iter().map(|track| track.collapsed).collect(),
)
})
.flatten()
.map(|topology| GridLanesTrackGeometry { topology })
}
fn geometry(&self, alignment: css::ContentAlignment, available: f32) -> GridLanesTrackGeometry {
if let Some(geometry) = &self.final_geometry {
return geometry.clone();
}
debug_assert!(self.repeat_range.clone().all(|index| matches!(
self.tracks[index].source,
GridLanesAutoRepeatTrackSource::Repeated { .. }
)));
let sizes = self
.tracks
.iter()
.map(|track| track.used_size.points())
.collect::<Vec<_>>();
let active = self
.tracks
.iter()
.map(|track| !track.collapsed)
.collect::<Vec<_>>();
let auto_sized = self
.tracks
.iter()
.map(|track| track.auto_sized && !track.collapsed)
.collect::<Vec<_>>();
GridLanesTrackGeometry::from_track_sizes_with_active(&sizes, self.gap.points(), &active)
.expect("an intrinsic auto-repeat resolution always has tracks")
.with_auto_track_stretch(&auto_sized, alignment, available)
.with_content_alignment(alignment, available)
}
fn resolved_range(
&self,
axis: GridLanesAxis,
child: &GridChild<'_>,
) -> Option<GridLanesTrackRange> {
let (start, end) = axis.placements(child);
grid_lanes_resolved_track_range(start, end, self.tracks.len(), Some(&self.line_names))
}
fn append_end_implicit_tracks(
&mut self,
count: usize,
size: GridLanesTrackBreadth,
auto_sized: bool,
) {
self.tracks
.extend((0..count).map(|_| GridLanesResolvedAutoRepeatTrack {
source: GridLanesAutoRepeatTrackSource::ImplicitEnd,
used_size: size,
auto_sized,
collapsed: false,
}));
self.line_names.resize_with(self.tracks.len() + 1, Vec::new);
}
fn collapse_unoccupied_repeated_tracks(&mut self, occupied: &[bool]) {
if occupied.len() != self.tracks.len() {
return;
}
for index in self.repeat_range.clone() {
self.tracks[index].collapsed = !occupied[index];
}
}
fn apply_auto_fit(&mut self, axis: GridLanesAxis, children: &[GridChild<'_>]) {
let mut occupied = vec![false; self.tracks.len()];
let mut automatic_span_count = 0_usize;
for child in children {
if let Some(range) = self.resolved_range(axis, child) {
for index in range.indices() {
occupied[index] = true;
}
} else {
automatic_span_count =
automatic_span_count.max(grid_lanes_span(axis, child, self.tracks.len()));
}
}
for is_occupied in occupied
.iter_mut()
.take(self.explicit_line_count.saturating_sub(1))
{
if automatic_span_count == 0 {
break;
}
if !*is_occupied {
*is_occupied = true;
automatic_span_count -= 1;
}
}
self.collapse_unoccupied_repeated_tracks(&occupied);
}
}
#[derive(Clone)]
struct GridLanesTrackGeometry {
topology: GridAxisTopology,
}
impl GridLanesTrackGeometry {
fn from_resolved_subgrid_axis(axis: &ResolvedSubgridAxis) -> Option<Self> {
debug_assert_eq!(axis.line_offsets().len(), axis.track_count() + 1);
debug_assert_eq!(
axis.gutter_sizes().len(),
axis.track_count().saturating_sub(1)
);
let collapsed = vec![false; axis.track_count()];
GridAxisTopology::from_track_bounds(axis.track_starts(), axis.track_ends(), collapsed)
.filter(|topology| topology.track_count() != 0)
.map(|topology| Self { topology })
}
fn from_grid_axis_topology(topology: &GridAxisTopology) -> Option<Self> {
(topology.track_count() != 0).then(|| Self {
topology: topology.clone(),
})
}
fn from_track_sizes(sizes: &[f32], gap: f32) -> Option<Self> {
if sizes.is_empty() {
return None;
}
GridAxisTopology::from_track_layout(
sizes.to_vec(),
vec![gap.max(0.0); sizes.len().saturating_sub(1)],
vec![false; sizes.len()],
)
.map(|topology| Self { topology })
}
fn from_track_sizes_with_active(sizes: &[f32], gap: f32, active: &[bool]) -> Option<Self> {
if sizes.len() != active.len() {
return None;
}
if sizes.is_empty() {
return None;
}
let topology = GridAxisTopology::from_auto_fit_track_layout(
sizes.to_vec(),
vec![gap.max(0.0); sizes.len().saturating_sub(1)],
active.iter().map(|&active| !active).collect(),
)?;
Self::from_grid_axis_topology(&topology)
}
fn track_count(&self) -> usize {
self.topology.track_count()
}
fn area_start(&self, range: &std::ops::Range<usize>) -> f32 {
self.topology
.track(range.start)
.map_or(0.0, |track| track.start())
}
fn area_size(&self, range: &std::ops::Range<usize>) -> f32 {
self.topology
.area_bounds(
u16::try_from(range.start + 1).unwrap_or(u16::MAX),
u16::try_from(range.end + 1).unwrap_or(u16::MAX),
)
.map_or(0.0, |(start, end)| (end - start).max(0.0))
}
fn active_tracks(&self) -> Vec<bool> {
self.topology
.collapsed_tracks_iter()
.map(|collapsed| !collapsed)
.collect()
}
fn topology(&self) -> GridAxisTopology {
self.topology.clone()
}
fn with_content_alignment(self, alignment: css::ContentAlignment, container_size: f32) -> Self {
if self.track_count() == 0 {
return self;
}
let occupied_size = self.topology.extent();
let free_space = container_size - occupied_size;
let free_space = if alignment.safety == AlignmentSafety::Unsafe {
free_space
} else {
free_space.max(0.0)
};
let count = self.track_count();
let (initial_offset, between_offset) = match alignment.keyword {
css::ContentAlignmentKeyword::End
| css::ContentAlignmentKeyword::FlexEnd
| css::ContentAlignmentKeyword::Right => (free_space, 0.0),
css::ContentAlignmentKeyword::Center => (free_space / 2.0, 0.0),
css::ContentAlignmentKeyword::SpaceBetween if count > 1 => {
(0.0, free_space / (count - 1) as f32)
}
css::ContentAlignmentKeyword::SpaceAround => {
let between = free_space / count as f32;
(between / 2.0, between)
}
css::ContentAlignmentKeyword::SpaceEvenly => {
let between = free_space / (count + 1) as f32;
(between, between)
}
_ => (0.0, 0.0),
};
let tracks = (0..count).filter_map(|index| {
let track = self.topology.track(index)?;
let offset = initial_offset + between_offset * index as f32;
Some((
track.start() + offset,
track.end() + offset,
!track.is_active(),
))
});
GridAxisTopology::from_track_geometry(tracks)
.map(|topology| Self { topology })
.unwrap_or(self)
}
fn with_auto_track_stretch(
self,
auto_sized_tracks: &[bool],
alignment: css::ContentAlignment,
container_size: f32,
) -> Self {
if self.track_count() != auto_sized_tracks.len()
|| !matches!(
alignment.keyword,
css::ContentAlignmentKeyword::Normal | css::ContentAlignmentKeyword::Stretch
)
{
return self;
}
let auto_track_count = auto_sized_tracks.iter().filter(|&&track| track).count();
if auto_track_count == 0 {
return self;
}
let occupied_size = self.topology.extent();
let additional_size =
((container_size - occupied_size).max(0.0) / auto_track_count as f32).max(0.0);
if additional_size == 0.0 {
return self;
}
let mut preceding_growth = 0.0;
let tracks = (0..self.track_count()).filter_map(|index| {
let track = self.topology.track(index)?;
let start = track.start() + preceding_growth;
let mut end = track.end() + preceding_growth;
if auto_sized_tracks[index] {
end += additional_size;
preceding_growth += additional_size;
}
Some((start, end, !track.is_active()))
});
GridAxisTopology::from_track_geometry(tracks)
.map(|topology| Self { topology })
.unwrap_or(self)
}
}
impl GridLanesAxis {
fn from_style(style: &ComputedStyle) -> Self {
match style.grid_lanes_direction {
css::GridLanesDirection::Axis {
axis: css::GridLanesAxis::Column,
..
} => Self::Columns,
css::GridLanesDirection::Axis {
axis: css::GridLanesAxis::Row,
..
} => Self::Rows,
css::GridLanesDirection::Normal => {
match (&style.grid_template_columns, &style.grid_template_rows) {
(css::GridTrackList::None, css::GridTrackList::Tracks { .. }) => Self::Rows,
_ => Self::Columns,
}
}
}
}
fn placements<'a>(
self,
child: &'a GridChild<'_>,
) -> (&'a css::GridPlacement, &'a css::GridPlacement) {
match self {
Self::Columns => (&child.style.grid_column_start, &child.style.grid_column_end),
Self::Rows => (&child.style.grid_row_start, &child.style.grid_row_end),
}
}
}
impl<'a> LayoutBuilder<'a> {
pub(super) fn apply_grid_lanes_placement(
&mut self,
style: &ComputedStyle,
children: &[GridChild<'_>],
stylesheets: &Stylesheets<'_>,
context: GridLanesLayoutContext<'_>,
mut layout: GridLayout,
) -> GridLayout {
let GridLanesLayoutContext {
width,
block_percentage_basis,
subgrid_context,
} = context;
let inline_percentage_basis = PercentageBasis::definite(layout_pt(width.points()));
let axis = GridLanesAxis::from_style(style);
let swaps_physical_grid_axes =
WritingModeAxes::new(style.writing_mode, style.direction).swaps_physical_axes();
let resolved_grid_axis = subgrid_context.and_then(|context| {
context.physical_axis(
match axis {
GridLanesAxis::Columns => GridAxis::Column,
GridLanesAxis::Rows => GridAxis::Row,
},
swaps_physical_grid_axes,
)
});
let grid_axis_tracks = match axis {
GridLanesAxis::Columns => &style.grid_template_columns,
GridLanesAxis::Rows => &style.grid_template_rows,
};
let grid_axis_topology = match axis {
GridLanesAxis::Columns => layout.columns.clone(),
GridLanesAxis::Rows => layout.rows.clone(),
};
let grid_axis_percentage_basis = match axis {
GridLanesAxis::Columns => PercentageBasis::definite(layout_pt(width.points())),
GridLanesAxis::Rows => block_percentage_basis,
};
let grid_axis_size = grid_lanes_basis_points(grid_axis_percentage_basis);
let grid_axis_gap = resolved_grid_axis.map_or_else(
|| {
used_grid_lanes_gap(
match axis {
GridLanesAxis::Columns => style.column_gap.clone(),
GridLanesAxis::Rows => style.row_gap.clone(),
},
grid_axis_percentage_basis,
)
},
ResolvedSubgridAxis::taffy_gap,
);
let grid_axis_content_alignment = match axis {
GridLanesAxis::Columns => style.justify_content,
GridLanesAxis::Rows => style.align_content,
};
let simple_track_template = grid_lanes_simple_track_template(
grid_axis_tracks,
&style.grid_template_areas,
match axis {
GridLanesAxis::Columns => &style.grid_auto_columns,
GridLanesAxis::Rows => &style.grid_auto_rows,
},
match axis {
GridLanesAxis::Columns => GridAxis::Column,
GridLanesAxis::Rows => GridAxis::Row,
},
grid_axis_percentage_basis,
);
let auto_repeat_resolution = self.grid_lanes_resolve_intrinsic_auto_repeat(
style,
axis,
grid_axis_tracks,
children,
&layout.items,
stylesheets,
width,
grid_axis_percentage_basis
.value()
.map(|basis| PhysicalContentHeight::new(content_box_pt(basis.points()))),
grid_axis_percentage_basis,
grid_axis_gap,
grid_axis_content_alignment,
);
let auto_repeat_geometry = auto_repeat_resolution
.as_ref()
.map(|resolution| resolution.geometry(grid_axis_content_alignment, grid_axis_size));
let auto_repeat_geometry_resolves_item_percentages = auto_repeat_geometry.is_some();
let auto_row_geometry = (axis == GridLanesAxis::Rows)
.then(|| {
grid_lanes_simple_row_offsets(
simple_track_template.as_ref()?,
children,
&layout.items,
inline_percentage_basis,
grid_axis_gap,
grid_axis_content_alignment,
grid_axis_size,
)
})
.flatten();
let has_auto_row_geometry = auto_row_geometry.is_some();
let auto_column_geometry = (axis == GridLanesAxis::Columns)
.then(|| {
self.grid_lanes_simple_column_offsets(
simple_track_template.as_ref()?,
children,
stylesheets,
inline_percentage_basis,
grid_axis_gap,
grid_axis_content_alignment,
grid_axis_size,
)
})
.flatten();
let geometry = resolved_grid_axis
.and_then(GridLanesTrackGeometry::from_resolved_subgrid_axis)
.or_else(|| {
simple_track_template
.as_ref()
.filter(|template| !template.has_auto_tracks())
.and_then(|template| {
GridLanesTrackGeometry::from_track_sizes(
&template.initial_track_sizes,
grid_axis_gap,
)
})
.map(|geometry| {
geometry.with_content_alignment(grid_axis_content_alignment, grid_axis_size)
})
.or(auto_repeat_geometry)
.or(auto_row_geometry)
.or(auto_column_geometry)
.or_else(|| {
GridLanesTrackGeometry::from_grid_axis_topology(&grid_axis_topology)
})
});
let Some(geometry) = geometry else {
return layout;
};
let lane_count = geometry.track_count();
if lane_count == 0 || layout.items.len() != children.len() {
return layout;
}
let stacking_gap = match axis {
GridLanesAxis::Columns => used_grid_lanes_gap(
style.row_gap.clone(),
PercentageBasis::definite(layout_pt(layout.height.points())),
),
GridLanesAxis::Rows => {
used_grid_lanes_gap(style.column_gap.clone(), inline_percentage_basis)
}
};
let final_estimates = children
.iter()
.map(|child| {
self.estimate_grid_item_size_for_parent_track_sizing(
child,
stylesheets,
width.points(),
grid_percentage_basis(
Some(content_box_pt(width.points())),
GridAvailableSizeSource::ContainerInlineSize,
),
grid_percentage_basis(None, GridAvailableSizeSource::ContainerBlockSize),
)
})
.collect::<Vec<_>>();
let mut lane_ends = vec![0.0_f32; lane_count];
let mut placed = layout.items.clone();
let mut stacking_placements = Vec::with_capacity(children.len());
let mut order = (0..children.len()).collect::<Vec<_>>();
order.sort_by_key(|&index| (children[index].style.order, index));
let mut auto_placement_cursor = 0;
let flow_tolerance = grid_lanes_flow_tolerance(style, grid_axis_percentage_basis);
let uses_dense_packing = matches!(
style.grid_auto_flow,
css::GridAutoFlow::RowDense | css::GridAutoFlow::ColumnDense
);
let mut occupied = vec![Vec::<GridLanesOccupiedInterval>::new(); lane_count];
let grid_axis_line_names = resolved_grid_axis
.map(|axis| axis.line_names().to_vec())
.or_else(|| {
auto_repeat_resolution
.as_ref()
.map(|resolution| resolution.line_names.clone())
})
.or_else(|| {
simple_track_template
.as_ref()
.map(|template| template.line_names.clone())
})
.or_else(|| grid_lanes_explicit_line_names(grid_axis_tracks));
let final_grid_axis_topology = geometry.topology();
let mut final_grid_axis_line_names =
grid_axis_line_names.clone().unwrap_or_else(|| match axis {
GridLanesAxis::Columns => layout.column_line_names.clone(),
GridLanesAxis::Rows => layout.row_line_names.clone(),
});
final_grid_axis_line_names
.resize_with(final_grid_axis_topology.track_count() + 1, Vec::new);
final_grid_axis_line_names.truncate(final_grid_axis_topology.track_count() + 1);
layout.set_physical_grid_axis_topology(
match axis {
GridLanesAxis::Columns => GridAxis::Column,
GridLanesAxis::Rows => GridAxis::Row,
},
final_grid_axis_topology,
final_grid_axis_line_names,
);
for index in order {
let child = &children[index];
let placement_provenance = grid_lanes_item_placement(style, child)
.expect("Grid Lanes placement is only queried for a Grid Lanes container");
let measured_item = &placed[index];
let span = grid_lanes_span(axis, child, lane_count);
let (mut packing_range, auto_placed) = match resolved_grid_axis
.and_then(|resolved_axis| {
let (start, end) = axis.placements(child);
matches!(
placement_provenance,
GridLanesItemPlacement::Definite { .. }
)
.then(|| resolved_axis.resolved_range(start, end, 1))
.and_then(|range| {
let range = range.track_range();
let start = range.start;
let end = range.end;
(start < end && end <= lane_count).then_some(start..end)
})
})
.or_else(|| {
auto_repeat_resolution
.as_ref()
.and_then(|resolution| resolution.resolved_range(axis, child))
.map(GridLanesTrackRange::indices)
})
.or_else(|| {
let (start, end) = axis.placements(child);
grid_lanes_resolved_track_range(
start,
end,
lane_count,
grid_axis_line_names.as_deref(),
)
.map(GridLanesTrackRange::indices)
}) {
Some(range) => (range, false),
None => (
grid_lanes_shortest_range(
&lane_ends,
&geometry.active_tracks(),
span,
auto_placement_cursor,
flow_tolerance,
),
true,
),
};
let track_reversed = matches!(
style.grid_lanes_direction,
css::GridLanesDirection::Axis {
track_reverse: true,
..
}
);
if auto_placed {
auto_placement_cursor = packing_range.end;
}
let mut range = if auto_placed && track_reversed {
grid_lanes_reverse_range(packing_range.clone(), lane_count)
} else {
packing_range.clone()
};
let normal_area = grid_lanes_item_area(axis, &range);
let measurement_context = GridLanesItemMeasurementContext {
stylesheets,
parent_style: style,
parent_layout: &layout,
area: normal_area,
placement: placement_provenance,
inline_percentage_basis,
axis,
};
let stacking_start = lane_ends[packing_range.clone()]
.iter()
.cloned()
.fold(0.0_f32, f32::max);
let margins = grid_lanes_margins(&child.style, inline_percentage_basis);
let final_percentage_size = match axis {
GridLanesAxis::Columns => resolve_grid_item_final_percentage_size(
child,
&final_estimates[index],
measured_item,
geometry.area_size(&range),
layout.height.points(),
width,
),
GridLanesAxis::Rows => resolve_grid_item_final_percentage_size(
child,
&final_estimates[index],
measured_item,
width.points(),
geometry.area_size(&range),
width,
),
};
let (item_width, item_height, grid_axis_offset) = match axis {
GridLanesAxis::Columns => {
let area_width = geometry.area_size(&range);
let measured_width = final_percentage_size.width.map_or_else(
|| {
if auto_repeat_geometry_resolves_item_percentages {
grid_lanes_grid_axis_specified_border_size(
axis,
&child.style,
layout_pt(area_width),
)
.map(|size| size.points())
.unwrap_or(measured_item.width())
} else {
measured_item.width()
}
},
SemanticLengthExt::points,
);
let (item_width, grid_axis_offset) = grid_lanes_grid_axis_alignment(
axis,
style,
&child.style,
area_width,
margins.left.points(),
margins.right.points(),
measured_width,
);
let item_height = final_percentage_size
.height
.map_or_else(
|| {
self.grid_lanes_item_border_block_size(
child,
item_width,
measurement_context,
)
.points()
},
SemanticLengthExt::points,
)
.max(0.0);
(item_width, item_height, grid_axis_offset)
}
GridLanesAxis::Rows => {
let area_height = geometry.area_size(&range);
let measured_height = final_percentage_size.height.map_or_else(
|| {
if auto_repeat_geometry_resolves_item_percentages {
grid_lanes_grid_axis_specified_border_size(
axis,
&child.style,
layout_pt(area_height),
)
.map(|size| size.points())
.unwrap_or(measured_item.height())
} else {
measured_item.height()
}
},
SemanticLengthExt::points,
);
let (item_height, grid_axis_offset) = grid_lanes_grid_axis_alignment(
axis,
style,
&child.style,
area_height,
margins.top.points(),
margins.bottom.points(),
measured_height,
);
let item_width = final_percentage_size
.width
.map(SemanticLengthExt::points)
.or_else(|| {
final_percentage_size.height.and_then(|_| {
grid_lanes_replaced_transferred_border_size(
&final_estimates[index],
axis,
item_height,
)
})
})
.unwrap_or_else(|| {
self.grid_lanes_item_border_block_size(
child,
item_height,
measurement_context,
)
.points()
})
.max(0.0);
(item_width, item_height, grid_axis_offset)
}
};
let stacking_size = match axis {
GridLanesAxis::Columns => {
item_height + margins.top.points() + margins.bottom.points()
}
GridLanesAxis::Rows => item_width + margins.left.points() + margins.right.points(),
}
.max(0.0);
let dense_placement = if uses_dense_packing {
grid_lanes_dense_backfill_position(
&occupied,
&geometry,
&packing_range,
stacking_size + stacking_gap,
stacking_start,
flow_tolerance,
)
} else {
None
};
if let Some((dense_range, _)) = &dense_placement {
packing_range = dense_range.clone();
range = if auto_placed && track_reversed {
grid_lanes_reverse_range(dense_range.clone(), lane_count)
} else {
dense_range.clone()
};
}
let placed_start = dense_placement
.as_ref()
.map(|(_, start)| *start)
.unwrap_or(stacking_start);
let item = &mut placed[index];
item.set_grid_lanes_placement(placement_provenance);
if final_percentage_size.width.is_some() {
item.mark_final_percentage_axis(GridAxis::Column);
}
if final_percentage_size.height.is_some() {
item.mark_final_percentage_axis(GridAxis::Row);
}
match axis {
GridLanesAxis::Columns => {
let area_x = geometry.area_start(&range);
item.set_axis_geometry(GridAxis::Column, area_x + grid_axis_offset, item_width);
item.set_axis_geometry(
GridAxis::Row,
placed_start + margins.top.points(),
item_height,
);
}
GridLanesAxis::Rows => {
let area_y = geometry.area_start(&range);
item.set_axis_geometry(GridAxis::Row, area_y + grid_axis_offset, item_height);
item.set_axis_geometry(
GridAxis::Column,
placed_start + margins.left.points(),
item_width,
);
}
}
item.area = Some(match axis {
GridLanesAxis::Columns => GridItemArea {
row_start: 1,
row_end: 2,
column_start: u16::try_from(range.start + 1).unwrap_or(u16::MAX),
column_end: u16::try_from(range.end + 1).unwrap_or(u16::MAX),
},
GridLanesAxis::Rows => GridItemArea {
row_start: u16::try_from(range.start + 1).unwrap_or(u16::MAX),
row_end: u16::try_from(range.end + 1).unwrap_or(u16::MAX),
column_start: 1,
column_end: 2,
},
});
let end = stacking_start + stacking_size.max(0.0) + stacking_gap;
let occupied_end = placed_start + stacking_size + stacking_gap;
for lane in packing_range.clone() {
occupied[lane].push(GridLanesOccupiedInterval {
start: placed_start,
end: occupied_end,
});
}
stacking_placements.push(GridLanesStackingPlacement {
item_index: index,
tracks: packing_range.clone(),
margin_start: placed_start,
margin_end: placed_start + stacking_size,
margin_start_size: match axis {
GridLanesAxis::Columns => margins.top.points(),
GridLanesAxis::Rows => margins.left.points(),
},
margin_end_size: match axis {
GridLanesAxis::Columns => margins.bottom.points(),
GridLanesAxis::Rows => margins.right.points(),
},
});
if dense_placement.is_none() {
for lane_end in &mut lane_ends[packing_range] {
*lane_end = end;
}
}
}
let stacking_range = GridLanesStackingRange::from_lane_ends(&lane_ends, stacking_gap);
apply_grid_lanes_stacking_axis_alignment(
axis,
style,
children,
&stacking_placements,
stacking_gap,
stacking_range,
&mut placed,
);
if axis == GridLanesAxis::Columns {
if used_length_percentage_or_auto(
style.box_values.height.value().clone(),
PercentageBasis::definite(layout_pt(layout.height.points())),
)
.is_none()
{
layout.height =
PhysicalContentHeight::new(content_box_pt(stacking_range.end_points()));
}
layout.rows = GridAxisTopology::from_track_layout(
vec![layout.height.points()],
Vec::new(),
vec![false],
)
.expect("one Grid Lanes stacking track has valid topology");
layout.content_height = layout.height.points();
} else {
if has_auto_row_geometry
&& used_length_percentage_or_auto(
style.box_values.height.value().clone(),
PercentageBasis::definite(layout_pt(layout.height.points())),
)
.is_none()
{
layout.height = PhysicalContentHeight::new(content_box_pt(
geometry
.topology
.track(geometry.track_count().saturating_sub(1))
.map_or_else(|| layout.height.points(), |track| track.end()),
));
layout.rows = geometry.topology();
layout.content_height = layout.height.points();
}
}
let (stacking_size, stacking_alignment) = match axis {
GridLanesAxis::Columns => (layout.height.points(), style.align_content),
GridLanesAxis::Rows => (width.points(), style.justify_content),
};
let stacking_offset = grid_lanes_content_alignment_offset(
stacking_alignment,
stacking_size,
stacking_range.end_points(),
);
match axis {
GridLanesAxis::Columns => {
for (item, child) in placed.iter_mut().zip(children) {
let margins = grid_lanes_margins(&child.style, inline_percentage_basis);
if matches!(
style.grid_lanes_direction,
css::GridLanesDirection::Axis {
fill_reverse: true,
..
}
) {
item.set_axis_geometry(
GridAxis::Row,
stacking_range.end_points()
- (item.y() + item.height() + margins.bottom.points())
+ margins.top.points(),
item.height(),
);
}
item.set_axis_geometry(
GridAxis::Row,
item.y() + stacking_offset,
item.height(),
);
}
}
GridLanesAxis::Rows => {
for (item, child) in placed.iter_mut().zip(children) {
let margins = grid_lanes_margins(&child.style, inline_percentage_basis);
if matches!(
style.grid_lanes_direction,
css::GridLanesDirection::Axis {
fill_reverse: true,
..
}
) {
item.set_axis_geometry(
GridAxis::Column,
stacking_range.end_points()
- (item.x() + item.width() + margins.right.points())
+ margins.left.points(),
item.width(),
);
}
item.set_axis_geometry(
GridAxis::Column,
item.x() + stacking_offset,
item.width(),
);
}
}
}
match axis {
GridLanesAxis::Columns => {
layout.columns = geometry.topology();
let mut names = resolved_grid_axis
.map(|axis| axis.physical_line_names().to_vec())
.or_else(|| {
auto_repeat_resolution
.as_ref()
.map(|resolution| resolution.line_names.clone())
})
.or_else(|| {
simple_track_template
.as_ref()
.map(|template| template.line_names.clone())
})
.unwrap_or_else(|| layout.column_line_names.clone());
names.resize_with(layout.columns.track_count() + 1, Vec::new);
names.truncate(layout.columns.track_count() + 1);
layout.column_line_names = names;
}
GridLanesAxis::Rows if !has_auto_row_geometry => {
layout.rows = geometry.topology();
let mut names = resolved_grid_axis
.map(|axis| axis.physical_line_names().to_vec())
.or_else(|| {
auto_repeat_resolution
.as_ref()
.map(|resolution| resolution.line_names.clone())
})
.or_else(|| {
simple_track_template
.as_ref()
.map(|template| template.line_names.clone())
})
.unwrap_or_else(|| layout.row_line_names.clone());
names.resize_with(layout.rows.track_count() + 1, Vec::new);
names.truncate(layout.rows.track_count() + 1);
layout.row_line_names = names;
}
GridLanesAxis::Rows => {}
}
apply_grid_replaced_item_size_corrections(style, children, &final_estimates, &mut placed);
layout.items = placed;
layout
}
fn grid_lanes_item_border_block_size(
&mut self,
child: &GridChild<'_>,
grid_axis_border_size: f32,
context: GridLanesItemMeasurementContext<'_>,
) -> BorderBoxLength {
let available_width = match context.axis {
GridLanesAxis::Columns => grid_lanes_content_inline_size(
child,
border_box_pt(grid_axis_border_size),
context.inline_percentage_basis,
),
GridLanesAxis::Rows => {
content_box_pt(grid_lanes_basis_points(context.inline_percentage_basis))
}
};
let estimate = if let Some(subgrid_context) = ResolvedSubgridContext::from_parent(
context.parent_style,
context.parent_layout,
&child.style,
context.area,
Some(context.placement),
) {
self.with_resolved_subgrid_context(subgrid_context, |layout| {
layout.estimate_grid_item_size_for_parent_track_sizing(
child,
context.stylesheets,
available_width.points(),
grid_percentage_basis(
Some(available_width),
GridAvailableSizeSource::ContainerInlineSize,
),
PercentageBasis::indefinite(),
)
})
} else {
self.estimate_grid_item_size_for_parent_track_sizing(
child,
context.stylesheets,
available_width.points(),
grid_percentage_basis(
Some(available_width),
GridAvailableSizeSource::ContainerInlineSize,
),
PercentageBasis::indefinite(),
)
};
border_box_pt(match context.axis {
GridLanesAxis::Columns => {
estimate.height.points()
+ grid_lanes_vertical_non_content(&child.style, context.inline_percentage_basis)
.points()
}
GridLanesAxis::Rows => {
estimate.width.points()
+ grid_lanes_horizontal_non_content(
&child.style,
context.inline_percentage_basis,
)
.points()
}
})
}
#[allow(dead_code, clippy::too_many_arguments)]
fn grid_lanes_simple_column_offsets(
&mut self,
template: &GridLanesSimpleTrackTemplate,
children: &[GridChild<'_>],
stylesheets: &Stylesheets<'_>,
inline_percentage_basis: GridLanesPercentageBasis,
grid_axis_gap: f32,
content_alignment: css::ContentAlignment,
grid_axis_size: f32,
) -> Option<GridLanesTrackGeometry> {
let column_count = template.track_count();
if column_count == 0
|| !template.has_auto_tracks()
|| children
.iter()
.any(|child| child.style.display.inner == DisplayInner::Grid)
|| grid_lanes_has_out_of_range_explicit_placement(
children,
GridLanesAxis::Columns,
column_count,
)
{
return None;
}
let mut track_sizes = template.initial_track_sizes.clone();
for child in children {
let margins = grid_lanes_margins(&child.style, inline_percentage_basis);
let estimate = self.estimate_grid_item_size(
child,
stylesheets,
grid_lanes_basis_points(inline_percentage_basis),
grid_percentage_basis(
inline_percentage_basis
.value()
.map(|value| content_box_pt(value.points())),
GridAvailableSizeSource::ContainerInlineSize,
),
PercentageBasis::indefinite(),
);
let contribution = estimate.min_width.points()
+ grid_lanes_horizontal_non_content(&child.style, inline_percentage_basis).points()
+ margins.left.points()
+ margins.right.points();
let (start, end) = GridLanesAxis::Columns.placements(child);
let range = grid_lanes_resolved_track_range(
start,
end,
column_count,
Some(&template.line_names),
);
let span = range.map_or_else(
|| grid_lanes_span(GridLanesAxis::Columns, child, column_count),
GridLanesTrackRange::span,
);
if span != 1 {
return None;
}
if let Some(range) = range {
if template.auto_tracks[range.start] {
track_sizes[range.start] = track_sizes[range.start].max(contribution);
}
} else {
for (size, &is_auto) in track_sizes.iter_mut().zip(&template.auto_tracks) {
if is_auto {
*size = size.max(contribution);
}
}
}
}
grid_lanes_simple_track_geometry(
&track_sizes,
&template.auto_tracks,
grid_axis_gap,
content_alignment,
grid_axis_size,
)
}
#[allow(dead_code, clippy::too_many_arguments)]
fn grid_lanes_auto_repeat_auto_geometry(
&mut self,
style: &ComputedStyle,
axis: GridLanesAxis,
tracks: &css::GridTrackList,
children: &[GridChild<'_>],
items: &[GridItemLayout],
stylesheets: &Stylesheets<'_>,
width: PhysicalContentWidth,
root_height: Option<PhysicalContentHeight>,
inline_percentage_basis: GridLanesPercentageBasis,
available_size: GridLanesPercentageBasis,
gap: f32,
content_alignment: css::ContentAlignment,
) -> Option<GridLanesTrackGeometry> {
if let Some(resolution) = self.grid_lanes_resolve_intrinsic_auto_repeat(
style,
axis,
tracks,
children,
items,
stylesheets,
width,
root_height,
available_size,
gap,
content_alignment,
) {
return Some(
resolution.geometry(content_alignment, grid_lanes_basis_points(available_size)),
);
}
let css::GridTrackList::Tracks { components, .. } = tracks else {
return None;
};
let [css::GridTrackListComponent::Repeat(_, repeat)] = components.as_slice() else {
return None;
};
if !matches!(
repeat.count,
css::GridRepeatCount::AutoFill | css::GridRepeatCount::AutoFit
) {
return None;
}
let [css::GridTrackListComponent::Track(_, track)] = repeat.tracks.as_slice() else {
return None;
};
let intrinsic_track = grid_lanes_intrinsic_auto_repeat_track(track.clone())?;
if children.len() != items.len() {
return None;
}
let mut contribution = 0.0_f32;
for (child, item) in children.iter().zip(items) {
let span = grid_lanes_span(axis, child, usize::MAX);
let margins = grid_lanes_margins(&child.style, inline_percentage_basis);
let (specified, measured, non_content, margin_sum) = match axis {
GridLanesAxis::Columns => (
child.style.box_values.width.clone(),
item.width(),
grid_lanes_horizontal_non_content(&child.style, inline_percentage_basis),
margins.left.points() + margins.right.points(),
),
GridLanesAxis::Rows => (
child.style.box_values.height.value().clone(),
item.height(),
grid_lanes_vertical_non_content(&child.style, inline_percentage_basis),
margins.top.points() + margins.bottom.points(),
),
};
let percentage_sized = matches!(
specified,
css::ComputedLengthPercentageOrAuto::LengthPercentage(ref value)
if value.contains_percentage()
);
let estimate = self.estimate_grid_item_size(
child,
stylesheets,
grid_lanes_basis_points(inline_percentage_basis),
grid_percentage_basis(
inline_percentage_basis
.value()
.map(|value| content_box_pt(value.points())),
GridAvailableSizeSource::ContainerInlineSize,
),
PercentageBasis::indefinite(),
);
let (min_content, max_content) = match axis {
GridLanesAxis::Columns => {
(estimate.min_width.points(), estimate.content_width.points())
}
GridLanesAxis::Rows => (
estimate.min_height.points(),
estimate.content_height.points(),
),
};
let item_contribution =
if matches!(intrinsic_track, GridLanesIntrinsicAutoRepeatTrack::Auto)
&& !percentage_sized
{
used_length_percentage_or_auto(specified, available_size)
.map(|size| {
let size = size.points();
if child.style.box_sizing == BoxSizing::ContentBox {
size + non_content.points()
} else {
size
}
})
.unwrap_or(measured)
+ margin_sum
} else {
let intrinsic_contribution = match intrinsic_track {
GridLanesIntrinsicAutoRepeatTrack::Auto
| GridLanesIntrinsicAutoRepeatTrack::MaxContent => max_content,
GridLanesIntrinsicAutoRepeatTrack::MinContent => min_content,
GridLanesIntrinsicAutoRepeatTrack::FitContent(ref limit) => max_content
.min(used_length_percentage((*limit).clone(), available_size).points()),
};
intrinsic_contribution + non_content.points() + margin_sum
};
let track_contribution =
(item_contribution - gap * span.saturating_sub(1) as f32).max(0.0) / span as f32;
contribution = contribution.max(track_contribution);
}
if contribution <= 0.0 {
return None;
}
let count = ((grid_lanes_basis_points(available_size) + gap) / (contribution + gap))
.floor()
.max(1.0) as usize;
GridLanesTrackGeometry::from_track_sizes(&vec![contribution; count], gap)
}
#[allow(clippy::too_many_arguments)]
fn grid_lanes_resolve_intrinsic_auto_repeat(
&mut self,
style: &ComputedStyle,
axis: GridLanesAxis,
tracks: &css::GridTrackList,
children: &[GridChild<'_>],
items: &[GridItemLayout],
stylesheets: &Stylesheets<'_>,
width: PhysicalContentWidth,
root_height: Option<PhysicalContentHeight>,
grid_axis_percentage_basis: GridLanesPercentageBasis,
gap: f32,
content_alignment: css::ContentAlignment,
) -> Option<GridLanesAutoRepeatResolution> {
let css::GridTrackList::Tracks { components, .. } = tracks else {
return None;
};
if children.len() != items.len() {
return None;
}
let mut fixed_sizes = Vec::new();
let mut repeat_start = None;
let mut repeated_tracks = None;
let mut repeat_kind = None;
for component in components {
match component {
css::GridTrackListComponent::Track(_, track) => {
fixed_sizes.push(grid_lanes_definite_track_size(
track.clone(),
grid_axis_percentage_basis,
)?);
}
css::GridTrackListComponent::Repeat(_, repeat) => match repeat.count {
css::GridRepeatCount::Number(count) => {
for _ in 0..count {
for component in &repeat.tracks {
let css::GridTrackListComponent::Track(_, track) = component else {
return None;
};
fixed_sizes.push(grid_lanes_definite_track_size(
track.clone(),
grid_axis_percentage_basis,
)?);
}
}
}
css::GridRepeatCount::AutoFill | css::GridRepeatCount::AutoFit => {
if repeated_tracks.is_some() {
return None;
}
let tracks = repeat
.tracks
.iter()
.map(|component| match component {
css::GridTrackListComponent::Track(_, track) => Some(track.clone()),
css::GridTrackListComponent::Repeat(_, _) => None,
})
.collect::<Option<Vec<_>>>()?;
repeat_start = Some(fixed_sizes.len());
repeat_kind = Some(match repeat.count {
css::GridRepeatCount::AutoFill => GridLanesAutoRepeatKind::Fill,
css::GridRepeatCount::AutoFit => GridLanesAutoRepeatKind::Fit,
css::GridRepeatCount::Number(_) => unreachable!(),
});
repeated_tracks = Some(tracks);
}
},
}
}
let repeat_start = repeat_start?;
let repeated_tracks = repeated_tracks?;
if repeated_tracks.is_empty() {
return None;
}
let largest_span = children
.iter()
.map(|child| grid_lanes_span(axis, child, usize::MAX))
.max()
.unwrap_or(1);
let hypothetical_repetitions = 2 + largest_span.saturating_sub(2) / repeated_tracks.len();
debug_assert!(hypothetical_repetitions >= 2);
let repeated_sizes = self.grid_lanes_virtual_intrinsic_auto_repeat_sizes(
style,
axis,
children,
stylesheets,
width,
root_height,
hypothetical_repetitions,
repeat_start,
repeated_tracks.len(),
)?;
let repeated_auto_sized = repeated_tracks
.iter()
.map(|track| {
matches!(
grid_lanes_intrinsic_auto_repeat_track(track.clone()),
Some(GridLanesIntrinsicAutoRepeatTrack::Auto)
)
})
.collect::<Vec<_>>();
let fixed_size = fixed_sizes.iter().sum::<f32>();
let fixed_track_count = fixed_sizes.len();
let repeat_size = repeated_sizes.iter().sum::<f32>();
let repeat_track_count = repeated_sizes.len();
let counting_repeat_size = repeated_sizes
.iter()
.map(|size| size.max(css::CSS_PX_TO_PT))
.sum::<f32>();
let first_repetition_size = fixed_size
+ counting_repeat_size
+ gap * (fixed_track_count + repeat_track_count).saturating_sub(1) as f32;
let repeat_constraint =
grid_lanes_repeat_count_constraint(style, axis, grid_axis_percentage_basis);
let repetitions = grid_lanes_intrinsic_auto_repeat_count(
repeat_constraint,
first_repetition_size,
counting_repeat_size + gap * repeat_track_count as f32,
);
let mut suffix_sizes = fixed_sizes.split_off(repeat_start);
let prefix_sizes = fixed_sizes;
let mut resolved_tracks = prefix_sizes
.into_iter()
.map(|used_size| GridLanesResolvedAutoRepeatTrack {
source: GridLanesAutoRepeatTrackSource::FixedPrefix,
used_size: GridLanesTrackBreadth::from_points(used_size),
auto_sized: false,
collapsed: false,
})
.collect::<Vec<_>>();
for repetition in 0..repetitions {
resolved_tracks.extend(repeated_sizes.iter().enumerate().map(|(slot, &used_size)| {
GridLanesResolvedAutoRepeatTrack {
source: GridLanesAutoRepeatTrackSource::Repeated { repetition, slot },
used_size: GridLanesTrackBreadth::from_points(used_size),
auto_sized: repeated_auto_sized[slot],
collapsed: false,
}
}));
}
resolved_tracks.extend(suffix_sizes.drain(..).map(|used_size| {
GridLanesResolvedAutoRepeatTrack {
source: GridLanesAutoRepeatTrackSource::FixedSuffix,
used_size: GridLanesTrackBreadth::from_points(used_size),
auto_sized: false,
collapsed: false,
}
}));
let repeat_range = repeat_start..repeat_start + repetitions * repeat_track_count;
let line_names = grid_lanes_expanded_auto_repeat_line_names(tracks, repetitions)?;
let explicit_line_count = resolved_tracks.len() + 1;
let mut resolution = GridLanesAutoRepeatResolution {
tracks: resolved_tracks,
explicit_line_count,
line_names,
repeat_range,
gap: GridLanesGutterBreadth::from_points(gap),
final_geometry: None,
};
let required_track_count =
grid_lanes_required_track_count(axis, children, resolution.tracks.len());
resolution.append_end_implicit_tracks(
required_track_count.saturating_sub(resolution.tracks.len()),
GridLanesTrackBreadth::from_points(grid_lanes_auto_implicit_track_size(
axis, style, children, items,
)),
grid_lanes_implicit_track_is_auto(axis, style),
);
if matches!(repeat_kind?, GridLanesAutoRepeatKind::Fit) {
resolution.apply_auto_fit(axis, children);
}
let legacy_auto_fit_with_automatic_items =
matches!(repeat_kind?, GridLanesAutoRepeatKind::Fit)
&& children
.iter()
.any(|child| resolution.resolved_range(axis, child).is_none());
let use_active_final_geometry = legacy_auto_fit_with_automatic_items
|| (axis == GridLanesAxis::Columns && repeat_track_count > 1);
let materialized_geometry = use_active_final_geometry
.then(|| {
self.grid_lanes_materialized_auto_repeat_geometry(
style,
axis,
children,
stylesheets,
width,
root_height,
&resolution,
repeat_track_count,
legacy_auto_fit_with_automatic_items,
)
})
.flatten();
if let Some(geometry) = &materialized_geometry {
let generated_end_tracks = geometry
.track_count()
.checked_sub(resolution.active_track_count())?;
resolution.append_end_implicit_tracks(
generated_end_tracks,
GridLanesTrackBreadth::from_points(grid_lanes_auto_implicit_track_size(
axis, style, children, items,
)),
grid_lanes_implicit_track_is_auto(axis, style),
);
resolution.final_geometry = resolution.expand_active_geometry(geometry);
}
let _ = content_alignment;
let _ = repeat_size;
Some(resolution)
}
#[allow(clippy::too_many_arguments)]
fn grid_lanes_materialized_auto_repeat_geometry(
&mut self,
style: &ComputedStyle,
axis: GridLanesAxis,
children: &[GridChild<'_>],
stylesheets: &Stylesheets<'_>,
width: PhysicalContentWidth,
root_height: Option<PhysicalContentHeight>,
topology: &GridLanesAutoRepeatResolution,
repeat_track_count: usize,
normalize_fixed_counting_fragments: bool,
) -> Option<GridLanesTrackGeometry> {
let mut materialized_style = style.clone();
let active_repetitions = topology
.active_repeated_track_count()
.checked_div(repeat_track_count)?;
let repetitions = u16::try_from(active_repetitions).ok()?;
{
let template = match axis {
GridLanesAxis::Columns => &mut materialized_style.grid_template_columns,
GridLanesAxis::Rows => &mut materialized_style.grid_template_rows,
};
let css::GridTrackList::Tracks { components, .. } = template else {
return None;
};
let intrinsic_auto_track = css::GridTrackSize {
min: css::GridMinTrackBreadth::Auto,
max: css::GridMaxTrackBreadth::Auto,
};
let mut materialized = false;
let mut implicit_track = None;
for component in components.iter_mut() {
match component {
css::GridTrackListComponent::Track(_, track)
if normalize_fixed_counting_fragments && !materialized =>
{
*track = intrinsic_auto_track.clone();
}
css::GridTrackListComponent::Repeat(_, repeat)
if matches!(
repeat.count,
css::GridRepeatCount::AutoFill | css::GridRepeatCount::AutoFit
) =>
{
repeat.count = css::GridRepeatCount::Number(repetitions);
implicit_track =
repeat.tracks.iter().find_map(|component| match component {
css::GridTrackListComponent::Track(_, track) => Some(track.clone()),
css::GridTrackListComponent::Repeat(_, _) => None,
});
materialized = true;
}
css::GridTrackListComponent::Repeat(_, repeat)
if normalize_fixed_counting_fragments && !materialized =>
{
for component in &mut repeat.tracks {
if let css::GridTrackListComponent::Track(_, track) = component {
*track = intrinsic_auto_track.clone();
}
}
}
_ => {}
}
}
materialized.then_some(())?;
let active_explicit_tracks =
components.iter().try_fold(0_usize, |count, component| {
let added = match component {
css::GridTrackListComponent::Track(_, _) => 1,
css::GridTrackListComponent::Repeat(_, repeat) => {
let css::GridRepeatCount::Number(repetitions) = repeat.count else {
return None;
};
let slots =
repeat.tracks.iter().try_fold(0_usize, |slots, component| {
match component {
css::GridTrackListComponent::Track(_, _) => {
slots.checked_add(1)
}
css::GridTrackListComponent::Repeat(_, _) => None,
}
})?;
usize::from(repetitions).checked_mul(slots)?
}
};
count.checked_add(added)
})?;
let implicit_track = implicit_track?;
let additional_tracks = topology
.active_track_count()
.checked_sub(active_explicit_tracks)?;
components.extend(
(0..additional_tracks).map(|_| {
css::GridTrackListComponent::Track(Vec::new(), implicit_track.clone())
}),
);
}
let mut sizing_children = Vec::with_capacity(children.len());
for child in children {
if let Some(range) = topology.resolved_range(axis, child) {
let mut copy = child.clone();
let start = topology.active_line(range.start);
let end = topology.active_line(range.end());
grid_lanes_set_virtual_axis_placement(
&mut copy.style,
axis,
start,
end.checked_sub(start)?,
)?;
sizing_children.push(copy);
} else {
sizing_children.push(child.clone());
}
}
let layout = self.compute_grid_layout_pass(
&materialized_style,
&sizing_children,
stylesheets,
None,
&[],
GridLayoutPassConfig {
width,
root_height: (axis == GridLanesAxis::Columns)
.then_some(root_height)
.flatten(),
item_width_basis: (axis == GridLanesAxis::Columns)
.then(GridPercentageBasis::indefinite),
item_height_basis: if axis == GridLanesAxis::Rows {
GridPercentageBasis::indefinite()
} else {
grid_percentage_basis(
root_height.map(PhysicalContentHeight::content_box_length),
GridAvailableSizeSource::ContainerBlockSize,
)
},
item_containing_block_bases: None,
frozen_tracks: GridFrozenTrackTopology::default(),
row_gap_basis: if axis == GridLanesAxis::Rows {
GridPercentageBasis::indefinite()
} else {
grid_percentage_basis(
root_height.map(PhysicalContentHeight::content_box_length),
GridAvailableSizeSource::ContainerBlockSize,
)
},
reported_height: None,
item_placement_overrides: Vec::new(),
baseline_plan: None,
},
)?;
let geometry = match axis {
GridLanesAxis::Columns => {
GridLanesTrackGeometry::from_grid_axis_topology(&layout.columns)
}
GridLanesAxis::Rows => GridLanesTrackGeometry::from_grid_axis_topology(&layout.rows),
}?;
Some(geometry)
}
#[allow(clippy::too_many_arguments)]
fn grid_lanes_virtual_intrinsic_auto_repeat_sizes(
&mut self,
style: &ComputedStyle,
axis: GridLanesAxis,
children: &[GridChild<'_>],
stylesheets: &Stylesheets<'_>,
width: PhysicalContentWidth,
root_height: Option<PhysicalContentHeight>,
repetitions: usize,
repeat_start: usize,
repeat_track_count: usize,
) -> Option<Vec<f32>> {
let mut virtual_style = style.clone();
let template = match axis {
GridLanesAxis::Columns => &mut virtual_style.grid_template_columns,
GridLanesAxis::Rows => &mut virtual_style.grid_template_rows,
};
let css::GridTrackList::Tracks { components, .. } = template else {
return None;
};
let repetitions = u16::try_from(repetitions).ok()?;
for component in components {
let css::GridTrackListComponent::Repeat(_, repeat) = component else {
continue;
};
if matches!(
repeat.count,
css::GridRepeatCount::AutoFill | css::GridRepeatCount::AutoFit
) {
repeat.count = css::GridRepeatCount::Number(repetitions);
}
}
match axis {
GridLanesAxis::Columns => {
virtual_style.justify_content =
css::ContentAlignment::new(css::ContentAlignmentKeyword::Start);
}
GridLanesAxis::Rows => {
virtual_style.align_content =
css::ContentAlignment::new(css::ContentAlignmentKeyword::Start);
}
}
let total_track_count = grid_lanes_template_track_count(template)?;
let mut virtual_children = Vec::new();
for child in children {
let span = grid_lanes_span(axis, child, total_track_count);
for start in 0..=total_track_count.saturating_sub(span) {
let mut copy = child.clone();
grid_lanes_set_virtual_axis_placement(&mut copy.style, axis, start, span)?;
grid_lanes_set_virtual_cross_axis_placement(&mut copy.style, axis)?;
virtual_children.push(copy);
}
}
let virtual_root_height = (axis == GridLanesAxis::Columns)
.then_some(root_height)
.flatten();
let layout = self.compute_grid_layout_pass(
&virtual_style,
&virtual_children,
stylesheets,
None,
&[],
GridLayoutPassConfig {
width,
root_height: virtual_root_height,
item_width_basis: (axis == GridLanesAxis::Columns)
.then(GridPercentageBasis::indefinite),
item_height_basis: if axis == GridLanesAxis::Rows {
GridPercentageBasis::indefinite()
} else {
grid_percentage_basis(
root_height.map(PhysicalContentHeight::content_box_length),
GridAvailableSizeSource::ContainerBlockSize,
)
},
item_containing_block_bases: None,
frozen_tracks: GridFrozenTrackTopology::default(),
row_gap_basis: if axis == GridLanesAxis::Rows {
GridPercentageBasis::indefinite()
} else {
grid_percentage_basis(
root_height.map(PhysicalContentHeight::content_box_length),
GridAvailableSizeSource::ContainerBlockSize,
)
},
reported_height: None,
item_placement_overrides: Vec::new(),
baseline_plan: None,
},
)?;
let track_sizes = layout.physical_track_sizes(match axis {
GridLanesAxis::Columns => GridAxis::Column,
GridLanesAxis::Rows => GridAxis::Row,
});
(track_sizes.len() >= repeat_start + usize::from(repetitions) * repeat_track_count)
.then_some(())?;
Some(
(0..repeat_track_count)
.map(|slot| {
(0..usize::from(repetitions))
.filter_map(|repetition| {
track_sizes.get(repeat_start + repetition * repeat_track_count + slot)
})
.copied()
.fold(0.0_f32, f32::max)
})
.collect::<Vec<_>>(),
)
}
}
fn grid_lanes_auto_implicit_track_size(
axis: GridLanesAxis,
style: &ComputedStyle,
children: &[GridChild<'_>],
items: &[GridItemLayout],
) -> f32 {
if !grid_lanes_implicit_track_is_auto(axis, style) {
return 0.0;
}
children
.iter()
.zip(items)
.map(|(child, item)| {
let span = grid_lanes_span(axis, child, usize::MAX).max(1) as f32;
let contribution = match axis {
GridLanesAxis::Columns => item.width(),
GridLanesAxis::Rows => item.height(),
};
(contribution / span).max(0.0)
})
.fold(0.0, f32::max)
}
fn grid_lanes_implicit_track_is_auto(axis: GridLanesAxis, style: &ComputedStyle) -> bool {
let auto_tracks = match axis {
GridLanesAxis::Columns => &style.grid_auto_columns,
GridLanesAxis::Rows => &style.grid_auto_rows,
};
auto_tracks.as_slice().iter().all(|track| {
matches!(
grid_lanes_intrinsic_auto_repeat_track(track.clone()),
Some(GridLanesIntrinsicAutoRepeatTrack::Auto)
)
})
}
fn grid_lanes_intrinsic_auto_repeat_track(
track: css::GridTrackSize,
) -> Option<GridLanesIntrinsicAutoRepeatTrack> {
match (track.min, track.max) {
(css::GridMinTrackBreadth::Auto, css::GridMaxTrackBreadth::Auto) => {
Some(GridLanesIntrinsicAutoRepeatTrack::Auto)
}
(css::GridMinTrackBreadth::MinContent, css::GridMaxTrackBreadth::MinContent) => {
Some(GridLanesIntrinsicAutoRepeatTrack::MinContent)
}
(css::GridMinTrackBreadth::MaxContent, css::GridMaxTrackBreadth::MaxContent)
| (css::GridMinTrackBreadth::MinContent, css::GridMaxTrackBreadth::MaxContent) => {
Some(GridLanesIntrinsicAutoRepeatTrack::MaxContent)
}
(css::GridMinTrackBreadth::Auto, css::GridMaxTrackBreadth::FitContent(limit)) => {
Some(GridLanesIntrinsicAutoRepeatTrack::FitContent(limit))
}
_ => None,
}
}
fn grid_lanes_expanded_auto_repeat_line_names(
tracks: &css::GridTrackList,
repetitions: usize,
) -> Option<Vec<Vec<String>>> {
let mut tracks = tracks.clone();
let css::GridTrackList::Tracks { components, .. } = &mut tracks else {
return None;
};
let repetitions = u16::try_from(repetitions).ok()?;
for component in components {
let css::GridTrackListComponent::Repeat(_, repeat) = component else {
continue;
};
if matches!(
repeat.count,
css::GridRepeatCount::AutoFill | css::GridRepeatCount::AutoFit
) {
repeat.count = css::GridRepeatCount::Number(repetitions);
}
}
let css::GridTrackList::Tracks {
components,
trailing_names,
} = tracks
else {
unreachable!();
};
explicit_grid_line_names(&components, &trailing_names)
}
fn grid_lanes_template_track_count(tracks: &css::GridTrackList) -> Option<usize> {
let css::GridTrackList::Tracks { components, .. } = tracks else {
return None;
};
components.iter().try_fold(0_usize, |count, component| {
let added = match component {
css::GridTrackListComponent::Track(_, _) => 1,
css::GridTrackListComponent::Repeat(_, repeat) => {
let css::GridRepeatCount::Number(repetitions) = repeat.count else {
return None;
};
let slots =
repeat
.tracks
.iter()
.try_fold(0_usize, |slots, component| match component {
css::GridTrackListComponent::Track(_, _) => slots.checked_add(1),
css::GridTrackListComponent::Repeat(_, _) => None,
})?;
usize::from(repetitions).checked_mul(slots)?
}
};
count.checked_add(added)
})
}
fn grid_lanes_set_virtual_axis_placement(
style: &mut GridUsedStyle,
axis: GridLanesAxis,
start: usize,
span: usize,
) -> Option<()> {
let start = i32::try_from(start.checked_add(1)?).ok()?;
let end = start.checked_add(i32::try_from(span).ok()?)?;
let start = css::GridPlacement::Line(css::GridLinePlacement::Number(
std::num::NonZeroI32::new(start)?,
));
let end = css::GridPlacement::Line(css::GridLinePlacement::Number(std::num::NonZeroI32::new(
end,
)?));
match axis {
GridLanesAxis::Columns => {
style.grid_column_start = start;
style.grid_column_end = end;
}
GridLanesAxis::Rows => {
style.grid_row_start = start;
style.grid_row_end = end;
}
}
Some(())
}
fn grid_lanes_set_virtual_cross_axis_placement(
style: &mut GridUsedStyle,
axis: GridLanesAxis,
) -> Option<()> {
let start = css::GridPlacement::Line(css::GridLinePlacement::Number(
std::num::NonZeroI32::new(1)?,
));
let end = css::GridPlacement::Line(css::GridLinePlacement::Number(std::num::NonZeroI32::new(
2,
)?));
match axis {
GridLanesAxis::Columns => {
style.grid_row_start = start;
style.grid_row_end = end;
style.align_self = css::SelfAlignment::new(SelfAlignmentKeyword::Start);
}
GridLanesAxis::Rows => {
style.grid_column_start = start;
style.grid_column_end = end;
style.justify_self = css::SelfAlignment::new(SelfAlignmentKeyword::Start);
}
}
Some(())
}
fn grid_lanes_required_track_count(
axis: GridLanesAxis,
children: &[GridChild<'_>],
explicit_track_count: usize,
) -> usize {
children
.iter()
.fold(explicit_track_count, |required, child| {
let (start, end) = axis.placements(child);
let span = grid_lanes_span(axis, child, usize::MAX);
let start_line = grid_lanes_positive_line(start);
let end_line = grid_lanes_positive_line(end);
let item_required = match (start_line, end_line) {
(Some(start), Some(end)) => start.max(end).saturating_sub(1),
(Some(start), None) => start.saturating_sub(1).saturating_add(span),
(None, Some(end)) => end.saturating_sub(1),
(None, None) => span,
};
required.max(item_required)
})
}
fn grid_lanes_positive_line(placement: &css::GridPlacement) -> Option<usize> {
let css::GridPlacement::Line(line) = placement else {
return None;
};
usize::try_from(line.index()?).ok().filter(|&line| line > 0)
}
fn grid_lanes_reverse_range(
range: std::ops::Range<usize>,
lane_count: usize,
) -> std::ops::Range<usize> {
lane_count.saturating_sub(range.end)..lane_count.saturating_sub(range.start)
}
fn grid_lanes_content_alignment_offset(
alignment: css::ContentAlignment,
container_size: f32,
content_size: f32,
) -> f32 {
let free_space = container_size - content_size;
let free_space = if alignment.safety == AlignmentSafety::Unsafe {
free_space
} else {
free_space.max(0.0)
};
match alignment.keyword {
css::ContentAlignmentKeyword::Center => free_space / 2.0,
css::ContentAlignmentKeyword::End
| css::ContentAlignmentKeyword::FlexEnd
| css::ContentAlignmentKeyword::Right => free_space,
_ => 0.0,
}
}
#[derive(Clone)]
struct GridLanesStackingPlacement {
item_index: usize,
tracks: std::ops::Range<usize>,
margin_start: f32,
margin_end: f32,
margin_start_size: f32,
margin_end_size: f32,
}
impl GridLanesStackingPlacement {
fn shares_track_with(&self, other: &Self) -> bool {
self.tracks.start < other.tracks.end && other.tracks.start < self.tracks.end
}
fn following_margin_start(&self, placements: &[Self]) -> Option<f32> {
placements
.iter()
.filter(|other| {
other.item_index != self.item_index
&& self.shares_track_with(other)
&& other.margin_start >= self.margin_end - 0.01
})
.map(|other| other.margin_start)
.min_by(f32::total_cmp)
}
}
fn apply_grid_lanes_stacking_axis_alignment(
axis: GridLanesAxis,
container_style: &ComputedStyle,
children: &[GridChild<'_>],
placements: &[GridLanesStackingPlacement],
stacking_gap: f32,
stacking_range: GridLanesStackingRange,
items: &mut [GridItemLayout],
) {
debug_assert_eq!(items.len(), children.len());
for placement in placements {
let alignment_end = placement
.following_margin_start(placements)
.map(|start| (start - stacking_gap).max(placement.margin_end))
.unwrap_or(stacking_range.end_points().max(placement.margin_end));
if alignment_end <= placement.margin_end + 0.01 {
continue;
}
let child = &children[placement.item_index];
let item_size = match axis {
GridLanesAxis::Columns => items[placement.item_index].height(),
GridLanesAxis::Rows => items[placement.item_index].width(),
};
let (border_size, border_offset) = grid_lanes_stacking_axis_alignment(
axis,
container_style,
&child.style,
placement.margin_start,
alignment_end,
placement.margin_start_size,
placement.margin_end_size,
item_size,
);
let item = &mut items[placement.item_index];
item.set_axis_geometry(
match axis {
GridLanesAxis::Columns => GridAxis::Row,
GridLanesAxis::Rows => GridAxis::Column,
},
border_offset,
border_size,
);
}
}
#[allow(clippy::too_many_arguments)]
fn grid_lanes_stacking_axis_alignment(
axis: GridLanesAxis,
container_style: &ComputedStyle,
child_style: &ComputedStyle,
container_start: f32,
container_end: f32,
margin_start: f32,
margin_end: f32,
measured_border_size: f32,
) -> (f32, f32) {
let alignment = match axis {
GridLanesAxis::Columns => effective_grid_align_self(child_style, container_style),
GridLanesAxis::Rows => effective_grid_justify_self(child_style, container_style),
};
let available_border_size =
(container_end - container_start - margin_start - margin_end).max(0.0);
let stretches = matches!(
alignment.keyword,
SelfAlignmentKeyword::Normal | SelfAlignmentKeyword::Stretch
) && grid_lanes_stacking_axis_size_is_auto(axis, child_style);
let border_size = if stretches {
available_border_size
} else {
measured_border_size.max(0.0)
};
let free_space = container_end - container_start - margin_start - border_size - margin_end;
let distributable_free_space = if alignment.safety == AlignmentSafety::Unsafe {
free_space
} else {
free_space.max(0.0)
};
let normal_start_is_physical_start = !matches!(
container_style.grid_lanes_direction,
css::GridLanesDirection::Axis {
fill_reverse: true,
..
}
);
let physical_start = grid_lanes_stacking_alignment_uses_physical_start(
axis,
alignment.keyword,
child_style,
container_style,
);
let normal_start_offset = match alignment.keyword {
SelfAlignmentKeyword::Center => distributable_free_space / 2.0,
SelfAlignmentKeyword::End
| SelfAlignmentKeyword::SelfEnd
| SelfAlignmentKeyword::FlexEnd
| SelfAlignmentKeyword::Right
| SelfAlignmentKeyword::LastBaseline => {
if physical_start == normal_start_is_physical_start {
distributable_free_space
} else {
0.0
}
}
SelfAlignmentKeyword::Start
| SelfAlignmentKeyword::SelfStart
| SelfAlignmentKeyword::FlexStart
| SelfAlignmentKeyword::Left
| SelfAlignmentKeyword::Baseline => {
if physical_start == normal_start_is_physical_start {
0.0
} else {
distributable_free_space
}
}
SelfAlignmentKeyword::Auto
| SelfAlignmentKeyword::Normal
| SelfAlignmentKeyword::Stretch => 0.0,
};
(
border_size,
container_start + margin_start + normal_start_offset,
)
}
fn grid_lanes_stacking_alignment_uses_physical_start(
axis: GridLanesAxis,
alignment: SelfAlignmentKeyword,
child_style: &ComputedStyle,
container_style: &ComputedStyle,
) -> bool {
match (axis, alignment) {
(GridLanesAxis::Columns, SelfAlignmentKeyword::SelfStart) => {
matches!(
grid_subject_self_start_side(child_style, PhysicalAxis::Vertical),
Some(PhysicalSide::Top)
)
}
(GridLanesAxis::Columns, SelfAlignmentKeyword::SelfEnd) => {
matches!(
grid_subject_self_end_side(child_style, PhysicalAxis::Vertical),
Some(PhysicalSide::Top)
)
}
(GridLanesAxis::Rows, SelfAlignmentKeyword::SelfStart) => {
matches!(
grid_subject_self_start_side(child_style, PhysicalAxis::Horizontal),
Some(PhysicalSide::Left)
)
}
(GridLanesAxis::Rows, SelfAlignmentKeyword::SelfEnd) => {
matches!(
grid_subject_self_end_side(child_style, PhysicalAxis::Horizontal),
Some(PhysicalSide::Left)
)
}
(GridLanesAxis::Rows, SelfAlignmentKeyword::Left) => true,
(GridLanesAxis::Rows, SelfAlignmentKeyword::Right) => false,
(GridLanesAxis::Rows, _) => container_style.direction != Direction::Rtl,
(GridLanesAxis::Columns, _) => true,
}
}
fn grid_lanes_stacking_axis_size_is_auto(axis: GridLanesAxis, style: &ComputedStyle) -> bool {
match axis {
GridLanesAxis::Columns => style.box_values.height.value().is_auto(),
GridLanesAxis::Rows => style.box_values.width.is_auto(),
}
}
fn grid_lanes_grid_axis_alignment(
axis: GridLanesAxis,
container_style: &ComputedStyle,
child_style: &ComputedStyle,
area_size: f32,
margin_start: f32,
margin_end: f32,
measured_border_size: f32,
) -> (f32, f32) {
let alignment = match axis {
GridLanesAxis::Columns => effective_grid_justify_self(child_style, container_style),
GridLanesAxis::Rows => effective_grid_align_self(child_style, container_style),
};
let available_border_size = (area_size - margin_start - margin_end).max(0.0);
let stretches = matches!(
alignment.keyword,
SelfAlignmentKeyword::Normal | SelfAlignmentKeyword::Stretch
) && grid_lanes_grid_axis_size_is_auto(axis, child_style);
let border_size = if stretches {
available_border_size
} else {
measured_border_size.max(0.0)
};
let free_space = area_size - margin_start - border_size - margin_end;
let overflow_is_safe = alignment.safety != AlignmentSafety::Unsafe;
let distributable_free_space = if overflow_is_safe {
free_space.max(0.0)
} else {
free_space
};
let start_side = grid_lanes_alignment_uses_physical_start(
axis,
alignment.keyword,
child_style,
container_style,
);
let offset = match alignment.keyword {
SelfAlignmentKeyword::Center => margin_start + distributable_free_space / 2.0,
SelfAlignmentKeyword::End
| SelfAlignmentKeyword::SelfEnd
| SelfAlignmentKeyword::FlexEnd
| SelfAlignmentKeyword::Right => {
if start_side {
margin_start + distributable_free_space
} else {
margin_start
}
}
SelfAlignmentKeyword::Start
| SelfAlignmentKeyword::SelfStart
| SelfAlignmentKeyword::FlexStart
| SelfAlignmentKeyword::Left => {
if start_side {
margin_start
} else {
margin_start + distributable_free_space
}
}
_ => margin_start,
};
(border_size, offset)
}
fn grid_lanes_grid_axis_specified_border_size(
axis: GridLanesAxis,
child_style: &ComputedStyle,
area_size: LayoutLength,
) -> Option<BorderBoxLength> {
let (specified, padding_start, padding_end, border_start, border_end) = match axis {
GridLanesAxis::Columns => (
child_style.box_values.width.clone(),
used_length_percentage(
child_style.box_values.padding.left.clone(),
PercentageBasis::definite(area_size),
),
used_length_percentage(
child_style.box_values.padding.right.clone(),
PercentageBasis::definite(area_size),
),
layout_pt(used_border_widths(child_style).left),
layout_pt(used_border_widths(child_style).right),
),
GridLanesAxis::Rows => (
child_style.box_values.height.value().clone(),
used_length_percentage(
child_style.box_values.padding.top.clone(),
PercentageBasis::definite(area_size),
),
used_length_percentage(
child_style.box_values.padding.bottom.clone(),
PercentageBasis::definite(area_size),
),
layout_pt(used_border_widths(child_style).top),
layout_pt(used_border_widths(child_style).bottom),
),
};
let size = used_length_percentage_or_auto(specified, PercentageBasis::definite(area_size))?;
let non_content = non_content_pt(
padding_start.points() + padding_end.points() + border_start.points() + border_end.points(),
);
Some(match child_style.box_sizing {
BoxSizing::ContentBox => content_box_to_border_box_length(
crate::units::layout_to_content_box_length(size),
non_content,
),
BoxSizing::BorderBox => crate::units::layout_to_border_box_length(size),
})
}
fn grid_lanes_alignment_uses_physical_start(
axis: GridLanesAxis,
alignment: SelfAlignmentKeyword,
child_style: &ComputedStyle,
container_style: &ComputedStyle,
) -> bool {
let side = match (axis, alignment) {
(GridLanesAxis::Columns, SelfAlignmentKeyword::Left) => return true,
(GridLanesAxis::Columns, SelfAlignmentKeyword::Right) => return false,
(GridLanesAxis::Columns, SelfAlignmentKeyword::SelfStart) => {
grid_subject_self_start_side(child_style, PhysicalAxis::Horizontal)
}
(GridLanesAxis::Columns, SelfAlignmentKeyword::SelfEnd) => {
grid_subject_self_end_side(child_style, PhysicalAxis::Horizontal)
}
(GridLanesAxis::Rows, SelfAlignmentKeyword::SelfStart) => {
grid_subject_self_start_side(child_style, PhysicalAxis::Vertical)
}
(GridLanesAxis::Rows, SelfAlignmentKeyword::SelfEnd) => {
grid_subject_self_end_side(child_style, PhysicalAxis::Vertical)
}
(GridLanesAxis::Columns, _) => {
return container_style.direction != Direction::Rtl;
}
(GridLanesAxis::Rows, _) => return true,
};
matches!(side, Some(PhysicalSide::Left | PhysicalSide::Top))
}
fn grid_lanes_grid_axis_size_is_auto(axis: GridLanesAxis, style: &ComputedStyle) -> bool {
match axis {
GridLanesAxis::Columns => style.box_values.width.is_auto(),
GridLanesAxis::Rows => style.box_values.height.value().is_auto(),
}
}
fn grid_lanes_replaced_transferred_border_size(
estimate: &GridItemEstimate,
definite_axis: GridLanesAxis,
definite_border_size: f32,
) -> Option<f32> {
let used_size = estimate.replaced_used_size?;
let (source_axis, target_axis) = match definite_axis {
GridLanesAxis::Columns => (used_size.width.points(), used_size.height.points()),
GridLanesAxis::Rows => (used_size.height.points(), used_size.width.points()),
};
(source_axis > 0.0).then(|| (definite_border_size * target_axis / source_axis).max(0.0))
}
#[derive(Clone, Copy)]
struct GridLanesMargins {
top: LayoutLength,
right: LayoutLength,
bottom: LayoutLength,
left: LayoutLength,
}
#[derive(Clone, Copy)]
struct GridLanesOccupiedInterval {
start: f32,
end: f32,
}
fn grid_lanes_dense_backfill_position(
occupied: &[Vec<GridLanesOccupiedInterval>],
geometry: &GridLanesTrackGeometry,
normal_range: &std::ops::Range<usize>,
reserved_size: f32,
normal_start: f32,
tolerance: f32,
) -> Option<(std::ops::Range<usize>, f32)> {
let normal_width = geometry.area_size(normal_range);
let mut candidates = std::iter::once(0.0)
.chain(
occupied
.iter()
.flat_map(|lane| lane.iter().map(|interval| interval.end)),
)
.collect::<Vec<_>>();
candidates.sort_by(f32::total_cmp);
candidates.dedup_by(|a, b| (*a - *b).abs() < 0.01);
let mut best: Option<(std::ops::Range<usize>, f32)> = None;
for start in candidates {
if start + reserved_size > normal_start + 0.01 {
continue;
}
for range_start in 0..=occupied.len().saturating_sub(normal_range.len()) {
let range_end = range_start + normal_range.len();
let width = geometry.area_size(&(range_start..range_end));
if (width - normal_width).abs() > 0.01 {
continue;
}
let fits = occupied[range_start..range_end].iter().all(|lane| {
lane.iter().all(|interval| {
start + reserved_size <= interval.start + 0.01 || start >= interval.end - 0.01
})
});
if fits
&& best
.as_ref()
.is_none_or(|(_, best_start)| start < *best_start - tolerance)
{
best = Some((range_start..range_end, start));
}
}
}
best.filter(|(_, start)| *start + 0.01 < normal_start)
}
fn grid_lanes_margins(
style: &ComputedStyle,
percentage_basis: GridLanesPercentageBasis,
) -> GridLanesMargins {
let margin = style.box_values.margin.clone();
GridLanesMargins {
top: used_length_percentage_or_auto(margin.top, percentage_basis)
.unwrap_or_else(|| layout_pt(0.0)),
right: used_length_percentage_or_auto(margin.right, percentage_basis)
.unwrap_or_else(|| layout_pt(0.0)),
bottom: used_length_percentage_or_auto(margin.bottom, percentage_basis)
.unwrap_or_else(|| layout_pt(0.0)),
left: used_length_percentage_or_auto(margin.left, percentage_basis)
.unwrap_or_else(|| layout_pt(0.0)),
}
}
fn grid_lanes_content_inline_size(
child: &GridChild<'_>,
border_box_width: BorderBoxLength,
inline_percentage_basis: GridLanesPercentageBasis,
) -> ContentBoxLength {
border_box_to_content_box_length(
border_box_width,
grid_lanes_horizontal_non_content(&child.style, inline_percentage_basis),
)
}
fn grid_lanes_horizontal_non_content(
style: &ComputedStyle,
percentage_basis: GridLanesPercentageBasis,
) -> NonContentLength {
let padding = style.box_values.padding.clone();
non_content_pt(
used_length_percentage(padding.left, percentage_basis).points()
+ used_length_percentage(padding.right, percentage_basis).points()
+ used_border_widths(style).left
+ used_border_widths(style).right,
)
}
fn grid_lanes_vertical_non_content(
style: &ComputedStyle,
percentage_basis: GridLanesPercentageBasis,
) -> NonContentLength {
let padding = style.box_values.padding.clone();
non_content_pt(
used_length_percentage(padding.top, percentage_basis).points()
+ used_length_percentage(padding.bottom, percentage_basis).points()
+ used_border_widths(style).top
+ used_border_widths(style).bottom,
)
}
fn grid_lanes_flow_tolerance(
style: &ComputedStyle,
grid_axis_size: GridLanesPercentageBasis,
) -> f32 {
match &style.grid_lanes_flow_tolerance {
css::GridLanesFlowTolerance::Normal => style.font_size.max(0.0),
css::GridLanesFlowTolerance::LengthPercentage(value) => {
used_length_percentage(value.clone(), grid_axis_size).points()
}
css::GridLanesFlowTolerance::Infinite => f32::INFINITY,
}
}
#[derive(Debug, Clone)]
struct GridLanesSimpleTrackTemplate {
initial_track_sizes: Vec<f32>,
auto_tracks: Vec<bool>,
line_names: Vec<Vec<String>>,
}
impl GridLanesSimpleTrackTemplate {
fn track_count(&self) -> usize {
debug_assert_eq!(self.initial_track_sizes.len(), self.auto_tracks.len());
self.initial_track_sizes.len()
}
fn has_auto_tracks(&self) -> bool {
self.auto_tracks.iter().any(|&track| track)
}
}
fn grid_lanes_simple_track_template(
tracks: &css::GridTrackList,
areas: &css::GridTemplateAreas,
auto_tracks: &css::GridAutoTrackList,
axis: GridAxis,
percentage_basis: GridLanesPercentageBasis,
) -> Option<GridLanesSimpleTrackTemplate> {
let mut template = GridLanesSimpleTrackTemplate {
initial_track_sizes: Vec::new(),
auto_tracks: Vec::new(),
line_names: match tracks {
css::GridTrackList::Tracks { .. } => grid_lanes_explicit_line_names(tracks)?,
css::GridTrackList::None => vec![Vec::new()],
css::GridTrackList::Subgrid { .. } => return None,
},
};
if let css::GridTrackList::Tracks { components, .. } = tracks {
grid_lanes_collect_simple_tracks(components, percentage_basis, &mut template)?;
}
let authored_track_count = template.track_count();
let area_track_count = grid_template_area_track_count(areas, axis);
for index in authored_track_count..area_track_count {
let auto_track = auto_tracks
.get((index - authored_track_count) % auto_tracks.len())?
.clone();
grid_lanes_append_simple_track(auto_track, percentage_basis, &mut template)?;
}
template
.line_names
.resize_with(template.track_count().saturating_add(1), Vec::new);
add_generated_area_line_names(&mut template.line_names, areas, axis);
if template.initial_track_sizes.is_empty()
|| template.line_names.len() != template.track_count().saturating_add(1)
{
return None;
}
Some(template)
}
fn grid_lanes_collect_simple_tracks(
components: &[css::GridTrackListComponent],
percentage_basis: GridLanesPercentageBasis,
template: &mut GridLanesSimpleTrackTemplate,
) -> Option<()> {
for component in components {
match component {
css::GridTrackListComponent::Track(_, size) => {
grid_lanes_append_simple_track(size.clone(), percentage_basis, template)?;
}
css::GridTrackListComponent::Repeat(_, repeat) => {
let css::GridRepeatCount::Number(count) = repeat.count else {
return None;
};
for _ in 0..count {
grid_lanes_collect_simple_tracks(&repeat.tracks, percentage_basis, template)?;
}
}
}
}
Some(())
}
fn grid_lanes_append_simple_track(
size: css::GridTrackSize,
percentage_basis: GridLanesPercentageBasis,
template: &mut GridLanesSimpleTrackTemplate,
) -> Option<()> {
match (&size.min, &size.max) {
(css::GridMinTrackBreadth::Auto, css::GridMaxTrackBreadth::Auto) => {
template.initial_track_sizes.push(0.0);
template.auto_tracks.push(true);
}
_ => {
template
.initial_track_sizes
.push(grid_lanes_definite_track_size(size, percentage_basis)?);
template.auto_tracks.push(false);
}
}
Some(())
}
fn grid_lanes_definite_track_size(
size: css::GridTrackSize,
percentage_basis: GridLanesPercentageBasis,
) -> Option<f32> {
let css::GridMinTrackBreadth::LengthPercentage(min) = size.min else {
return None;
};
let css::GridMaxTrackBreadth::LengthPercentage(max) = size.max else {
return None;
};
let min = used_length_percentage_with_basis(min, percentage_basis)?.points();
let max = used_length_percentage_with_basis(max, percentage_basis)?.points();
((min - max).abs() < 0.01).then_some(min.max(0.0))
}
fn grid_lanes_simple_row_offsets(
template: &GridLanesSimpleTrackTemplate,
children: &[GridChild<'_>],
items: &[GridItemLayout],
inline_percentage_basis: GridLanesPercentageBasis,
grid_axis_gap: f32,
grid_axis_content_alignment: css::ContentAlignment,
grid_axis_size: f32,
) -> Option<GridLanesTrackGeometry> {
let row_count = template.track_count();
if row_count == 0 || !template.has_auto_tracks() || children.len() != items.len() {
return None;
}
if children
.iter()
.any(|child| child.style.display.inner == DisplayInner::Grid)
|| grid_lanes_has_out_of_range_explicit_placement(children, GridLanesAxis::Rows, row_count)
{
return None;
}
let mut track_sizes = template.initial_track_sizes.clone();
for (child, item) in children.iter().zip(items) {
let margins = grid_lanes_margins(&child.style, inline_percentage_basis);
let contribution = item.height() + margins.top.points() + margins.bottom.points();
let (start, end) = GridLanesAxis::Rows.placements(child);
let range =
grid_lanes_resolved_track_range(start, end, row_count, Some(&template.line_names));
let span = range.map_or_else(
|| grid_lanes_span(GridLanesAxis::Rows, child, row_count),
GridLanesTrackRange::span,
);
if span != 1 {
return None;
}
if let Some(range) = range {
if template.auto_tracks[range.start] {
track_sizes[range.start] = track_sizes[range.start].max(contribution);
}
} else {
for (size, &is_auto) in track_sizes.iter_mut().zip(&template.auto_tracks) {
if is_auto {
*size = size.max(contribution);
}
}
}
}
grid_lanes_simple_track_geometry(
&track_sizes,
&template.auto_tracks,
grid_axis_gap,
grid_axis_content_alignment,
grid_axis_size,
)
}
fn grid_lanes_simple_track_geometry(
track_sizes: &[f32],
auto_tracks: &[bool],
grid_axis_gap: f32,
content_alignment: css::ContentAlignment,
grid_axis_size: f32,
) -> Option<GridLanesTrackGeometry> {
GridLanesTrackGeometry::from_track_sizes(track_sizes, grid_axis_gap).map(|geometry| {
geometry
.with_auto_track_stretch(auto_tracks, content_alignment, grid_axis_size)
.with_content_alignment(content_alignment, grid_axis_size)
})
}
fn grid_lanes_has_out_of_range_explicit_placement(
children: &[GridChild<'_>],
axis: GridLanesAxis,
track_count: usize,
) -> bool {
let last_explicit_line = i32::try_from(track_count + 1).unwrap_or(i32::MAX);
children.iter().any(|child| {
let (start, end) = axis.placements(child);
[start, end].into_iter().any(|placement| {
matches!(placement, css::GridPlacement::Line(line) if line.name().is_none()
&& line.index().is_some_and(|index| index > last_explicit_line))
})
})
}
fn grid_lanes_span(axis: GridLanesAxis, child: &GridChild<'_>, lane_count: usize) -> usize {
let (start, end) = axis.placements(child);
match (start, end) {
(css::GridPlacement::Span(span), _) | (_, css::GridPlacement::Span(span)) => {
usize::from(span.count().unwrap_or(1))
}
(css::GridPlacement::Line(start), css::GridPlacement::Line(end))
if start.name().is_none() && end.name().is_none() =>
{
let start = start.index().expect("numeric grid line has an index");
let end = end.index().expect("numeric grid line has an index");
usize::try_from((end - start).unsigned_abs())
.unwrap_or(usize::MAX)
.max(1)
}
_ => 1,
}
.clamp(1, lane_count)
}
fn grid_lanes_item_area(axis: GridLanesAxis, range: &std::ops::Range<usize>) -> GridItemArea {
let start = u16::try_from(range.start.saturating_add(1)).unwrap_or(u16::MAX);
let end = u16::try_from(range.end.saturating_add(1)).unwrap_or(u16::MAX);
match axis {
GridLanesAxis::Columns => GridItemArea {
row_start: 1,
row_end: 2,
column_start: start,
column_end: end,
},
GridLanesAxis::Rows => GridItemArea {
row_start: start,
row_end: end,
column_start: 1,
column_end: 2,
},
}
}
fn grid_lanes_resolved_track_range(
start: &css::GridPlacement,
end: &css::GridPlacement,
lane_count: usize,
line_names: Option<&[Vec<String>]>,
) -> Option<GridLanesTrackRange> {
let start_line = grid_lanes_line(start, GridLanesLineEdge::Start, line_names, lane_count);
let end_line = grid_lanes_line(end, GridLanesLineEdge::End, line_names, lane_count);
let authored_span = |placement: &css::GridPlacement| match placement {
css::GridPlacement::Span(span) => usize::from(span.count().unwrap_or(1)),
_ => 1,
};
let range = match (start_line, end_line) {
(Some(start), Some(end)) => {
let (start, end) = if start > end {
(end, start)
} else {
(start, end)
};
GridLanesTrackRange::new(start, end.saturating_sub(start).max(1))?
}
(Some(start), None) => GridLanesTrackRange::new(start, authored_span(end))?,
(_, Some(end)) => {
let span = authored_span(start);
GridLanesTrackRange::new(end.checked_sub(span)?, span)?
}
_ => return None,
};
(range.end() <= lane_count).then_some(range)
}
fn grid_lanes_shortest_range(
lane_ends: &[f32],
active_tracks: &[bool],
span: usize,
cursor: usize,
tolerance: f32,
) -> std::ops::Range<usize> {
debug_assert_eq!(lane_ends.len(), active_tracks.len());
let mut best_end = f32::INFINITY;
for start in 0..=lane_ends.len().saturating_sub(span) {
if !active_tracks[start..start + span]
.iter()
.all(|&active| active)
{
continue;
}
let end = lane_ends[start..start + span]
.iter()
.cloned()
.fold(0.0_f32, f32::max);
best_end = best_end.min(end);
}
let mut first = None;
for start in 0..=lane_ends.len().saturating_sub(span) {
if !active_tracks[start..start + span]
.iter()
.all(|&active| active)
{
continue;
}
let end = lane_ends[start..start + span]
.iter()
.cloned()
.fold(0.0_f32, f32::max);
if end <= best_end + tolerance {
first.get_or_insert(start);
if start >= cursor {
return start..start + span;
}
}
}
let start =
first.unwrap_or_else(|| active_tracks.iter().position(|&active| active).unwrap_or(0));
start..start + span
}
fn grid_lanes_line(
placement: &css::GridPlacement,
edge: GridLanesLineEdge,
line_names: Option<&[Vec<String>]>,
lane_count: usize,
) -> Option<usize> {
if let Some(line_names) = line_names {
if let css::GridPlacement::Line(line) = placement
&& let Some(name) = line.name()
&& line.index().is_none()
{
let area_edge_name = format!(
"{name}-{}",
match edge {
GridLanesLineEdge::Start => "start",
GridLanesLineEdge::End => "end",
}
);
if let Some(line) = named_grid_line_index(line_names, &area_edge_name, 1) {
return usize::try_from(line - 1)
.ok()
.filter(|line| *line <= lane_count);
}
}
return grid_line_index(placement, line_names)
.and_then(|line| usize::try_from(line - 1).ok())
.filter(|line| *line <= lane_count);
}
let css::GridPlacement::Line(line) = placement else {
return None;
};
let index = line.index()?;
if index > 0 {
usize::try_from(index - 1)
.ok()
.filter(|index| *index <= lane_count)
} else {
let line_count = i32::try_from(lane_count + 1).ok()?;
usize::try_from(line_count + index)
.ok()
.filter(|index| *index <= lane_count)
}
}
fn grid_lanes_explicit_line_names(tracks: &css::GridTrackList) -> Option<Vec<Vec<String>>> {
let css::GridTrackList::Tracks {
components,
trailing_names,
} = tracks
else {
return None;
};
explicit_grid_line_names(components, trailing_names)
}
fn used_grid_lanes_gap(gap: css::ComputedGap, basis: GridLanesPercentageBasis) -> f32 {
match gap {
css::ComputedGap::Normal => 0.0,
css::ComputedGap::LengthPercentage(value) => used_length_percentage(value, basis).points(),
}
}
#[cfg(test)]
mod tests {
use super::*;
fn numeric_line(index: i32) -> css::GridPlacement {
css::GridPlacement::Line(css::GridLinePlacement::Number(
std::num::NonZeroI32::new(index).expect("test grid lines are non-zero"),
))
}
fn numeric_span(count: u16) -> css::GridPlacement {
css::GridPlacement::Span(css::GridSpanPlacement::Count(
std::num::NonZeroU16::new(count).expect("test spans are non-zero"),
))
}
fn resolved_range(
start: css::GridPlacement,
end: css::GridPlacement,
line_names: Option<&[Vec<String>]>,
) -> Option<GridLanesTrackRange> {
grid_lanes_resolved_track_range(&start, &end, 4, line_names)
}
#[test]
fn fixed_line_range_preserves_the_implicit_span_between_two_lines() {
assert_eq!(
resolved_range(numeric_line(2), numeric_line(5), None),
Some(GridLanesTrackRange::new(1, 3).unwrap())
);
}
#[test]
fn fixed_line_range_applies_grid_placement_conflict_handling() {
let expected = Some(GridLanesTrackRange::new(1, 3).unwrap());
assert_eq!(
resolved_range(numeric_line(5), numeric_line(2), None),
expected
);
assert_eq!(
resolved_range(numeric_line(3), numeric_line(3), None),
Some(GridLanesTrackRange::new(2, 1).unwrap())
);
assert_eq!(resolved_range(numeric_span(2), numeric_span(3), None), None);
}
#[test]
fn fixed_line_range_resolves_spans_and_negative_lines() {
assert_eq!(
resolved_range(numeric_line(2), numeric_span(2), None),
Some(GridLanesTrackRange::new(1, 2).unwrap())
);
assert_eq!(
resolved_range(numeric_span(2), numeric_line(5), None),
Some(GridLanesTrackRange::new(2, 2).unwrap())
);
assert_eq!(
resolved_range(numeric_line(-4), numeric_line(-1), None),
Some(GridLanesTrackRange::new(1, 3).unwrap())
);
}
#[test]
fn fixed_line_range_prefers_named_area_edges() {
let names = vec![
vec!["sidebar-start".to_string()],
Vec::new(),
vec!["sidebar-end".to_string()],
Vec::new(),
Vec::new(),
];
let named = |name: &str| {
css::GridPlacement::Line(css::GridLinePlacement::Named {
name: name.to_string(),
occurrence: None,
})
};
assert_eq!(
resolved_range(named("sidebar"), named("sidebar"), Some(&names)),
Some(GridLanesTrackRange::new(0, 2).unwrap())
);
}
#[test]
fn collapsed_auto_fit_track_merges_its_adjacent_gutters() {
let geometry = GridLanesTrackGeometry::from_track_sizes_with_active(
&[37.5, 37.5, 0.0, 37.5],
7.5,
&[true, true, false, true],
)
.expect("non-empty track list has geometry");
assert_eq!(
geometry.topology.line_offsets(),
vec![0.0, 45.0, 90.0, 90.0, 127.5]
);
assert_eq!(geometry.topology.track_sizes(), vec![37.5, 37.5, 0.0, 37.5]);
}
#[test]
fn topology_round_trip_retains_gutter_before_zero_sized_lane() {
let geometry = GridLanesTrackGeometry::from_track_sizes(&[100.0, 0.0], 20.0)
.expect("non-empty track list has geometry");
let topology = geometry.topology();
assert_eq!(topology.track_sizes(), vec![100.0, 0.0]);
assert_eq!(topology.interior_gutters(), vec![20.0]);
assert_eq!(topology.line_offsets(), vec![0.0, 120.0, 120.0]);
let round_trip = GridLanesTrackGeometry::from_grid_axis_topology(&topology)
.expect("canonical topology has lane geometry");
assert_eq!(round_trip.topology.line_offsets(), vec![0.0, 120.0, 120.0]);
assert_eq!(round_trip.topology.track_sizes(), vec![100.0, 0.0]);
}
#[test]
fn auto_fit_occupancy_collapses_only_repeated_tracks() {
for _axis in [GridLanesAxis::Columns, GridLanesAxis::Rows] {
let track = |source| GridLanesResolvedAutoRepeatTrack {
source,
used_size: GridLanesTrackBreadth::from_points(20.0),
auto_sized: true,
collapsed: false,
};
let mut resolution = GridLanesAutoRepeatResolution {
tracks: vec![
track(GridLanesAutoRepeatTrackSource::FixedPrefix),
track(GridLanesAutoRepeatTrackSource::Repeated {
repetition: 0,
slot: 0,
}),
track(GridLanesAutoRepeatTrackSource::Repeated {
repetition: 1,
slot: 0,
}),
track(GridLanesAutoRepeatTrackSource::ImplicitEnd),
],
explicit_line_count: 4,
line_names: vec![Vec::new(); 5],
repeat_range: 1..3,
gap: GridLanesGutterBreadth::from_points(0.0),
final_geometry: None,
};
resolution.collapse_unoccupied_repeated_tracks(&[true, true, false, true]);
assert_eq!(
resolution
.tracks
.iter()
.map(|track| track.collapsed)
.collect::<Vec<_>>(),
vec![false, false, true, false]
);
}
}
#[test]
fn frozen_auto_fit_geometry_preserves_active_coordinates_on_both_axes() {
for _axis in [GridLanesAxis::Columns, GridLanesAxis::Rows] {
let track = |source, collapsed| GridLanesResolvedAutoRepeatTrack {
source,
used_size: GridLanesTrackBreadth::from_points(0.0),
auto_sized: true,
collapsed,
};
let resolution = GridLanesAutoRepeatResolution {
tracks: vec![
track(
GridLanesAutoRepeatTrackSource::Repeated {
repetition: 0,
slot: 0,
},
false,
),
track(
GridLanesAutoRepeatTrackSource::Repeated {
repetition: 1,
slot: 0,
},
true,
),
track(
GridLanesAutoRepeatTrackSource::Repeated {
repetition: 2,
slot: 0,
},
false,
),
track(GridLanesAutoRepeatTrackSource::ImplicitEnd, false),
],
explicit_line_count: 4,
line_names: vec![Vec::new(); 5],
repeat_range: 0..3,
gap: GridLanesGutterBreadth::from_points(5.0),
final_geometry: None,
};
let active_geometry = GridLanesTrackGeometry::from_track_sizes_with_active(
&[20.0, 30.0, 40.0],
5.0,
&[true, true, true],
)
.expect("non-empty active topology has geometry");
let expanded = resolution
.expand_active_geometry(&active_geometry)
.expect("the active geometry maps back to the source topology");
assert_eq!(resolution.active_line(2), 1);
assert_eq!(resolution.active_line(4), 3);
assert_eq!(
expanded.topology.line_offsets(),
vec![0.0, 20.0, 25.0, 60.0, 100.0]
);
assert_eq!(expanded.topology.track_sizes(), vec![20.0, 0.0, 30.0, 40.0]);
assert_eq!(expanded.active_tracks(), vec![true, false, true, true]);
assert_eq!(
grid_lanes_shortest_range(
&[10.0, 0.0, 5.0, 0.0],
&expanded.active_tracks(),
1,
1,
0.0,
),
3..4
);
}
}
#[test]
fn intrinsic_auto_repeat_count_uses_the_css_pixel_counting_floor() {
let count = grid_lanes_intrinsic_auto_repeat_count(
GridLanesRepeatCountConstraint::DefinitePreferred(GridLanesTrackBreadth::from_points(
6.0,
)),
css::CSS_PX_TO_PT,
0.0,
);
assert_eq!(count, 8);
}
#[test]
fn intrinsic_auto_repeat_minimum_chooses_the_smallest_satisfying_count() {
let count = grid_lanes_intrinsic_auto_repeat_count(
GridLanesRepeatCountConstraint::DefiniteMinimum(GridLanesTrackBreadth::from_points(
95.0,
)),
20.0,
25.0,
);
assert_eq!(count, 4);
}
fn stacking_placement(
item_index: usize,
tracks: std::ops::Range<usize>,
margin_start: f32,
margin_end: f32,
) -> GridLanesStackingPlacement {
GridLanesStackingPlacement {
item_index,
tracks,
margin_start,
margin_end,
margin_start_size: 0.0,
margin_end_size: 0.0,
}
}
#[test]
fn stacking_alignment_uses_the_first_shared_successor() {
let placements = vec![
stacking_placement(0, 0..2, 0.0, 40.0),
stacking_placement(1, 2..3, 0.0, 80.0),
stacking_placement(2, 0..3, 90.0, 140.0),
stacking_placement(3, 1..2, 150.0, 180.0),
];
assert_eq!(
placements[0].following_margin_start(&placements),
Some(90.0)
);
assert_eq!(
placements[1].following_margin_start(&placements),
Some(90.0)
);
assert_eq!(
placements[2].following_margin_start(&placements),
Some(150.0)
);
}
#[test]
fn stacking_alignment_keeps_terminal_items_distinct() {
let placements = vec![
stacking_placement(0, 0..1, 0.0, 40.0),
stacking_placement(1, 1..2, 0.0, 80.0),
];
assert_eq!(placements[0].following_margin_start(&placements), None);
assert_eq!(placements[1].following_margin_start(&placements), None);
}
#[test]
fn stacking_range_excludes_the_terminal_gutter() {
let range = GridLanesStackingRange::from_lane_ends(&[150.0, 100.0], 10.0);
assert_eq!(range.end_points(), 140.0);
}
#[test]
fn empty_stacking_range_does_not_become_negative() {
let range = GridLanesStackingRange::from_lane_ends(&[], 10.0);
assert_eq!(range.end_points(), 0.0);
}
}