Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-06 06:00:15 +01:00
Code Issues Projects Releases Packages Wiki Activity

layout: Make table column constraint distribution more generic (#35042)

Browse source 
This will be useful for distributing colspan constraints to their
columns

Signed-off-by: Martin Robinson <mrobinson@igalia.com>
Co-authored-by: Oriol Brufau <obrufau@igalia.com>
This commit is contained in:
Martin Robinson 2025-01-18 15:54:38 +01:00 • committed by GitHub
parent efd126f27d
commit 17b70c5178
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
1 changed files with 57 additions and 59 deletions
Download patch file Download diff file Expand all files Collapse all files

116
components/layout_2020/table/layout.rs
View file

@ -109,6 +109,8 @@ struct RowLayout {
struct ColumnLayout { struct ColumnLayout {
constrained: bool, constrained: bool,
has_originating_cells: bool, has_originating_cells: bool,
content_sizes: ContentSizes,
percentage: Percentage,
} }
/// A calculated collapsed border. /// A calculated collapsed border.
@ -213,7 +215,6 @@ pub(crate) struct TableLayout<'a> {
/// width that we will be able to allocate to the columns. /// width that we will be able to allocate to the columns.
assignable_width: Au, assignable_width: Au,
final_table_height: Au, final_table_height: Au,
column_measures: Vec<CellOrTrackMeasure>,
distributed_column_widths: Vec<Au>, distributed_column_widths: Vec<Au>,
row_sizes: Vec<Au>, row_sizes: Vec<Au>,
/// The accumulated baseline of each row, relative to the top of the row. /// The accumulated baseline of each row, relative to the top of the row.
@ -254,7 +255,6 @@ impl<'a> TableLayout<'a> {
table_width: Au::zero(), table_width: Au::zero(),
assignable_width: Au::zero(), assignable_width: Au::zero(),
final_table_height: Au::zero(), final_table_height: Au::zero(),
column_measures: Vec::new(),
distributed_column_widths: Vec::new(), distributed_column_widths: Vec::new(),
row_sizes: Vec::new(), row_sizes: Vec::new(),
row_baselines: Vec::new(), row_baselines: Vec::new(),
@ -463,8 +463,6 @@ impl<'a> TableLayout<'a> {
/// This is an implementation of *Computing Column Measures* from /// This is an implementation of *Computing Column Measures* from
/// <https://drafts.csswg.org/css-tables/#computing-column-measures>. /// <https://drafts.csswg.org/css-tables/#computing-column-measures>.
fn compute_column_measures(&mut self, writing_mode: WritingMode) { fn compute_column_measures(&mut self, writing_mode: WritingMode) {
let mut column_measures = Vec::new();
// Compute the column measures only taking into account cells with colspan == 1. // Compute the column measures only taking into account cells with colspan == 1.
// This is the base case that will be used to iteratively account for cells with // This is the base case that will be used to iteratively account for cells with
// larger colspans afterward. // larger colspans afterward.
@ -497,9 +495,13 @@ impl<'a> TableLayout<'a> {
// TODO: Take into account changes to this computation for fixed table layout. // TODO: Take into account changes to this computation for fixed table layout.
let mut next_span_n = usize::MAX; let mut next_span_n = usize::MAX;
for column_index in 0..self.table.size.width { for column_index in 0..self.table.size.width {
let mut column_measure = self let column = &mut self.columns[column_index];
let column_measure = self
.table .table
.get_column_measure_for_column_at_index(writing_mode, column_index); .get_column_measure_for_column_at_index(writing_mode, column_index);
column.content_sizes = column_measure.content_sizes;
column.percentage = column_measure.percentage;
for row_index in 0..self.table.size.height { for row_index in 0..self.table.size.height {
let coords = TableSlotCoordinates::new(column_index, row_index); let coords = TableSlotCoordinates::new(column_index, row_index);
@ -515,22 +517,18 @@ impl<'a> TableLayout<'a> {
// This takes the max of `min_content`, `max_content`, and // This takes the max of `min_content`, `max_content`, and
// intrinsic percentage width as described above. // intrinsic percentage width as described above.
let cell_measure = &self.cell_measures[row_index][column_index].inline; let cell_measure = &self.cell_measures[row_index][column_index].inline;
column_measure column.content_sizes.max_assign(cell_measure.content_sizes);
.content_sizes column.percentage =
.max_assign(cell_measure.content_sizes);
column_measure.percentage =
Percentage(column_measure.percentage.0.max(cell_measure.percentage.0)); Percentage(column_measure.percentage.0.max(cell_measure.percentage.0));
} }
column_measures.push(column_measure);
} }
// Now we have the base computation complete, so iteratively take into account cells // Now we have the base computation complete, so iteratively take into account cells
// with higher colspan. Using `next_span_n` we can skip over span counts that don't // with higher colspan. Using `next_span_n` we can skip over span counts that don't
// correspond to any cells. // correspond to any cells.
while next_span_n < usize::MAX { while next_span_n < usize::MAX {
(next_span_n, column_measures) = self (next_span_n, self.columns) =
.compute_content_sizes_for_columns_with_span_up_to_n(next_span_n, &column_measures); self.compute_content_sizes_for_columns_with_span_up_to_n(next_span_n);
} }
// > intrinsic percentage width of a column: // > intrinsic percentage width of a column:
@ -540,31 +538,28 @@ impl<'a> TableLayout<'a> {
// > * 100% minus the sum of the intrinsic percentage width of all prior columns in // > * 100% minus the sum of the intrinsic percentage width of all prior columns in
// > the table (further left when direction is "ltr" (right for "rtl")) // > the table (further left when direction is "ltr" (right for "rtl"))
let mut total_intrinsic_percentage_width = 0.; let mut total_intrinsic_percentage_width = 0.;
for column_measure in column_measures.iter_mut() { for column in self.columns.iter_mut() {
let final_intrinsic_percentage_width = column_measure let final_intrinsic_percentage_width = column
.percentage .percentage
.0 .0
.min(1. - total_intrinsic_percentage_width); .min(1. - total_intrinsic_percentage_width);
total_intrinsic_percentage_width += final_intrinsic_percentage_width; total_intrinsic_percentage_width += final_intrinsic_percentage_width;
column_measure.percentage = Percentage(final_intrinsic_percentage_width); column.percentage = Percentage(final_intrinsic_percentage_width);
} }
self.column_measures = column_measures;
} }
fn compute_content_sizes_for_columns_with_span_up_to_n( fn compute_content_sizes_for_columns_with_span_up_to_n(
&self, &self,
n: usize, n: usize,
old_column_measures: &[CellOrTrackMeasure], ) -> (usize, Vec<ColumnLayout>) {
) -> (usize, Vec<CellOrTrackMeasure>) {
let mut next_span_n = usize::MAX; let mut next_span_n = usize::MAX;
let mut new_content_sizes_for_columns = Vec::new(); let mut new_columns = Vec::new();
let border_spacing = self.table.border_spacing(); let border_spacing = self.table.border_spacing();
for column_index in 0..self.table.size.width { for column_index in 0..self.table.size.width {
let old_column_measure = &old_column_measures[column_index]; let old_column = &self.columns[column_index];
let mut new_column_content_sizes = old_column_measure.content_sizes; let mut new_column_content_sizes = old_column.content_sizes;
let mut new_column_intrinsic_percentage_width = old_column_measure.percentage; let mut new_column_intrinsic_percentage_width = old_column.percentage;
for row_index in 0..self.table.size.height { for row_index in 0..self.table.size.height {
let coords = TableSlotCoordinates::new(column_index, row_index); let coords = TableSlotCoordinates::new(column_index, row_index);
@ -590,11 +585,11 @@ impl<'a> TableLayout<'a> {
let baseline_content_sizes: ContentSizes = columns_spanned.clone().fold( let baseline_content_sizes: ContentSizes = columns_spanned.clone().fold(
ContentSizes::zero(), ContentSizes::zero(),
|total: ContentSizes, spanned_column_index| { |total: ContentSizes, spanned_column_index| {
total + old_column_measures[spanned_column_index].content_sizes total + self.columns[spanned_column_index].content_sizes
}, },
); );
let old_column_content_size = old_column_measure.content_sizes; let old_column_content_size = old_column.content_sizes;
// > **min-content width of a column based on cells of span up to N (N > 1)** // > **min-content width of a column based on cells of span up to N (N > 1)**
// > // >
@ -714,7 +709,7 @@ impl<'a> TableLayout<'a> {
// > Otherwise, it is the largest of the contributions of the cells in the column // > Otherwise, it is the largest of the contributions of the cells in the column
// > whose colSpan is N, where the contribution of a cell is the result of taking // > whose colSpan is N, where the contribution of a cell is the result of taking
// > the following steps: // > the following steps:
if old_column_measure.percentage.0 <= 0. && cell_measures.percentage.0 != 0. { if old_column.percentage.0 <= 0. && cell_measures.percentage.0 != 0. {
// > 1. Start with the percentage contribution of the cell. // > 1. Start with the percentage contribution of the cell.
// > 2. Subtract the intrinsic percentage width of the column based on cells // > 2. Subtract the intrinsic percentage width of the column based on cells
// > of span up to N-1 of all columns that the cell spans. If this gives a // > of span up to N-1 of all columns that the cell spans. If this gives a
@ -723,7 +718,7 @@ impl<'a> TableLayout<'a> {
let other_column_percentages_sum = let other_column_percentages_sum =
(columns_spanned).fold(0., |sum, spanned_column_index| { (columns_spanned).fold(0., |sum, spanned_column_index| {
let spanned_column_percentage = let spanned_column_percentage =
old_column_measures[spanned_column_index].percentage; self.columns[spanned_column_index].percentage;
if spanned_column_percentage.0 == 0. { if spanned_column_percentage.0 == 0. {
spanned_columns_with_zero += 1; spanned_columns_with_zero += 1;
} }
@ -748,12 +743,12 @@ impl<'a> TableLayout<'a> {
Percentage(new_column_intrinsic_percentage_width.0.max(step_3)); Percentage(new_column_intrinsic_percentage_width.0.max(step_3));
} }
} }
new_content_sizes_for_columns.push(CellOrTrackMeasure { let mut new_column = old_column.clone();
content_sizes: new_column_content_sizes, new_column.content_sizes = new_column_content_sizes;
percentage: new_column_intrinsic_percentage_width, new_column.percentage = new_column_intrinsic_percentage_width;
}); new_columns.push(new_column);
} }
(next_span_n, new_content_sizes_for_columns) (next_span_n, new_columns)
} }
/// Compute the GRIDMIN and GRIDMAX. /// Compute the GRIDMIN and GRIDMAX.
@ -774,7 +769,7 @@ impl<'a> TableLayout<'a> {
// > The row/column-grid width maximum (GRIDMAX) width is the sum of the max-content width of // > The row/column-grid width maximum (GRIDMAX) width is the sum of the max-content width of
// > all the columns plus cell spacing or borders. // > all the columns plus cell spacing or borders.
let mut grid_min_max = self let mut grid_min_max = self
.column_measures .columns
.iter() .iter()
.fold(ContentSizes::zero(), |result, measure| { .fold(ContentSizes::zero(), |result, measure| {
result + measure.content_sizes result + measure.content_sizes
@ -852,7 +847,11 @@ impl<'a> TableLayout<'a> {
/// Distribute width to columns, performing step 2.4 of table layout from /// Distribute width to columns, performing step 2.4 of table layout from
/// <https://drafts.csswg.org/css-tables/#table-layout-algorithm>. /// <https://drafts.csswg.org/css-tables/#table-layout-algorithm>.
fn distribute_width_to_columns(&self) -> Vec<Au> { fn distribute_width_to_columns(
&self,
target_inline_size: Au,
columns: &[ColumnLayout],
) -> Vec<Au> {
// No need to do anything if there is no column. // No need to do anything if there is no column.
// Note that tables without rows may still have columns. // Note that tables without rows may still have columns.
if self.table.size.width.is_zero() { if self.table.size.width.is_zero() {
@ -892,18 +891,17 @@ impl<'a> TableLayout<'a> {
let mut min_content_specified_sizing_guesses = Vec::new(); let mut min_content_specified_sizing_guesses = Vec::new();
let mut max_content_sizing_guesses = Vec::new(); let mut max_content_sizing_guesses = Vec::new();
for column_idx in 0..self.table.size.width { for column in columns {
let column_measure = &self.column_measures[column_idx]; let min_content_width = column.content_sizes.min_content;
let min_content_width = column_measure.content_sizes.min_content; let max_content_width = column.content_sizes.max_content;
let max_content_width = column_measure.content_sizes.max_content; let constrained = column.constrained;
let constrained = self.columns[column_idx].constrained;
let ( let (
min_content_percentage_sizing_guess, min_content_percentage_sizing_guess,
min_content_specified_sizing_guess, min_content_specified_sizing_guess,
max_content_sizing_guess, max_content_sizing_guess,
) = if !column_measure.percentage.is_zero() { ) = if !column.percentage.is_zero() {
let resolved = self.assignable_width.scale_by(column_measure.percentage.0); let resolved = target_inline_size.scale_by(column.percentage.0);
let percent_guess = min_content_width.max(resolved); let percent_guess = min_content_width.max(resolved);
(percent_guess, percent_guess, percent_guess) (percent_guess, percent_guess, percent_guess)
} else if constrained { } else if constrained {
@ -930,7 +928,7 @@ impl<'a> TableLayout<'a> {
} }
let max_content_sizing_sum = sum(&max_content_sizing_guesses); let max_content_sizing_sum = sum(&max_content_sizing_guesses);
if self.assignable_width >= max_content_sizing_sum { if target_inline_size >= max_content_sizing_sum {
self.distribute_extra_width_to_columns( self.distribute_extra_width_to_columns(
&mut max_content_sizing_guesses, &mut max_content_sizing_guesses,
max_content_sizing_sum, max_content_sizing_sum,
@ -938,27 +936,26 @@ impl<'a> TableLayout<'a> {
return max_content_sizing_guesses; return max_content_sizing_guesses;
} }
let min_content_specified_sizing_sum = sum(&min_content_specified_sizing_guesses); let min_content_specified_sizing_sum = sum(&min_content_specified_sizing_guesses);
if self.assignable_width == min_content_specified_sizing_sum { if target_inline_size == min_content_specified_sizing_sum {
return min_content_specified_sizing_guesses; return min_content_specified_sizing_guesses;
} }
let min_content_percentage_sizing_sum = sum(&min_content_percentage_sizing_guesses); let min_content_percentage_sizing_sum = sum(&min_content_percentage_sizing_guesses);
if self.assignable_width == min_content_percentage_sizing_sum { if target_inline_size == min_content_percentage_sizing_sum {
return min_content_percentage_sizing_guesses; return min_content_percentage_sizing_guesses;
} }
let min_content_sizes_sum = sum(&min_content_sizing_guesses); let min_content_sizes_sum = sum(&min_content_sizing_guesses);
if self.assignable_width <= min_content_sizes_sum { if target_inline_size <= min_content_sizes_sum {
return min_content_sizing_guesses; return min_content_sizing_guesses;
} }
let bounds = |sum_a, sum_b| self.assignable_width > sum_a && self.assignable_width < sum_b; let bounds = |sum_a, sum_b| target_inline_size > sum_a && target_inline_size < sum_b;
let blend = |a: &[Au], sum_a: Au, b: &[Au], sum_b: Au| { let blend = |a: &[Au], sum_a: Au, b: &[Au], sum_b: Au| {
// First convert the Au units to f32 in order to do floating point division. // First convert the Au units to f32 in order to do floating point division.
let weight_a = let weight_a = (target_inline_size - sum_b).to_f32_px() / (sum_a - sum_b).to_f32_px();
(self.assignable_width - sum_b).to_f32_px() / (sum_a - sum_b).to_f32_px();
let weight_b = 1.0 - weight_a; let weight_b = 1.0 - weight_a;
let mut remaining_assignable_width = self.assignable_width; let mut remaining_assignable_width = target_inline_size;
let mut widths: Vec<Au> = a let mut widths: Vec<Au> = a
.iter() .iter()
.zip(b.iter()) .zip(b.iter())
@ -990,7 +987,7 @@ impl<'a> TableLayout<'a> {
widths[0] += remaining_assignable_width; widths[0] += remaining_assignable_width;
} }
debug_assert!(widths.iter().sum::<Au>() == self.assignable_width); debug_assert!(widths.iter().sum::<Au>() == target_inline_size);
widths widths
}; };
@ -1039,17 +1036,17 @@ impl<'a> TableLayout<'a> {
let is_constrained = |column_index: &usize| self.columns[*column_index].constrained; let is_constrained = |column_index: &usize| self.columns[*column_index].constrained;
let is_unconstrained = |column_index: &usize| !is_constrained(column_index); let is_unconstrained = |column_index: &usize| !is_constrained(column_index);
let has_percent_greater_than_zero = let has_percent_greater_than_zero =
|column_index: &usize| self.column_measures[*column_index].percentage.0 > 0.; |column_index: &usize| self.columns[*column_index].percentage.0 > 0.;
let has_percent_zero = |column_index: &usize| !has_percent_greater_than_zero(column_index); let has_percent_zero = |column_index: &usize| !has_percent_greater_than_zero(column_index);
let has_max_content = |column_index: &usize| { let has_max_content = |column_index: &usize| {
!self.column_measures[*column_index] !self.columns[*column_index]
.content_sizes .content_sizes
.max_content .max_content
.is_zero() .is_zero()
}; };
let max_content_sum = let max_content_sum =
|column_index: usize| self.column_measures[column_index].content_sizes.max_content; |column_index: usize| self.columns[column_index].content_sizes.max_content;
// > If there are non-constrained columns that have originating cells with intrinsic // > If there are non-constrained columns that have originating cells with intrinsic
// > percentage width of 0% and with nonzero max-content width (aka the columns allowed to // > percentage width of 0% and with nonzero max-content width (aka the columns allowed to
@ -1069,7 +1066,7 @@ impl<'a> TableLayout<'a> {
if total_max_content_width != Au::zero() { if total_max_content_width != Au::zero() {
for column_index in unconstrained_max_content_columns { for column_index in unconstrained_max_content_columns {
column_sizes[column_index] += extra_inline_size.scale_by( column_sizes[column_index] += extra_inline_size.scale_by(
self.column_measures[column_index] self.columns[column_index]
.content_sizes .content_sizes
.max_content .max_content
.to_f32_px() / .to_f32_px() /
@ -1117,7 +1114,7 @@ impl<'a> TableLayout<'a> {
if total_max_content_width != Au::zero() { if total_max_content_width != Au::zero() {
for column_index in constrained_max_content_columns { for column_index in constrained_max_content_columns {
column_sizes[column_index] += extra_inline_size.scale_by( column_sizes[column_index] += extra_inline_size.scale_by(
self.column_measures[column_index] self.columns[column_index]
.content_sizes .content_sizes
.max_content .max_content
.to_f32_px() / .to_f32_px() /
@ -1135,12 +1132,12 @@ impl<'a> TableLayout<'a> {
let columns_with_percentage = all_columns.clone().filter(has_percent_greater_than_zero); let columns_with_percentage = all_columns.clone().filter(has_percent_greater_than_zero);
let total_percent = columns_with_percentage let total_percent = columns_with_percentage
.clone() .clone()
.map(|column_index| self.column_measures[column_index].percentage.0) .map(|column_index| self.columns[column_index].percentage.0)
.sum::<f32>(); .sum::<f32>();
if total_percent > 0. { if total_percent > 0. {
for column_index in columns_with_percentage { for column_index in columns_with_percentage {
column_sizes[column_index] += extra_inline_size column_sizes[column_index] += extra_inline_size
.scale_by(self.column_measures[column_index].percentage.0 / total_percent); .scale_by(self.columns[column_index].percentage.0 / total_percent);
} }
return; return;
} }
@ -1856,7 +1853,8 @@ impl<'a> TableLayout<'a> {
containing_block_for_logical_conversion: &ContainingBlock, containing_block_for_logical_conversion: &ContainingBlock,
containing_block_for_children: &ContainingBlock, containing_block_for_children: &ContainingBlock,
) -> BoxFragment { ) -> BoxFragment {
self.distributed_column_widths = self.distribute_width_to_columns(); self.distributed_column_widths =
self.distribute_width_to_columns(self.assignable_width, &self.columns);
self.layout_cells_in_row( self.layout_cells_in_row(
layout_context, layout_context,
containing_block_for_children, containing_block_for_children,