Struct Toast

pub struct Toast<Msg: Clone> {
    pub id: WidgetId,
    pub message: String,
    pub duration: Duration,
    pub on_dismiss: Option<Msg>,
    pub bg: Option<Color>,
    pub fg: Option<Color>,
}

Builder for a transient bottom-anchored notification overlay.

Toast does not own its own timer — the application is responsible for clearing the toast (typically by storing its message in an Option and resetting it via a delayed message).

Fields

id: WidgetId

Stable id for the overlay. Used to derive the OverlayId so the same toast persists across frames when the message stays the same.

message: String

Body text rendered inside the pill.

duration: Duration

Display duration. The runtime does not consume this — it is returned through Toast::duration_value so the app’s timer scheduler can read it back.

on_dismiss: Option<Msg>

Optional message fired when the user taps anywhere outside the pill. Convenient for “tap anywhere to dismiss” behaviour.

bg: Option<Color>

Optional override for the pill background colour.

fg: Option<Color>

Optional override for the body text colour.

Implementations

impl<Msg: Clone + 'static> Toast<Msg>

pub fn new(message: impl Into<String>) -> Self

Create a toast with the given message text. The default id is "toast/default"; override with Self::id when more than one toast variant might coexist.

pub fn id(self, id: WidgetId) -> Self

Override the stable id used to derive the OverlayId.

pub fn duration(self, secs: f32) -> Self

Set the display duration. The toast itself does not auto-hide; this value is stored so the application’s timer scheduler can read it back via Self::duration_value.

pub fn duration_value(&self) -> Duration

Read back the configured duration. Lets the app delegate timer setup to a helper that does not need to know how the toast was configured.

pub fn on_dismiss(self, msg: Msg) -> Self

Set the dismiss message fired on a tap outside the pill.

pub fn background(self, c: Color) -> Self

Override the pill background colour.

pub fn color(self, c: Color) -> Self

Override the body text colour.

pub fn view(self) -> Element<Msg>

Build an Element that paints the toast pill bottom-anchored inside its parent rect. The intended pattern is to push it on top of the main view via a Stack:

fn view( &self ) -> Element<Msg>
{
    let body = column().push( … );
    let mut s = stack().push( body );
    if self.toast_until.is_some()
    {
        s = s.push( toast( "Saved" ).view() );
    }
    s.into()
}

Works on every compositor — no wlr-layer-shell needed — because the pill is just a regular widget tree drawn on top of the existing canvas. Use Self::overlay only when you specifically need the toast to render above other windows (notification-style), which requires wlr-layer-shell.

pub fn overlay(self) -> OverlaySpec<Msg>

Build the OverlaySpec the application returns from App::overlays. The overlay is anchored to the bottom edge of the screen with a small breathing margin.

Requires the compositor to advertise wlr-layer-shell. For a portable variant that works everywhere — at the cost of being confined to the application’s surface — use Self::view.