Struct Shadow 

pub struct Shadow { /* private fields */ }

A configurable shadow that can be rendered behind a Block.

A Shadow is rendered in an offset area relative to the block. Its Style is applied first, then an optional cell effect can modify the affected cells, for example by filling them with a shading symbol or dimming the existing background.

Built-in presets:

• Shadow::overlay applies only style
• Shadow::block fills with full block symbols
• Shadow::light_shade, Shadow::medium_shade, and Shadow::dark_shade fill with shade symbols

┌Popup─────┐
│content   │▒
└──────────┘▒
  ▒▒▒▒▒▒▒▒▒▒▒

Custom effects

use ratatui::buffer::Buffer;
use ratatui::layout::{Position, Rect};
use ratatui::widgets::{Block, CellEffect, Shadow};

#[derive(Debug)]
struct Checker;

impl CellEffect for Checker {
    fn apply(&self, shadow_area: Rect, base_area: Rect, buf: &mut Buffer) {
        for y in shadow_area.top()..shadow_area.bottom() {
            for x in shadow_area.left()..shadow_area.right() {
                if base_area.contains(Position { x, y }) {
                    continue;
                }
                if (x + y) % 2 == 0 {
                    buf[(x, y)].set_symbol("░");
                }
            }
        }
    }
}

let shadow = Shadow::custom(Checker);
let block = Block::bordered().shadow(shadow);

Implementations

impl Shadow

pub fn overlay() -> Shadow

Creates a shadow that only applies style to the offset area.

This leaves the existing cell symbols unchanged.

Example

use ratatui::style::Stylize;
use ratatui::widgets::{Block, Shadow};

let shadow = Shadow::overlay().black().on_white();
let block = Block::bordered().shadow(shadow);

pub fn block() -> Shadow

Creates a shadow filled with full block symbols.

Example

use ratatui::widgets::{Block, Shadow};

let block = Block::bordered().shadow(Shadow::block());

pub fn light_shade() -> Shadow

Creates a shadow filled with light shade symbols.

Example

use ratatui::widgets::{Block, Shadow};

let block = Block::bordered().shadow(Shadow::light_shade());

pub fn medium_shade() -> Shadow

Creates a shadow filled with medium shade symbols.

Example

use ratatui::widgets::{Block, Shadow};

let block = Block::bordered().shadow(Shadow::medium_shade());

pub fn dark_shade() -> Shadow

Creates a shadow filled with dark shade symbols.

Example

use ratatui::layout::Offset;
use ratatui::style::Stylize;
use ratatui::widgets::{Block, Shadow};

let block = Block::bordered().shadow(
    Shadow::dark_shade()
        .black()
        .on_white()
        .offset(Offset::new(2, 1)),
);

pub fn symbol(symbol: &'static str) -> Shadow

Creates a shadow filled with the given symbol.

Example

use ratatui::widgets::{Block, Shadow};

let shadow = Shadow::symbol("░");
let block = Block::bordered().shadow(shadow);

pub fn custom<F>(effect: F) -> Shadow

where F: CellEffect + 'static,

Creates a new shadow from a custom cell effect.

The effect receives the shadow area, the original block area, and the target buffer. It is called after the shadow style has been applied.

pub fn new<F>(effect: F) -> Shadow

where F: CellEffect + 'static,

Creates a new shadow from a custom cell effect.

Alias for Shadow::custom.

pub fn style<S>(self, style: S) -> Shadow

where S: Into<Style>,

Sets the style applied to the shadow area.

pub const fn offset(self, offset: Offset) -> Shadow

Sets the shadow offset relative to the original area.

Positive horizontal values move the shadow to the right and positive vertical values move it downward.

Trait Implementations

impl Clone for Shadow

fn clone(&self) -> Shadow

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Shadow

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

Formats the value using the given formatter.

impl Default for Shadow

fn default() -> Shadow

Returns the “default value” for a type.

impl Eq for Shadow

impl Hash for Shadow

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

fn eq(&self, other: &Shadow) -> 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 Styled for Shadow

type Item = Shadow

fn style(&self) -> Style

Returns the style of the object.

fn set_style<S>(self, style: S) -> <Shadow as Styled>::Item

where S: Into<Style>,

Sets the style of the object.

impl Widget for &Shadow

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.