use super::*;
#[allow(dead_code)] #[derive(Debug, Clone, Copy)]
pub(in crate::layout) struct TableWrapperFlexSizing {
pub(in crate::layout) grid_min_content_inline: LogicalInlineContentSize,
pub(in crate::layout) grid_max_content_inline: TableMaxContentInline,
pub(in crate::layout) wrapper_preferred_inline: TableMaxContentInline,
pub(in crate::layout) wrapper_intrinsic_block: LogicalBlockContentSize,
pub(in crate::layout) inline_non_content: NonContentLength,
pub(in crate::layout) block_non_content: NonContentLength,
pub(in crate::layout) margins: css::Edges,
}
#[derive(Debug, Clone, Copy)]
pub(in crate::layout) enum TableMaxContentInline {
Finite(LogicalInlineContentSize),
Unbounded,
}
impl TableMaxContentInline {
pub(in crate::layout) fn from_table_measurement(value: f32) -> Self {
if value >= f32::MAX / 4.0 {
Self::Unbounded
} else {
Self::Finite(LogicalInlineContentSize::new(content_box_pt(
value.max(0.0),
)))
}
}
pub(in crate::layout) fn resolve_against(
self,
available: LogicalInlineContentSize,
) -> LogicalInlineContentSize {
match self {
Self::Finite(value) => value,
Self::Unbounded => available,
}
}
}
pub(in crate::layout) fn intrinsic_table_wrapper_block_probe_style(
style: &ComputedStyle,
) -> ComputedStyle {
let mut probe = style.clone();
probe
.box_values
.height
.replace_with_used(css::ComputedLengthPercentageOrAuto::Auto);
probe.box_values.min_height = css::ComputedLengthPercentageOrAuto::Auto;
probe
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub(in crate::layout) struct ResolvedTableWrapperInsets {
pub(in crate::layout) border_widths: css::Edges,
}
impl ResolvedTableWrapperInsets {
pub(in crate::layout) const ZERO: Self = Self {
border_widths: css::Edges::ZERO,
};
pub(in crate::layout) fn horizontal_non_content(self) -> NonContentLength {
non_content_pt(self.border_widths.left + self.border_widths.right)
}
pub(in crate::layout) fn vertical_non_content(self) -> NonContentLength {
non_content_pt(self.border_widths.top + self.border_widths.bottom)
}
}
#[derive(Debug, Clone, Copy)]
pub(in crate::layout::table) struct UsedTableWrapperGeometry {
pub(in crate::layout::table) grid_inline: LogicalInlineContentSize,
pub(in crate::layout::table) axes: TableAxes,
pub(in crate::layout::table) content_width: ContentBoxLength,
pub(in crate::layout::table) border_widths: css::Edges,
pub(in crate::layout::table) padding: css::Edges,
}
impl UsedTableWrapperGeometry {
pub(in crate::layout::table) fn set_grid_inline(
&mut self,
grid_inline: LogicalInlineContentSize,
) {
self.grid_inline = grid_inline;
self.content_width = grid_inline.content_box_length();
}
pub(in crate::layout::table) fn content_x(self, outer_x: f32) -> f32 {
outer_x + self.border_widths.left + self.padding.left
}
pub(in crate::layout::table) fn inline_non_content(self) -> NonContentLength {
if self.axes.flow.writing_mode().has_vertical_lines() {
non_content_pt(
self.border_widths.top
+ self.border_widths.bottom
+ self.padding.top
+ self.padding.bottom,
)
} else {
non_content_pt(
self.border_widths.left
+ self.border_widths.right
+ self.padding.left
+ self.padding.right,
)
}
}
pub(in crate::layout::table) fn block_non_content(self) -> NonContentLength {
if self.axes.flow.writing_mode().has_vertical_lines() {
non_content_pt(
self.border_widths.left
+ self.border_widths.right
+ self.padding.left
+ self.padding.right,
)
} else {
non_content_pt(
self.border_widths.top
+ self.border_widths.bottom
+ self.padding.top
+ self.padding.bottom,
)
}
}
}
pub(in crate::layout::table) type UsedTableWidth = UsedTableWrapperGeometry;
pub(in crate::layout::table) fn table_root_inline_size(
style: &ComputedStyle,
) -> css::ComputedLengthPercentageOrAuto {
if style.writing_mode.has_vertical_lines() {
style.box_values.height.value().clone()
} else {
style.box_values.width.clone()
}
}
pub(in crate::layout::table) fn table_root_distributes_extra_inline_space(
style: &ComputedStyle,
) -> bool {
if !table_root_inline_size(style).is_auto() {
return true;
}
let min_inline_size = table_root_min_inline_size(style);
match min_inline_size {
css::ComputedLengthPercentageOrAuto::LengthPercentage(value) => {
!value.length_is_zero() || value.percentage_coefficient_or_zero() != 0.0
}
css::ComputedLengthPercentageOrAuto::Auto => false,
css::ComputedLengthPercentageOrAuto::MinContent
| css::ComputedLengthPercentageOrAuto::MaxContent
| css::ComputedLengthPercentageOrAuto::FitContent(_)
| css::ComputedLengthPercentageOrAuto::Stretch
| css::ComputedLengthPercentageOrAuto::CalcSize(_) => true,
}
}
pub(in crate::layout::table) fn table_root_min_inline_size(
style: &ComputedStyle,
) -> css::ComputedLengthPercentageOrAuto {
if style.writing_mode.has_vertical_lines() {
style.box_values.min_height.clone()
} else {
style.box_values.min_width.clone()
}
}
pub(in crate::layout::table) fn table_root_max_inline_size(
style: &ComputedStyle,
) -> css::ComputedLengthPercentageOrAuto {
if style.writing_mode.has_vertical_lines() {
style.box_values.max_height.clone()
} else {
style.box_values.max_width.clone()
}
}
pub(in crate::layout::table) fn table_root_block_size(
style: &ComputedStyle,
) -> css::ComputedLengthPercentageOrAuto {
if style.writing_mode.has_vertical_lines() {
style.box_values.width.clone()
} else {
style.box_values.height.value().clone()
}
}
pub(in crate::layout::table) fn used_table_wrapper_geometry(
style: &ComputedStyle,
available_outer_inline: f32,
collapsed_outer_insets: Option<css::Edges>,
) -> UsedTableWrapperGeometry {
used_table_wrapper_geometry_with_percentage_basis(
style,
available_outer_inline,
collapsed_outer_insets,
PercentageBasis::definite(layout_pt(available_outer_inline)),
)
}
pub(in crate::layout::table) fn used_table_wrapper_geometry_with_percentage_basis(
style: &ComputedStyle,
available_outer_inline: f32,
collapsed_outer_insets: Option<css::Edges>,
percentage_basis: PercentageBasis<LayoutLength>,
) -> UsedTableWrapperGeometry {
let collapsed = style.border_collapse == css::BorderCollapse::Collapse;
let wrapper_insets = if collapsed {
ResolvedTableWrapperInsets {
border_widths: collapsed_outer_insets.unwrap_or(css::Edges::ZERO),
}
} else {
ResolvedTableWrapperInsets {
border_widths: used_border_widths(style),
}
};
let border_widths = wrapper_insets.border_widths;
let padding = if collapsed {
css::Edges::ZERO
} else {
used_padding_edges(style, percentage_basis).to_css_edges()
};
let geometry = UsedTableWrapperGeometry {
grid_inline: LogicalInlineContentSize::new(content_box_pt(0.0)),
axes: TableAxes::for_style(style),
content_width: content_box_pt(0.0),
border_widths,
padding,
};
let inline_non_content = geometry.inline_non_content();
let requested_inline = table_root_inline_content_box_size(
table_root_inline_size(style),
style.box_sizing,
percentage_basis.map_value(|basis| content_box_pt(basis.points())),
inline_non_content,
)
.unwrap_or_else(|| {
content_box_pt((available_outer_inline - inline_non_content.points()).max(0.0))
});
let grid_inline = constrain_table_root_inline_size(
style,
requested_inline,
percentage_basis.map_value(|basis| content_box_pt(basis.points())),
inline_non_content,
);
UsedTableWrapperGeometry {
grid_inline,
content_width: grid_inline.content_box_length(),
..geometry
}
}
pub(in crate::layout::table) fn used_table_width(
style: &ComputedStyle,
available_outer_inline: f32,
collapsed_outer_insets: Option<css::Edges>,
) -> UsedTableWrapperGeometry {
used_table_wrapper_geometry(style, available_outer_inline, collapsed_outer_insets)
}
pub(in crate::layout::table) fn used_empty_table_grid_inline_size(
style: &ComputedStyle,
available_outer_inline: f32,
table_geometry: UsedTableWrapperGeometry,
) -> ContentBoxLength {
let inline_non_content = table_geometry.inline_non_content();
let requested_inline = table_root_inline_content_box_size(
table_root_inline_size(style),
style.box_sizing,
PercentageBasis::definite(content_box_pt(available_outer_inline)),
inline_non_content,
)
.unwrap_or_else(|| content_box_pt(0.0));
constrain_table_root_inline_size(
style,
requested_inline,
PercentageBasis::definite(content_box_pt(available_outer_inline)),
inline_non_content,
)
.content_box_length()
}
pub(in crate::layout::table) fn table_root_inline_content_box_size<Source>(
value: css::ComputedLengthPercentageOrAuto,
box_sizing: BoxSizing,
percentage_basis: PercentageBasis<ContentBoxLength, Source>,
inline_non_content: NonContentLength,
) -> Option<ContentBoxLength> {
used_content_box_size(value, box_sizing, percentage_basis, inline_non_content)
}
pub(in crate::layout::table) fn constrain_table_root_inline_size<Source>(
style: &ComputedStyle,
value: ContentBoxLength,
percentage_basis: PercentageBasis<ContentBoxLength, Source>,
inline_non_content: NonContentLength,
) -> LogicalInlineContentSize {
let max_percentage_basis = match percentage_basis {
PercentageBasis::Definite { value, .. } => PercentageBasis::definite(value),
PercentageBasis::Indefinite => PercentageBasis::indefinite(),
};
let min = table_root_inline_content_box_size(
table_root_min_inline_size(style),
style.box_sizing,
max_percentage_basis,
inline_non_content,
);
let max = table_root_inline_content_box_size(
table_root_max_inline_size(style),
style.box_sizing,
percentage_basis,
inline_non_content,
);
let min = min.unwrap_or_else(|| content_box_pt(0.0));
let max = max.map(|max| max.max(min));
let constrained = value.max(min);
LogicalInlineContentSize::new(content_box_pt(
max.map_or(constrained, |maximum| constrained.min(maximum))
.points()
.max(0.0),
))
}
pub(in crate::layout::table) fn used_empty_table_grid_width(
style: &ComputedStyle,
available_outer_inline: f32,
table_geometry: UsedTableWrapperGeometry,
) -> ContentBoxLength {
used_empty_table_grid_inline_size(style, available_outer_inline, table_geometry)
}
pub(in crate::layout::table) fn used_empty_table_grid_height(
style: &ComputedStyle,
percentage_height_basis: BlockSizePercentageBasis,
table_width: UsedTableWidth,
wrapper_border_box_block_size: Option<BorderBoxLength>,
wrapper_non_grid_block_size: LayoutLength,
) -> ContentBoxLength {
let vertical_non_content = non_content_pt(
table_width.border_widths.top
+ table_width.border_widths.bottom
+ table_width.padding.top
+ table_width.padding.bottom,
);
if let Some(wrapper_border_box_block_size) = wrapper_border_box_block_size {
return content_box_pt(
(wrapper_border_box_block_size.points()
- vertical_non_content.points()
- wrapper_non_grid_block_size.points())
.max(0.0),
);
}
used_table_target_content_height(style, percentage_height_basis, vertical_non_content)
.unwrap_or_else(|| content_box_pt(0.0))
}
pub(in crate::layout::table) fn used_table_target_content_height(
style: &ComputedStyle,
percentage_height_basis: BlockSizePercentageBasis,
vertical_non_content: NonContentLength,
) -> Option<ContentBoxLength> {
let height = table_wrapper_size_to_grid_content_height(
table_root_block_size(style),
style.box_sizing,
percentage_height_basis,
vertical_non_content,
);
let min_height = table_wrapper_size_to_grid_content_height(
if style.writing_mode.has_vertical_lines() {
style.box_values.min_width.clone()
} else {
style.box_values.min_height.clone()
},
style.box_sizing,
percentage_height_basis,
vertical_non_content,
);
let max_height = table_wrapper_size_to_grid_content_height(
if style.writing_mode.has_vertical_lines() {
style.box_values.max_width.clone()
} else {
style.box_values.max_height.clone()
},
style.box_sizing,
percentage_height_basis,
vertical_non_content,
);
let mut target = height.or(min_height)?;
if let Some(max_height) = max_height {
target = target.min(max_height);
}
if let Some(min_height) = min_height {
target = target.max(min_height);
}
Some(target.max(content_box_pt(0.0)))
}
fn table_wrapper_size_to_grid_content_height(
value: css::ComputedLengthPercentageOrAuto,
box_sizing: BoxSizing,
percentage_basis: BlockSizePercentageBasis,
vertical_non_content: NonContentLength,
) -> Option<ContentBoxLength> {
let specified = used_length_percentage_or_auto_with_basis(value, percentage_basis)?;
Some(match box_sizing {
BoxSizing::BorderBox => border_box_to_content_box_length(
crate::units::layout_to_border_box_length(specified),
vertical_non_content,
),
BoxSizing::ContentBox => crate::units::layout_to_content_box_length(specified),
})
}