Struct BackFallbackView 

pub struct BackFallbackView<V> { /* private fields */ }

An app-level back rule for per-tab navigator stacks: BackFallback claims a back press only when no navigator does (it ranks after every navigator, whatever the wire order), and back_fallback wraps the view it belongs to. The Android/Material tab convention — back at a tab root returns to the home tab, back at the home tab root exits — is one fallback:

use frust::{
    BackFallback, Component, Get, GetUntracked, IndexedStack, NavigatorController, RwSignal,
    Set, View, back_fallback, navigator, text,
};

const HOME: usize = 0;

#[derive(Default)]
struct App;

struct AppState {
    selected: RwSignal<usize>,
    tabs: [NavigatorController<AppState>; 3],
    home_fallback: BackFallback,
}

impl Component for App {
    type State = AppState;

    fn init(&self) -> AppState {
        let selected = RwSignal::new(HOME);
        let tabs = [
            NavigatorController::new(),
            NavigatorController::new(),
            NavigatorController::new(),
        ];
        let probe = tabs.clone();
        // Constructed ONCE. It claims a press only off the home tab with the
        // selected tab at its root; any poppable tab claims first anyway.
        let home_fallback = BackFallback::new(
            move || {
                let sel = selected.get_untracked();
                sel != HOME && probe[sel].depth() <= 1
            },
            move || selected.set(HOME),
        );
        AppState { selected, tabs, home_fallback }
    }

    fn build(&self, state: &mut AppState) -> impl View<AppState> {
        let [home, b, c] = &state.tabs;
        // A tracked read: a selection change rebuilds.
        let sel = state.selected.get();
        back_fallback(
            &state.home_fallback,
            IndexedStack(
                Some(sel),
                (
                    navigator(home, || text("home")),
                    navigator(b, || text("search")),
                    navigator(c, || text("profile")),
                ),
            ),
        )
    }
}

frust::app!(App);

Liveness contract. A fallback claims only while a back_fallback wrapper over it is mounted: leaving the screen unmounts the wrapper and the fallback stops claiming, though the handle lives on in app state. Wrap the view every Component::build that should honor it, like navigator.

Accepted residual. A wrapper mounted inside a branch input does not reach — a non-selected IndexedStack child, or the page under a covering page whose own navigator does not claim — still counts as live (it is mounted). Gate the interest closure there on that branch being current. An app-level back rule for per-tab navigator stacks: BackFallback claims a back press only when no navigator does (it ranks after every navigator, whatever the wire order), and back_fallback wraps the view it belongs to. The Android/Material tab convention — back at a tab root returns to the home tab, back at the home tab root exits — is one fallback:

use frust::{
    BackFallback, Component, Get, GetUntracked, IndexedStack, NavigatorController, RwSignal,
    Set, View, back_fallback, navigator, text,
};

const HOME: usize = 0;

#[derive(Default)]
struct App;

struct AppState {
    selected: RwSignal<usize>,
    tabs: [NavigatorController<AppState>; 3],
    home_fallback: BackFallback,
}

impl Component for App {
    type State = AppState;

    fn init(&self) -> AppState {
        let selected = RwSignal::new(HOME);
        let tabs = [
            NavigatorController::new(),
            NavigatorController::new(),
            NavigatorController::new(),
        ];
        let probe = tabs.clone();
        // Constructed ONCE. It claims a press only off the home tab with the
        // selected tab at its root; any poppable tab claims first anyway.
        let home_fallback = BackFallback::new(
            move || {
                let sel = selected.get_untracked();
                sel != HOME && probe[sel].depth() <= 1
            },
            move || selected.set(HOME),
        );
        AppState { selected, tabs, home_fallback }
    }

    fn build(&self, state: &mut AppState) -> impl View<AppState> {
        let [home, b, c] = &state.tabs;
        // A tracked read: a selection change rebuilds.
        let sel = state.selected.get();
        back_fallback(
            &state.home_fallback,
            IndexedStack(
                Some(sel),
                (
                    navigator(home, || text("home")),
                    navigator(b, || text("search")),
                    navigator(c, || text("profile")),
                ),
            ),
        )
    }
}

