235 lines
8.4 KiB
Rust
235 lines
8.4 KiB
Rust
//! The shell's dialogs: unsaved, conflict, password (FILE-05).
|
|
|
|
use std::{path::PathBuf, rc::Rc};
|
|
|
|
use ely_gpui_component::{
|
|
buttons::{Button, ButtonVariant},
|
|
forms::TextInput,
|
|
overlays::{Close, Dialog as Card, PromptDialog},
|
|
};
|
|
use gpui::{AnyElement, App, AppContext as _, Context, Entity, IntoElement, SharedString, Window};
|
|
|
|
use crate::files::file_name;
|
|
use crate::{After, Closing, Host, Opening, Saving, Source, Tabs, text};
|
|
|
|
pub enum Dialog {
|
|
Unsaved {
|
|
tab: u64,
|
|
after: After,
|
|
},
|
|
Conflict {
|
|
tab: u64,
|
|
then: Option<After>,
|
|
},
|
|
Password {
|
|
path: PathBuf,
|
|
wrong: bool,
|
|
/// An untitled copy, not the user's file.
|
|
copy: bool,
|
|
field: Entity<TextInput>,
|
|
},
|
|
}
|
|
|
|
pub trait Dialogs: Host {
|
|
/// Asks for `path`'s password; `wrong` when one just failed.
|
|
fn ask_password(
|
|
&mut self,
|
|
path: PathBuf,
|
|
wrong: bool,
|
|
copy: bool,
|
|
window: &mut Window,
|
|
cx: &mut Context<Self>,
|
|
) {
|
|
log::info!(
|
|
"office: {} is locked, a password failed: {wrong}",
|
|
path.display()
|
|
);
|
|
if self.core().dialog.is_some() {
|
|
return self.core_mut().locked.push_back((path, wrong, copy));
|
|
}
|
|
let field = cx.new(|cx| TextInput::new(window, cx).masked());
|
|
self.core_mut().dialog = Some(Dialog::Password { path, wrong, copy, field });
|
|
cx.notify();
|
|
}
|
|
|
|
/// Clears the dialog; a waiting locked file asks next.
|
|
fn dialog_done(&mut self, window: &mut Window, cx: &mut Context<Self>) {
|
|
self.core_mut().dialog = None;
|
|
if let Some((path, wrong, copy)) = self.core_mut().locked.pop_front() {
|
|
self.ask_password(path, wrong, copy, window, cx);
|
|
}
|
|
cx.notify();
|
|
}
|
|
|
|
/// The shell's open dialog, if any.
|
|
fn core_dialog(&self, cx: &mut Context<Self>) -> Option<AnyElement> {
|
|
let this = cx.entity();
|
|
let dismiss = {
|
|
let this = this.clone();
|
|
move |window: &mut Window, cx: &mut App| {
|
|
this.update(cx, |host, cx| host.dialog_done(window, cx))
|
|
}
|
|
};
|
|
let name = |tab| {
|
|
self.tab(tab)
|
|
.map(|tab| tab.name.clone())
|
|
.unwrap_or_default()
|
|
};
|
|
let card = match self.core().dialog.as_ref()? {
|
|
Dialog::Password { path, wrong, copy, field } => {
|
|
let prompt = password(this, (path, *wrong, *copy, field), dismiss, cx);
|
|
return Some(prompt.into_any_element());
|
|
}
|
|
Dialog::Unsaved { tab, after } => {
|
|
let (tab, after) = (*tab, *after);
|
|
let title = text(cx, "office.unsaved.title", &[("name", &name(tab))]);
|
|
let owner = this.clone();
|
|
// Cancel stops the whole close.
|
|
let cancelled = move |window: &mut Window, cx: &mut App| {
|
|
owner.update(cx, |host, cx| {
|
|
host.close_stopped(cx);
|
|
host.dialog_done(window, cx)
|
|
})
|
|
};
|
|
Card::new("office-unsaved", title, cancelled)
|
|
.detail(text(cx, "office.unsaved.detail", &[]))
|
|
.action(cancel(cx))
|
|
.action(choice(
|
|
&this,
|
|
"office-unsaved-discard",
|
|
text(cx, "office.unsaved.discard", &[]),
|
|
ButtonVariant::Danger,
|
|
move |host, window, cx| {
|
|
host.close_tab(tab, cx);
|
|
host.proceed(after, window, cx);
|
|
},
|
|
))
|
|
.action(choice(
|
|
&this,
|
|
"office-unsaved-save",
|
|
text(cx, "office.unsaved.save", &[]),
|
|
ButtonVariant::Primary,
|
|
move |host, window, cx| host.save(tab, Some(after), window, cx),
|
|
))
|
|
}
|
|
Dialog::Conflict { tab, then } => {
|
|
let (tab, then) = (*tab, *then);
|
|
let title = text(cx, "office.conflict.title", &[("name", &name(tab))]);
|
|
let owner = this.clone();
|
|
let cancelled = move |window: &mut Window, cx: &mut App| {
|
|
owner.update(cx, |host, cx| {
|
|
if then.is_some() {
|
|
host.close_stopped(cx);
|
|
}
|
|
host.dialog_done(window, cx)
|
|
})
|
|
};
|
|
Card::new("office-conflict", title, cancelled)
|
|
.detail(text(cx, "office.conflict.detail", &[]))
|
|
.action(cancel(cx))
|
|
.action(choice(
|
|
&this,
|
|
"office-conflict-reload",
|
|
text(cx, "office.conflict.reload", &[]),
|
|
ButtonVariant::Secondary,
|
|
move |host, _, cx| {
|
|
// Reloading ends the close that waited.
|
|
if then.is_some() {
|
|
host.close_stopped(cx);
|
|
}
|
|
host.reload(tab, cx)
|
|
},
|
|
))
|
|
.action(choice(
|
|
&this,
|
|
"office-conflict-copy",
|
|
text(cx, "office.conflict.copy", &[]),
|
|
ButtonVariant::Secondary,
|
|
move |host, _, cx| host.save_as(tab, then, cx),
|
|
))
|
|
.action(choice(
|
|
&this,
|
|
"office-conflict-keep",
|
|
text(cx, "office.conflict.keep", &[]),
|
|
ButtonVariant::Primary,
|
|
move |host, window, cx| host.keep_mine(tab, then, window, cx),
|
|
))
|
|
}
|
|
};
|
|
Some(card.into_any_element())
|
|
}
|
|
}
|
|
|
|
impl<H: Host> Dialogs for H {}
|
|
|
|
/// A dialog's Cancel button.
|
|
pub fn cancel(cx: &App) -> impl FnOnce(Close) -> Button + 'static {
|
|
let label = text(cx, "office.cancel", &[]);
|
|
move |close| {
|
|
Button::new("office-dialog-cancel", label).on_click(move |_, window, cx| close(window, cx))
|
|
}
|
|
}
|
|
|
|
/// A dialog button that closes the dialog, then runs `run`.
|
|
fn choice<H: Host>(
|
|
this: &Entity<H>,
|
|
id: &'static str,
|
|
label: SharedString,
|
|
variant: ButtonVariant,
|
|
run: impl Fn(&mut H, &mut Window, &mut Context<H>) + 'static,
|
|
) -> impl FnOnce(Close) -> Button + 'static {
|
|
let this = this.clone();
|
|
let run = Rc::new(run);
|
|
move |_| {
|
|
Button::new(id, label)
|
|
.variant(variant)
|
|
.on_click(move |_, window, cx| {
|
|
let run = run.clone();
|
|
this.update(cx, |host, cx| {
|
|
host.core_mut().dialog = None;
|
|
run(host, window, cx);
|
|
if host.core().dialog.is_none() {
|
|
host.dialog_done(window, cx);
|
|
}
|
|
})
|
|
})
|
|
}
|
|
}
|
|
|
|
/// The masked prompt for a locked file.
|
|
fn password<H: Host>(
|
|
this: Entity<H>,
|
|
(path, wrong, copy, field): (&PathBuf, bool, bool, &Entity<TextInput>),
|
|
dismiss: impl Fn(&mut Window, &mut App) + 'static,
|
|
cx: &App,
|
|
) -> PromptDialog {
|
|
let name = file_name(path);
|
|
let title = text(cx, "office.locked.title", &[("name", &name)]);
|
|
let empty = text(cx, "office.locked.empty", &[]);
|
|
// Each ask its own dialog, so focus is its own.
|
|
let id = ("office-locked", field.entity_id().as_u64());
|
|
let mut prompt = PromptDialog::new(id, title, field, dismiss)
|
|
.label(text(cx, "office.locked.label", &[]))
|
|
.submit(text(cx, "office.locked.open", &[]));
|
|
if wrong {
|
|
prompt = prompt.label(text(cx, "office.locked.wrong", &[]));
|
|
}
|
|
let path = path.clone();
|
|
prompt
|
|
.check(move |text| {
|
|
if text.is_empty() {
|
|
Err(empty.clone())
|
|
} else {
|
|
Ok(())
|
|
}
|
|
})
|
|
// The dialog closed first; the next ask may show.
|
|
.on_submit(move |text, _, cx| {
|
|
let (path, password) = (path.clone(), text.to_string());
|
|
this.update(cx, |host, cx| match copy {
|
|
true => host.load(Source::Locked(path, password), cx),
|
|
false => host.open_with(path, password, cx),
|
|
})
|
|
})
|
|
}
|