Struct Table 

pub struct Table<'a> { /* private fields */ }

A widget to display data in formatted columns.

It is a collection of Rows, themselves composed of Cells:

Table::new(vec![
    // Row can be created from simple strings.
    Row::new(vec!["Row11", "Row12", "Row13"]),
    // You can style the entire row.
    Row::new(vec!["Row21", "Row22", "Row23"]).style(Style::default().fg(Color::Blue)),
    // If you need more control over the styling you may need to create Cells directly
    Row::new(vec![
        Cell::from("Row31"),
        Cell::from("Row32").style(Style::default().fg(Color::Yellow)),
        Cell::from(Spans::from(vec![
            Span::raw("Row"),
            Span::styled("33", Style::default().fg(Color::Green))
        ])),
    ]),
    // If a Row need to display some content over multiple lines, you just have to change
    // its height.
    Row::new(vec![
        Cell::from("Row\n41"),
        Cell::from("Row\n42"),
        Cell::from("Row\n43"),
    ]).height(2),
])
// You can set the style of the entire Table.
.style(Style::default().fg(Color::White))
// It has an optional header, which is simply a Row always visible at the top.
.header(
    Row::new(vec!["Col1", "Col2", "Col3"])
        .style(Style::default().fg(Color::Yellow))
        // If you want some space between the header and the rest of the rows, you can always
        // specify some margin at the bottom.
        .bottom_margin(1)
)
// As any other widget, a Table can be wrapped in a Block.
.block(Block::default().title("Table"))
// Columns widths are constrained in the same way as Layout...
.widths(&[Constraint::Length(5), Constraint::Length(5), Constraint::Length(10)])
// ...and they can be separated by a fixed spacing.
.column_spacing(1)
// If you wish to highlight a row in any specific way when it is selected...
.highlight_style(Style::default().add_modifier(Modifier::BOLD))
// ...and potentially show a symbol in front of the selection.
.highlight_symbol(">>");

Implementations

impl<'a> Table<'a>

pub fn new<T>(rows: T) -> Self

where T: IntoIterator<Item = Row<'a>>,

pub fn block(self, block: Block<'a>) -> Self

pub fn header(self, header: Row<'a>) -> Self

pub fn widths(self, widths: &'a [Constraint]) -> Self

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

pub fn highlight_symbol(self, highlight_symbol: &'a str) -> Self

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

pub fn column_spacing(self, spacing: u16) -> Self

Trait Implementations

impl<'a> Clone for Table<'a>

fn clone(&self) -> Table<'a>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for Table<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> PartialEq for Table<'a>

fn eq(&self, other: &Table<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> StatefulWidget for Table<'a>

type State = TableState

fn render(self, area: Rect, buf: &mut Buffer, state: &mut Self::State)

impl<'a> Widget for Table<'a>

fn render(self, area: Rect, buf: &mut Buffer)

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

impl<'a> StructuralPartialEq for Table<'a>