frust::app!(App);

Liveness contract. A fallback claims only while a back_fallback wrapper over it is mounted: leaving the screen unmounts the wrapper and the fallback stops claiming, though the handle lives on in app state. Wrap the view every Component::build that should honor it, like navigator.

Accepted residual. A wrapper mounted inside a branch input does not reach — a non-selected IndexedStack child, or the page under a covering page whose own navigator does not claim — still counts as live (it is mounted). Gate the interest closure there on that branch being current. An app-level back rule for per-tab navigator stacks: BackFallback claims a back press only when no navigator does (it ranks after every navigator, whatever the wire order), and back_fallback wraps the view it belongs to. The Android/Material tab convention — back at a tab root returns to the home tab, back at the home tab root exits — is one fallback:

use frust::{
    BackFallback, Component, Get, GetUntracked, IndexedStack, NavigatorController, RwSignal,
    Set, View, back_fallback, navigator, text,
};

const HOME: usize = 0;

#[derive(Default)]
struct App;

struct AppState {
    selected: RwSignal<usize>,
    tabs: [NavigatorController<AppState>; 3],
    home_fallback: BackFallback,
}

impl Component for App {
    type State = AppState;

    fn init(&self) -> AppState {
        let selected = RwSignal::new(HOME);
        let tabs = [
            NavigatorController::new(),
            NavigatorController::new(),
            NavigatorController::new(),
        ];
        let probe = tabs.clone();
        // Constructed ONCE. It claims a press only off the home tab with the
        // selected tab at its root; any poppable tab claims first anyway.
        let home_fallback = BackFallback::new(
            move || {
                let sel = selected.get_untracked();
                sel != HOME && probe[sel].depth() <= 1
            },
            move || selected.set(HOME),
        );
        AppState { selected, tabs, home_fallback }
    }

    fn build(&self, state: &mut AppState) -> impl View<AppState> {
        let [home, b, c] = &state.tabs;
        // A tracked read: a selection change rebuilds.
        let sel = state.selected.get();
        back_fallback(
            &state.home_fallback,
            IndexedStack(
                Some(sel),
                (
                    navigator(home, || text("home")),
                    navigator(b, || text("search")),
                    navigator(c, || text("profile")),
                ),
            ),
        )
    }
}

frust::app!(App);

Liveness contract. A fallback claims only while a back_fallback wrapper over it is mounted: leaving the screen unmounts the wrapper and the fallback stops claiming, though the handle lives on in app state. Wrap the view every Component::build that should honor it, like navigator.

Accepted residual. A wrapper mounted inside a branch input does not reach — a non-selected IndexedStack child, or the page under a covering page whose own navigator does not claim — still counts as live (it is mounted). Gate the interest closure there on that branch being current. The pass-through view back_fallback returns: renders its child unchanged (Element is the child’s own) and counts its own mounts into the BackFallback’s liveness — build increments it before the child builds, teardown decrements it after the child is torn down.

Trait Implementations

impl<State: 'static, V: View<State>> View<State> for BackFallbackView<V>

type Element = <V as View<State>>::Element

The retained widget this view produces.

fn build(&self, ctx: &mut BuildCtx<'_>) -> Self::Element

Materialise a fresh widget for this view.

fn rebuild( &self, prev: &Self, element: &mut Self::Element, ctx: &mut BuildCtx<'_>, ) -> ChangeFlags

Reconcile prev (the previous view of the same type) against the live element, mutating it in place and reporting what changed.

fn teardown(&self, element: &mut Self::Element, ctx: &mut BuildCtx<'_>)

Tear down element when this view is being removed.

fn message(&self, element: &mut Self::Element, state: &mut State)

Deliver an event message to this view, mutating application state.