pub mod disconnected_overlay;mod remote_connections;mod remote_servers;mod ssh_config; #[cfg(target_os = "windows")]mod wsl_picker; use remote::RemoteConnectionOptions;pub use remote_connections::{RemoteConnectionModal, connect, open_remote_project}; use disconnected_overlay::DisconnectedOverlay;use fuzzy::{StringMatch, StringMatchCandidate};use gpui::{    Action, AnyElement, App, Context, DismissEvent, Entity, EventEmitter, FocusHandle, Focusable,    Subscription, Task, WeakEntity, Window,};use ordered_float::OrderedFloat;use picker::{    Picker, PickerDelegate,    highlighted_match_with_paths::{HighlightedMatch, HighlightedMatchWithPaths},};pub use remote_connections::SshSettings;pub use remote_servers::RemoteServerProjects;use settings::Settings;use std::{path::Path, sync::Arc};use ui::{KeyBinding, ListItem, ListItemSpacing, Tooltip, prelude::*, tooltip_container};use util::{ResultExt, paths::PathExt};use workspace::{    CloseIntent, HistoryManager, ModalView, OpenOptions, PathList, SerializedWorkspaceLocation,    WORKSPACE_DB, Workspace, WorkspaceId, notifications::DetachAndPromptErr,    with_active_or_new_workspace,};use zed_actions::{OpenRecent, OpenRemote}; pub fn init(cx: &mut App) {    SshSettings::register(cx);     #[cfg(target_os = "windows")]    cx.on_action(|open_wsl: &zed_actions::wsl_actions::OpenFolderInWsl, cx| {        let create_new_window = open_wsl.create_new_window;        with_active_or_new_workspace(cx, move |workspace, window, cx| {            use gpui::PathPromptOptions;            use project::DirectoryLister;             let paths = workspace.prompt_for_open_path(                PathPromptOptions {                    files: true,                    directories: true,                    multiple: false,                    prompt: None,                },                DirectoryLister::Local(                    workspace.project().clone(),                    workspace.app_state().fs.clone(),                ),                window,                cx,            );             cx.spawn_in(window, async move |workspace, cx| {                use util::paths::SanitizedPath;                 let Some(paths) = paths.await.log_err().flatten() else {                    return;                };                 let paths = paths                    .into_iter()                    .filter_map(|path| SanitizedPath::new(&path).local_to_wsl())                    .collect::<Vec<_>>();                 if paths.is_empty() {                    let message = indoc::indoc! { r#"                        Invalid path specified when trying to open a folder inside WSL.                         Please note that Zed currently does not support opening network share folders inside wsl.                    "#};                     let _ = cx.prompt(gpui::PromptLevel::Critical, "Invalid path", Some(&message), &["Ok"]).await;                    return;                }                 workspace.update_in(cx, |workspace, window, cx| {                    workspace.toggle_modal(window, cx, |window, cx| {                        crate::wsl_picker::WslOpenModal::new(paths, create_new_window, window, cx)                    });                }).log_err();            })            .detach();        });    });     #[cfg(target_os = "windows")]    cx.on_action(|open_wsl: &zed_actions::wsl_actions::OpenWsl, cx| {        let create_new_window = open_wsl.create_new_window;        with_active_or_new_workspace(cx, move |workspace, window, cx| {            let handle = cx.entity().downgrade();            let fs = workspace.project().read(cx).fs().clone();            workspace.toggle_modal(window, cx, |window, cx| {                RemoteServerProjects::wsl(create_new_window, fs, window, handle, cx)            });        });    });     #[cfg(target_os = "windows")]    cx.on_action(|open_wsl: &remote::OpenWslPath, cx| {        let open_wsl = open_wsl.clone();        with_active_or_new_workspace(cx, move |workspace, window, cx| {            let fs = workspace.project().read(cx).fs().clone();            add_wsl_distro(fs, &open_wsl.distro, cx);            let open_options = OpenOptions {                replace_window: window.window_handle().downcast::<Workspace>(),                ..Default::default()            };             let app_state = workspace.app_state().clone();             cx.spawn_in(window, async move |_, cx| {                open_remote_project(                    RemoteConnectionOptions::Wsl(open_wsl.distro.clone()),                    open_wsl.paths,                    app_state,                    open_options,                    cx,                )                .await            })            .detach();        });    });     cx.on_action(|open_recent: &OpenRecent, cx| {        let create_new_window = open_recent.create_new_window;        with_active_or_new_workspace(cx, move |workspace, window, cx| {            let Some(recent_projects) = workspace.active_modal::<RecentProjects>(cx) else {                RecentProjects::open(workspace, create_new_window, window, cx);                return;            };             recent_projects.update(cx, |recent_projects, cx| {                recent_projects                    .picker                    .update(cx, |picker, cx| picker.cycle_selection(window, cx))            });        });    });    cx.on_action(|open_remote: &OpenRemote, cx| {        let from_existing_connection = open_remote.from_existing_connection;        let create_new_window = open_remote.create_new_window;        with_active_or_new_workspace(cx, move |workspace, window, cx| {            if from_existing_connection {                cx.propagate();                return;            }            let handle = cx.entity().downgrade();            let fs = workspace.project().read(cx).fs().clone();            workspace.toggle_modal(window, cx, |window, cx| {                RemoteServerProjects::new(create_new_window, fs, window, handle, cx)            })        });    });     cx.observe_new(DisconnectedOverlay::register).detach();} #[cfg(target_os = "windows")]pub fn add_wsl_distro(    fs: Arc<dyn project::Fs>,    connection_options: &remote::WslConnectionOptions,    cx: &App,) {    use gpui::ReadGlobal;    use settings::SettingsStore;     let distro_name = SharedString::from(&connection_options.distro_name);    let user = connection_options.user.clone();    SettingsStore::global(cx).update_settings_file(fs, move |setting, _| {        let connections = setting            .remote            .wsl_connections            .get_or_insert(Default::default());         if !connections            .iter()            .any(|conn| conn.distro_name == distro_name && conn.user == user)        {            use std::collections::BTreeSet;             connections.push(settings::WslConnection {                distro_name,                user,                projects: BTreeSet::new(),            })        }    });} pub struct RecentProjects {    pub picker: Entity<Picker<RecentProjectsDelegate>>,    rem_width: f32,    _subscription: Subscription,} impl ModalView for RecentProjects {} impl RecentProjects {    fn new(        delegate: RecentProjectsDelegate,        rem_width: f32,        window: &mut Window,        cx: &mut Context<Self>,    ) -> Self {        let picker = cx.new(|cx| {            // We want to use a list when we render paths, because the items can have different heights (multiple paths).            if delegate.render_paths {                Picker::list(delegate, window, cx)            } else {                Picker::uniform_list(delegate, window, cx)            }        });        let _subscription = cx.subscribe(&picker, |_, _, _, cx| cx.emit(DismissEvent));        // We do not want to block the UI on a potentially lengthy call to DB, so we're gonna swap        // out workspace locations once the future runs to completion.        cx.spawn_in(window, async move |this, cx| {            let workspaces = WORKSPACE_DB                .recent_workspaces_on_disk()                .await                .log_err()                .unwrap_or_default();            this.update_in(cx, move |this, window, cx| {                this.picker.update(cx, move |picker, cx| {                    picker.delegate.set_workspaces(workspaces);                    picker.update_matches(picker.query(cx), window, cx)                })            })            .ok()        })        .detach();        Self {            picker,            rem_width,            _subscription,        }    }     pub fn open(        workspace: &mut Workspace,        create_new_window: bool,        window: &mut Window,        cx: &mut Context<Workspace>,    ) {        let weak = cx.entity().downgrade();        workspace.toggle_modal(window, cx, |window, cx| {            let delegate = RecentProjectsDelegate::new(weak, create_new_window, true);             Self::new(delegate, 34., window, cx)        })    }} impl EventEmitter<DismissEvent> for RecentProjects {} impl Focusable for RecentProjects {    fn focus_handle(&self, cx: &App) -> FocusHandle {        self.picker.focus_handle(cx)    }} impl Render for RecentProjects {    fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {        v_flex()            .key_context("RecentProjects")            .w(rems(self.rem_width))            .child(self.picker.clone())            .on_mouse_down_out(cx.listener(|this, _, window, cx| {                this.picker.update(cx, |this, cx| {                    this.cancel(&Default::default(), window, cx);                })            }))    }} pub struct RecentProjectsDelegate {    workspace: WeakEntity<Workspace>,    workspaces: Vec<(WorkspaceId, SerializedWorkspaceLocation, PathList)>,    selected_match_index: usize,    matches: Vec<StringMatch>,    render_paths: bool,    create_new_window: bool,    // Flag to reset index when there is a new query vs not reset index when user delete an item    reset_selected_match_index: bool,    has_any_non_local_projects: bool,} impl RecentProjectsDelegate {    fn new(workspace: WeakEntity<Workspace>, create_new_window: bool, render_paths: bool) -> Self {        Self {            workspace,            workspaces: Vec::new(),            selected_match_index: 0,            matches: Default::default(),            create_new_window,            render_paths,            reset_selected_match_index: true,            has_any_non_local_projects: false,        }    }     pub fn set_workspaces(        &mut self,        workspaces: Vec<(WorkspaceId, SerializedWorkspaceLocation, PathList)>,    ) {        self.workspaces = workspaces;        self.has_any_non_local_projects = !self            .workspaces            .iter()            .all(|(_, location, _)| matches!(location, SerializedWorkspaceLocation::Local));    }}impl EventEmitter<DismissEvent> for RecentProjectsDelegate {}impl PickerDelegate for RecentProjectsDelegate {    type ListItem = ListItem;     fn placeholder_text(&self, window: &mut Window, _: &mut App) -> Arc<str> {        let (create_window, reuse_window) = if self.create_new_window {            (                window.keystroke_text_for(&menu::Confirm),                window.keystroke_text_for(&menu::SecondaryConfirm),            )        } else {            (                window.keystroke_text_for(&menu::SecondaryConfirm),                window.keystroke_text_for(&menu::Confirm),            )        };        Arc::from(format!(            "{reuse_window} reuses this window, {create_window} opens a new one",        ))    }     fn match_count(&self) -> usize {        self.matches.len()    }     fn selected_index(&self) -> usize {        self.selected_match_index    }     fn set_selected_index(        &mut self,        ix: usize,        _window: &mut Window,        _cx: &mut Context<Picker<Self>>,    ) {        self.selected_match_index = ix;    }     fn update_matches(        &mut self,        query: String,        _: &mut Window,        cx: &mut Context<Picker<Self>>,    ) -> gpui::Task<()> {        let query = query.trim_start();        let smart_case = query.chars().any(|c| c.is_uppercase());        let candidates = self            .workspaces            .iter()            .enumerate()            .filter(|(_, (id, _, _))| !self.is_current_workspace(*id, cx))            .map(|(id, (_, _, paths))| {                let combined_string = paths                    .ordered_paths()                    .map(|path| path.compact().to_string_lossy().into_owned())                    .collect::<Vec<_>>()                    .join("");                StringMatchCandidate::new(id, &combined_string)            })            .collect::<Vec<_>>();        self.matches = smol::block_on(fuzzy::match_strings(            candidates.as_slice(),            query,            smart_case,            true,            100,            &Default::default(),            cx.background_executor().clone(),        ));        self.matches.sort_unstable_by(|a, b| {            b.score                .partial_cmp(&a.score) // Descending score                .unwrap_or(std::cmp::Ordering::Equal)                .then_with(|| a.candidate_id.cmp(&b.candidate_id)) // Ascending candidate_id for ties        });         if self.reset_selected_match_index {            self.selected_match_index = self                .matches                .iter()                .enumerate()                .rev()                .max_by_key(|(_, m)| OrderedFloat(m.score))                .map(|(ix, _)| ix)                .unwrap_or(0);        }        self.reset_selected_match_index = true;        Task::ready(())    }     fn confirm(&mut self, secondary: bool, window: &mut Window, cx: &mut Context<Picker<Self>>) {        if let Some((selected_match, workspace)) = self            .matches            .get(self.selected_index())            .zip(self.workspace.upgrade())        {            let (candidate_workspace_id, candidate_workspace_location, candidate_workspace_paths) =                &self.workspaces[selected_match.candidate_id];            let replace_current_window = if self.create_new_window {                secondary            } else {                !secondary            };            workspace.update(cx, |workspace, cx| {                if workspace.database_id() == Some(*candidate_workspace_id) {                    return;                }                match candidate_workspace_location.clone() {                    SerializedWorkspaceLocation::Local => {                        let paths = candidate_workspace_paths.paths().to_vec();                        if replace_current_window {                            cx.spawn_in(window, async move |workspace, cx| {                                let continue_replacing = workspace                                    .update_in(cx, |workspace, window, cx| {                                        workspace.prepare_to_close(                                            CloseIntent::ReplaceWindow,                                            window,                                            cx,                                        )                                    })?                                    .await?;                                if continue_replacing {                                    workspace                                        .update_in(cx, |workspace, window, cx| {                                            workspace                                                .open_workspace_for_paths(true, paths, window, cx)                                        })?                                        .await                                } else {                                    Ok(())                                }                            })                        } else {                            workspace.open_workspace_for_paths(false, paths, window, cx)                        }                    }                    SerializedWorkspaceLocation::Remote(mut connection) => {                        let app_state = workspace.app_state().clone();                         let replace_window = if replace_current_window {                            window.window_handle().downcast::<Workspace>()                        } else {                            None                        };                         let open_options = OpenOptions {                            replace_window,                            ..Default::default()                        };                         if let RemoteConnectionOptions::Ssh(connection) = &mut connection {                            SshSettings::get_global(cx)                                .fill_connection_options_from_settings(connection);                        };                         let paths = candidate_workspace_paths.paths().to_vec();                         cx.spawn_in(window, async move |_, cx| {                            open_remote_project(                                connection.clone(),                                paths,                                app_state,                                open_options,                                cx,                            )                            .await                        })                    }                }                .detach_and_prompt_err(                    "Failed to open project",                    window,                    cx,                    |_, _, _| None,                );            });            cx.emit(DismissEvent);        }    } 

Lines 1–500 of 923. Load more