diff options
Diffstat (limited to 'crates/typst-layout/src')
| -rw-r--r-- | crates/typst-layout/src/grid/cells.rs | 1349 | ||||
| -rw-r--r-- | crates/typst-layout/src/grid/layouter.rs | 18 | ||||
| -rw-r--r-- | crates/typst-layout/src/grid/lines.rs | 38 | ||||
| -rw-r--r-- | crates/typst-layout/src/grid/mod.rs | 410 | ||||
| -rw-r--r-- | crates/typst-layout/src/grid/repeated.rs | 41 | ||||
| -rw-r--r-- | crates/typst-layout/src/grid/rowspans.rs | 6 | ||||
| -rw-r--r-- | crates/typst-layout/src/lists.rs | 3 |
7 files changed, 50 insertions, 1815 deletions
diff --git a/crates/typst-layout/src/grid/cells.rs b/crates/typst-layout/src/grid/cells.rs deleted file mode 100644 index 175e2183..00000000 --- a/crates/typst-layout/src/grid/cells.rs +++ /dev/null @@ -1,1349 +0,0 @@ -use std::num::NonZeroUsize; -use std::sync::Arc; - -use ecow::eco_format; -use typst_library::diag::{bail, At, Hint, HintedStrResult, HintedString, SourceResult}; -use typst_library::engine::Engine; -use typst_library::foundations::{Content, Smart, StyleChain}; -use typst_library::introspection::Locator; -use typst_library::layout::{ - Abs, Alignment, Axes, Celled, Fragment, Length, Regions, Rel, ResolvedCelled, Sides, - Sizing, -}; -use typst_library::visualize::{Paint, Stroke}; -use typst_syntax::Span; -use typst_utils::NonZeroExt; - -use super::{Footer, Header, Line, Repeatable}; - -/// Used for cell-like elements which are aware of their final properties in -/// the table, and may have property overrides. -pub trait ResolvableCell { - /// Resolves the cell's fields, given its coordinates and default grid-wide - /// fill, align, inset and stroke properties, plus the expected value of - /// the `breakable` field. - /// Returns a final Cell. - #[allow(clippy::too_many_arguments)] - fn resolve_cell<'a>( - self, - x: usize, - y: usize, - fill: &Option<Paint>, - align: Smart<Alignment>, - inset: Sides<Option<Rel<Length>>>, - stroke: Sides<Option<Option<Arc<Stroke<Abs>>>>>, - breakable: bool, - locator: Locator<'a>, - styles: StyleChain, - ) -> Cell<'a>; - - /// Returns this cell's column override. - fn x(&self, styles: StyleChain) -> Smart<usize>; - - /// Returns this cell's row override. - fn y(&self, styles: StyleChain) -> Smart<usize>; - - /// The amount of columns spanned by this cell. - fn colspan(&self, styles: StyleChain) -> NonZeroUsize; - - /// The amount of rows spanned by this cell. - fn rowspan(&self, styles: StyleChain) -> NonZeroUsize; - - /// The cell's span, for errors. - fn span(&self) -> Span; -} - -/// A grid item, possibly affected by automatic cell positioning. Can be either -/// a line or a cell. -pub enum ResolvableGridItem<T: ResolvableCell> { - /// A horizontal line in the grid. - HLine { - /// The row above which the horizontal line is drawn. - y: Smart<usize>, - start: usize, - end: Option<NonZeroUsize>, - stroke: Option<Arc<Stroke<Abs>>>, - /// The span of the corresponding line element. - span: Span, - /// The line's position. "before" here means on top of row `y`, while - /// "after" means below it. - position: LinePosition, - }, - /// A vertical line in the grid. - VLine { - /// The column before which the vertical line is drawn. - x: Smart<usize>, - start: usize, - end: Option<NonZeroUsize>, - stroke: Option<Arc<Stroke<Abs>>>, - /// The span of the corresponding line element. - span: Span, - /// The line's position. "before" here means to the left of column `x`, - /// while "after" means to its right (both considering LTR). - position: LinePosition, - }, - /// A cell in the grid. - Cell(T), -} - -/// Represents a cell in CellGrid, to be laid out by GridLayouter. -pub struct Cell<'a> { - /// The cell's body. - pub body: Content, - /// The cell's locator. - pub locator: Locator<'a>, - /// The cell's fill. - pub fill: Option<Paint>, - /// The amount of columns spanned by the cell. - pub colspan: NonZeroUsize, - /// The amount of rows spanned by the cell. - pub rowspan: NonZeroUsize, - /// The cell's stroke. - /// - /// We use an Arc to avoid unnecessary space usage when all sides are the - /// same, or when the strokes come from a common source. - pub stroke: Sides<Option<Arc<Stroke<Abs>>>>, - /// Which stroke sides were explicitly overridden by the cell, over the - /// grid's global stroke setting. - /// - /// This is used to define whether or not this cell's stroke sides should - /// have priority over adjacent cells' stroke sides, if those don't - /// override their own stroke properties (and thus have less priority when - /// defining with which stroke to draw grid lines around this cell). - pub stroke_overridden: Sides<bool>, - /// Whether rows spanned by this cell can be placed in different pages. - /// By default, a cell spanning only fixed-size rows is unbreakable, while - /// a cell spanning at least one `auto`-sized row is breakable. - pub breakable: bool, -} - -impl<'a> Cell<'a> { - /// Create a simple cell given its body and its locator. - pub fn new(body: Content, locator: Locator<'a>) -> Self { - Self { - body, - locator, - fill: None, - colspan: NonZeroUsize::ONE, - rowspan: NonZeroUsize::ONE, - stroke: Sides::splat(None), - stroke_overridden: Sides::splat(false), - breakable: true, - } - } - - /// Layout the cell into the given regions. - /// - /// The `disambiguator` indicates which instance of this cell this should be - /// layouted as. For normal cells, it is always `0`, but for headers and - /// footers, it indicates the index of the header/footer among all. See the - /// [`Locator`] docs for more details on the concepts behind this. - pub fn layout( - &self, - engine: &mut Engine, - disambiguator: usize, - styles: StyleChain, - regions: Regions, - ) -> SourceResult<Fragment> { - let mut locator = self.locator.relayout(); - if disambiguator > 0 { - locator = locator.split().next_inner(disambiguator as u128); - } - crate::layout_fragment(engine, &self.body, locator, styles, regions) - } -} - -/// Indicates whether the line should be drawn before or after the track with -/// its index. This is mostly only relevant when gutter is used, since, then, -/// the position after a track is not the same as before the next -/// non-gutter track. -#[derive(Copy, Clone, PartialEq, Eq)] -pub enum LinePosition { - /// The line should be drawn before its track (e.g. hline on top of a row). - Before, - /// The line should be drawn after its track (e.g. hline below a row). - After, -} - -/// A grid entry. -pub enum Entry<'a> { - /// An entry which holds a cell. - Cell(Cell<'a>), - /// An entry which is merged with another cell. - Merged { - /// The index of the cell this entry is merged with. - parent: usize, - }, -} - -impl<'a> Entry<'a> { - /// Obtains the cell inside this entry, if this is not a merged cell. - fn as_cell(&self) -> Option<&Cell<'a>> { - match self { - Self::Cell(cell) => Some(cell), - Self::Merged { .. } => None, - } - } -} - -/// Any grid child, which can be either a header or an item. -pub enum ResolvableGridChild<T: ResolvableCell, I> { - Header { repeat: bool, span: Span, items: I }, - Footer { repeat: bool, span: Span, items: I }, - Item(ResolvableGridItem<T>), -} - -/// A grid of cells, including the columns, rows, and cell data. -pub struct CellGrid<'a> { - /// The grid cells. - pub entries: Vec<Entry<'a>>, - /// The column tracks including gutter tracks. - pub cols: Vec<Sizing>, - /// The row tracks including gutter tracks. - pub rows: Vec<Sizing>, - /// The vertical lines before each column, or on the end border. - /// Gutter columns are not included. - /// Contains up to 'cols_without_gutter.len() + 1' vectors of lines. - pub vlines: Vec<Vec<Line>>, - /// The horizontal lines on top of each row, or on the bottom border. - /// Gutter rows are not included. - /// Contains up to 'rows_without_gutter.len() + 1' vectors of lines. - pub hlines: Vec<Vec<Line>>, - /// The repeatable header of this grid. - pub header: Option<Repeatable<Header>>, - /// The repeatable footer of this grid. - pub footer: Option<Repeatable<Footer>>, - /// Whether this grid has gutters. - pub has_gutter: bool, -} - -impl<'a> CellGrid<'a> { - /// Generates the cell grid, given the tracks and cells. - pub fn new( - tracks: Axes<&[Sizing]>, - gutter: Axes<&[Sizing]>, - cells: impl IntoIterator<Item = Cell<'a>>, - ) -> Self { - let entries = cells.into_iter().map(Entry::Cell).collect(); - Self::new_internal(tracks, gutter, vec![], vec![], None, None, entries) - } - - /// Resolves and positions all cells in the grid before creating it. - /// Allows them to keep track of their final properties and positions - /// and adjust their fields accordingly. - /// Cells must implement Clone as they will be owned. Additionally, they - /// must implement Default in order to fill positions in the grid which - /// weren't explicitly specified by the user with empty cells. - #[allow(clippy::too_many_arguments)] - pub fn resolve<T, C, I>( - tracks: Axes<&[Sizing]>, - gutter: Axes<&[Sizing]>, - locator: Locator<'a>, - children: C, - fill: &Celled<Option<Paint>>, - align: &Celled<Smart<Alignment>>, - inset: &Celled<Sides<Option<Rel<Length>>>>, - stroke: &ResolvedCelled<Sides<Option<Option<Arc<Stroke>>>>>, - engine: &mut Engine, - styles: StyleChain, - span: Span, - ) -> SourceResult<Self> - where - T: ResolvableCell + Default, - I: Iterator<Item = ResolvableGridItem<T>>, - C: IntoIterator<Item = ResolvableGridChild<T, I>>, - C::IntoIter: ExactSizeIterator, - { - let mut locator = locator.split(); - - // Number of content columns: Always at least one. - let c = tracks.x.len().max(1); - - // Lists of lines. - // Horizontal lines are only pushed later to be able to check for row - // validity, since the amount of rows isn't known until all items were - // analyzed in the for loop below. - // We keep their spans so we can report errors later. - // The additional boolean indicates whether the hline had an automatic - // 'y' index, and is used to change the index of hlines at the top of a - // header or footer. - let mut pending_hlines: Vec<(Span, Line, bool)> = vec![]; - - // For consistency, only push vertical lines later as well. - let mut pending_vlines: Vec<(Span, Line)> = vec![]; - let has_gutter = gutter.any(|tracks| !tracks.is_empty()); - - let mut header: Option<Header> = None; - let mut repeat_header = false; - - // Stores where the footer is supposed to end, its span, and the - // actual footer structure. - let mut footer: Option<(usize, Span, Footer)> = None; - let mut repeat_footer = false; - - // Resolves the breakability of a cell. Cells that span at least one - // auto-sized row or gutter are considered breakable. - let resolve_breakable = |y, rowspan| { - let auto = Sizing::Auto; - let zero = Sizing::Rel(Rel::zero()); - tracks - .y - .iter() - .chain(std::iter::repeat(tracks.y.last().unwrap_or(&auto))) - .skip(y) - .take(rowspan) - .any(|row| row == &Sizing::Auto) - || gutter - .y - .iter() - .chain(std::iter::repeat(gutter.y.last().unwrap_or(&zero))) - .skip(y) - .take(rowspan - 1) - .any(|row_gutter| row_gutter == &Sizing::Auto) - }; - - // We can't just use the cell's index in the 'cells' vector to - // determine its automatic position, since cells could have arbitrary - // positions, so the position of a cell in 'cells' can differ from its - // final position in 'resolved_cells' (see below). - // Therefore, we use a counter, 'auto_index', to determine the position - // of the next cell with (x: auto, y: auto). It is only stepped when - // a cell with (x: auto, y: auto), usually the vast majority, is found. - let mut auto_index: usize = 0; - - // We have to rebuild the grid to account for arbitrary positions. - // Create at least 'children.len()' positions, since there could be at - // least 'children.len()' cells (if no explicit lines were specified), - // even though some of them might be placed in arbitrary positions and - // thus cause the grid to expand. - // Additionally, make sure we allocate up to the next multiple of 'c', - // since each row will have 'c' cells, even if the last few cells - // weren't explicitly specified by the user. - // We apply '% c' twice so that the amount of cells potentially missing - // is zero when 'children.len()' is already a multiple of 'c' (thus - // 'children.len() % c' would be zero). - let children = children.into_iter(); - let Some(child_count) = children.len().checked_add((c - children.len() % c) % c) - else { - bail!(span, "too many cells or lines were given") - }; - let mut resolved_cells: Vec<Option<Entry>> = Vec::with_capacity(child_count); - for child in children { - let mut is_header = false; - let mut is_footer = false; - let mut child_start = usize::MAX; - let mut child_end = 0; - let mut child_span = Span::detached(); - let mut start_new_row = false; - let mut first_index_of_top_hlines = usize::MAX; - let mut first_index_of_non_top_hlines = usize::MAX; - - let (header_footer_items, simple_item) = match child { - ResolvableGridChild::Header { repeat, span, items, .. } => { - if header.is_some() { - bail!(span, "cannot have more than one header"); - } - - is_header = true; - child_span = span; - repeat_header = repeat; - - // If any cell in the header is automatically positioned, - // have it skip to the next row. This is to avoid having a - // header after a partially filled row just add cells to - // that row instead of starting a new one. - // FIXME: Revise this approach when headers can start from - // arbitrary rows. - start_new_row = true; - - // Any hlines at the top of the header will start at this - // index. - first_index_of_top_hlines = pending_hlines.len(); - - (Some(items), None) - } - ResolvableGridChild::Footer { repeat, span, items, .. } => { - if footer.is_some() { - bail!(span, "cannot have more than one footer"); - } - - is_footer = true; - child_span = span; - repeat_footer = repeat; - - // If any cell in the footer is automatically positioned, - // have it skip to the next row. This is to avoid having a - // footer after a partially filled row just add cells to - // that row instead of starting a new one. - start_new_row = true; - - // Any hlines at the top of the footer will start at this - // index. - first_index_of_top_hlines = pending_hlines.len(); - - (Some(items), None) - } - ResolvableGridChild::Item(item) => (None, Some(item)), - }; - - let items = header_footer_items - .into_iter() - .flatten() - .chain(simple_item.into_iter()); - for item in items { - let cell = match item { - ResolvableGridItem::HLine { - y, - start, - end, - stroke, - span, - position, - } => { - let has_auto_y = y.is_auto(); - let y = y.unwrap_or_else(|| { - // Avoid placing the hline inside consecutive - // rowspans occupying all columns, as it'd just - // disappear, at least when there's no column - // gutter. - skip_auto_index_through_fully_merged_rows( - &resolved_cells, - &mut auto_index, - c, - ); - - // When no 'y' is specified for the hline, we place - // it under the latest automatically positioned - // cell. - // The current value of the auto index is always - // the index of the latest automatically positioned - // cell placed plus one (that's what we do in - // 'resolve_cell_position'), so we subtract 1 to - // get that cell's index, and place the hline below - // its row. The exception is when the auto_index is - // 0, meaning no automatically positioned cell was - // placed yet. In that case, we place the hline at - // the top of the table. - // - // Exceptionally, the hline will be placed before - // the minimum auto index if the current auto index - // from previous iterations is smaller than the - // minimum it should have for the current grid - // child. Effectively, this means that a hline at - // the start of a header will always appear above - // that header's first row. Similarly for footers. - auto_index - .checked_sub(1) - .map_or(0, |last_auto_index| last_auto_index / c + 1) - }); - if end.is_some_and(|end| end.get() < start) { - bail!(span, "line cannot end before it starts"); - } - let line = Line { index: y, start, end, stroke, position }; - - // Since the amount of rows is dynamic, delay placing - // hlines until after all cells were placed so we can - // properly verify if they are valid. Note that we - // can't place hlines even if we already know they - // would be in a valid row, since it's possible that we - // pushed pending hlines in the same row as this one in - // previous iterations, and we need to ensure that - // hlines from previous iterations are pushed to the - // final vector of hlines first - the order of hlines - // must be kept, as this matters when determining which - // one "wins" in case of conflict. Pushing the current - // hline before we push pending hlines later would - // change their order! - pending_hlines.push((span, line, has_auto_y)); - continue; - } - ResolvableGridItem::VLine { - x, - start, - end, - stroke, - span, - position, - } => { - let x = x.unwrap_or_else(|| { - // When no 'x' is specified for the vline, we place - // it after the latest automatically positioned - // cell. - // The current value of the auto index is always - // the index of the latest automatically positioned - // cell placed plus one (that's what we do in - // 'resolve_cell_position'), so we subtract 1 to - // get that cell's index, and place the vline after - // its column. The exception is when the auto_index - // is 0, meaning no automatically positioned cell - // was placed yet. In that case, we place the vline - // to the left of the table. - // - // Exceptionally, a vline is also placed to the - // left of the table if we should start a new row - // for the next automatically positioned cell. - // For example, this means that a vline at - // the beginning of a header will be placed to its - // left rather than after the previous - // automatically positioned cell. Same for footers. - auto_index - .checked_sub(1) - .filter(|_| !start_new_row) - .map_or(0, |last_auto_index| last_auto_index % c + 1) - }); - if end.is_some_and(|end| end.get() < start) { - bail!(span, "line cannot end before it starts"); - } - let line = Line { index: x, start, end, stroke, position }; - - // For consistency with hlines, we only push vlines to - // the final vector of vlines after processing every - // cell. - pending_vlines.push((span, line)); - continue; - } - ResolvableGridItem::Cell(cell) => cell, - }; - let cell_span = cell.span(); - let colspan = cell.colspan(styles).get(); - let rowspan = cell.rowspan(styles).get(); - // Let's calculate the cell's final position based on its - // requested position. - let resolved_index = { - let cell_x = cell.x(styles); - let cell_y = cell.y(styles); - resolve_cell_position( - cell_x, - cell_y, - colspan, - rowspan, - &resolved_cells, - &mut auto_index, - &mut start_new_row, - c, - ) - .at(cell_span)? - }; - let x = resolved_index % c; - let y = resolved_index / c; - - if colspan > c - x { - bail!( - cell_span, - "cell's colspan would cause it to exceed the available column(s)"; - hint: "try placing the cell in another position or reducing its colspan" - ) - } - - let Some(largest_index) = c - .checked_mul(rowspan - 1) - .and_then(|full_rowspan_offset| { - resolved_index.checked_add(full_rowspan_offset) - }) - .and_then(|last_row_pos| last_row_pos.checked_add(colspan - 1)) - else { - bail!( - cell_span, - "cell would span an exceedingly large position"; - hint: "try reducing the cell's rowspan or colspan" - ) - }; - - // Let's resolve the cell so it can determine its own fields - // based on its final position. - let cell = cell.resolve_cell( - x, - y, - &fill.resolve(engine, styles, x, y)?, - align.resolve(engine, styles, x, y)?, - inset.resolve(engine, styles, x, y)?, - stroke.resolve(engine, styles, x, y)?, - resolve_breakable(y, rowspan), - locator.next(&cell_span), - styles, - ); - - if largest_index >= resolved_cells.len() { - // Ensure the length of the vector of resolved cells is - // always a multiple of 'c' by pushing full rows every - // time. Here, we add enough absent positions (later - // converted to empty cells) to ensure the last row in the - // new vector length is completely filled. This is - // necessary so that those positions, even if not - // explicitly used at the end, are eventually susceptible - // to show rules and receive grid styling, as they will be - // resolved as empty cells in a second loop below. - let Some(new_len) = largest_index - .checked_add(1) - .and_then(|new_len| new_len.checked_add((c - new_len % c) % c)) - else { - bail!(cell_span, "cell position too large") - }; - - // Here, the cell needs to be placed in a position which - // doesn't exist yet in the grid (out of bounds). We will - // add enough absent positions for this to be possible. - // They must be absent as no cells actually occupy them - // (they can be overridden later); however, if no cells - // occupy them as we finish building the grid, then such - // positions will be replaced by empty cells. - resolved_cells.resize_with(new_len, || None); - } - - // The vector is large enough to contain the cell, so we can - // just index it directly to access the position it will be - // placed in. However, we still need to ensure we won't try to - // place a cell where there already is one. - let slot = &mut resolved_cells[resolved_index]; - if slot.is_some() { - bail!( - cell_span, - "attempted to place a second cell at column {x}, row {y}"; - hint: "try specifying your cells in a different order" - ); - } - - *slot = Some(Entry::Cell(cell)); - - // Now, if the cell spans more than one row or column, we fill - // the spanned positions in the grid with Entry::Merged - // pointing to the original cell as its parent. - for rowspan_offset in 0..rowspan { - let spanned_y = y + rowspan_offset; - let first_row_index = resolved_index + c * rowspan_offset; - for (colspan_offset, slot) in resolved_cells[first_row_index..] - [..colspan] - .iter_mut() - .enumerate() - { - let spanned_x = x + colspan_offset; - if spanned_x == x && spanned_y == y { - // This is the parent cell. - continue; - } - if slot.is_some() { - bail!( - cell_span, - "cell would span a previously placed cell at column {spanned_x}, row {spanned_y}"; - hint: "try specifying your cells in a different order or reducing the cell's rowspan or colspan" - ) - } - *slot = Some(Entry::Merged { parent: resolved_index }); - } - } - - if is_header || is_footer { - // Ensure each cell in a header or footer is fully - // contained within it. - child_start = child_start.min(y); - child_end = child_end.max(y + rowspan); - - if start_new_row && child_start <= auto_index.div_ceil(c) { - // No need to start a new row as we already include - // the row of the next automatically positioned cell in - // the header or footer. - start_new_row = false; - } - - if !start_new_row { - // From now on, upcoming hlines won't be at the top of - // the child, as the first automatically positioned - // cell was placed. - first_index_of_non_top_hlines = - first_index_of_non_top_hlines.min(pending_hlines.len()); - } - } - } - - if (is_header || is_footer) && child_start == usize::MAX { - // Empty header/footer: consider the header/footer to be - // at the next empty row after the latest auto index. - auto_index = find_next_empty_row(&resolved_cells, auto_index, c); - child_start = auto_index.div_ceil(c); - child_end = child_start + 1; - - if resolved_cells.len() <= c * child_start { - // Ensure the automatically chosen row actually exists. - resolved_cells.resize_with(c * (child_start + 1), || None); - } - } - - if is_header { - if child_start != 0 { - bail!( - child_span, - "header must start at the first row"; - hint: "remove any rows before the header" - ); - } - - header = Some(Header { - // Later on, we have to correct this number in case there - // is gutter. But only once all cells have been analyzed - // and the header has fully expanded in the fixup loop - // below. - end: child_end, - }); - } - - if is_footer { - // Only check if the footer is at the end later, once we know - // the final amount of rows. - footer = Some(( - child_end, - child_span, - Footer { - // Later on, we have to correct this number in case there - // is gutter, but only once all cells have been analyzed - // and the header's and footer's exact boundaries are - // known. That is because the gutter row immediately - // before the footer might not be included as part of - // the footer if it is contained within the header. - start: child_start, - }, - )); - } - - if is_header || is_footer { - let amount_hlines = pending_hlines.len(); - for (_, top_hline, has_auto_y) in pending_hlines - .get_mut( - first_index_of_top_hlines - ..first_index_of_non_top_hlines.min(amount_hlines), - ) - .unwrap_or(&mut []) - { - if *has_auto_y { - // Move this hline to the top of the child, as it was - // placed before the first automatically positioned cell - // and had an automatic index. - top_hline.index = child_start; - } - } - - // Next automatically positioned cell goes under this header. - // FIXME: Consider only doing this if the header has any fully - // automatically positioned cells. Otherwise, - // `resolve_cell_position` should be smart enough to skip - // upcoming headers. - // Additionally, consider that cells with just an 'x' override - // could end up going too far back and making previous - // non-header rows into header rows (maybe they should be - // placed at the first row that is fully empty or something). - // Nothing we can do when both 'x' and 'y' were overridden, of - // course. - // None of the above are concerns for now, as headers must - // start at the first row. - auto_index = auto_index.max(c * child_end); - } - } - - // If the user specified cells occupying less rows than the given rows, - // we shall expand the grid so that it has at least the given amount of - // rows. - let Some(expected_total_cells) = c.checked_mul(tracks.y.len()) else { - bail!(span, "too many rows were specified"); - }; - let missing_cells = expected_total_cells.saturating_sub(resolved_cells.len()); - - // Fixup phase (final step in cell grid generation): - // 1. Replace absent entries by resolved empty cells, and produce a - // vector of 'Entry' from 'Option<Entry>'. - // 2. Add enough empty cells to the end of the grid such that it has at - // least the given amount of rows. - // 3. If any cells were added to the header's rows after the header's - // creation, ensure the header expands enough to accommodate them - // across all of their spanned rows. Same for the footer. - // 4. If any cells before the footer try to span it, error. - let resolved_cells = resolved_cells - .into_iter() - .chain(std::iter::repeat_with(|| None).take(missing_cells)) - .enumerate() - .map(|(i, cell)| { - if let Some(cell) = cell { - if let Some(parent_cell) = cell.as_cell() { - if let Some(header) = &mut header - { - let y = i / c; - if y < header.end { - // Ensure the header expands enough such that - // all cells inside it, even those added later, - // are fully contained within the header. - // FIXME: check if start < y < end when start can - // be != 0. - // FIXME: when start can be != 0, decide what - // happens when a cell after the header placed - // above it tries to span the header (either - // error or expand upwards). - header.end = header.end.max(y + parent_cell.rowspan.get()); - } - } - - if let Some((end, footer_span, footer)) = &mut footer { - let x = i % c; - let y = i / c; - let cell_end = y + parent_cell.rowspan.get(); - if y < footer.start && cell_end > footer.start { - // Don't allow a cell before the footer to span - // it. Surely, we could move the footer to - // start at where this cell starts, so this is - // more of a design choice, as it's unlikely - // for the user to intentionally include a cell - // before the footer spanning it but not - // being repeated with it. - bail!( - *footer_span, - "footer would conflict with a cell placed before it at column {x} row {y}"; - hint: "try reducing that cell's rowspan or moving the footer" - ); - } - if y >= footer.start && y < *end { - // Expand the footer to include all rows - // spanned by this cell, as it is inside the - // footer. - *end = (*end).max(cell_end); - } - } - } - - Ok(cell) - } else { - let x = i % c; - let y = i / c; - - // Ensure all absent entries are affected by show rules and - // grid styling by turning them into resolved empty cells. - let new_cell = T::default().resolve_cell( - x, - y, - &fill.resolve(engine, styles, x, y)?, - align.resolve(engine, styles, x, y)?, - inset.resolve(engine, styles, x, y)?, - stroke.resolve(engine, styles, x, y)?, - resolve_breakable(y, 1), - locator.next(&()), - styles, - ); - Ok(Entry::Cell(new_cell)) - } - }) - .collect::<SourceResult<Vec<Entry>>>()?; - - // Populate the final lists of lines. - // For each line type (horizontal or vertical), we keep a vector for - // every group of lines with the same index. - let mut vlines: Vec<Vec<Line>> = vec![]; - let mut hlines: Vec<Vec<Line>> = vec![]; - let row_amount = resolved_cells.len().div_ceil(c); - - for (line_span, line, _) in pending_hlines { - let y = line.index; - if y > row_amount { - bail!(line_span, "cannot place horizontal line at invalid row {y}"); - } - if y == row_amount && line.position == LinePosition::After { - bail!( - line_span, - "cannot place horizontal line at the 'bottom' position of the bottom border (y = {y})"; - hint: "set the line's position to 'top' or place it at a smaller 'y' index" - ); - } - let line = if line.position == LinePosition::After - && (!has_gutter || y + 1 == row_amount) - { - // Just place the line on top of the next row if - // there's no gutter and the line should be placed - // after the one with given index. - // - // Note that placing after the last row is also the same as - // just placing on the grid's bottom border, even with - // gutter. - Line { - index: y + 1, - position: LinePosition::Before, - ..line - } - } else { - line - }; - let y = line.index; - - if hlines.len() <= y { - hlines.resize_with(y + 1, Vec::new); - } - hlines[y].push(line); - } - - for (line_span, line) in pending_vlines { - let x = line.index; - if x > c { - bail!(line_span, "cannot place vertical line at invalid column {x}"); - } - if x == c && line.position == LinePosition::After { - bail!( - line_span, - "cannot place vertical line at the 'end' position of the end border (x = {c})"; - hint: "set the line's position to 'start' or place it at a smaller 'x' index" - ); - } - let line = - if line.position == LinePosition::After && (!has_gutter || x + 1 == c) { - // Just place the line before the next column if - // there's no gutter and the line should be placed - // after the one with given index. - // - // Note that placing after the last column is also the - // same as just placing on the grid's end border, even - // with gutter. - Line { - index: x + 1, - position: LinePosition::Before, - ..line - } - } else { - line - }; - let x = line.index; - - if vlines.len() <= x { - vlines.resize_with(x + 1, Vec::new); - } - vlines[x].push(line); - } - - let header = header - .map(|mut header| { - // Repeat the gutter below a header (hence why we don't - // subtract 1 from the gutter case). - // Don't do this if there are no rows under the header. - if has_gutter { - // - 'header.end' is always 'last y + 1'. The header stops - // before that row. - // - Therefore, '2 * header.end' will be 2 * (last y + 1), - // which is the adjusted index of the row before which the - // header stops, meaning it will still stop right before it - // even with gutter thanks to the multiplication below. - // - This means that it will span all rows up to - // '2 * (last y + 1) - 1 = 2 * last y + 1', which equates - // to the index of the gutter row right below the header, - // which is what we want (that gutter spacing should be - // repeated across pages to maintain uniformity). - header.end *= 2; - - // If the header occupies the entire grid, ensure we don't - // include an extra gutter row when it doesn't exist, since - // the last row of the header is at the very bottom, - // therefore '2 * last y + 1' is not a valid index. - let row_amount = (2 * row_amount).saturating_sub(1); - header.end = header.end.min(row_amount); - } - header - }) - .map(|header| { - if repeat_header { - Repeatable::Repeated(header) - } else { - Repeatable::NotRepeated(header) - } - }); - - let footer = footer - .map(|(footer_end, footer_span, mut footer)| { - if footer_end != row_amount { - bail!(footer_span, "footer must end at the last row"); - } - - let header_end = - header.as_ref().map(Repeatable::unwrap).map(|header| header.end); - - if has_gutter { - // Convert the footer's start index to post-gutter coordinates. - footer.start *= 2; - - // Include the gutter right before the footer, unless there is - // none, or the gutter is already included in the header (no - // rows between the header and the footer). - if header_end.map_or(true, |header_end| header_end != footer.start) { - footer.start = footer.start.saturating_sub(1); - } - } - - if header_end.is_some_and(|header_end| header_end > footer.start) { - bail!(footer_span, "header and footer must not have common rows"); - } - - Ok(footer) - }) - .transpose()? - .map(|footer| { - if repeat_footer { - Repeatable::Repeated(footer) - } else { - Repeatable::NotRepeated(footer) - } - }); - - Ok(Self::new_internal( - tracks, - gutter, - vlines, - hlines, - header, - footer, - resolved_cells, - )) - } - - /// Generates the cell grid, given the tracks and resolved entries. - pub fn new_internal( - tracks: Axes<&[Sizing]>, - gutter: Axes<&[Sizing]>, - vlines: Vec<Vec<Line>>, - hlines: Vec<Vec<Line>>, - header: Option<Repeatable<Header>>, - footer: Option<Repeatable<Footer>>, - entries: Vec<Entry<'a>>, - ) -> Self { - let mut cols = vec![]; - let mut rows = vec![]; - - // Number of content columns: Always at least one. - let c = tracks.x.len().max(1); - - // Number of content rows: At least as many as given, but also at least - // as many as needed to place each item. - let r = { - let len = entries.len(); - let given = tracks.y.len(); - let needed = len / c + (len % c).clamp(0, 1); - given.max(needed) - }; - - let has_gutter = gutter.any(|tracks| !tracks.is_empty()); - let auto = Sizing::Auto; - let zero = Sizing::Rel(Rel::zero()); - let get_or = |tracks: &[_], idx, default| { - tracks.get(idx).or(tracks.last()).copied().unwrap_or(default) - }; - - // Collect content and gutter columns. - for x in 0..c { - cols.push(get_or(tracks.x, x, auto)); - if has_gutter { - cols.push(get_or(gutter.x, x, zero)); - } - } - - // Collect content and gutter rows. - for y in 0..r { - rows.push(get_or(tracks.y, y, auto)); - if has_gutter { - rows.push(get_or(gutter.y, y, zero)); - } - } - - // Remove superfluous gutter tracks. - if has_gutter { - cols.pop(); - rows.pop(); - } - - Self { - cols, - rows, - entries, - vlines, - hlines, - header, - footer, - has_gutter, - } - } - - /// Get the grid entry in column `x` and row `y`. - /// - /// Returns `None` if it's a gutter cell. - #[track_caller] - pub fn entry(&self, x: usize, y: usize) -> Option<&Entry<'a>> { - assert!(x < self.cols.len()); - assert!(y < self.rows.len()); - - if self.has_gutter { - // Even columns and rows are children, odd ones are gutter. - if x % 2 == 0 && y % 2 == 0 { - let c = 1 + self.cols.len() / 2; - self.entries.get((y / 2) * c + x / 2) - } else { - None - } - } else { - let c = self.cols.len(); - self.entries.get(y * c + x) - } - } - - /// Get the content of the cell in column `x` and row `y`. - /// - /// Returns `None` if it's a gutter cell or merged position. - #[track_caller] - pub fn cell(&self, x: usize, y: usize) -> Option<&Cell<'a>> { - self.entry(x, y).and_then(Entry::as_cell) - } - - /// Returns the position of the parent cell of the grid entry at the given - /// position. It is guaranteed to have a non-gutter, non-merged cell at - /// the returned position, due to how the grid is built. - /// - If the entry at the given position is a cell, returns the given - /// position. - /// - If it is a merged cell, returns the parent cell's position. - /// - If it is a gutter cell, returns None. - #[track_caller] - pub fn parent_cell_position(&self, x: usize, y: usize) -> Option<Axes<usize>> { - self.entry(x, y).map(|entry| match entry { - Entry::Cell(_) => Axes::new(x, y), - Entry::Merged { parent } => { - let c = if self.has_gutter { - 1 + self.cols.len() / 2 - } else { - self.cols.len() - }; - let factor = if self.has_gutter { 2 } else { 1 }; - Axes::new(factor * (*parent % c), factor * (*parent / c)) - } - }) - } - - /// Returns the position of the actual parent cell of a merged position, - /// even if the given position is gutter, in which case we return the - /// parent of the nearest adjacent content cell which could possibly span - /// the given gutter position. If the given position is not a gutter cell, - /// then this function will return the same as `parent_cell_position` would. - /// If the given position is a gutter cell, but no cell spans it, returns - /// `None`. - /// - /// This is useful for lines. A line needs to check if a cell next to it - /// has a stroke override - even at a gutter position there could be a - /// stroke override, since a cell could be merged with two cells at both - /// ends of the gutter cell (e.g. to its left and to its right), and thus - /// that cell would impose a stroke under the gutter. This function allows - /// getting the position of that cell (which spans the given gutter - /// position, if it is gutter), if it exists; otherwise returns None (it's - /// gutter and no cell spans it). - #[track_caller] - pub fn effective_parent_cell_position( - &self, - x: usize, - y: usize, - ) -> Option<Axes<usize>> { - if self.has_gutter { - // If (x, y) is a gutter cell, we skip it (skip a gutter column and - // row) to the nearest adjacent content cell, in the direction - // which merged cells grow toward (increasing x and increasing y), - // such that we can verify if that adjacent cell is merged with the - // gutter cell by checking if its parent would come before (x, y). - // Otherwise, no cell is merged with this gutter cell, and we - // return None. - self.parent_cell_position(x + x % 2, y + y % 2) - .filter(|&parent| parent.x <= x && parent.y <= y) - } else { - self.parent_cell_position(x, y) - } - } - - /// Checks if the track with the given index is gutter. - /// Does not check if the index is a valid track. - #[inline] - pub fn is_gutter_track(&self, index: usize) -> bool { - self.has_gutter && index % 2 == 1 - } - - /// Returns the effective colspan of a cell, considering the gutters it - /// might span if the grid has gutters. - #[inline] - pub fn effective_colspan_of_cell(&self, cell: &Cell) -> usize { - if self.has_gutter { - 2 * cell.colspan.get() - 1 - } else { - cell.colspan.get() - } - } - - /// Returns the effective rowspan of a cell, considering the gutters it - /// might span if the grid has gutters. - #[inline] - pub fn effective_rowspan_of_cell(&self, cell: &Cell) -> usize { - if self.has_gutter { - 2 * cell.rowspan.get() - 1 - } else { - cell.rowspan.get() - } - } -} - -/// Given a cell's requested x and y, the vector with the resolved cell -/// positions, the `auto_index` counter (determines the position of the next -/// `(auto, auto)` cell) and the amount of columns in the grid, returns the -/// final index of this cell in the vector of resolved cells. -/// -/// The `start_new_row` parameter is used to ensure that, if this cell is -/// fully automatically positioned, it should start a new, empty row. This is -/// useful for headers and footers, which must start at their own rows, without -/// interference from previous cells. -#[allow(clippy::too_many_arguments)] -fn resolve_cell_position( - cell_x: Smart<usize>, - cell_y: Smart<usize>, - colspan: usize, - rowspan: usize, - resolved_cells: &[Option<Entry>], - auto_index: &mut usize, - start_new_row: &mut bool, - columns: usize, -) -> HintedStrResult<usize> { - // Translates a (x, y) position to the equivalent index in the final cell vector. - // Errors if the position would be too large. - let cell_index = |x, y: usize| { - y.checked_mul(columns) - .and_then(|row_index| row_index.checked_add(x)) - .ok_or_else(|| HintedString::from(eco_format!("cell position too large"))) - }; - match (cell_x, cell_y) { - // Fully automatic cell positioning. The cell did not - // request a coordinate. - (Smart::Auto, Smart::Auto) => { - // Let's find the first available position starting from the - // automatic position counter, searching in row-major order. - let mut resolved_index = *auto_index; - if *start_new_row { - resolved_index = - find_next_empty_row(resolved_cells, resolved_index, columns); - - // Next cell won't have to start a new row if we just did that, - // in principle. - *start_new_row = false; - } else { - while let Some(Some(_)) = resolved_cells.get(resolved_index) { - // Skip any non-absent cell positions (`Some(None)`) to - // determine where this cell will be placed. An out of - // bounds position (thus `None`) is also a valid new - // position (only requires expanding the vector). - resolved_index += 1; - } - } - - // Ensure the next cell with automatic position will be - // placed after this one (maybe not immediately after). - // - // The calculation below also affects the position of the upcoming - // automatically-positioned lines. - *auto_index = if colspan == columns { - // The cell occupies all columns, so no cells can be placed - // after it until all of its rows have been spanned. - resolved_index + colspan * rowspan - } else { - // The next cell will have to be placed at least after its - // spanned columns. - resolved_index + colspan - }; - - Ok(resolved_index) - } - // Cell has chosen at least its column. - (Smart::Custom(cell_x), cell_y) => { - if cell_x >= columns { - return Err(HintedString::from(eco_format!( - "cell could not be placed at invalid column {cell_x}" - ))); - } - if let Smart::Custom(cell_y) = cell_y { - // Cell has chosen its exact position. - cell_index(cell_x, cell_y) - } else { - // Cell has only chosen its column. - // Let's find the first row which has that column available. - let mut resolved_y = 0; - while let Some(Some(_)) = - resolved_cells.get(cell_index(cell_x, resolved_y)?) - { - // Try each row until either we reach an absent position - // (`Some(None)`) or an out of bounds position (`None`), - // in which case we'd create a new row to place this cell in. - resolved_y += 1; - } - cell_index(cell_x, resolved_y) - } - } - // Cell has only chosen its row, not its column. - (Smart::Auto, Smart::Custom(cell_y)) => { - // Let's find the first column which has that row available. - let first_row_pos = cell_index(0, cell_y)?; - let last_row_pos = first_row_pos - .checked_add(columns) - .ok_or_else(|| eco_format!("cell position too large"))?; - - (first_row_pos..last_row_pos) - .find(|possible_index| { - // Much like in the previous cases, we skip any occupied - // positions until we either reach an absent position - // (`Some(None)`) or an out of bounds position (`None`), - // in which case we can just expand the vector enough to - // place this cell. In either case, we found an available - // position. - !matches!(resolved_cells.get(*possible_index), Some(Some(_))) - }) - .ok_or_else(|| { - eco_format!( - "cell could not be placed in row {cell_y} because it was full" - ) - }) - .hint("try specifying your cells in a different order") - } - } -} - -/// Computes the index of the first cell in the next empty row in the grid, -/// starting with the given initial index. -fn find_next_empty_row( - resolved_cells: &[Option<Entry>], - initial_index: usize, - columns: usize, -) -> usize { - let mut resolved_index = initial_index.next_multiple_of(columns); - while resolved_cells - .get(resolved_index..resolved_index + columns) - .is_some_and(|row| row.iter().any(Option::is_some)) - { - // Skip non-empty rows. - resolved_index += columns; - } - - resolved_index -} - -/// Fully merged rows under the cell of latest auto index indicate rowspans -/// occupying all columns, so we skip the auto index until the shortest rowspan -/// ends, such that, in the resulting row, we will be able to place an -/// automatically positioned cell - and, in particular, hlines under it. The -/// idea is that an auto hline will be placed after the shortest such rowspan. -/// Otherwise, the hline would just be placed under the first row of those -/// rowspans and disappear (except at the presence of column gutter). -fn skip_auto_index_through_fully_merged_rows( - resolved_cells: &[Option<Entry>], - auto_index: &mut usize, - columns: usize, -) { - // If the auto index isn't currently at the start of a row, that means - // there's still at least one auto position left in the row, ignoring - // cells with manual positions, so we wouldn't have a problem in placing - // further cells or, in this case, hlines here. - if *auto_index % columns == 0 { - while resolved_cells - .get(*auto_index..*auto_index + columns) - .is_some_and(|row| { - row.iter().all(|entry| matches!(entry, Some(Entry::Merged { .. }))) - }) - { - *auto_index += columns; - } - } -} diff --git a/crates/typst-layout/src/grid/layouter.rs b/crates/typst-layout/src/grid/layouter.rs index 7c94617d..1f9cf679 100644 --- a/crates/typst-layout/src/grid/layouter.rs +++ b/crates/typst-layout/src/grid/layouter.rs @@ -3,6 +3,7 @@ use std::fmt::Debug; use typst_library::diag::{bail, SourceResult}; use typst_library::engine::Engine; use typst_library::foundations::{Resolve, StyleChain}; +use typst_library::layout::grid::resolve::{Cell, CellGrid, LinePosition, Repeatable}; use typst_library::layout::{ Abs, Axes, Dir, Fr, Fragment, Frame, FrameItem, Length, Point, Region, Regions, Rel, Size, Sizing, @@ -13,8 +14,8 @@ use typst_syntax::Span; use typst_utils::{MaybeReverseIter, Numeric}; use super::{ - generate_line_segments, hline_stroke_at_column, vline_stroke_at_row, Cell, CellGrid, - LinePosition, LineSegment, Repeatable, Rowspan, UnbreakableRowGroup, + generate_line_segments, hline_stroke_at_column, layout_cell, vline_stroke_at_row, + LineSegment, Rowspan, UnbreakableRowGroup, }; /// Performs grid layout. @@ -843,7 +844,8 @@ impl<'a> GridLayouter<'a> { let size = Size::new(available, height); let pod = Region::new(size, Axes::splat(false)); - let frame = cell.layout(engine, 0, self.styles, pod.into())?.into_frame(); + let frame = + layout_cell(cell, engine, 0, self.styles, pod.into())?.into_frame(); resolved.set_max(frame.width() - already_covered_width); } @@ -1086,7 +1088,7 @@ impl<'a> GridLayouter<'a> { }; let frames = - cell.layout(engine, disambiguator, self.styles, pod)?.into_frames(); + layout_cell(cell, engine, disambiguator, self.styles, pod)?.into_frames(); // Skip the first region if one cell in it is empty. Then, // remeasure. @@ -1252,9 +1254,9 @@ impl<'a> GridLayouter<'a> { // rows. pod.full = self.regions.full; } - let frame = cell - .layout(engine, disambiguator, self.styles, pod)? - .into_frame(); + let frame = + layout_cell(cell, engine, disambiguator, self.styles, pod)? + .into_frame(); let mut pos = pos; if self.is_rtl { // In the grid, cell colspans expand to the right, @@ -1310,7 +1312,7 @@ impl<'a> GridLayouter<'a> { // Push the layouted frames into the individual output frames. let fragment = - cell.layout(engine, disambiguator, self.styles, pod)?; + layout_cell(cell, engine, disambiguator, self.styles, pod)?; for (output, frame) in outputs.iter_mut().zip(fragment) { let mut pos = pos; if self.is_rtl { diff --git a/crates/typst-layout/src/grid/lines.rs b/crates/typst-layout/src/grid/lines.rs index 3e89612a..1227953d 100644 --- a/crates/typst-layout/src/grid/lines.rs +++ b/crates/typst-layout/src/grid/lines.rs @@ -1,41 +1,11 @@ -use std::num::NonZeroUsize; use std::sync::Arc; use typst_library::foundations::{AlternativeFold, Fold}; +use typst_library::layout::grid::resolve::{CellGrid, Line, Repeatable}; use typst_library::layout::Abs; use typst_library::visualize::Stroke; -use super::{CellGrid, LinePosition, Repeatable, RowPiece}; - -/// Represents an explicit grid line (horizontal or vertical) specified by the -/// user. -pub struct Line { - /// The index of the track after this line. This will be the index of the - /// row a horizontal line is above of, or of the column right after a - /// vertical line. - /// - /// Must be within `0..=tracks.len()` (where `tracks` is either `grid.cols` - /// or `grid.rows`, ignoring gutter tracks, as appropriate). - pub index: usize, - /// The index of the track at which this line starts being drawn. - /// This is the first column a horizontal line appears in, or the first row - /// a vertical line appears in. - /// - /// Must be within `0..tracks.len()` minus gutter tracks. - pub start: usize, - /// The index after the last track through which the line is drawn. - /// Thus, the line is drawn through tracks `start..end` (note that `end` is - /// exclusive). - /// - /// Must be within `1..=tracks.len()` minus gutter tracks. - /// `None` indicates the line should go all the way to the end. - pub end: Option<NonZeroUsize>, - /// The line's stroke. This is `None` when the line is explicitly used to - /// override a previously specified line. - pub stroke: Option<Arc<Stroke<Abs>>>, - /// The line's position in relation to the track with its index. - pub position: LinePosition, -} +use super::RowPiece; /// Indicates which priority a particular grid line segment should have, based /// on the highest priority configuration that defined the segment's stroke. @@ -588,13 +558,13 @@ pub fn hline_stroke_at_column( #[cfg(test)] mod test { + use std::num::NonZeroUsize; use typst_library::foundations::Content; use typst_library::introspection::Locator; + use typst_library::layout::grid::resolve::{Cell, Entry, LinePosition}; use typst_library::layout::{Axes, Sides, Sizing}; use typst_utils::NonZeroExt; - use super::super::cells::Entry; - use super::super::Cell; use super::*; fn sample_cell() -> Cell<'static> { diff --git a/crates/typst-layout/src/grid/mod.rs b/crates/typst-layout/src/grid/mod.rs index 769bef8c..1b4380f0 100644 --- a/crates/typst-layout/src/grid/mod.rs +++ b/crates/typst-layout/src/grid/mod.rs @@ -1,40 +1,44 @@ -mod cells; mod layouter; mod lines; mod repeated; mod rowspans; -pub use self::cells::{Cell, CellGrid}; pub use self::layouter::GridLayouter; -use std::num::NonZeroUsize; -use std::sync::Arc; - -use ecow::eco_format; -use typst_library::diag::{SourceResult, Trace, Tracepoint}; +use typst_library::diag::SourceResult; use typst_library::engine::Engine; -use typst_library::foundations::{Fold, Packed, Smart, StyleChain}; +use typst_library::foundations::{Packed, StyleChain}; use typst_library::introspection::Locator; -use typst_library::layout::{ - Abs, Alignment, Axes, Dir, Fragment, GridCell, GridChild, GridElem, GridItem, Length, - OuterHAlignment, OuterVAlignment, Regions, Rel, Sides, -}; -use typst_library::model::{TableCell, TableChild, TableElem, TableItem}; -use typst_library::text::TextElem; -use typst_library::visualize::{Paint, Stroke}; -use typst_syntax::Span; +use typst_library::layout::grid::resolve::{grid_to_cellgrid, table_to_cellgrid, Cell}; +use typst_library::layout::{Fragment, GridElem, Regions}; +use typst_library::model::TableElem; -use self::cells::{ - LinePosition, ResolvableCell, ResolvableGridChild, ResolvableGridItem, -}; use self::layouter::RowPiece; use self::lines::{ - generate_line_segments, hline_stroke_at_column, vline_stroke_at_row, Line, - LineSegment, + generate_line_segments, hline_stroke_at_column, vline_stroke_at_row, LineSegment, }; -use self::repeated::{Footer, Header, Repeatable}; use self::rowspans::{Rowspan, UnbreakableRowGroup}; +/// Layout the cell into the given regions. +/// +/// The `disambiguator` indicates which instance of this cell this should be +/// layouted as. For normal cells, it is always `0`, but for headers and +/// footers, it indicates the index of the header/footer among all. See the +/// [`Locator`] docs for more details on the concepts behind this. +pub fn layout_cell( + cell: &Cell, + engine: &mut Engine, + disambiguator: usize, + styles: StyleChain, + regions: Regions, +) -> SourceResult<Fragment> { + let mut locator = cell.locator.relayout(); + if disambiguator > 0 { + locator = locator.split().next_inner(disambiguator as u128); + } + crate::layout_fragment(engine, &cell.body, locator, styles, regions) +} + /// Layout the grid. #[typst_macros::time(span = elem.span())] pub fn layout_grid( @@ -44,54 +48,8 @@ pub fn layout_grid( styles: StyleChain, regions: Regions, ) -> SourceResult<Fragment> { - let inset = elem.inset(styles); - let align = elem.align(styles); - let columns = elem.columns(styles); - let rows = elem.rows(styles); - let column_gutter = elem.column_gutter(styles); - let row_gutter = elem.row_gutter(styles); - let fill = elem.fill(styles); - let stroke = elem.stroke(styles); - - let tracks = Axes::new(columns.0.as_slice(), rows.0.as_slice()); - let gutter = Axes::new(column_gutter.0.as_slice(), row_gutter.0.as_slice()); - // Use trace to link back to the grid when a specific cell errors - let tracepoint = || Tracepoint::Call(Some(eco_format!("grid"))); - let resolve_item = |item: &GridItem| grid_item_to_resolvable(item, styles); - let children = elem.children().iter().map(|child| match child { - GridChild::Header(header) => ResolvableGridChild::Header { - repeat: header.repeat(styles), - span: header.span(), - items: header.children().iter().map(resolve_item), - }, - GridChild::Footer(footer) => ResolvableGridChild::Footer { - repeat: footer.repeat(styles), - span: footer.span(), - items: footer.children().iter().map(resolve_item), - }, - GridChild::Item(item) => { - ResolvableGridChild::Item(grid_item_to_resolvable(item, styles)) - } - }); - let grid = CellGrid::resolve( - tracks, - gutter, - locator, - children, - fill, - align, - &inset, - &stroke, - engine, - styles, - elem.span(), - ) - .trace(engine.world, tracepoint, elem.span())?; - - let layouter = GridLayouter::new(&grid, regions, styles, elem.span()); - - // Measure the columns and layout the grid row-by-row. - layouter.layout(engine) + let grid = grid_to_cellgrid(elem, engine, locator, styles)?; + GridLayouter::new(&grid, regions, styles, elem.span()).layout(engine) } /// Layout the table. @@ -103,314 +61,6 @@ pub fn layout_table( styles: StyleChain, regions: Regions, ) -> SourceResult<Fragment> { - let inset = elem.inset(styles); - let align = elem.align(styles); - let columns = elem.columns(styles); - let rows = elem.rows(styles); - let column_gutter = elem.column_gutter(styles); - let row_gutter = elem.row_gutter(styles); - let fill = elem.fill(styles); - let stroke = elem.stroke(styles); - - let tracks = Axes::new(columns.0.as_slice(), rows.0.as_slice()); - let gutter = Axes::new(column_gutter.0.as_slice(), row_gutter.0.as_slice()); - // Use trace to link back to the table when a specific cell errors - let tracepoint = || Tracepoint::Call(Some(eco_format!("table"))); - let resolve_item = |item: &TableItem| table_item_to_resolvable(item, styles); - let children = elem.children().iter().map(|child| match child { - TableChild::Header(header) => ResolvableGridChild::Header { - repeat: header.repeat(styles), - span: header.span(), - items: header.children().iter().map(resolve_item), - }, - TableChild::Footer(footer) => ResolvableGridChild::Footer { - repeat: footer.repeat(styles), - span: footer.span(), - items: footer.children().iter().map(resolve_item), - }, - TableChild::Item(item) => { - ResolvableGridChild::Item(table_item_to_resolvable(item, styles)) - } - }); - let grid = CellGrid::resolve( - tracks, - gutter, - locator, - children, - fill, - align, - &inset, - &stroke, - engine, - styles, - elem.span(), - ) - .trace(engine.world, tracepoint, elem.span())?; - - let layouter = GridLayouter::new(&grid, regions, styles, elem.span()); - layouter.layout(engine) -} - -fn grid_item_to_resolvable( - item: &GridItem, - styles: StyleChain, -) -> ResolvableGridItem<Packed<GridCell>> { - match item { - GridItem::HLine(hline) => ResolvableGridItem::HLine { - y: hline.y(styles), - start: hline.start(styles), - end: hline.end(styles), - stroke: hline.stroke(styles), - span: hline.span(), - position: match hline.position(styles) { - OuterVAlignment::Top => LinePosition::Before, - OuterVAlignment::Bottom => LinePosition::After, - }, - }, - GridItem::VLine(vline) => ResolvableGridItem::VLine { - x: vline.x(styles), - start: vline.start(styles), - end: vline.end(styles), - stroke: vline.stroke(styles), - span: vline.span(), - position: match vline.position(styles) { - OuterHAlignment::Left if TextElem::dir_in(styles) == Dir::RTL => { - LinePosition::After - } - OuterHAlignment::Right if TextElem::dir_in(styles) == Dir::RTL => { - LinePosition::Before - } - OuterHAlignment::Start | OuterHAlignment::Left => LinePosition::Before, - OuterHAlignment::End | OuterHAlignment::Right => LinePosition::After, - }, - }, - GridItem::Cell(cell) => ResolvableGridItem::Cell(cell.clone()), - } -} - -fn table_item_to_resolvable( - item: &TableItem, - styles: StyleChain, -) -> ResolvableGridItem<Packed<TableCell>> { - match item { - TableItem::HLine(hline) => ResolvableGridItem::HLine { - y: hline.y(styles), - start: hline.start(styles), - end: hline.end(styles), - stroke: hline.stroke(styles), - span: hline.span(), - position: match hline.position(styles) { - OuterVAlignment::Top => LinePosition::Before, - OuterVAlignment::Bottom => LinePosition::After, - }, - }, - TableItem::VLine(vline) => ResolvableGridItem::VLine { - x: vline.x(styles), - start: vline.start(styles), - end: vline.end(styles), - stroke: vline.stroke(styles), - span: vline.span(), - position: match vline.position(styles) { - OuterHAlignment::Left if TextElem::dir_in(styles) == Dir::RTL => { - LinePosition::After - } - OuterHAlignment::Right if TextElem::dir_in(styles) == Dir::RTL => { - LinePosition::Before - } - OuterHAlignment::Start | OuterHAlignment::Left => LinePosition::Before, - OuterHAlignment::End | OuterHAlignment::Right => LinePosition::After, - }, - }, - TableItem::Cell(cell) => ResolvableGridItem::Cell(cell.clone()), - } -} - -impl ResolvableCell for Packed<TableCell> { - fn resolve_cell<'a>( - mut self, - x: usize, - y: usize, - fill: &Option<Paint>, - align: Smart<Alignment>, - inset: Sides<Option<Rel<Length>>>, - stroke: Sides<Option<Option<Arc<Stroke<Abs>>>>>, - breakable: bool, - locator: Locator<'a>, - styles: StyleChain, - ) -> Cell<'a> { - let cell = &mut *self; - let colspan = cell.colspan(styles); - let rowspan = cell.rowspan(styles); - let breakable = cell.breakable(styles).unwrap_or(breakable); - let fill = cell.fill(styles).unwrap_or_else(|| fill.clone()); - - let cell_stroke = cell.stroke(styles); - let stroke_overridden = - cell_stroke.as_ref().map(|side| matches!(side, Some(Some(_)))); - - // Using a typical 'Sides' fold, an unspecified side loses to a - // specified side. Additionally, when both are specified, an inner - // None wins over the outer Some, and vice-versa. When both are - // specified and Some, fold occurs, which, remarkably, leads to an Arc - // clone. - // - // In the end, we flatten because, for layout purposes, an unspecified - // cell stroke is the same as specifying 'none', so we equate the two - // concepts. - let stroke = cell_stroke.fold(stroke).map(Option::flatten); - cell.push_x(Smart::Custom(x)); - cell.push_y(Smart::Custom(y)); - cell.push_fill(Smart::Custom(fill.clone())); - cell.push_align(match align { - Smart::Custom(align) => { - Smart::Custom(cell.align(styles).map_or(align, |inner| inner.fold(align))) - } - // Don't fold if the table is using outer alignment. Use the - // cell's alignment instead (which, in the end, will fold with - // the outer alignment when it is effectively displayed). - Smart::Auto => cell.align(styles), - }); - cell.push_inset(Smart::Custom( - cell.inset(styles).map_or(inset, |inner| inner.fold(inset)), - )); - cell.push_stroke( - // Here we convert the resolved stroke to a regular stroke, however - // with resolved units (that is, 'em' converted to absolute units). - // We also convert any stroke unspecified by both the cell and the - // outer stroke ('None' in the folded stroke) to 'none', that is, - // all sides are present in the resulting Sides object accessible - // by show rules on table cells. - stroke.as_ref().map(|side| { - Some(side.as_ref().map(|cell_stroke| { - Arc::new((**cell_stroke).clone().map(Length::from)) - })) - }), - ); - cell.push_breakable(Smart::Custom(breakable)); - Cell { - body: self.pack(), - locator, - fill, - colspan, - rowspan, - stroke, - stroke_overridden, - breakable, - } - } - - fn x(&self, styles: StyleChain) -> Smart<usize> { - (**self).x(styles) - } - - fn y(&self, styles: StyleChain) -> Smart<usize> { - (**self).y(styles) - } - - fn colspan(&self, styles: StyleChain) -> NonZeroUsize { - (**self).colspan(styles) - } - - fn rowspan(&self, styles: StyleChain) -> NonZeroUsize { - (**self).rowspan(styles) - } - - fn span(&self) -> Span { - Packed::span(self) - } -} - -impl ResolvableCell for Packed<GridCell> { - fn resolve_cell<'a>( - mut self, - x: usize, - y: usize, - fill: &Option<Paint>, - align: Smart<Alignment>, - inset: Sides<Option<Rel<Length>>>, - stroke: Sides<Option<Option<Arc<Stroke<Abs>>>>>, - breakable: bool, - locator: Locator<'a>, - styles: StyleChain, - ) -> Cell<'a> { - let cell = &mut *self; - let colspan = cell.colspan(styles); - let rowspan = cell.rowspan(styles); - let breakable = cell.breakable(styles).unwrap_or(breakable); - let fill = cell.fill(styles).unwrap_or_else(|| fill.clone()); - - let cell_stroke = cell.stroke(styles); - let stroke_overridden = - cell_stroke.as_ref().map(|side| matches!(side, Some(Some(_)))); - - // Using a typical 'Sides' fold, an unspecified side loses to a - // specified side. Additionally, when both are specified, an inner - // None wins over the outer Some, and vice-versa. When both are - // specified and Some, fold occurs, which, remarkably, leads to an Arc - // clone. - // - // In the end, we flatten because, for layout purposes, an unspecified - // cell stroke is the same as specifying 'none', so we equate the two - // concepts. - let stroke = cell_stroke.fold(stroke).map(Option::flatten); - cell.push_x(Smart::Custom(x)); - cell.push_y(Smart::Custom(y)); - cell.push_fill(Smart::Custom(fill.clone())); - cell.push_align(match align { - Smart::Custom(align) => { - Smart::Custom(cell.align(styles).map_or(align, |inner| inner.fold(align))) - } - // Don't fold if the grid is using outer alignment. Use the - // cell's alignment instead (which, in the end, will fold with - // the outer alignment when it is effectively displayed). - Smart::Auto => cell.align(styles), - }); - cell.push_inset(Smart::Custom( - cell.inset(styles).map_or(inset, |inner| inner.fold(inset)), - )); - cell.push_stroke( - // Here we convert the resolved stroke to a regular stroke, however - // with resolved units (that is, 'em' converted to absolute units). - // We also convert any stroke unspecified by both the cell and the - // outer stroke ('None' in the folded stroke) to 'none', that is, - // all sides are present in the resulting Sides object accessible - // by show rules on grid cells. - stroke.as_ref().map(|side| { - Some(side.as_ref().map(|cell_stroke| { - Arc::new((**cell_stroke).clone().map(Length::from)) - })) - }), - ); - cell.push_breakable(Smart::Custom(breakable)); - Cell { - body: self.pack(), - locator, - fill, - colspan, - rowspan, - stroke, - stroke_overridden, - breakable, - } - } - - fn x(&self, styles: StyleChain) -> Smart<usize> { - (**self).x(styles) - } - - fn y(&self, styles: StyleChain) -> Smart<usize> { - (**self).y(styles) - } - - fn colspan(&self, styles: StyleChain) -> NonZeroUsize { - (**self).colspan(styles) - } - - fn rowspan(&self, styles: StyleChain) -> NonZeroUsize { - (**self).rowspan(styles) - } - - fn span(&self) -> Span { - Packed::span(self) - } + let grid = table_to_cellgrid(elem, engine, locator, styles)?; + GridLayouter::new(&grid, regions, styles, elem.span()).layout(engine) } diff --git a/crates/typst-layout/src/grid/repeated.rs b/crates/typst-layout/src/grid/repeated.rs index 8d08d56d..22d2a09e 100644 --- a/crates/typst-layout/src/grid/repeated.rs +++ b/crates/typst-layout/src/grid/repeated.rs @@ -1,50 +1,11 @@ use typst_library::diag::SourceResult; use typst_library::engine::Engine; +use typst_library::layout::grid::resolve::{Footer, Header, Repeatable}; use typst_library::layout::{Abs, Axes, Frame, Regions}; use super::layouter::GridLayouter; use super::rowspans::UnbreakableRowGroup; -/// A repeatable grid header. Starts at the first row. -pub struct Header { - /// The index after the last row included in this header. - pub end: usize, -} - -/// A repeatable grid footer. Stops at the last row. -pub struct Footer { - /// The first row included in this footer. - pub start: usize, -} - -/// A possibly repeatable grid object. -/// It still exists even when not repeatable, but must not have additional -/// considerations by grid layout, other than for consistency (such as making -/// a certain group of rows unbreakable). -pub enum Repeatable<T> { - Repeated(T), - NotRepeated(T), -} - -impl<T> Repeatable<T> { - /// Gets the value inside this repeatable, regardless of whether - /// it repeats. - pub fn unwrap(&self) -> &T { - match self { - Self::Repeated(repeated) => repeated, - Self::NotRepeated(not_repeated) => not_repeated, - } - } - - /// Returns `Some` if the value is repeated, `None` otherwise. - pub fn as_repeated(&self) -> Option<&T> { - match self { - Self::Repeated(repeated) => Some(repeated), - Self::NotRepeated(_) => None, - } - } -} - impl GridLayouter<'_> { /// Layouts the header's rows. /// Skips regions as necessary. diff --git a/crates/typst-layout/src/grid/rowspans.rs b/crates/typst-layout/src/grid/rowspans.rs index 93d4c960..5039695d 100644 --- a/crates/typst-layout/src/grid/rowspans.rs +++ b/crates/typst-layout/src/grid/rowspans.rs @@ -1,12 +1,12 @@ use typst_library::diag::SourceResult; use typst_library::engine::Engine; use typst_library::foundations::Resolve; +use typst_library::layout::grid::resolve::Repeatable; use typst_library::layout::{Abs, Axes, Frame, Point, Region, Regions, Size, Sizing}; use typst_utils::MaybeReverseIter; use super::layouter::{in_last_with_offset, points, Row, RowPiece}; -use super::repeated::Repeatable; -use super::{Cell, GridLayouter}; +use super::{layout_cell, Cell, GridLayouter}; /// All information needed to layout a single rowspan. pub struct Rowspan { @@ -141,7 +141,7 @@ impl GridLayouter<'_> { } // Push the layouted frames directly into the finished frames. - let fragment = cell.layout(engine, disambiguator, self.styles, pod)?; + let fragment = layout_cell(cell, engine, disambiguator, self.styles, pod)?; let (current_region, current_rrows) = current_region_data.unzip(); for ((i, finished), frame) in self .finished diff --git a/crates/typst-layout/src/lists.rs b/crates/typst-layout/src/lists.rs index 0d51a1e4..9479959b 100644 --- a/crates/typst-layout/src/lists.rs +++ b/crates/typst-layout/src/lists.rs @@ -4,11 +4,12 @@ use typst_library::diag::SourceResult; use typst_library::engine::Engine; use typst_library::foundations::{Content, Context, Depth, Packed, StyleChain}; use typst_library::introspection::Locator; +use typst_library::layout::grid::resolve::{Cell, CellGrid}; use typst_library::layout::{Axes, Fragment, HAlignment, Regions, Sizing, VAlignment}; use typst_library::model::{EnumElem, ListElem, Numbering, ParElem}; use typst_library::text::TextElem; -use crate::grid::{Cell, CellGrid, GridLayouter}; +use crate::grid::GridLayouter; /// Layout the list. #[typst_macros::time(span = elem.span())] |