use anyhow::Result;use editor::{scroll::Autoscroll, Editor};use gpui::{    actions, div, impl_actions, list, prelude::*, uniform_list, AnyElement, App, ClickEvent,    Context, DismissEvent, Entity, EventEmitter, FocusHandle, Focusable, Length,    ListSizingBehavior, ListState, MouseButton, MouseUpEvent, Render, ScrollHandle, ScrollStrategy,    Stateful, Task, UniformListScrollHandle, Window,};use head::Head;use schemars::JsonSchema;use serde::Deserialize;use std::{sync::Arc, time::Duration};use ui::{    prelude::*, v_flex, Color, Divider, Label, ListItem, ListItemSpacing, Scrollbar, ScrollbarState,};use util::ResultExt;use workspace::ModalView; mod head;pub mod highlighted_match_with_paths; enum ElementContainer {    List(ListState),    UniformList(UniformListScrollHandle),} actions!(picker, [ConfirmCompletion]); /// ConfirmInput is an alternative editor action which - instead of selecting active picker entry - treats pickers editor input literally,/// performing some kind of action on it.#[derive(Clone, PartialEq, Deserialize, JsonSchema, Default)]#[serde(deny_unknown_fields)]pub struct ConfirmInput {    pub secondary: bool,} impl_actions!(picker, [ConfirmInput]); struct PendingUpdateMatches {    delegate_update_matches: Option<Task<()>>,    _task: Task<Result<()>>,} pub struct Picker<D: PickerDelegate> {    pub delegate: D,    element_container: ElementContainer,    head: Head,    pending_update_matches: Option<PendingUpdateMatches>,    confirm_on_update: Option<bool>,    width: Option<Length>,    widest_item: Option<usize>,    max_height: Option<Length>,    focus_handle: FocusHandle,    /// An external control to display a scrollbar in the `Picker`.    show_scrollbar: bool,    /// An internal state that controls whether to show the scrollbar based on the user's focus.    scrollbar_visibility: bool,    scrollbar_state: ScrollbarState,    hide_scrollbar_task: Option<Task<()>>,    /// Whether the `Picker` is rendered as a self-contained modal.    ///    /// Set this to `false` when rendering the `Picker` as part of a larger modal.    is_modal: bool,} #[derive(Debug, Default, Clone, Copy, PartialEq)]pub enum PickerEditorPosition {    #[default]    /// Render the editor at the start of the picker. Usually the top    Start,    /// Render the editor at the end of the picker. Usually the bottom    End,} pub trait PickerDelegate: Sized + 'static {    type ListItem: IntoElement;     fn match_count(&self) -> usize;    fn selected_index(&self) -> usize;    fn separators_after_indices(&self) -> Vec<usize> {        Vec::new()    }    fn set_selected_index(        &mut self,        ix: usize,        window: &mut Window,        cx: &mut Context<Picker<Self>>,    );    // Allows binding some optional effect to when the selection changes.    fn selected_index_changed(        &self,        _ix: usize,        _window: &mut Window,        _cx: &mut Context<Picker<Self>>,    ) -> Option<Box<dyn Fn(&mut Window, &mut App) + 'static>> {        None    }    fn placeholder_text(&self, _window: &mut Window, _cx: &mut App) -> Arc<str>;    fn no_matches_text(&self, _window: &mut Window, _cx: &mut App) -> SharedString {        "No matches".into()    }    fn update_matches(        &mut self,        query: String,        window: &mut Window,        cx: &mut Context<Picker<Self>>,    ) -> Task<()>;     // Delegates that support this method (e.g. the CommandPalette) can chose to block on any background    // work for up to `duration` to try and get a result synchronously.    // This avoids a flash of an empty command-palette on cmd-shift-p, and lets workspace::SendKeystrokes    // mostly work when dismissing a palette.    fn finalize_update_matches(        &mut self,        _query: String,        _duration: Duration,        _window: &mut Window,        _cx: &mut Context<Picker<Self>>,    ) -> bool {        false    }     /// Override if you want to have <enter> update the query instead of confirming.    fn confirm_update_query(        &mut self,        _window: &mut Window,        _cx: &mut Context<Picker<Self>>,    ) -> Option<String> {        None    }    fn confirm(&mut self, secondary: bool, window: &mut Window, cx: &mut Context<Picker<Self>>);    /// Instead of interacting with currently selected entry, treats editor input literally,    /// performing some kind of action on it.    fn confirm_input(        &mut self,        _secondary: bool,        _window: &mut Window,        _: &mut Context<Picker<Self>>,    ) {    }    fn dismissed(&mut self, window: &mut Window, cx: &mut Context<Picker<Self>>);    fn should_dismiss(&self) -> bool {        true    }    fn confirm_completion(        &mut self,        _query: String,        _window: &mut Window,        _: &mut Context<Picker<Self>>,    ) -> Option<String> {        None    }     fn editor_position(&self) -> PickerEditorPosition {        PickerEditorPosition::default()    }     fn render_editor(        &self,        editor: &Entity<Editor>,        _window: &mut Window,        _cx: &mut Context<Picker<Self>>,    ) -> Div {        v_flex()            .when(                self.editor_position() == PickerEditorPosition::End,                |this| this.child(Divider::horizontal()),            )            .child(                h_flex()                    .overflow_hidden()                    .flex_none()                    .h_9()                    .px_3()                    .child(editor.clone()),            )            .when(                self.editor_position() == PickerEditorPosition::Start,                |this| this.child(Divider::horizontal()),            )    }     fn render_match(        &self,        ix: usize,        selected: bool,        window: &mut Window,        cx: &mut Context<Picker<Self>>,    ) -> Option<Self::ListItem>;    fn render_header(        &self,        _window: &mut Window,        _: &mut Context<Picker<Self>>,    ) -> Option<AnyElement> {        None    }    fn render_footer(        &self,        _window: &mut Window,        _: &mut Context<Picker<Self>>,    ) -> Option<AnyElement> {        None    }} impl<D: PickerDelegate> Focusable for Picker<D> {    fn focus_handle(&self, cx: &App) -> FocusHandle {        match &self.head {            Head::Editor(editor) => editor.focus_handle(cx),            Head::Empty(head) => head.focus_handle(cx),        }    }} #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]enum ContainerKind {    List,    UniformList,} impl<D: PickerDelegate> Picker<D> {    /// A picker, which displays its matches using `gpui::uniform_list`, all matches should have the same height.    /// The picker allows the user to perform search items by text.    /// If `PickerDelegate::render_match` can return items with different heights, use `Picker::list`.    pub fn uniform_list(delegate: D, window: &mut Window, cx: &mut Context<Self>) -> Self {        let head = Head::editor(            delegate.placeholder_text(window, cx),            Self::on_input_editor_event,            window,            cx,        );         Self::new(delegate, ContainerKind::UniformList, head, window, cx)    }     /// A picker, which displays its matches using `gpui::uniform_list`, all matches should have the same height.    /// If `PickerDelegate::render_match` can return items with different heights, use `Picker::list`.    pub fn nonsearchable_uniform_list(        delegate: D,        window: &mut Window,        cx: &mut Context<Self>,    ) -> Self {        let head = Head::empty(Self::on_empty_head_blur, window, cx);         Self::new(delegate, ContainerKind::UniformList, head, window, cx)    }     /// A picker, which displays its matches using `gpui::list`, matches can have different heights.    /// The picker allows the user to perform search items by text.    /// If `PickerDelegate::render_match` only returns items with the same height, use `Picker::uniform_list` as its implementation is optimized for that.    pub fn list(delegate: D, window: &mut Window, cx: &mut Context<Self>) -> Self {        let head = Head::editor(            delegate.placeholder_text(window, cx),            Self::on_input_editor_event,            window,            cx,        );         Self::new(delegate, ContainerKind::List, head, window, cx)    }     fn new(        delegate: D,        container: ContainerKind,        head: Head,        window: &mut Window,        cx: &mut Context<Self>,    ) -> Self {        let element_container = Self::create_element_container(container, cx);        let scrollbar_state = match &element_container {            ElementContainer::UniformList(scroll_handle) => {                ScrollbarState::new(scroll_handle.clone())            }            ElementContainer::List(_) => {                // todo smit: implement for list                ScrollbarState::new(ScrollHandle::new())            }        };        let focus_handle = cx.focus_handle();        let mut this = Self {            delegate,            head,            element_container,            pending_update_matches: None,            confirm_on_update: None,            width: None,            widest_item: None,            max_height: Some(rems(18.).into()),            focus_handle,            show_scrollbar: false,            scrollbar_visibility: true,            scrollbar_state,            is_modal: true,            hide_scrollbar_task: None,        };        this.update_matches("".to_string(), window, cx);        // give the delegate 4ms to render the first set of suggestions.        this.delegate            .finalize_update_matches("".to_string(), Duration::from_millis(4), window, cx);        this    }     fn create_element_container(        container: ContainerKind,        cx: &mut Context<Self>,    ) -> ElementContainer {        match container {            ContainerKind::UniformList => {                ElementContainer::UniformList(UniformListScrollHandle::new())            }            ContainerKind::List => {                let entity = cx.entity().downgrade();                ElementContainer::List(ListState::new(                    0,                    gpui::ListAlignment::Top,                    px(1000.),                    move |ix, window, cx| {                        entity                            .upgrade()                            .map(|entity| {                                entity.update(cx, |this, cx| {                                    this.render_element(window, cx, ix).into_any_element()                                })                            })                            .unwrap_or_else(|| div().into_any_element())                    },                ))            }        }    }     pub fn width(mut self, width: impl Into<gpui::Length>) -> Self {        self.width = Some(width.into());        self    }     pub fn widest_item(mut self, ix: Option<usize>) -> Self {        self.widest_item = ix;        self    }     pub fn max_height(mut self, max_height: Option<gpui::Length>) -> Self {        self.max_height = max_height;        self    }     pub fn show_scrollbar(mut self, show_scrollbar: bool) -> Self {        self.show_scrollbar = show_scrollbar;        self    }     pub fn modal(mut self, modal: bool) -> Self {        self.is_modal = modal;        self    }     pub fn focus(&self, window: &mut Window, cx: &mut App) {        self.focus_handle(cx).focus(window);    }     /// Handles the selecting an index, and passing the change to the delegate.    /// If `scroll_to_index` is true, the new selected index will be scrolled into view.    ///    /// If some effect is bound to `selected_index_changed`, it will be executed.    pub fn set_selected_index(        &mut self,        ix: usize,        scroll_to_index: bool,        window: &mut Window,        cx: &mut Context<Self>,    ) {        let previous_index = self.delegate.selected_index();        self.delegate.set_selected_index(ix, window, cx);        let current_index = self.delegate.selected_index();         if previous_index != current_index {            if let Some(action) = self.delegate.selected_index_changed(ix, window, cx) {                action(window, cx);            }            if scroll_to_index {                self.scroll_to_item_index(ix);            }        }    }     pub fn select_next(        &mut self,        _: &menu::SelectNext,        window: &mut Window,        cx: &mut Context<Self>,    ) {        let count = self.delegate.match_count();        if count > 0 {            let index = self.delegate.selected_index();            let ix = if index == count - 1 { 0 } else { index + 1 };            self.set_selected_index(ix, true, window, cx);            cx.notify();        }    }     fn select_previous(        &mut self,        _: &menu::SelectPrevious,        window: &mut Window,        cx: &mut Context<Self>,    ) {        let count = self.delegate.match_count();        if count > 0 {            let index = self.delegate.selected_index();            let ix = if index == 0 { count - 1 } else { index - 1 };            self.set_selected_index(ix, true, window, cx);            cx.notify();        }    }     fn select_first(&mut self, _: &menu::SelectFirst, window: &mut Window, cx: &mut Context<Self>) {        let count = self.delegate.match_count();        if count > 0 {            self.set_selected_index(0, true, window, cx);            cx.notify();        }    }     fn select_last(&mut self, _: &menu::SelectLast, window: &mut Window, cx: &mut Context<Self>) {        let count = self.delegate.match_count();        if count > 0 {            self.set_selected_index(count - 1, true, window, cx);            cx.notify();        }    }     pub fn cycle_selection(&mut self, window: &mut Window, cx: &mut Context<Self>) {        let count = self.delegate.match_count();        let index = self.delegate.selected_index();        let new_index = if index + 1 == count { 0 } else { index + 1 };        self.set_selected_index(new_index, true, window, cx);        cx.notify();    }     pub fn cancel(&mut self, _: &menu::Cancel, window: &mut Window, cx: &mut Context<Self>) {        if self.delegate.should_dismiss() {            self.delegate.dismissed(window, cx);            cx.emit(DismissEvent);        }    }     fn confirm(&mut self, _: &menu::Confirm, window: &mut Window, cx: &mut Context<Self>) {        if self.pending_update_matches.is_some()            && !self.delegate.finalize_update_matches(                self.query(cx),                Duration::from_millis(16),                window,                cx,            )        {            self.confirm_on_update = Some(false)        } else {            self.pending_update_matches.take();            self.do_confirm(false, window, cx);        }    }     fn secondary_confirm(        &mut self,        _: &menu::SecondaryConfirm,        window: &mut Window,        cx: &mut Context<Self>,    ) {        if self.pending_update_matches.is_some()            && !self.delegate.finalize_update_matches(                self.query(cx),                Duration::from_millis(16),                window,                cx,            )        {            self.confirm_on_update = Some(true)        } else {            self.do_confirm(true, window, cx);        }    }     fn confirm_input(&mut self, input: &ConfirmInput, window: &mut Window, cx: &mut Context<Self>) {        self.delegate.confirm_input(input.secondary, window, cx);    }     fn confirm_completion(        &mut self,        _: &ConfirmCompletion,        window: &mut Window,        cx: &mut Context<Self>,    ) {        if let Some(new_query) = self.delegate.confirm_completion(self.query(cx), window, cx) {            self.set_query(new_query, window, cx);        } else {            cx.propagate()        }    }     fn handle_click(

Lines 1–500 of 872. Load more