Struct Table 

pub struct Table<'a, T, Selection = RowSelection>
where
    T: Copy,
{ /* private fields */ }

Table widget that renders data from an Iterator.

This will do minimal rendering of the visible rows/cells of the table.

Table::default()
        .data(state.table_data.iter())
        .widths([
            Constraint::Length(6),
            Constraint::Length(20),
            Constraint::Length(15),
            Constraint::Length(15),
            Constraint::Length(3),
        ])
        .render_cell(0, |_v, area, buf, ctx| {
            format!("{:>5}", ctx.row).render(area, buf)
        })
        .render_cell(1, |v, area, buf, _ctx| {
            v.text.render(area, buf)
        })
        .render_cell(2, |v, area, buf, _ctx| {
            format!("{:5.2}", v.num1).render(area, buf)
        })
        .render_cell(3, |v, area, buf, _ctx| {
            format!("{:5.2}", v.num2).render(area, buf)
        })
        .render_cell(4, |v, area, buf, _ctx| {
            let cc = if v.check { "\u{2622}" } else { "\u{2623}" };
            cc.render(area, buf);
        })
        .column_spacing(1)
        .header(vec!["Nr", "Text", "Val1", "Val2", "State"])
        .footer(vec!["a", "b", "c", "d", "e"])
        .block(
            Block::bordered()
                .border_type(BorderType::Rounded)
                .title("tabledata-iter (no row-count)"),
        )
        .vscroll(Scroll::new())
        .styles(table(&ctx.theme))
        .render(l0[0], buf, &mut state.table);

Implementations

impl<'a, T, Selection> Table<'a, T, Selection>

where T: Copy,

pub fn new() -> Table<'a, T, Selection>

where Selection: Default,

New, empty Table.

pub fn data( self, data: impl IntoIterator<Item = T> + 'a, ) -> Table<'a, T, Selection>

Set the table-data as an iterator over the row-values.

pub fn row_height( self, row_height_fn: impl FnMut(T, &TableContext<'_>) -> u8 + 'a, ) -> Table<'a, T, Selection>

A closure that calculates the row-height for a given row-value.

pub fn render_row( self, render_row_fn: impl FnMut(T, Rect, &mut Buffer, &TableContext<'_>) -> bool + 'a, ) -> Table<'a, T, Selection>

A closure for row-level rendering. The area covers the full row.

Return

Returns true if the individual cells should be rendered too.

pub fn render_cell( self, column: usize, render_cell_fn: impl FnMut(T, Rect, &mut Buffer, &TableContext<'_>) + 'a, ) -> Table<'a, T, Selection>

A closure for rendering a single column.

The area covers the exact column. Extra information is available in the TableContext.

The given Buffer covers the full row so you could render something outside the cells bounds. Cells for a given row are always rendered in ascending order.

pub fn header<I>(self, header: I) -> Table<'a, T, Selection>

where I: IntoIterator, <I as IntoIterator>::Item: Into<Text<'a>>,

Set the table-header.

pub fn footer<I>(self, footer: I) -> Table<'a, T, Selection>

where I: IntoIterator, <I as IntoIterator>::Item: Into<Text<'a>>,

Set the table-footer.

pub fn widths<I>(self, widths: I) -> Table<'a, T, Selection>

where I: IntoIterator, <I as IntoIterator>::Item: Into<Constraint>,

Column widths as Constraints.

The constraints work in tandem with Table::layout_width.

pub fn varying_heights(self, varying: bool) -> Table<'a, T, Selection>

If your table uses varying row-heights for each row calculating visible positions and offsets will fail.

If you set this flag the row-height for each row is stored in the state and will be used for positioning and offset.

pub fn flex(self, flex: Flex) -> Table<'a, T, Selection>

Flex for the column layout.

pub fn column_spacing(self, spacing: u16) -> Table<'a, T, Selection>

Spacing between columns.

pub fn layout_width(self, width: LayoutWidth) -> Table<'a, T, Selection>

Set the display width of the table.

Default The width of the rendered area is used.

pub fn block(self, block: Block<'a>) -> Table<'a, T, Selection>

Draws a block around the table widget.

pub fn border_style(self, style: Style) -> Table<'a, T, Selection>

Sets the border-style for the Block, if any.

pub fn title_style(self, style: Style) -> Table<'a, T, Selection>

Sets the title-style for the Block, if any.

pub fn scroll(self, scroll: Scroll<'a>) -> Table<'a, T, Selection>

Scrollbars

pub fn hscroll(self, scroll: Scroll<'a>) -> Table<'a, T, Selection>

Scrollbars

pub fn vscroll(self, scroll: Scroll<'a>) -> Table<'a, T, Selection>

Scrollbars

pub fn styles(self, styles: TableStyle) -> Table<'a, T, Selection>

Set all styles as a bundle.

pub fn style(self, style: Style) -> Table<'a, T, Selection>

Base style for the table.

pub fn header_style(self, style: Option<Style>) -> Table<'a, T, Selection>

Base style for the table.

pub fn footer_style(self, style: Option<Style>) -> Table<'a, T, Selection>

Base style for the table.

pub fn select_row_style( self, select_style: Option<Style>, ) -> Table<'a, T, Selection>

Style for a selected row. The chosen selection must support row-selection for this to take effect.

pub fn show_row_focus(self, show: bool) -> Table<'a, T, Selection>

Add the focus-style to the row-style if the table is focused.

pub fn select_column_style( self, select_style: Option<Style>, ) -> Table<'a, T, Selection>

Style for a selected column. The chosen selection must support column-selection for this to take effect.

pub fn show_column_focus(self, show: bool) -> Table<'a, T, Selection>

Add the focus-style to the column-style if the table is focused.

pub fn select_cell_style( self, select_style: Option<Style>, ) -> Table<'a, T, Selection>

Style for a selected cell. The chosen selection must support cell-selection for this to take effect.

pub fn show_cell_focus(self, show: bool) -> Table<'a, T, Selection>

Add the focus-style to the cell-style if the table is focused.

pub fn select_header_style( self, select_style: Option<Style>, ) -> Table<'a, T, Selection>

Style for a selected header cell. The chosen selection must support column-selection for this to take effect.

pub fn show_header_focus(self, show: bool) -> Table<'a, T, Selection>

Add the focus-style to the header-style if the table is focused.

pub fn select_footer_style( self, select_style: Option<Style>, ) -> Table<'a, T, Selection>

Style for a selected footer cell. The chosen selection must support column-selection for this to take effect.

pub fn show_footer_focus(self, show: bool) -> Table<'a, T, Selection>

Add the footer-style to the table-style if the table is focused.

pub fn focus_style(self, focus_style: Option<Style>) -> Table<'a, T, Selection>

This style will be patched onto the selection to indicate that the widget has the input focus.

The selection must support some kind of selection for this to be effective.

pub fn width(&self) -> u16

Inherent width.

pub fn height(&self) -> u16

Inherent height.

Trait Implementations

impl<'a, T, Selection> Default for Table<'a, T, Selection>

where T: Copy,

fn default() -> Table<'a, T, Selection>

Returns the “default value” for a type.

impl<'a, T, Selection> StatefulWidget for Table<'a, T, Selection>

where T: Copy + 'a, Selection: TableSelection + Default,

type State = TableState<Selection>

State associated with the stateful widget.

fn render( self, area: Rect, buf: &mut Buffer, state: &mut <Table<'a, T, Selection> as StatefulWidget>::State, )

Draws the current state of the widget in the given buffer. That is the only method required to implement a custom stateful widget.