Struct IndeterminateState 

pub struct IndeterminateState { /* private fields */ }

A clock-backed state for indeterminate canvas indicators.

Implementations

impl IndeterminateState

pub fn new(started_at: Instant) -> Self

Creates a new indeterminate animation state.

Examples found in repository

examples/showcase/app.rs (lines 230-232)

    fn default() -> Self {
        Self {
            navigation: navigation::NavigationState::new(ShowcasePage::Inputs),
            window_size: Size::new(1080.0, 980.0),
            count: 0,
            note: String::new(),
            editor_content: material::widget::text_editor::Content::with_text(
                "Material 3 multi-line text editor",
            ),
            select_choice: Some("Assist"),
            combobox_options: material::widget::combobox::State::with_selection(
                vec!["Assist", "Suggestion", "Filter"],
                Some(&"Suggestion"),
            ),
            combobox_choice: Some("Suggestion"),
            combobox_input: String::new(),
            search_query: String::new(),
            date_picker: material::widget::picker::DatePickerState::new(
                material::widget::picker::Date::new(2026, 7, 4),
            ),
            date_range_picker: material::widget::picker::DateRangePickerState::new(
                material::widget::picker::Date::new(2026, 7, 4),
                material::widget::picker::Date::new(2026, 7, 10),
            ),
            time_picker: material::widget::picker::TimePickerState::new(14, 30, false),
            progress: 42.0,
            enabled: true,
            radio_choice: Some(RadioChoice::Standard),
            segment_choice: SegmentChoice::List,
            segment_state: material::widget::segmented_button::State::new(
                SegmentChoice::List.index(),
            ),
            primary_tab: TabChoice::Inputs,
            primary_tab_state: material::widget::tabs::State::new(TabChoice::Inputs.index()),
            secondary_tab: TabChoice::Controls,
            secondary_tab_state: material::widget::tabs::State::new(TabChoice::Controls.index()),
            progress_animation: material::widget::progress_bar::IndeterminateState::new(
                Instant::now(),
            ),
            alert_dialog: material::widget::dialog::Transition::default(),
            snackbar: material::widget::snackbar::Transition::default(),
            theme_controller: theme_picker::ThemeController::default(),
        }
    }

pub fn advance(&mut self, now: Instant)

Advances the state to now.

Examples found in repository

examples/showcase/app.rs (line 390)

fn update(state: &mut Showcase, message: Message) -> Task<Message> {
    match message {
        #[cfg(any(target_arch = "wasm32", test))]
        Message::CjkCoreFontFinished => load_cjk_regional_font(),
        #[cfg(any(target_arch = "wasm32", test))]
        Message::CjkRegionalFontFinished => Task::none(),
        Message::Navigate(page) => {
            state
                .navigation
                .select(page, Instant::now(), state.adaptive_navigation_layout());
            Task::none()
        }
        Message::Increment => {
            state.count += 1;
            Task::none()
        }
        Message::Decrement => {
            state.count -= 1;
            Task::none()
        }
        Message::TextChanged(note) => {
            state.note = note;
            Task::none()
        }
        Message::EditorAction(action) => {
            state.editor_content.perform(action);
            Task::none()
        }
        Message::SelectChanged(choice) => {
            state.select_choice = Some(choice);
            Task::none()
        }
        Message::ComboboxSelected(choice) => {
            state.combobox_choice = Some(choice);
            state.combobox_input.clear();
            state.combobox_options.set_selection(Some(&choice));
            Task::none()
        }
        Message::ComboboxInputChanged(input) => {
            state.combobox_options.set_input(input.clone());
            state.combobox_input = input;
            state.combobox_choice = None;
            Task::none()
        }
        Message::SearchChanged(query) => {
            state.search_query = query;
            Task::none()
        }
        Message::DatePickerChanged(action) => state.date_picker.update_and_scroll(action),
        Message::DateRangePickerChanged(action) => {
            state.date_range_picker.update_and_scroll(action)
        }
        Message::TimePickerChanged(action) => {
            state.time_picker.update(action);
            Task::none()
        }
        Message::SliderChanged(progress) => {
            state.progress = progress;
            Task::none()
        }
        Message::EnabledChanged(enabled) => {
            state.enabled = enabled;
            Task::none()
        }
        Message::ChoiceSelected(choice) => {
            state.radio_choice = Some(choice);
            Task::none()
        }
        Message::SegmentSelected(choice) => {
            state.segment_choice = choice;
            state.segment_state.select(choice.index(), Instant::now());
            Task::none()
        }
        Message::PrimaryTabSelected(choice) => {
            state.primary_tab = choice;
            state.primary_tab_state.select(
                choice.index(),
                Instant::now(),
                material::widget::tabs::Variant::Primary,
            );
            Task::none()
        }
        Message::SecondaryTabSelected(choice) => {
            state.secondary_tab = choice;
            state.secondary_tab_state.select(
                choice.index(),
                Instant::now(),
                material::widget::tabs::Variant::Secondary,
            );
            Task::none()
        }
        Message::MenuPressed => {
            state.navigation.toggle_menu_now();
            Task::none()
        }
        Message::DialogOpened => {
            state.alert_dialog.show(Instant::now());
            Task::none()
        }
        Message::DialogDismissed => {
            state.alert_dialog.dismiss(Instant::now());
            Task::none()
        }
        Message::DialogConfirmed => {
            state.alert_dialog.dismiss(Instant::now());
            state.count += 1;
            Task::none()
        }
        Message::ShowSnackbar => {
            state.snackbar.show(Instant::now());
            Task::none()
        }
        Message::SnackbarUndo => {
            state.count -= 1;
            state.snackbar.dismiss(Instant::now());
            Task::none()
        }
        Message::WindowResized(size) => {
            state.window_size = size;
            Task::none()
        }
        Message::ThemeChanged(action) => {
            state.theme_controller.update(
                action,
                state.window_size,
                theme_picker::bottom_margin(state.adaptive_navigation_layout()),
                Instant::now(),
            );
            Task::none()
        }
        Message::Frame(now) => {
            let _ = state.theme_controller.advance(now);
            let _ = state.navigation.advance(now);
            let _ = state.segment_state.advance(now);
            let _ = state.primary_tab_state.advance(now);
            let _ = state.secondary_tab_state.advance(now);
            state.progress_animation.advance(now);
            let _ = state.alert_dialog.advance(now);
            let _ = state.snackbar.advance(now);
            let _ = state.date_picker.advance(now);
            let _ = state.date_range_picker.advance(now);
            let _ = state.time_picker.advance(now);
            Task::none()
        }
    }
}

