Struct Fill 

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

A widget that fills its render area with a single repeated symbol and style.

Fill is a small building block for painting solid blocks of one symbol — backgrounds, separators, scrollbar tracks, custom borders, etc. — without writing the nested loop yourself. It composes naturally with the Stylize trait so the typical call site is a one-liner.

Examples

use ratatui::layout::Rect;
use ratatui::style::Stylize;
use ratatui::widgets::{Fill, Widget};

let fill = Fill::new("X").blue().bold();
fill.render(Rect::new(0, 0, 10, 3), &mut buf);

This renders as:

XXXXXXXXXX
XXXXXXXXXX
XXXXXXXXXX

Fill accepts anything that converts into a Cow<str>, so both string literals and owned Strings work:

use ratatui::widgets::Fill;

let _ = Fill::new("•");
let _ = Fill::new(String::from("•"));

Cells outside the buffer are silently clipped, mirroring the behavior of other widgets such as Clear.

Implementations

impl<'a> Fill<'a>

pub fn new<S: Into<Cow<'a, str>>>(symbol: S) -> Self

Create a new Fill widget that paints symbol into every cell of its render area.

The style defaults to Style::default; use the Stylize shorthands or Fill::style to customize it.

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

Set the style used to paint each cell.

style accepts any value convertible into a Style (e.g. Style, Color, or your own type implementing Into<Style>).

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

pub fn symbol<S: Into<Cow<'a, str>>>(self, symbol: S) -> Self

Set the symbol painted into each cell.

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

Trait Implementations

impl<'a> Clone for Fill<'a>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Fill<'a>

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

Formats the value using the given formatter.

impl<'a> Default for Fill<'a>

fn default() -> Fill<'a>

Returns the “default value” for a type.

impl<'a> Eq for Fill<'a>

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

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

impl Styled for Fill<'_>

type Item = Fill<'_>

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 Widget for &Fill<'_>

fn render(self, area: Rect, buf: &mut Buffer)

Draws the current state of the widget in the given buffer. That is the only method required to implement a custom widget.

impl Widget for Fill<'_>

fn render(self, area: Rect, buf: &mut Buffer)

Draws the current state of the widget in the given buffer. That is the only method required to implement a custom widget.