Struct TimePickerState 

pub struct TimePickerState { /* private fields */ }

State held by a Material time picker.

Implementations

impl TimePickerState

pub fn new(hour: u8, minute: u8, is_24_hour: bool) -> Self

Creates time picker state. Invalid initial values are clamped to official ranges.

Examples found in repository

examples/showcase/app.rs (line 197)

    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 auto_switch_to_minute(self, auto_switch_to_minute: bool) -> Self

Sets whether analog hour taps automatically move focus to minute selection.

pub fn hour(&self) -> u8

pub fn minute(&self) -> u8

pub fn is_24_hour(&self) -> bool

pub fn selection(&self) -> TimePickerSelectionMode

pub fn auto_switches_to_minute(&self) -> bool

pub fn hour_input(&self) -> &str

pub fn minute_input(&self) -> &str

pub fn period(&self) -> Period

pub fn hour_for_display(&self) -> u8

pub fn formatted_time(&self) -> String

pub fn is_hour_input_valid(&self) -> bool

pub fn is_minute_input_valid(&self) -> bool

pub fn is_input_valid(&self) -> bool

pub fn update(&mut self, action: TimePickerAction)

Applies a time picker action.

Examples found in repository

examples/showcase/app.rs (line 282)

fn update(state: &mut Showcase, message: Message) -> Task<Message> {
    match message {
        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 update_at(&mut self, action: TimePickerAction, now: Instant)

Applies a time picker action, using now as the transition start time.

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

Advances any running Material time picker transitions.

Examples found in repository

examples/showcase/app.rs (line 370)

fn update(state: &mut Showcase, message: Message) -> Task<Message> {
    match message {
        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 is_animating(&self) -> bool

Returns whether this picker needs frame ticks for animations.

Examples found in repository

examples/showcase/app.rs (line 393)

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)
}

pub fn subscription<Message, F>(&self, on_frame: F) -> Subscription<Message>

where Message: 'static, F: Fn(Instant) -> Message + Send + Clone + 'static,

Returns a frame subscription while picker animations are running.

Trait Implementations

impl Clone for TimePickerState

fn clone(&self) -> TimePickerState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TimePickerState

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

Formats the value using the given formatter.

impl Default for TimePickerState

fn default() -> Self

Returns the “default value” for a type.