Struct Row

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

A single row of data to be displayed in a Table widget.

A Row is a collection of Cells.

By default, a row has a height of 1 but you can change this using Row::height.

You can set the style of the entire row using Row::style. This Style will be combined with the Style of each individual Cell by adding the Style of the Cell to the Style of the Row.

Examples

You can create Rows from simple strings.

use ratatui::widgets::Row;

Row::new(vec!["Cell1", "Cell2", "Cell3"]);

If you need a bit more control over individual cells, you can explicitly create Cells:

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

Row::new(vec![
    Cell::from("Cell1"),
    Cell::from("Cell2").red().italic(),
]);

You can also construct a row from any type that can be converted into Text:

use std::borrow::Cow;

use ratatui::widgets::{Cell, Row};

Row::new(vec![
    Cow::Borrowed("hello"),
    Cow::Owned("world".to_uppercase()),
]);

An iterator whose item type is convertible into Text can be collected into a row.

use ratatui::widgets::Row;

(0..10).map(|i| format!("{i}")).collect::<Row>();

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

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

let cells = vec!["Cell1", "Cell2", "Cell3"];
Row::new(cells).red().italic();

Implementations

impl<'a> Row<'a>

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

where T: IntoIterator, T::Item: Into<Cell<'a>>,

Creates a new Row

The cells parameter accepts any value that can be converted into an iterator of anything that can be converted into a Cell (e.g. Vec<&str>, &[Cell<'a>], Vec<String>, etc.)

Examples

use ratatui::widgets::{Cell, Row};

let row = Row::new(vec!["Cell 1", "Cell 2", "Cell 3"]);
let row = Row::new(vec![
    Cell::new("Cell 1"),
    Cell::new("Cell 2"),
    Cell::new("Cell 3"),
]);

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

where T: IntoIterator, T::Item: Into<Cell<'a>>,

Set the cells of the Row

The cells parameter accepts any value that can be converted into an iterator of anything that can be converted into a Cell (e.g. Vec<&str>, &[Cell<'a>], Vec<String>, etc.)

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

Examples

use ratatui::widgets::{Cell, Row};

let row = Row::default().cells(vec!["Cell 1", "Cell 2", "Cell 3"]);
let row = Row::default().cells(vec![
    Cell::new("Cell 1"),
    Cell::new("Cell 2"),
    Cell::new("Cell 3"),
]);

pub const fn height(self, height: u16) -> Self

Set the fixed height of the Row

Any Cell whose content has more lines than this height will see its content truncated.

By default, the height is 1.

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

Examples

use ratatui::widgets::Row;

let cells = vec!["Cell 1\nline 2", "Cell 2", "Cell 3"];
let row = Row::new(cells).height(2);

pub const fn top_margin(self, margin: u16) -> Self

Set the top margin. By default, the top margin is 0.

The top margin is the number of blank lines to be displayed before the row.

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

Examples

use ratatui::widgets::Row;
let cells = vec!["Cell 1", "Cell 2", "Cell 3"];

let row = Row::default().top_margin(1);

pub const fn bottom_margin(self, margin: u16) -> Self

Set the bottom margin. By default, the bottom margin is 0.

The bottom margin is the number of blank lines to be displayed after the row.

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

Examples

use ratatui::widgets::Row;

let cells = vec!["Cell 1", "Cell 2", "Cell 3"];
let row = Row::default().bottom_margin(1);

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

Set the Style of the entire row

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

This Style can be overridden by the Style of a any individual Cell or by their 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::Row,
};
let cells = vec!["Cell 1", "Cell 2", "Cell 3"];
let row = Row::new(cells).style(Style::new().red().italic());

Row 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::Row};

let cells = vec!["Cell 1", "Cell 2", "Cell 3"];
let row = Row::new(cells).red().italic();

Trait Implementations

impl<'a> Clone for Row<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Row<'a>

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

Formats the value using the given formatter.

impl<'a> Default for Row<'a>

fn default() -> Row<'a>

Returns the “default value” for a type.

impl<'a, Item> FromIterator<Item> for Row<'a>

where Item: Into<Cell<'a>>,

fn from_iter<IterCells: IntoIterator<Item = Item>>(cells: IterCells) -> Self

Creates a value from an iterator.

impl<'a> Hash for Row<'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 Row<'a>

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

type Item = Row<'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 Row<'a>

impl<'a> StructuralPartialEq for Row<'a>