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() -> Self

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() -> Self

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() -> Self

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() -> Self

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() -> Self

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) -> Self

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: CellEffect + 'static>(effect: F) -> Self

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: CellEffect + 'static>(effect: F) -> Self

Creates a new shadow from a custom cell effect.

Alias for Shadow::custom.

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

Sets the style applied to the shadow area.

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

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

Formats the value using the given formatter.

impl Default for Shadow

fn default() -> Self

Returns the “default value” for a type.

impl Eq for Shadow

impl Hash for Shadow

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

fn eq(&self, other: &Self) -> 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: Into<Style>>(self, style: S) -> Self::Item

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.