Struct StepperController 

pub struct StepperController { /* private fields */ }

Shared handle controlling a Stepper.

Implementations

impl StepperController

pub fn new(step_count: usize) -> Self

A controller for a stepper with step_count steps, starting at step 0.

pub fn next(&self)

Advance to the next reachable step, recording the current one on the back-stack. Invisible (Step::visible_when) and StepStatus::Disabled steps are stepped over; a no-op when none remains.

pub fn skip(&self)

Mark the current (optional) step skipped, then advance like next.

pub fn back(&self)

Return to the most recently visited reachable step (the back-stack top). Entries that became unreachable meanwhile are popped and skipped. No-op on an empty stack.

pub fn go_to(&self, idx: usize)

Jump to step idx (non-linear), recording the current step on the back-stack so back returns here. A no-op when idx is out of range or not reachable.

pub fn reset(&self)

Reset to the first reachable step: clears the back-stack, restores the statuses the stepper was declared with (so a Disabled / Optional step keeps its character), and clears visited/skipped flags. Per-step visibility is app-owned and left untouched.

pub fn set_status(&self, idx: usize, status: StepStatus)

Override a step’s StepStatus (e.g. mark it Error after async validation). Setting StepStatus::Disabled takes the step out of the flow — next / go_to skip it — but does not move off it if it is the active step.

pub fn set_visible(&self, idx: usize, visible: bool)

Show or hide step idx. A hidden step is skipped by next / back / go_to and drops out of the indicator strip — the branching-wizard shape (“this step only if you chose X”) without maintaining two step lists.

Usually driven declaratively by Step::visible_when; this is the imperative twin. Hiding the active step does not navigate away from it — hide steps the user has not reached yet.

pub fn current(&self) -> usize

pub fn status(&self, idx: usize) -> StepStatus

pub fn visited(&self, idx: usize) -> bool

true if step idx has ever been the active step.

pub fn skipped(&self, idx: usize) -> bool

true if step idx was skipped via skip.

pub fn is_visible(&self, idx: usize) -> bool

true if step idx is visible (see set_visible).

pub fn is_reachable(&self, idx: usize) -> bool

true if step idx participates in the flow — visible and not StepStatus::Disabled.

pub fn next_reachable(&self, from: usize) -> Option<usize>

The next reachable step after from, if any.

pub fn has_next(&self) -> bool

true if next would move — i.e. the active step is not the last reachable one. The footer shows Next when this holds and Finish when it does not.

pub fn step_count(&self) -> usize

pub fn can_back(&self) -> bool

true if there is a previously-visited, still-reachable step to return to.

pub fn current_step_signal(&self) -> Signal<usize>

The active-step signal — the stepper’s Switcher and indicators bind to it.

pub fn version_signal(&self) -> Signal<u64>

Bumped on every structural mutation; bind at BindingLevel::Rebuild.

Trait Implementations

impl Clone for StepperController

fn clone(&self) -> StepperController

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StepperController

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

Formats the value using the given formatter.