use std::sync::Arc; use fuzzy::{StringMatch, StringMatchCandidate};use gpui::{AnyElement, App, Context, DismissEvent, SharedString, Task, Window};use picker::{Picker, PickerDelegate};use theme::ThemeRegistry;use ui::{ListItem, ListItemSpacing, prelude::*}; type IconThemePicker = Picker<IconThemePickerDelegate>; pub struct IconThemePickerDelegate {    icon_themes: Vec<SharedString>,    filtered_themes: Vec<StringMatch>,    selected_index: usize,    current_theme: SharedString,    on_theme_changed: Arc<dyn Fn(SharedString, &mut Window, &mut App) + 'static>,} impl IconThemePickerDelegate {    fn new(        current_theme: SharedString,        on_theme_changed: impl Fn(SharedString, &mut Window, &mut App) + 'static,        cx: &mut Context<IconThemePicker>,    ) -> Self {        let theme_registry = ThemeRegistry::global(cx);         let icon_themes: Vec<SharedString> = theme_registry            .list_icon_themes()            .into_iter()            .map(|theme_meta| theme_meta.name)            .collect();         let selected_index = icon_themes            .iter()            .position(|icon_theme| *icon_theme == current_theme)            .unwrap_or(0);         let filtered_themes = icon_themes            .iter()            .enumerate()            .map(|(index, theme)| StringMatch {                candidate_id: index,                string: theme.to_string(),                positions: Vec::new(),                score: 0.0,            })            .collect();         Self {            icon_themes,            filtered_themes,            selected_index,            current_theme,            on_theme_changed: Arc::new(on_theme_changed),        }    }} impl PickerDelegate for IconThemePickerDelegate {    type ListItem = AnyElement;     fn name() -> &'static str {        "icon theme picker"    }     fn match_count(&self) -> usize {        self.filtered_themes.len()    }     fn selected_index(&self) -> usize {        self.selected_index    }     fn set_selected_index(        &mut self,        index: usize,        _window: &mut Window,        cx: &mut Context<IconThemePicker>,    ) {        self.selected_index = index.min(self.filtered_themes.len().saturating_sub(1));        cx.notify();    }     fn placeholder_text(&self, _window: &mut Window, _cx: &mut App) -> Arc<str> {        "Search icon themes…".into()    }     fn update_matches(        &mut self,        query: String,        _window: &mut Window,        cx: &mut Context<IconThemePicker>,    ) -> Task<()> {        let icon_themes = self.icon_themes.clone();        let current_theme = self.current_theme.clone();         let matches: Vec<StringMatch> = if query.is_empty() {            icon_themes                .iter()                .enumerate()                .map(|(index, theme)| StringMatch {                    candidate_id: index,                    string: theme.to_string(),                    positions: Vec::new(),                    score: 0.0,                })                .collect()        } else {            let _candidates: Vec<StringMatchCandidate> = icon_themes                .iter()                .enumerate()                .map(|(id, theme)| StringMatchCandidate::new(id, theme.as_ref()))                .collect();             icon_themes                .iter()                .enumerate()                .filter(|(_, theme)| theme.to_lowercase().contains(&query.to_lowercase()))                .map(|(index, theme)| StringMatch {                    candidate_id: index,                    string: theme.to_string(),                    positions: Vec::new(),                    score: 0.0,                })                .collect()        };         let selected_index = if query.is_empty() {            icon_themes                .iter()                .position(|theme| *theme == current_theme)                .unwrap_or(0)        } else {            matches                .iter()                .position(|m| icon_themes[m.candidate_id] == current_theme)                .unwrap_or(0)        };         self.filtered_themes = matches;        self.selected_index = selected_index;        cx.notify();         Task::ready(())    }     fn confirm(        &mut self,        _secondary: bool,        window: &mut Window,        cx: &mut Context<IconThemePicker>,    ) {        if let Some(theme_match) = self.filtered_themes.get(self.selected_index) {            let theme = theme_match.string.clone();            (self.on_theme_changed)(theme.into(), window, cx);        }    }     fn dismissed(&mut self, window: &mut Window, cx: &mut Context<IconThemePicker>) {        cx.defer_in(window, |picker, window, cx| {            picker.set_query("", window, cx);        });        cx.emit(DismissEvent);    }     fn render_match(        &self,        index: usize,        selected: bool,        _window: &mut Window,        _cx: &mut Context<IconThemePicker>,    ) -> Option<Self::ListItem> {        let theme_match = self.filtered_themes.get(index)?;         Some(            ListItem::new(index)                .inset(true)                .spacing(ListItemSpacing::Sparse)                .toggle_state(selected)                .child(Label::new(theme_match.string.clone()))                .into_any_element(),        )    }} pub fn icon_theme_picker(    current_theme: SharedString,    on_theme_changed: impl Fn(SharedString, &mut Window, &mut App) + 'static,    window: &mut Window,    cx: &mut Context<IconThemePicker>,) -> IconThemePicker {    let delegate = IconThemePickerDelegate::new(current_theme, on_theme_changed, cx);     Picker::uniform_list(delegate, window, cx)        .show_scrollbar(true)        .initial_width(rems_from_px(210.))        .max_height(rems(18.))        .popover()}