Struct tuirealm::tui::widgets::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::{prelude::*, widgets::*};

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

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

use ratatui::{prelude::*, widgets::*};

Row::new(vec![
    Cell::from("Cell1"),
    Cell::from("Cell2").style(Style::default().fg(Color::Yellow)),
]);

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

use std::borrow::Cow;

use ratatui::{prelude::*, widgets::*};

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::{prelude::*, widgets::*};
let cells = vec!["Cell1", "Cell2", "Cell3"];
Row::new(cells).red().italic();

Implementations

impl<'a> Row<'a>

pub fn new<T>(cells: T) -> Row<'a>

where T: IntoIterator, <T as IntoIterator>::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

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) -> Row<'a>

where T: IntoIterator, <T as IntoIterator>::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

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 fn height(self, height: u16) -> Row<'a>

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

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

pub fn top_margin(self, margin: u16) -> Row<'a>

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

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

pub fn bottom_margin(self, margin: u16) -> Row<'a>

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

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

pub fn style<S>(self, style: S) -> Row<'a>

where S: Into<Style>,

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

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.

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<(), Error>

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>(cells: IterCells) -> Row<'a>

where IterCells: IntoIterator<Item = Item>,

Creates a value from an iterator.

impl<'a> Hash for Row<'a>

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

where __H: Hasher,

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

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

type Item = Row<'a>

fn style(&self) -> Style

Returns the style of the object.

fn set_style<S>(self, style: S) -> <Row<'a> as Styled>::Item

where S: Into<Style>,

Sets the style of the object.

impl<'a> Eq for Row<'a>

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