Struct EffectCell 

pub struct EffectCell {
    pub fg: Color,
    pub bg: Color,
    pub underline_color: Color,
    pub modifier: Modifier,
    pub diff_option: CellDiffOption,
    pub skip: bool,
    /* private fields */
}

Terminal cell type passed to CellEffect::apply. A buffer cell

Fields

fg: Color

The foreground color of the cell.

bg: Color

The background color of the cell.

underline_color: Color

The underline color of the cell.

modifier: Modifier

The modifier of the cell.

diff_option: CellDiffOption

Special option applied when copying (diffing) the buffer to the screen (or another buffer).

skip: bool

👎Deprecated since 0.30.1:

use set_diff_option(CellDiffOption::Skip) instead

Whether the cell should be skipped when copying (diffing) the buffer to the screen.

Use CellDiffOption::Skip via set_diff_option instead.

Implementations

impl Cell

pub const EMPTY: Cell

An empty Cell

pub const fn new(symbol: &'static str) -> Cell

Creates a new Cell with the given symbol.

This works at compile time and puts the symbol onto the stack. Fails to build when the symbol doesn’t fit onto the stack and requires to be placed on the heap. Use Self::default().set_symbol() in that case. See CompactString::const_new for more details on this.

pub fn symbol(&self) -> &str

Gets the symbol of the cell.

If the cell has no symbol, returns a single space character.

pub fn merge_symbol( &mut self, symbol: &str, strategy: MergeStrategy, ) -> &mut Cell

Merges the symbol of the cell with the one already on the cell, using the provided MergeStrategy.

Merges Box Drawing Unicode block characters to create a single character representing their combination, useful for border collapsing. Currently limited to box drawing characters, with potential future support for others.

Merging may not be perfect due to Unicode limitations; some symbol combinations might not produce a valid character. MergeStrategy defines how to handle such cases, e.g., Exact for valid merges only, or Fuzzy for close matches.

If the cell has no symbol set, it will set the symbol to the provided one rather than merging.

Example

use ratatui_core::symbols::merge::MergeStrategy;

assert_eq!(
    Cell::new("┘")
        .merge_symbol("┏", MergeStrategy::Exact)
        .symbol(),
    "╆",
);

assert_eq!(
    Cell::new("╭")
        .merge_symbol("┘", MergeStrategy::Fuzzy)
        .symbol(),
    "┼",
);

pub fn set_symbol(&mut self, symbol: &str) -> &mut Cell

Sets the symbol of the cell.

pub fn set_char(&mut self, ch: char) -> &mut Cell

Sets the symbol of the cell to a single character.

pub const fn set_fg(&mut self, color: Color) -> &mut Cell

Sets the foreground color of the cell.

pub const fn set_bg(&mut self, color: Color) -> &mut Cell

Sets the background color of the cell.

pub fn set_style<S>(&mut self, style: S) -> &mut Cell

where S: Into<Style>,

Sets the style of the cell.

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

pub const fn style(&self) -> Style

Returns the style of the cell.

pub const fn set_skip(&mut self, skip: bool) -> &mut Cell

👎Deprecated since 0.30.1:

use set_diff_option(CellDiffOption::Skip) instead

Sets the cell to be skipped when copying (diffing) the buffer to the screen.

This is helpful when it is necessary to prevent the buffer from overwriting a cell that is covered by an image from some terminal graphics protocol (Sixel / iTerm / Kitty …).

pub const fn set_diff_option( &mut self, diff_option: CellDiffOption, ) -> &mut Cell

Sets cell CellDiffOption.

The diff options are for dealing with cells that are wider than a unit, that should always be updated, or that should not be updated at all (skip output due to preceding wider cells).

pub fn reset(&mut self)

Resets the cell to the empty state.

Trait Implementations

impl CellWidth for Cell

fn cell_width(&self) -> u16

Returns CellDiffOption::ForcedWidth when set, otherwise computes the width from the cell’s symbol.

impl Clone for Cell

fn clone(&self) -> Cell

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Cell

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

Formats the value using the given formatter.

impl Default for Cell

fn default() -> Cell

Returns the “default value” for a type.

impl Eq for Cell

impl From<char> for Cell

fn from(ch: char) -> Cell

Converts to this type from the input type.

impl Hash for Cell

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

where H: Hasher,

Hashes the cell.

This treats symbols with Some(“ “) as equal to None, so that empty cells are treated uniformly, regardless of how they were created.

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 PartialEq for Cell

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

Compares two Cells for equality.

Note that cells with no symbol (i.e., Cell::EMPTY) are considered equal to cells with a single space symbol. This is to ensure that empty cells are treated uniformly, regardless of how they were created

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

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