use super::*;
#[derive(Debug, Clone, Copy)]
pub(super) struct CommittedMulticolColumns(NonZeroUsize);
impl CommittedMulticolColumns {
pub(super) fn from_source_subject_count(count: usize) -> Self {
Self(NonZeroUsize::new(count.max(1)).expect("source subject count is nonzero"))
}
pub(super) fn from_temporary_column_pages(
temporary_page_count: usize,
trailing_column_was_never_entered: bool,
) -> Self {
let count = temporary_page_count
.saturating_sub(usize::from(trailing_column_was_never_entered))
.max(1);
Self(NonZeroUsize::new(count).expect("committed multicol column count is nonzero"))
}
pub(super) fn count(self) -> usize {
self.0.get()
}
}
#[derive(Debug, Clone, Copy)]
pub(super) struct CommittedMulticolFragmentPlan {
in_flow_columns: CommittedMulticolColumns,
physical_column_count: NonZeroUsize,
}
impl CommittedMulticolFragmentPlan {
pub(super) fn new(
in_flow_columns: CommittedMulticolColumns,
physical_column_count: usize,
) -> Self {
Self {
in_flow_columns,
physical_column_count: NonZeroUsize::new(physical_column_count.max(1))
.expect("committed multicol physical range is non-empty"),
}
}
pub(super) fn in_flow_columns(self) -> CommittedMulticolColumns {
self.in_flow_columns
}
pub(super) fn physical_column_count(self) -> usize {
self.physical_column_count.get()
}
}
#[derive(Debug, Clone, Copy)]
pub(super) struct CommittedMulticolRows {
columns: CommittedMulticolColumns,
columns_per_row: NonZeroUsize,
count: NonZeroUsize,
}
impl CommittedMulticolRows {
pub(super) fn new(columns: CommittedMulticolColumns, columns_per_row: NonZeroUsize) -> Self {
let count = columns.count().div_ceil(columns_per_row.get()).max(1);
Self {
columns,
columns_per_row,
count: NonZeroUsize::new(count).expect("committed multicol row count is nonzero"),
}
}
pub(super) fn row_count(self) -> usize {
self.count.get()
}
pub(super) fn plan(
self,
row: MulticolumnRowIndex,
row_gap: Option<f32>,
reverse_rule_order: bool,
) -> Option<CommittedMulticolRowPlan> {
let row_index = row.get();
(row_index < self.row_count()).then(|| {
let row_start = row_index * self.columns_per_row.get();
let occupied_columns = self
.columns
.count()
.saturating_sub(row_start)
.min(self.columns_per_row.get())
.max(1);
let boundary = if row_index + 1 == self.row_count() {
MulticolRowBoundary::Final
} else if let Some(gap) = row_gap {
let sequence = NonZeroUsize::new(self.row_count().saturating_sub(1))
.expect("a non-final committed row has a rule sequence");
let rule_index = if reverse_rule_order {
sequence.get().saturating_sub(1).saturating_sub(row_index)
} else {
row_index
};
let slot = GapRuleSlot::new(GapRuleIndex::new(rule_index), sequence)
.expect("committed row rule index is inside its sequence");
MulticolRowBoundary::FollowedBy { gap, slot }
} else {
MulticolRowBoundary::Final
};
CommittedMulticolRowPlan {
row,
occupied_columns,
boundary,
}
})
}
}
#[derive(Debug, Clone, Copy)]
pub(super) struct CommittedMulticolRowPlan {
pub(super) row: MulticolumnRowIndex,
pub(super) occupied_columns: usize,
pub(super) boundary: MulticolRowBoundary,
}
#[derive(Debug, Clone, Copy)]
pub(super) enum CommittedMulticolFlowEntry {
ColumnRow {
plan: CommittedMulticolRowPlan,
source_offset: MulticolRowBlockOffset,
nominal_block_size: UsedMulticolColumnBlockSize,
flow_consumed_block_size: UsedMulticolColumnBlockSize,
},
#[allow(
dead_code,
reason = "spanner commit is migrated after column-row placement"
)]
Spanner {
source_offset: MulticolRowBlockOffset,
used_block_size: LogicalBlockContentSize,
},
}
#[derive(Debug, Clone)]
pub(super) struct CommittedMulticolFlow {
entries: Vec<CommittedMulticolFlowEntry>,
block_extent: LayoutLength,
}
impl CommittedMulticolFlow {
pub(super) fn from_column_rows(
rows: CommittedMulticolRows,
used_block_size: UsedMulticolColumnBlockSize,
initial_row_used_block_size: Option<UsedMulticolColumnBlockSize>,
final_row_used_block_size: UsedMulticolColumnBlockSize,
row_gap: Option<f32>,
reverse_rule_order: bool,
) -> Self {
let gap = row_gap.unwrap_or(0.0).max(0.0);
let mut entries = Vec::with_capacity(rows.row_count());
let mut source_offset = layout_pt(0.0);
for row_index in 0..rows.row_count() {
let row = MulticolumnRowIndex::new(row_index);
let plan = rows
.plan(row, row_gap, reverse_rule_order)
.expect("a committed row index is inside its row sequence");
let nominal_block_size = if row_index == 0 {
initial_row_used_block_size.unwrap_or(used_block_size)
} else {
used_block_size
};
let flow_consumed_block_size = if row_index + 1 == rows.row_count() {
final_row_used_block_size
} else {
nominal_block_size
};
entries.push(CommittedMulticolFlowEntry::ColumnRow {
plan,
source_offset: MulticolRowBlockOffset::new(source_offset),
nominal_block_size,
flow_consumed_block_size,
});
if row_index + 1 == rows.row_count() {
source_offset += layout_pt(flow_consumed_block_size.points());
} else {
source_offset += layout_pt(nominal_block_size.points());
source_offset += layout_pt(gap);
}
}
Self {
entries,
block_extent: source_offset,
}
}
pub(super) fn block_extent(&self) -> LayoutLength {
self.block_extent
}
pub(super) fn row_plan(&self, row: MulticolumnRowIndex) -> Option<CommittedMulticolRowPlan> {
self.entries.iter().find_map(|entry| match entry {
CommittedMulticolFlowEntry::ColumnRow { plan, .. } if plan.row == row => Some(*plan),
CommittedMulticolFlowEntry::ColumnRow { .. }
| CommittedMulticolFlowEntry::Spanner { .. } => None,
})
}
pub(super) fn row_geometry(
&self,
row: MulticolumnRowIndex,
) -> Option<(MulticolRowBlockOffset, UsedMulticolColumnBlockSize)> {
self.entries.iter().find_map(|entry| match entry {
CommittedMulticolFlowEntry::ColumnRow {
plan,
source_offset,
nominal_block_size,
..
} if plan.row == row => Some((*source_offset, *nominal_block_size)),
CommittedMulticolFlowEntry::ColumnRow { .. }
| CommittedMulticolFlowEntry::Spanner { .. } => None,
})
}
pub(super) fn row_flow_consumed_block_size(
&self,
row: MulticolumnRowIndex,
) -> Option<UsedMulticolColumnBlockSize> {
self.entries.iter().find_map(|entry| match entry {
CommittedMulticolFlowEntry::ColumnRow {
plan,
flow_consumed_block_size,
..
} if plan.row == row => Some(*flow_consumed_block_size),
CommittedMulticolFlowEntry::ColumnRow { .. }
| CommittedMulticolFlowEntry::Spanner { .. } => None,
})
}
#[cfg(test)]
fn entries(&self) -> &[CommittedMulticolFlowEntry] {
&self.entries
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub(super) struct UsedMulticolColumnBlockSize(LogicalBlockContentSize);
impl UsedMulticolColumnBlockSize {
pub(super) fn new(value: LogicalBlockContentSize) -> Self {
debug_assert!(
value.points() >= 0.0,
"a used CSS block size is non-negative"
);
Self(LogicalBlockContentSize::new(content_box_pt(
value.points().max(0.0),
)))
}
pub(super) fn from_points(value: f32) -> Self {
Self::new(LogicalBlockContentSize::new(content_box_pt(value.max(0.0))))
}
pub(super) fn points(self) -> f32 {
self.0.points()
}
pub(super) fn logical_size(self) -> LogicalBlockContentSize {
self.0
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub(super) struct FragmentationProgressCapacity(LayoutLength);
impl FragmentationProgressCapacity {
pub(super) fn for_used_column(size: UsedMulticolColumnBlockSize) -> Self {
let capacity = layout_pt(size.logical_size().points().max(css::CSS_PX_TO_PT));
debug_assert!(capacity.points() > 0.0);
Self(capacity)
}
pub(super) fn layout_length(self) -> LayoutLength {
self.0
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub(super) struct MulticolRowBlockOffset(LayoutLength);
impl MulticolRowBlockOffset {
#[allow(dead_code, reason = "used by the staged committed-row planner")]
pub(super) fn new(value: LayoutLength) -> Self {
debug_assert!(
value.points() >= 0.0,
"a row offset is source-local and non-negative"
);
Self(layout_pt(value.points().max(0.0)))
}
#[allow(dead_code, reason = "used by the staged committed-row planner")]
pub(super) fn layout_length(self) -> LayoutLength {
self.0
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn zero_used_column_size_has_positive_progress_capacity() {
let used = UsedMulticolColumnBlockSize::from_points(0.0);
let progress = FragmentationProgressCapacity::for_used_column(used);
assert_eq!(used.points(), 0.0);
assert_eq!(progress.layout_length().points(), css::CSS_PX_TO_PT);
}
#[test]
fn positive_used_column_size_is_its_progress_capacity() {
let used = UsedMulticolColumnBlockSize::from_points(24.0);
let progress = FragmentationProgressCapacity::for_used_column(used);
assert_eq!(used.points(), 24.0);
assert_eq!(progress.layout_length().points(), 24.0);
assert_eq!(progress.layout_length(), layout_pt(24.0));
assert_eq!(used.logical_size().points(), 24.0);
}
#[test]
fn parallel_fragment_spans_do_not_create_in_flow_rows() {
let plan = CommittedMulticolFragmentPlan::new(
CommittedMulticolColumns::from_temporary_column_pages(1, false),
3,
);
let rows =
CommittedMulticolRows::new(plan.in_flow_columns(), NonZeroUsize::new(2).unwrap());
assert_eq!(plan.physical_column_count(), 3);
assert_eq!(rows.row_count(), 1);
}
#[test]
fn committed_zero_height_rows_advance_only_by_row_gap() {
let rows = CommittedMulticolRows::new(
CommittedMulticolColumns::from_temporary_column_pages(6, false),
NonZeroUsize::new(2).unwrap(),
);
let flow = CommittedMulticolFlow::from_column_rows(
rows,
UsedMulticolColumnBlockSize::from_points(0.0),
None,
UsedMulticolColumnBlockSize::from_points(0.0),
Some(20.0),
false,
);
assert_eq!(flow.block_extent(), layout_pt(40.0));
assert_eq!(flow.entries().len(), 3);
let offsets = flow
.entries()
.iter()
.map(|entry| match entry {
CommittedMulticolFlowEntry::ColumnRow { source_offset, .. } => {
source_offset.layout_length()
}
CommittedMulticolFlowEntry::Spanner { .. } => unreachable!(),
})
.collect::<Vec<_>>();
assert_eq!(
offsets,
vec![layout_pt(0.0), layout_pt(20.0), layout_pt(40.0)]
);
}
#[test]
fn committed_flow_separates_nominal_and_consumed_final_extents() {
let rows = CommittedMulticolRows::new(
CommittedMulticolColumns::from_source_subject_count(6),
NonZeroUsize::new(2).unwrap(),
);
let flow = CommittedMulticolFlow::from_column_rows(
rows,
UsedMulticolColumnBlockSize::from_points(20.0),
Some(UsedMulticolColumnBlockSize::from_points(5.0)),
UsedMulticolColumnBlockSize::from_points(10.0),
Some(10.0),
false,
);
assert_eq!(flow.block_extent(), layout_pt(55.0));
assert_eq!(
flow.row_geometry(MulticolumnRowIndex::new(0))
.unwrap()
.1
.points(),
5.0
);
assert_eq!(
flow.row_geometry(MulticolumnRowIndex::new(2))
.unwrap()
.1
.points(),
20.0
);
assert_eq!(
flow.row_flow_consumed_block_size(MulticolumnRowIndex::new(2))
.unwrap()
.points(),
10.0
);
}
}