Struct Step 

pub struct Step { /* private fields */ }

One page in a Stepper.

A step carries a localized title, optional supporting_text, a content factory (the body shown when the step is active), and an optional completion gate. The recommended data-flow pattern: the application owns its form state as Signals, the content factory binds widgets to those signals (write side), and complete_when derives the Next gate from the same signals.

Implementations

impl Step

pub fn new(title: impl Into<LocalizedString>) -> Self

pub fn content<W, F>(self, factory: F) -> Self

where W: Widget + 'static, F: Fn() -> W + 'static,

The body shown while this step is active. The factory may capture clones of the application’s form Signals to read/write step input.

pub fn content_boxed( self, factory: impl Fn() -> Box<dyn Widget> + 'static, ) -> Self

The body shown while this step is active, as a boxed widget — the escape hatch for a body whose concrete type varies at runtime.

content is generic over one W: Widget, and Box<dyn Widget> does not itself implement Widget, so a step whose body branches on app state cannot be expressed as a single content factory. Box each branch instead of duplicating the surrounding builder:

Step::new(lit!("Details")).content_boxed({
    let purpose = purpose.clone();
    move || -> Box<dyn Widget> {
        match purpose.get() {
            Purpose::Novel => Box::new(novel_form()),
            Purpose::Import => Box::new(import_form()),
        }
    }
})

pub fn supporting_text(self, text: impl Into<LocalizedString>) -> Self

Secondary line under the title in the header / indicator.

pub fn status(self, status: StepStatus) -> Self

Set the step’s initial StepStatus.

pub fn optional(self, optional: bool) -> Self

Mark the step optional (reachable but skippable — surfaces a Skip button while active). Equivalent to .status(StepStatus::Optional).

pub fn complete_when(self, signal: impl Into<Prop<bool>>) -> Self

Reactive Next gate: while this step is active, Next is enabled iff signal is true. Derive it from the same form signals the step’s content writes — e.g. name.map(|n| !n.is_empty()).

pub fn validate_on_next(self, f: impl Fn() -> bool + 'static) -> Self

Imperative validation fallback: checked on the Next click. Returning false blocks navigation. Prefer complete_when where a reactive signal is available.

pub fn visible_when(self, visible: impl Into<Prop<bool>>) -> Self

Reactive visibility: while visible is false this step drops out of the flow — Next / Back / indicator clicks skip it, and its marker is hidden from the indicator strip (and from AT).

This is how a branching wizard is expressed: declare every step once and gate the conditional ones on the choice that selects them, instead of maintaining one step list per branch.

let purpose = Signal::new(Purpose::Novel);
Stepper::new()
    .step(Step::new(lit!("Purpose")).content(|| purpose_picker()))
    .step(Step::new(lit!("Import source"))
        .visible_when(purpose.map(|p| *p == Purpose::Import))
        .content(|| import_form()))

Hiding the step the user is currently on does not navigate away from it — gate steps ahead of the choice, not the one making it.

Trait Implementations

impl Clone for Step

fn clone(&self) -> Step

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Step

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.