pub fn linear_phase(&self) -> f32

Returns the current phase for Material linear progress keyframes.

Examples found in repository

examples/showcase/pages/feedback.rs (line 21)

fn progress_indicators(state: &Showcase) -> material::Element<'_, Message> {
    use material::widget::progress_bar::{self, LinearProgressMode, LoadingIndicatorMode};

    let progress = state.progress / 100.0;
    let linear_phase = state.progress_animation.linear_phase();
    let loading_phase = state.progress_animation.loading_phase();

    page::dense_stack([
        page::labeled_value_row("Determinate", format!("{:.0}%", state.progress)).into(),
        material::widget::slider::continuous(0.0..=100.0, state.progress, Message::SliderChanged)
            .step(1.0)
            .into(),
        progress_bar::linear(LinearProgressMode::determinate(progress, linear_phase)).into(),
        progress_bar::linear(LinearProgressMode::indeterminate(linear_phase)).into(),
        page::indicator_row([
            progress_bar::loading(LoadingIndicatorMode::indeterminate(loading_phase)).into(),
            progress_bar::loading(LoadingIndicatorMode::contained_indeterminate(loading_phase))
                .into(),
        ])
        .into(),
    ])
    .into()
}

pub fn color_phase(&self) -> f32

Returns the slower phase used by the four-color linear progress cycle.

pub fn loading_phase(&self) -> f32

Returns the current phase for expressive loading indicator rotation.

Examples found in repository

examples/showcase/pages/feedback.rs (line 22)

fn progress_indicators(state: &Showcase) -> material::Element<'_, Message> {
    use material::widget::progress_bar::{self, LinearProgressMode, LoadingIndicatorMode};

    let progress = state.progress / 100.0;
    let linear_phase = state.progress_animation.linear_phase();
    let loading_phase = state.progress_animation.loading_phase();

    page::dense_stack([
        page::labeled_value_row("Determinate", format!("{:.0}%", state.progress)).into(),
        material::widget::slider::continuous(0.0..=100.0, state.progress, Message::SliderChanged)
            .step(1.0)
            .into(),
        progress_bar::linear(LinearProgressMode::determinate(progress, linear_phase)).into(),
        progress_bar::linear(LinearProgressMode::indeterminate(linear_phase)).into(),
        page::indicator_row([
            progress_bar::loading(LoadingIndicatorMode::indeterminate(loading_phase)).into(),
            progress_bar::loading(LoadingIndicatorMode::contained_indeterminate(loading_phase))
                .into(),
        ])
        .into(),
    ])
    .into()
}

pub const fn is_animating(&self) -> bool

Indeterminate indicators animate for as long as they are displayed.

Examples found in repository

examples/showcase/app.rs (line 425)

fn subscription(state: &Showcase) -> Subscription<Message> {
    let mut subscriptions =
        vec![iced::window::resize_events().map(|(_id, size)| Message::WindowResized(size))];

    if state.theme_controller.is_animating()
        || state.navigation.is_animating()
        || state.segment_state.is_animating()
        || state.primary_tab_state.is_animating()
        || state.secondary_tab_state.is_animating()
        || state.alert_dialog.is_animating()
        || state.snackbar.is_active()
        || state.date_picker.is_animating()
        || state.date_range_picker.is_animating()
        || state.time_picker.is_animating()
        || (state.navigation.selected() == ShowcasePage::Feedback
            && state.progress_animation.is_animating())
    {
        subscriptions.push(iced::window::frames().map(Message::Frame));
    }

    Subscription::batch(subscriptions)
}

Trait Implementations

impl Clone for IndeterminateState

fn clone(&self) -> IndeterminateState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for IndeterminateState

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

Formats the value using the given formatter.

impl Default for IndeterminateState

fn default() -> Self

Returns the “default value” for a type.