Skip to content

armgit / zed

Public Imported from GitHub
0

Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.

project_panel: Confirm before trashing unsaved file on undo (#62294)

Dinod4010e91ccc9
diff --git a/crates/project_panel/src/project_panel.rs b/crates/project_panel/src/project_panel.rs
index ce99110563b..675d0238146 100644
--- a/crates/project_panel/src/project_panel.rs
+++ b/crates/project_panel/src/project_panel.rs
@@ -649,6 +649,17 @@ enum RemoveEntryTask {
Delete(Task<Result<()>>),
}
+struct RemovalPrompt {
+ message: String,
+ detail: Option<&'static str>,
+ confirmation_label: &'static str,
+}
+
+enum RemovalKind {
+ Trash,
+ Delete,
+}
+
impl ProjectPanel {
fn new(
workspace: &mut Workspace,
@@ -2549,6 +2560,74 @@ impl ProjectPanel {
});
}
+ /// Builds the confirmation prompt shared by direct removal and undo/redo.
+ ///
+ /// The `names` slice must contain every path being removed, and this
+ /// function will apply markdown formatting and display truncation. The
+ /// `dirty_buffers` parameter should be the number of those paths that have
+ /// unsaved changes.
+ fn build_removal_prompt<S>(
+ kind: RemovalKind,
+ names: &[S],
+ dirty_buffers: usize,
+ ) -> RemovalPrompt
+ where
+ S: AsRef<str>,
+ {
+ let (message_start, confirmation_label, detail) = match kind {
+ RemovalKind::Trash => ("Do you want to trash", "Trash", None),
+ RemovalKind::Delete => (
+ "Are you sure you want to permanently delete",
+ "Delete",
+ Some("This cannot be undone."),
+ ),
+ };
+
+ let mut message = match names {
+ [name] => format!("{message_start} {}?", MarkdownInlineCode(name.as_ref())),
+ _ => {
+ const CUTOFF_POINT: usize = 10;
+ let mut listed_names = names
+ .iter()
+ .take(CUTOFF_POINT)
+ .map(|name| MarkdownInlineCode(name.as_ref()).to_string())
+ .collect::<Vec<_>>();
+ let omitted_count = names.len().saturating_sub(CUTOFF_POINT);
+ if omitted_count == 1 {
+ listed_names.push(".. 1 file not shown".into());
+ } else if omitted_count > 1 {
+ listed_names.push(format!(".. {omitted_count} files not shown"));
+ }
+
+ format!(
+ "{message_start} the following {} files?\n{}",
+ names.len(),
+ listed_names.join("\n")
+ )
+ }
+ };
+ match dirty_buffers {
+ 0 => {}
+ 1 if names.len() == 1 => {
+ message.push_str("\n\nIt has unsaved changes, which will be lost.");
+ }
+ 1 => {
+ message.push_str("\n\n1 of these has unsaved changes, which will be lost.");
+ }
+ dirty_buffers => {
+ message.push_str(&format!(
+ "\n\n{dirty_buffers} of these have unsaved changes, which will be lost."
+ ));
+ }
+ }
+
+ RemovalPrompt {
+ message,
+ detail,
+ confirmation_label,
+ }
+ }
+
// TODO(yara|dino): trashing and deleting are conceptually distinct, even
// more so with the fact that trashing can now be undone, whereas deleting
// cannot.
@@ -2587,70 +2666,24 @@ impl ProjectPanel {
return None;
}
let answer = if !skip_prompt {
- let operation = if trash { "Trash" } else { "Delete" };
- let message_start = if trash {
- "Do you want to trash"
+ let names = file_paths
+ .iter()
+ .map(|(_, _, name)| name.as_str())
+ .collect::<Vec<_>>();
+
+ let removal_kind = if trash {
+ RemovalKind::Trash
} else {
- "Are you sure you want to permanently delete"
+ RemovalKind::Delete
};
- let prompt = match file_paths.first() {
- Some((_, _, path)) if file_paths.len() == 1 => {
- let unsaved_warning = if dirty_buffers > 0 {
- "\n\nIt has unsaved changes, which will be lost."
- } else {
- ""
- };
- format!(
- "{message_start} {}?{unsaved_warning}",
- MarkdownInlineCode(path)
- )
- }
- _ => {
- const CUTOFF_POINT: usize = 10;
- let names = if file_paths.len() > CUTOFF_POINT {
- let truncated_path_counts = file_paths.len() - CUTOFF_POINT;
- let mut paths = file_paths
- .iter()
- .map(|(_, _, path)| MarkdownInlineCode(path).to_string())
- .take(CUTOFF_POINT)
- .collect::<Vec<String>>();
- paths.truncate(CUTOFF_POINT);
- if truncated_path_counts == 1 {
- paths.push(".. 1 file not shown".into());
- } else {
- paths.push(format!(".. {} files not shown", truncated_path_counts));
- }
- paths
- } else {
- file_paths
- .iter()
- .map(|(_, _, path)| MarkdownInlineCode(path).to_string())
- .collect()
- };
- let unsaved_warning = if dirty_buffers == 0 {
- String::new()
- } else if dirty_buffers == 1 {
- "\n\n1 of these has unsaved changes, which will be lost.".to_string()
- } else {
- format!(
- "\n\n{dirty_buffers} of these have unsaved changes, which will be lost."
- )
- };
+ let prompt = Self::build_removal_prompt(removal_kind, &names, dirty_buffers);
- format!(
- "{message_start} the following {} files?\n{}{unsaved_warning}",
- file_paths.len(),
- names.join("\n")
- )
- }
- };
- let detail = (!trash).then_some("This cannot be undone.");
Some(window.prompt(
PromptLevel::Info,
- &prompt,
- detail,
- &[operation, "Cancel"],
+ &prompt.message,
+ prompt.detail,
+ &[prompt.confirmation_label, "Cancel"],
cx,
))
} else {
diff --git a/crates/project_panel/src/tests/undo.rs b/crates/project_panel/src/tests/undo.rs
index 6f419c0750a..ca2ec15331b 100644
--- a/crates/project_panel/src/tests/undo.rs
+++ b/crates/project_panel/src/tests/undo.rs
@@ -2,17 +2,18 @@
use client::proto;
use collections::HashSet;
+use editor::Editor;
use fs::{FakeFs, Fs};
-use gpui::{App, BorrowAppContext, Entity, VisualTestContext};
+use gpui::{App, BorrowAppContext, Context, Entity, VisualTestContext, Window};
use project::Project;
use serde_json::{Value, json};
use settings::SettingsStore;
use std::path::Path;
use std::sync::Arc;
-use workspace::{MultiWorkspace, register_project_item};
+use workspace::{Item, MultiWorkspace, register_project_item};
use crate::project_panel_tests::{self, TestProjectItemView, find_project_entry, select_path};
-use crate::{NewDirectory, NewFile, ProjectPanel, Redo, Rename, Trash, Undo};
+use crate::{NewDirectory, NewFile, Open, ProjectPanel, Redo, Rename, Trash, Undo};
struct TestContext {
panel: Entity<ProjectPanel>,
@@ -50,6 +51,7 @@ impl TestContext {
});
self.cx.run_until_parked();
}
+
async fn redo(&mut self) {
self.panel.update_in(&mut self.cx, |panel, window, cx| {
panel.redo(&Redo, window, cx);
@@ -57,7 +59,40 @@ impl TestContext {
self.cx.run_until_parked();
}
+ fn open_path(&mut self, path: &str) {
+ select_path(&self.panel, &format!("workspace/{path}"), &mut self.cx);
+ self.panel.update_in(&mut self.cx, |panel, window, cx| {
+ panel.open(&Open, window, cx)
+ });
+ self.cx.run_until_parked();
+ }
+
+ #[track_caller]
+ fn assert_prompt(&self, expected: &str) {
+ let (prompt, _) = self
+ .cx
+ .cx
+ .pending_prompt()
+ .expect("should have pending prompt");
+ assert!(
+ prompt.contains(expected),
+ "expected prompt to contain {expected:?}, got {prompt:?}"
+ );
+ }
+
+ #[track_caller]
+ fn answer(&self, answer: &str) {
+ assert!(
+ self.cx.cx.has_pending_prompt(),
+ "should have pending prompt"
+ );
+
+ self.cx.cx.simulate_prompt_answer(answer);
+ self.cx.run_until_parked();
+ }
+
/// Note this only works when every file has an extension
+ #[track_caller]
fn assert_fs_state_is(&mut self, state: &[&str]) {
let state: HashSet<_> = state
.into_iter()
@@ -94,6 +129,7 @@ impl TestContext {
);
}
+ #[track_caller]
fn assert_not_exists(&mut self, file: &str) {
assert_eq!(
find_project_entry(&self.panel, &format!("workspace/{file}"), &mut self.cx),
@@ -231,6 +267,7 @@ impl TestContext {
async fn new_with_tree(cx: &mut gpui::TestAppContext, tree: Value) -> TestContext {
project_panel_tests::init_test(cx);
+ cx.update(register_project_item::<Editor>);
let fs = FakeFs::new(cx.executor());
fs.insert_tree("/workspace", tree).await;
@@ -256,6 +293,23 @@ impl TestContext {
fn update_app<R>(&mut self, update: impl FnOnce(&mut App) -> R) -> R {
self.cx.cx.update(update)
}
+
+ #[track_caller]
+ fn update_active_editor<R>(
+ &mut self,
+ update: impl FnOnce(&mut Editor, &mut Window, &mut Context<'_, Editor>) -> R,
+ ) -> R {
+ let editor = self
+ .panel
+ .read_with(&self.cx, |panel, _| panel.workspace.upgrade())
+ .expect("workspace should still exist")
+ .read_with(&self.cx, |workspace, cx| {
+ workspace.active_item_as::<Editor>(cx)
+ })
+ .expect("editor should be open");
+
+ editor.update_in(&mut self.cx, update)
+ }
}
#[gpui::test]
@@ -287,6 +341,7 @@ async fn create_undo_redo(cx: &mut gpui::TestAppContext) {
cx.fs.write(Path::new(&path), b"Hello!").await.unwrap();
cx.undo().await;
+ cx.answer("Trash");
cx.assert_not_exists("c.txt");
cx.redo().await;
@@ -294,6 +349,45 @@ async fn create_undo_redo(cx: &mut gpui::TestAppContext) {
assert_eq!(cx.fs.load(Path::new(&path)).await.unwrap(), "Hello!");
}
+#[gpui::test]
+async fn undo_create_cancel_trash(cx: &mut gpui::TestAppContext) {
+ let mut cx = TestContext::new(cx).await;
+
+ cx.create_file("c.txt").await;
+
+ cx.undo().await;
+ cx.answer("Cancel");
+ cx.assert_exists("c.txt");
+
+ cx.undo().await;
+ cx.answer("Trash");
+ cx.assert_not_exists("c.txt");
+}
+
+#[gpui::test]
+async fn undo_create_dirty_file(cx: &mut gpui::TestAppContext) {
+ let mut cx = TestContext::new(cx).await;
+
+ cx.create_file("c.txt").await;
+
+ // After `c.txt` is created, it should now be open in the editor, so we'll
+ // simulate inserting some content into the file, without saving, in order
+ // to make it dirty.
+ cx.update_active_editor(|editor, window, cx| {
+ editor.handle_input("unsaved changes", window, cx);
+ assert!(editor.is_dirty(cx));
+ });
+
+ cx.undo().await;
+ cx.answer("Cancel");
+ cx.assert_exists("c.txt");
+ cx.update_active_editor(|editor, _window, cx| assert!(editor.is_dirty(cx)));
+
+ cx.undo().await;
+ cx.answer("Don't Save");
+ cx.assert_not_exists("c.txt");
+}
+
#[gpui::test]
async fn create_dir_undo(cx: &mut gpui::TestAppContext) {
let mut cx = TestContext::new(cx).await;
@@ -301,6 +395,7 @@ async fn create_dir_undo(cx: &mut gpui::TestAppContext) {
cx.create_directory("new_dir").await;
cx.assert_exists("new_dir");
cx.undo().await;
+ cx.answer("Trash");
cx.assert_not_exists("new_dir");
}
@@ -365,6 +460,7 @@ async fn two_sequential_undos(cx: &mut gpui::TestAppContext) {
cx.assert_fs_state_is(&["b.txt", "x.txt", "y.txt"]);
cx.undo().await;
+ cx.answer("Trash");
cx.assert_fs_state_is(&["b.txt", "x.txt"]);
cx.undo().await;
@@ -392,6 +488,7 @@ async fn trash_undo_redo(cx: &mut gpui::TestAppContext) {
cx.assert_fs_state_is(&["a.txt", "b.txt"]);
cx.redo().await;
+ cx.answer("Trash");
cx.assert_fs_state_is(&[]);
}
@@ -423,6 +520,7 @@ async fn trash_directory_undo_redo(cx: &mut gpui::TestAppContext) {
);
cx.redo().await;
+ cx.answer("Trash");
cx.assert_fs_state_is(&["a.txt"]);
}
@@ -543,3 +641,41 @@ async fn excluded_create_is_not_recorded(cx: &mut gpui::TestAppContext) {
cx.undo().await;
cx.assert_fs_state_is(&["a.txt", "token.secret", "banana.secret"]);
}
+
+#[gpui::test]
+async fn cancel_partial_trash_batch(cx: &mut gpui::TestAppContext) {
+ let mut cx = TestContext::new(cx).await;
+
+ cx.trash(&["a.txt", "b.txt"]).await;
+ cx.undo().await;
+ cx.assert_fs_state_is(&["a.txt", "b.txt"]);
+
+ cx.redo().await;
+ cx.answer("Cancel");
+ cx.assert_fs_state_is(&["a.txt", "b.txt"]);
+
+ cx.redo().await;
+ cx.answer("Trash");
+ cx.assert_fs_state_is(&[]);
+}
+
+#[gpui::test]
+async fn batch_trash_warns_about_unsaved_changes(cx: &mut gpui::TestAppContext) {
+ let mut cx = TestContext::new(cx).await;
+
+ cx.trash(&["a.txt", "b.txt"]).await;
+ cx.undo().await;
+ cx.assert_fs_state_is(&["a.txt", "b.txt"]);
+
+ cx.open_path("a.txt");
+ cx.update_active_editor(|editor, window, cx| {
+ editor.handle_input("unsaved changes", window, cx);
+ });
+
+ cx.redo().await;
+ cx.assert_prompt("1 of these has unsaved changes, which will be lost.");
+
+ cx.answer("Cancel");
+ cx.assert_fs_state_is(&["a.txt", "b.txt"]);
+ cx.update_active_editor(|editor, _window, cx| assert!(editor.is_dirty(cx)));
+}
diff --git a/crates/project_panel/src/undo.rs b/crates/project_panel/src/undo.rs
index 65c365c2ef4..3bc552b7cf1 100644
--- a/crates/project_panel/src/undo.rs
+++ b/crates/project_panel/src/undo.rs
@@ -130,11 +130,13 @@
//! List of "tainted files" that the user may not operate on
-use crate::ProjectPanel;
+use crate::{ProjectPanel, RemovalKind};
use anyhow::{Context, Result, anyhow};
use fs::{TrashId, TrashRestoreError};
use futures::channel::mpsc;
-use gpui::{AppContext, AsyncApp, IntoElement, SharedString, Styled, Task, WeakEntity};
+use gpui::{
+ AppContext, AsyncApp, IntoElement, PromptLevel, SharedString, Styled, Task, WeakEntity,
+};
use markdown::{Markdown, MarkdownElement};
use project::Project;
use project::{ProjectPath, WorktreeId};
@@ -143,7 +145,7 @@ use std::{collections::VecDeque, sync::Arc};
use ui::{App, TextSize};
use util::{paths::PathStyle, rel_path::RelPath};
use workspace::{
- Workspace,
+ Pane, SaveIntent, Workspace,
notifications::{
NotificationId, markdown_style, simple_message_notification::MessageNotification,
},
@@ -158,10 +160,63 @@ enum Operation {
}
impl Operation {
- async fn execute(self, undo_manager: &Inner, cx: &mut AsyncApp) -> Result<Change> {
- Ok(match self {
+ /// Attempts to execute the operation, returning an `Err` if the operation
+ /// failed to execute or `Ok(None)` if the operation was cancelled by the
+ /// user, for example, cancelling trashing a file with unsaved edits.
+ async fn execute(self, undo_manager: &Inner, cx: &mut AsyncApp) -> Result<Option<Change>> {
+ let change = match self {
Operation::Trash(project_path) => {
- let trash_id = undo_manager.trash(&project_path, cx).await?;
+ let Some(trash_id) = undo_manager.trash(&project_path, cx).await? else {
+ return Ok(None);
+ };
+ Change::Trashed(project_path.worktree_id, trash_id)
+ }
+ Operation::Batch(operations) => {
+ let mut trash_paths = Vec::new();
+
+ for operation in &operations {
+ operation.trash_paths(&mut trash_paths);
+ }
+
+ if !trash_paths.is_empty()
+ && !undo_manager.confirm_batch_trash(trash_paths, cx).await?
+ {
+ return Ok(None);
+ }
+
+ let mut changes = Vec::new();
+
+ for operation in operations {
+ changes.push(Box::pin(operation.execute_confirmed(undo_manager, cx)).await?);
+ }
+
+ Change::Batched(changes)
+ }
+ operation => {
+ return operation
+ .execute_confirmed(undo_manager, cx)
+ .await
+ .map(Some);
+ }
+ };
+
+ Ok(Some(change))
+ }
+
+ /// Same as [`Self::execute`], but assumes the operation has already been
+ /// confirmed in order to avoid showing confirmation modals to the user.
+ ///
+ /// Useful in scenarios where undoing a batch of operations would lead to
+ /// multiple files being trashed, in which case we only ask the user once
+ /// whether they'd like to trash the files, and then execute each trash
+ /// operation without confirming each file one by one.
+ async fn execute_confirmed(self, undo_manager: &Inner, cx: &mut AsyncApp) -> Result<Change> {
+ let change = match self {
+ Operation::Trash(project_path) => {
+ let trash_id = undo_manager
+ .trash_without_confirmation(&project_path, cx)
+ .await?;
+
Change::Trashed(project_path.worktree_id, trash_id)
}
Operation::Rename(from, to) => {
@@ -173,13 +228,29 @@ impl Operation {
Change::Restored(project_path)
}
Operation::Batch(operations) => {
- let mut res = Vec::new();
- for op in operations {
- res.push(Box::pin(op.execute(undo_manager, cx)).await?);
+ let mut changes = Vec::new();
+
+ for operation in operations {
+ changes.push(Box::pin(operation.execute_confirmed(undo_manager, cx)).await?);
+ }
+
+ Change::Batched(changes)
+ }
+ };
+
+ Ok(change)
+ }
+
+ fn trash_paths<'a>(&'a self, paths: &mut Vec<&'a ProjectPath>) {
+ match self {
+ Operation::Trash(path) => paths.push(path),
+ Operation::Batch(operations) => {
+ for operation in operations {
+ operation.trash_paths(paths);
}
- Change::Batched(res)
}
- })
+ Operation::Rename(..) | Operation::Restore(..) => {}
+ }
}
}
@@ -449,14 +520,17 @@ impl Inner {
// manual intervention would likely be needed in order to undo. As such,
// we remove the change from the `history` even before attempting to
// execute its inversion.
- let undo_change = self
- .history
- .remove(before_cursor)
- .expect("we can undo")
- .to_inverse()
- .execute(self, cx)
- .await?;
- self.history.insert(before_cursor, undo_change);
+ let change = self.history.remove(before_cursor).expect("we can undo");
+ let operation = change.clone().to_inverse();
+
+ match operation.execute(self, cx).await? {
+ Some(undo_change) => self.history.insert(before_cursor, undo_change),
+ None => {
+ self.history.insert(before_cursor, change);
+ self.cursor += 1;
+ }
+ };
+
Ok(())
}
@@ -469,15 +543,15 @@ impl Inner {
// manual intervention would likely be needed in order to redo. As such,
// we remove the change from the `history` even before attempting to
// execute its inversion.
- let redo_change = self
- .history
- .remove(self.cursor)
- .expect("we can redo")
- .to_inverse()
- .execute(self, cx)
- .await?;
- self.history.insert(self.cursor, redo_change);
- self.cursor += 1;
+ let change = self.history.remove(self.cursor).expect("we can redo");
+ let operation = change.clone().to_inverse();
+ match operation.execute(self, cx).await? {
+ Some(redo_change) => {
+ self.history.insert(self.cursor, redo_change);
+ self.cursor += 1;
+ }
+ None => self.history.insert(self.cursor, change),
+ }
Ok(())
}
@@ -569,7 +643,43 @@ impl Inner {
})
}
- async fn trash(&self, project_path: &ProjectPath, cx: &mut AsyncApp) -> Result<TrashId> {
+ /// Trashes the specified `project_path` after prompting the user for
+ /// confirmation. If the path has unsaved changes, the prompt also lets the
+ /// user save or discard them.
+ ///
+ /// Returns `Ok(None)` if the user cancels the operation.
+ async fn trash(
+ &self,
+ project_path: &ProjectPath,
+ cx: &mut AsyncApp,
+ ) -> Result<Option<TrashId>> {
+ let Some(workspace) = self.workspace.upgrade() else {
+ return Err(anyhow!("Failed to obtain workspace."));
+ };
+
+ let name = workspace.update(cx, |workspace, cx| {
+ let project = workspace.project().read(cx);
+ let path_style = project.path_style(cx);
+
+ project_path_display(project, project_path, path_style, cx)
+ });
+
+ if !self.confirm_trash(project_path, &name, cx).await? {
+ return Ok(None);
+ }
+
+ self.trash_without_confirmation(project_path, cx)
+ .await
+ .map(Some)
+ }
+
+ /// Same as [`Self::trash`] but proceeds without confirming if the user
+ /// wishes to trash the file.
+ async fn trash_without_confirmation(
+ &self,
+ project_path: &ProjectPath,
+ cx: &mut AsyncApp,
+ ) -> Result<TrashId> {
let Some(workspace) = self.workspace.upgrade() else {
return Err(anyhow!("Failed to obtain workspace."));
};
@@ -683,4 +793,111 @@ impl Inner {
})
.ok();
}
+
+ /// Prompts the user to confirm whether they really want to trash the file.
+ /// In the case the file has unsaved changes, the prompt will ask whether
+ /// the user wants to save or discard these changes.
+ ///
+ /// Returns `true` if the user confirmed they want to trash the file,
+ /// `false` otherwise.
+ async fn confirm_trash(
+ &self,
+ project_path: &ProjectPath,
+ name: &str,
+ cx: &mut AsyncApp,
+ ) -> Result<bool> {
+ let open_item = self.workspace.update(cx, |workspace, cx| {
+ workspace.panes().iter().find_map(|pane| {
+ pane.read(cx).items().find_map(|item| {
+ (item.is_dirty(cx)
+ && item
+ .project_path(cx)
+ .iter()
+ .any(|item_path| item_path == project_path))
+ .then(|| (pane.clone(), item.boxed_clone()))
+ })
+ })
+ })?;
+
+ let Some((pane, item)) = open_item else {
+ return self.trash_prompt(&[name], 0, cx).await;
+ };
+
+ let mut async_window_cx = self
+ .panel
+ .update_in(cx, |_panel, window, cx| window.to_async(cx))?;
+ let project = self
+ .panel
+ .read_with(cx, |panel, _cx| panel.project.clone())?;
+
+ Pane::save_item(
+ project,
+ pane,
+ item.as_ref(),
+ SaveIntent::Close,
+ &mut async_window_cx,
+ )
+ .await
+ }
+
+ /// Prompts the user to confirm whether they really want to trash all of the
+ /// provided `trash_paths`.
+ ///
+ /// Meant to be used when executing a batch of operations that will lead to
+ /// one or more paths being trashed.
+ ///
+ /// Returns `true` if the user confirmed they want to trash the files,
+ /// `false` otherwise.
+ async fn confirm_batch_trash(
+ &self,
+ trash_paths: Vec<&ProjectPath>,
+ cx: &mut AsyncApp,
+ ) -> Result<bool> {
+ let (names, dirty_buffers) = self.workspace.update(cx, |workspace, cx| {
+ let project = workspace.project().read(cx);
+ let path_style = project.path_style(cx);
+ let dirty_buffers = project
+ .dirty_buffers(cx)
+ .filter(|dirty_path| trash_paths.contains(&dirty_path))
+ .count();
+ let names = trash_paths
+ .iter()
+ .map(|project_path| project_path_display(project, project_path, path_style, cx))
+ .collect::<Vec<_>>();
+
+ (names, dirty_buffers)
+ })?;
+
+ self.trash_prompt(&names, dirty_buffers, cx).await
+ }
+
+ /// Prompts the user to confirm whether they actually want to trash the
+ /// file.
+ ///
+ /// Returns `true` if the user confirms, `false` otherwise.
+ async fn trash_prompt<S>(
+ &self,
+ names: &[S],
+ dirty_buffers: usize,
+ cx: &mut AsyncApp,
+ ) -> Result<bool>
+ where
+ S: AsRef<str>,
+ {
+ let prompt = ProjectPanel::build_removal_prompt(RemovalKind::Trash, names, dirty_buffers);
+ let answer = self
+ .panel
+ .update_in(cx, |_panel, window, cx| {
+ window.prompt(
+ PromptLevel::Info,
+ &prompt.message,
+ prompt.detail,
+ &[prompt.confirmation_label, "Cancel"],
+ cx,
+ )
+ })?
+ .await?;
+
+ Ok(answer == 0)
+ }
}