Struct NavigationStack 

pub struct NavigationStack<T>
where
    T: 'static,
{ /* private fields */ }

A navigation view that retains a stack of destination views for an explicit path.

NavigationStack is designed for hierarchical navigation where the caller owns the full path and updates it over time. The path is interpreted from root to top:

• [A] shows A
• [A, B] shows B
• [A, B, C] shows C

On each update, the stack compares the old and new path using stable keys:

• the shared prefix is retained
• any diverging tail is removed and disposed
• any new tail is created

This means destination views in the shared prefix keep their local view state while deeper navigation changes happen above them.

NavigationStack is intentionally built through NavigationStack::new, which returns a builder. That builder lets callers choose whether to:

• use the path item itself as the stable key, or provide NavigationStackBuilder::key
• use the path item itself as the destination view, or provide NavigationStackBuilder::view

Typical usage when the route type implements both IntoView and Eq + Hash + Clone:

let path = RwSignal::new(vec![Route("Home".to_string())]);

let stack = NavigationStack::new(path);

Typical usage when route data needs explicit keying and destination construction:

let path = RwSignal::new(vec![Route::Home]);

let stack = NavigationStack::new(path)
    .key(|route| match route {
        Route::Home => "home".to_string(),
        Route::Detail(id) => format!("detail:{id}"),
    })
    .view(|route| match route {
        Route::Home => "Home".to_string(),
        Route::Detail(id) => format!("Detail {id}"),
    });

Implementations

impl<T> NavigationStack<T>

where T: 'static,

pub fn new<P>(path: P) -> NavigationStackBuilder<T>

where P: NavigationPath<T>,

Start building a NavigationStack from a path source.

This is the single entrypoint for the navigation stack API. It accepts a path source and returns a NavigationStackBuilder, which can then be used in one of two ways:

1. Build directly when T already provides everything the stack needs:
   • T: IntoView for destination construction
   • T: Eq + Hash + Clone for stable destination identity
2. Refine the builder with:
   • NavigationStackBuilder::key when identity should come from a derived key rather than the whole item
   • NavigationStackBuilder::view when the path item is route data rather than a view

The path argument can be any supported NavigationPath, including:

• a plain Vec<T>
• a closure returning an iterable path
• ReadSignal<P>
• RwSignal<P>

The stack reads the full path and retains destination views for the shared prefix across updates.

Example: route items are their own views

let path = RwSignal::new(vec![Route("Home".to_string())]);

let stack = NavigationStack::new(path);

Example: route items need explicit key and view functions

let path = RwSignal::new(vec![Route::Home]);

let stack = NavigationStack::new(path)
    .key(|route| match route {
        Route::Home => "home".to_string(),
        Route::Detail(id) => format!("detail:{id}"),
    })
    .view(|route| match route {
        Route::Home => "Home".to_string(),
        Route::Detail(id) => format!("Detail {id}"),
    });

Trait Implementations

impl<T> View for NavigationStack<T>

where T: 'static,

fn id(&self) -> ViewId

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

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 view_style(&self) -> Option<Style>

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

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<'_>)