Struct Overlay 

pub struct Overlay { /* private fields */ }

A declarative overlay that renders content above all other views.

The overlay content remains in the view tree as a child of this view, maintaining proper parent-child lifetime semantics. Floem reparents overlay nodes in the box tree to the window root so they participate in normal z-index ordering above regular content.

Visibility can be controlled through styles on the content itself.

Example

use floem::prelude::*;
use floem::views::{Label, Overlay, Decorators};

let show_dialog = RwSignal::new(false);

Stack::vertical((
    Button::new("Show Dialog").action(move || show_dialog.set(true)),
    Overlay::new_dyn(move || {
        let visible = show_dialog.get();
        Stack::vertical((
            Label::derived(|| "This is a dialog!".to_string()),
            Button::new("Close").action(move || show_dialog.set(false)),
        ))
        .style(move |s| {
            s.apply_if(!visible, |s| s.hide())
                .background(Color::WHITE)
                .padding(20)
                .border_radius(8)
        })
    }),
));

Notes

• The overlay is positioned absolutely at the window level
• Overlay uses a default z-index: 1 so it sorts above non-overlay content
• You can style the overlay content using the view returned by Overlay::new(...)
• The overlay is automatically removed when this view is cleaned up

Implementations

impl Overlay

pub fn new(child: impl IntoView + 'static) -> Overlay

Creates a new overlay.

Example

use floem::prelude::*;
use floem::views::{Overlay, Label};

Overlay::new("Static overlay content");

pub fn base() -> Overlay

Creates a new overlay with no child.

Example

use floem::prelude::*;
use floem::views::Overlay;

Overlay::base();

pub fn new_dyn<CF, V>(child_fn: CF) -> Overlay

where CF: Fn() -> V + 'static, V: IntoView + 'static,

Creates a new overlay whose child will dynamically update in response to signal changes.

Example

use floem::prelude::*;
use floem::views::{Label, Overlay};

let message = RwSignal::new("Loading...".to_string());

Overlay::new_dyn(move || Label::new(message.get()));

pub fn with_id(id: ViewId) -> Overlay

Creates a new empty overlay with a specific ViewId.

This is useful when you need to control the ViewId for the overlay.

Arguments

• id - The ViewId to use for this overlay

Trait Implementations

impl Default for Overlay

fn default() -> Overlay

Returns the “default value” for a type.

impl ParentView for Overlay

fn scope(&self) -> Option<Scope>

Returns the scope associated with this view, if any.

fn child(self, child: impl IntoView + 'static) -> Self

Adds a single child to this view.

fn children(self, children: impl IntoViewIter + 'static) -> Self

Adds multiple children to this view.

fn derived_children<CF, C>(self, children_fn: CF) -> Self

where CF: Fn() -> C + 'static, C: IntoViewIter + 'static,

Adds reactive children that update when signals change.

fn stateful_child<S, SF, CF, V>(self, state_fn: SF, child_fn: CF) -> Self

where SF: Fn() -> S + 'static, CF: Fn(S) -> V + 'static, V: IntoView + 'static, S: 'static,

Adds a single reactive child with explicit state tracking.

fn keyed_children<IF, I, T, K, KF, VF, V>( self, items_fn: IF, key_fn: KF, view_fn: VF, ) -> Self

where IF: Fn() -> I + 'static, I: IntoIterator<Item = T>, KF: Fn(&T) -> K + 'static, K: Eq + Hash + 'static, VF: Fn(T) -> V + 'static, V: IntoView + 'static, T: 'static,

Adds keyed reactive children that efficiently update when signals change.

fn derived_child<CF, V>(self, child_fn: CF) -> Self

where CF: Fn() -> V + 'static, V: IntoView + 'static,

Adds a single reactive child that updates when signals change.

impl View for Overlay

fn id(&self) -> ViewId

fn view_style(&self) -> Option<Style>

fn debug_name(&self) -> Cow<'static, str>

fn view_class(&self) -> Option<StyleClassRef>

fn update(&mut self, cx: &mut UpdateCx<'_>, state: Box<dyn Any>)

Use this method to react to changes in view-related state. You will usually send state to this hook manually using the View’s Id handle

fn style_pass(&mut self, cx: &mut StyleCx<'_>)

Use this method to style the view’s children.

fn event_capture(&mut self, _cx: &mut EventCx<'_>) -> EventPropagation

Handles an event during the capture phase of event propagation.

fn event(&mut self, _cx: &mut EventCx<'_>) -> EventPropagation

Handles an event during the target and bubble phases of event propagation.

fn paint(&mut self, cx: &mut PaintCx<'_>)

View-specific implementation. Called during paint traversal for this view. Children are painted automatically by Floem. Views should only paint their own content (backgrounds, borders, custom drawing).

fn post_paint(&mut self, cx: &mut PaintCx<'_>)