Struct CellGrid

pub struct CellGrid<'a> {
    pub entries: Vec<Entry<'a>>,
    pub cols: Vec<Sizing>,
    pub rows: Vec<Sizing>,
    pub vlines: Vec<Vec<Line>>,
    pub hlines: Vec<Vec<Line>>,
    pub header: Option<Repeatable<Header>>,
    pub footer: Option<Repeatable<Footer>>,
    pub has_gutter: bool,
}

A grid of cells, including the columns, rows, and cell data.

Fields

entries: Vec<Entry<'a>>

The grid cells.

cols: Vec<Sizing>

The column tracks including gutter tracks.

rows: Vec<Sizing>

The row tracks including gutter tracks.

vlines: Vec<Vec<Line>>

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.

hlines: 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.

header: Option<Repeatable<Header>>

The repeatable header of this grid.

footer: Option<Repeatable<Footer>>

The repeatable footer of this grid.

has_gutter: bool

Whether this grid has gutters.

Implementations

impl<'a> CellGrid<'a>

pub fn new( tracks: Axes<&[Sizing]>, gutter: Axes<&[Sizing]>, cells: impl IntoIterator<Item = Cell<'a>>, ) -> CellGrid<'a>

Generates the cell grid, given the tracks and cells.

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>>>, stroke: &ResolvedCelled<Sides<Option<Option<Arc<Stroke>>>>>, engine: &mut Engine<'_>, styles: StyleChain<'_>, span: Span, ) -> Result<CellGrid<'a>, EcoVec<SourceDiagnostic>>

where T: ResolvableCell + Default, I: Iterator<Item = ResolvableGridItem<T>>, C: IntoIterator<Item = ResolvableGridChild<T, I>>, <C as IntoIterator>::IntoIter: ExactSizeIterator,

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.

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>>, ) -> CellGrid<'a>

Generates the cell grid, given the tracks and resolved entries.

pub fn entry(&self, x: usize, y: usize) -> Option<&Entry<'a>>

Get the grid entry in column x and row y.

Returns None if it’s a gutter cell.

pub fn cell(&self, x: usize, y: usize) -> Option<&Cell<'a>>

Get the content of the cell in column x and row y.

Returns None if it’s a gutter cell or merged position.

pub fn parent_cell_position(&self, x: usize, y: usize) -> Option<Axes<usize>>

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.

pub fn effective_parent_cell_position( &self, x: usize, y: usize, ) -> Option<Axes<usize>>

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).

pub fn is_gutter_track(&self, index: usize) -> bool

Checks if the track with the given index is gutter. Does not check if the index is a valid track.

pub fn effective_colspan_of_cell(&self, cell: &Cell<'_>) -> usize

Returns the effective colspan of a cell, considering the gutters it might span if the grid has gutters.

pub fn effective_rowspan_of_cell(&self, cell: &Cell<'_>) -> usize

Returns the effective rowspan of a cell, considering the gutters it might span if the grid has gutters.

pub fn non_gutter_column_count(&self) -> usize