Struct State 

pub struct State<Id> { /* private fields */ }

Selection and scroll identity for a log viewer.

Implementations

impl<Id> State<Id>

pub fn new() -> Self

Creates an empty viewer state with an independent scroll identity.

Examples found in repository

examples/showcase/app.rs (line 233)

    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()),
            log_viewer: material::widget::log_viewer::State::new(),
            log_entries: sample_log_entries(),
            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 selected_ids(&self) -> &[Id]

Returns the selected identifiers in selection order.

pub fn clear_selection(&mut self)

Clears the current selection.

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

Advances the contextual selection bar animation.

Call this from window frame events while Self::is_animating is true.

Examples found in repository

examples/showcase/app.rs (line 396)

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::LogViewer(action) => state.log_viewer.update(action, &state.log_entries),
        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);
            let _ = state.log_viewer.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 the contextual selection bar is animating.

Examples found in repository

examples/showcase/app.rs (line 583)

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.log_viewer.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 selection_bar_progress(&self) -> f32

Returns the contextual selection bar visibility progress.

impl<Id: Eq> State<Id>

pub fn is_selected(&self, id: &Id) -> bool

Returns whether an identifier is currently selected.

pub fn toggle(&mut self, id: Id) -> bool

Toggles an identifier and returns its new selected state.

pub fn retain_entries(&mut self, entries: &[LogEntry<Id>])

Drops selections whose entries are no longer present.

pub fn selected_count(&self, entries: &[LogEntry<Id>]) -> usize

Counts selected entries that are still present in the supplied list.

pub fn selected_text(&self, entries: &[LogEntry<Id>]) -> String

Builds clipboard text in the current visible entry order.

pub fn update<Message>( &mut self, action: Action<Id>, entries: &[LogEntry<Id>], ) -> Task<Message>

Applies a viewer action, including clipboard writes for copy actions.

Examples found in repository

examples/showcase/app.rs (line 350)

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::LogViewer(action) => state.log_viewer.update(action, &state.log_entries),
        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);
            let _ = state.log_viewer.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()
        }
    }
}

Trait Implementations

impl<Id: Debug> Debug for State<Id>

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

Formats the value using the given formatter.

impl<Id> Default for State<Id>

fn default() -> Self

Returns the “default value” for a type.