Struct Cell

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

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

You can apply a Style to the Cell using Cell::style. This will set the style for the entire area of the cell. Any Style set on the Text content will be combined with the Style of the Cell by adding the Style of the Text content to the Style of the Cell. Styles set on the text content will only affect the content.

You can use Text::alignment when creating a cell to align its content.

Examples

You can create a Cell from anything that can be converted to a Text.

use std::borrow::Cow;

use ratatui::{
    style::Stylize,
    text::{Line, Span, Text},
    widgets::Cell,
};

Cell::from("simple string");
Cell::from(Span::from("span"));
Cell::from(Line::from(vec![
    Span::from("a vec of "),
    Span::from("spans").bold(),
]));
Cell::from(Text::from("a text"));
Cell::from(Text::from(Cow::Borrowed("hello")));

Cell implements Styled which means you can use style shorthands from the Stylize trait to set the style of the cell concisely.

use ratatui::{style::Stylize, widgets::Cell};

Cell::new("Cell 1").red().italic();

Implementations

impl<'a> Cell<'a>

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

where T: Into<Text<'a>>,

Creates a new Cell

The content parameter accepts any value that can be converted into a Text.

Examples

use ratatui::{
    style::Stylize,
    text::{Line, Span, Text},
    widgets::Cell,
};

Cell::new("simple string");
Cell::new(Span::from("span"));
Cell::new(Line::from(vec![
    Span::raw("a vec of "),
    Span::from("spans").bold(),
]));
Cell::new(Text::from("a text"));

pub fn content<T>(self, content: T) -> Self

where T: Into<Text<'a>>,

Set the content of the Cell

The content parameter accepts any value that can be converted into a Text.

This is a fluent setter method which must be chained or used as it consumes self

Examples

use ratatui::{
    style::Stylize,
    text::{Line, Span, Text},
    widgets::Cell,
};

Cell::default().content("simple string");
Cell::default().content(Span::from("span"));
Cell::default().content(Line::from(vec![
    Span::raw("a vec of "),
    Span::from("spans").bold(),
]));
Cell::default().content(Text::from("a text"));

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

Set the Style of this cell

style accepts any type that is convertible to Style (e.g. Style, Color, or your own type that implements Into<Style>).

This Style will override the Style of the Row and can be overridden by the Style of the Text content.

This is a fluent setter method which must be chained or used as it consumes self

Examples

use ratatui::{
    style::{Style, Stylize},
    widgets::Cell,
};

Cell::new("Cell 1").style(Style::new().red().italic());

Cell also implements the Styled trait, which means you can use style shorthands from the Stylize trait to set the style of the widget more concisely.

use ratatui::{style::Stylize, widgets::Cell};

Cell::new("Cell 1").red().italic();

Trait Implementations

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

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

Returns a duplicate 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) -> Self

Converts to this type from the input type.

impl<'a> Hash for Cell<'a>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

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

fn eq(&self, other: &Cell<'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> Styled for Cell<'a>

type Item = Cell<'a>

fn style(&self) -> Style

Returns the style of the object.

fn set_style<S: Into<Style>>(self, style: S) -> Self::Item

Sets the style of the object.

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

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