Struct Table 

pub struct Table { /* private fields */ }

A grid of cells rendered inside a box. Mirrors rich.table.Table.

Implementations

impl Table

pub fn new() -> Self

pub fn grid() -> Self

A table with no borders, for laying out columns. Port of Table.grid: box=None, no header or edge, padding=0, collapse_padding=True and pad_edge=False.

pub fn without_box(self) -> Self

Draw no borders and no column dividers (upstream box=None).

pub fn padding( self, top: usize, right: usize, bottom: usize, left: usize, ) -> Self

Cell padding as (top, right, bottom, left) (upstream padding).

pub fn box_set(self, box_set: BoxSet) -> Self

Choose the box-drawing set.

pub fn border_style(self, style: Style) -> Self

Style the box border (edges + dividers). Composed over the table-level style: border = style + border_style. Port of Table(border_style=…).

pub fn show_header(self, show: bool) -> Self

Whether to render the header row.

pub fn expand(self, expand: bool) -> Self

Expand the table to fill the available width.

pub fn show_lines(self, show: bool) -> Self

Draw a separator line between each body row.

pub fn show_edge(self, show: bool) -> Self

Draw the outer box edges (top/bottom borders + left/right glyphs). When off, only the internal dividers and content remain. Port of show_edge.

pub fn pad_edge(self, pad: bool) -> Self

Pad the outer cell edges. When off, the first column drops its left pad and the last column its right pad. Port of pad_edge.

pub fn collapse_padding(self, collapse: bool) -> Self

Merge adjacent cell padding: an interior column’s left pad is reduced by the previous column’s right pad. Port of collapse_padding.

pub fn style(self, style: Style) -> Self

Default style for the whole table. Upstream applies it as the base of the border style (border_style = style + border_style); cell content keeps its own styles. Port of Table(style=…).

pub fn highlight(self, highlight: bool) -> Self

Highlight string cells with the console’s highlighter (upstream Table(highlight=…), default off). Columns added without their own setting use it.

pub fn title(self, title: impl Into<String>) -> Self

A centered title rendered above the table.

pub fn caption(self, caption: impl Into<String>) -> Self

A centered caption rendered below the table.

pub fn add_column(&mut self, header: impl Into<String>) -> &mut Self

Add a left-justified column with the given header, which is console markup as upstream’s add_column("[b]Name") is.

pub fn add_column_justify( &mut self, header: impl Into<String>, justify: Justify, ) -> &mut Self

Add a column with an explicit justification. The header is console markup; use add_column_text for a literal one.

pub fn add_column_text(&mut self, header: Text, justify: Justify) -> &mut Self

Add a column whose header is a styled Text, as upstream’s add_column(header=Text(...)) does. The text’s spans survive into the header cell; its own justify, overflow and no_wrap override the column’s, as Text.__rich_console__ prefers them over the options.

pub fn add_column_with( &mut self, header: Text, options: ColumnOptions, ) -> &mut Self

Add a column with every ColumnOptions set, as upstream’s add_column(header, justify=…, width=…, ratio=…, …) does.

pub fn column_width(&mut self, width: usize) -> &mut Self

Pin the most-recently-added column to an explicit content width. Content wider than this wraps (with ellipsis overflow) instead of shrinking the column. Chain after add_column.

pub fn column_ratio(&mut self, ratio: usize) -> &mut Self

Give the most-recently-added column a flex ratio: when the table is expanded, ratio columns share the free width in proportion. Chain after add_column. Port of Column.ratio.

pub fn column_min_width(&mut self, min_width: usize) -> &mut Self

Set a minimum content width on the most-recently-added column. Chain after add_column. Port of Column.min_width.

pub fn column_max_width(&mut self, max_width: usize) -> &mut Self

Set a maximum content width on the most-recently-added column — wider cells wrap. Chain after add_column. Port of Column.max_width.

pub fn column_style(&mut self, style: Style) -> &mut Self

Apply a style to the most-recently-added column’s body cells. Chain after add_column.

pub fn column_header_style(&mut self, style: Style) -> &mut Self

Style the most-recently-added column’s header content (the visible characters), leaving its padding as the base header_style. Chain after add_column. Mirrors upstream stylizing the heading Text.

pub fn column_header_fill(&mut self, style: Style) -> &mut Self

Style the most-recently-added column’s whole header cell (content + padding), combined over the table-level header_style. Chain after add_column. Port of Column.header_style.

pub fn column_overflow(&mut self, overflow: Overflow) -> &mut Self

Set how the most-recently-added column handles over-long text (upstream Column.overflow, default ellipsis). Chain after add_column.

pub fn column_highlight(&mut self, highlight: bool) -> &mut Self

Set whether the most-recently-added column highlights its string cells (upstream Column.highlight). Chain after add_column.

pub fn column_no_wrap(&mut self) -> &mut Self

Mark the most-recently-added column no_wrap: its cells crop to a single line (with ellipsis) instead of wrapping. Chain after add_column.

pub fn add_row(&mut self, cells: &[&str]) -> &mut Self

Add a row of string cells (extra cells are ignored; missing cells render empty). Each string is console markup, as upstream’s add_row("[b]x") is; use add_row_text for literal data.

pub fn add_row_text(&mut self, cells: Vec<Text>) -> &mut Self

Add a row of styled Text cells, as upstream’s add_row(Text(...)). Each cell keeps its spans, and its own justify, overflow and no_wrap override the column’s.

pub fn add_row_cells(&mut self, cells: Vec<Cell>) -> &mut Self

Add a row of Cells, which may be any renderable.

Trait Implementations

impl Default for Table

fn default() -> Self

Returns the “default value” for a type.

impl LineRenderable for Table

fn try_for_each_line<E>( &self, console: &Console, options: &ConsoleOptions, emit: impl FnMut(Vec<Segment>) -> Result<(), E>, ) -> Result<(), E>

Render visual lines in order without retaining the full rendered table.

Like upstream’s Table.__rich_console__ / _render generators, this measures all columns first, then renders only one row block at a time. Lines contain styled segments without a trailing newline. The callback may write each line immediately; its first error stops rendering. The table still owns its source rows for column-width measurement.

impl OwnedTableRows for Table

fn extend_owned_rows(&mut self, rows: Vec<Vec<String>>) -> &mut Self

impl Renderable for Table

fn measure(&self, console: &Console, options: &ConsoleOptions) -> Measurement

Port of Table.__rich_measure__: the column widths the table would render at, then each column measured within their total.

fn rich_render( &self, console: &Console, options: &ConsoleOptions, ) -> Vec<Segment>

fn fit_to_measurement(&self) -> bool

Whether a top-level Console::print shrinks this renderable to its measured width. Upstream renders every top-level renderable at the full console width, so the default is false; an extension may opt in.