Struct ratatui::widgets::Cell

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

A Cell contains the Text to be displayed in a Row of a Table.

It can be created from anything that can be converted to a Text.

Cell::from("simple string");

Cell::from(Span::from("span"));

Cell::from(Line::from(vec![
    Span::raw("a vec of "),
    Span::styled("spans", Style::default().add_modifier(Modifier::BOLD))
]));

Cell::from(Text::from("a text"));

Cell::from(Text::from(Cow::Borrowed("hello")));

You can apply a Style on the entire Cell using Cell::style or rely on the styling capabilities of Text.

Implementations

impl<'a> Cell<'a>

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

Set the Style of this cell.

Examples found in repository

examples/table.rs (line 131)

fn ui<B: Backend>(f: &mut Frame<B>, app: &mut App) {
    let rects = Layout::default()
        .constraints([Constraint::Percentage(100)].as_ref())
        .margin(5)
        .split(f.size());

    let selected_style = Style::default().add_modifier(Modifier::REVERSED);
    let normal_style = Style::default().bg(Color::Blue);
    let header_cells = ["Header1", "Header2", "Header3"]
        .iter()
        .map(|h| Cell::from(*h).style(Style::default().fg(Color::Red)));
    let header = Row::new(header_cells)
        .style(normal_style)
        .height(1)
        .bottom_margin(1);
    let rows = app.items.iter().map(|item| {
        let height = item
            .iter()
            .map(|content| content.chars().filter(|c| *c == '\n').count())
            .max()
            .unwrap_or(0)
            + 1;
        let cells = item.iter().map(|c| Cell::from(*c));
        Row::new(cells).height(height as u16).bottom_margin(1)
    });
    let t = Table::new(rows)
        .header(header)
        .block(Block::default().borders(Borders::ALL).title("Table"))
        .highlight_style(selected_style)
        .highlight_symbol(">> ")
        .widths(&[
            Constraint::Percentage(50),
            Constraint::Length(30),
            Constraint::Min(10),
        ]);
    f.render_stateful_widget(t, rects[0], &mut app.state);
}

Trait Implementations

impl<'a> Clone for Cell<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Cell<'a>

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

Formats the value using the given formatter.

impl<'a> Default for Cell<'a>

fn default() -> Cell<'a>

Returns the “default value” for a type.

impl<'a, T> From<T> for Cell<'a>where T: Into<Text<'a>>,

fn from(content: T) -> Cell<'a>

Converts to this type from the input type.

impl<'a> PartialEq<Cell<'a>> for Cell<'a>

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<'a> Eq for Cell<'a>

impl<'a> StructuralEq for Cell<'a>

impl<'a> StructuralPartialEq for Cell<'a>