Commit 42499fefe59cff82e17b0f6ec64b92bf090a6a78 | snowbound

arc/platforms.md+3-1

 @@ -77,7 +77,9 @@ keyboard, the toolbar and the macOS menu bar all run commands from it.
   popover menus on GNOME, shown and hidden at once as GTK 4 does, and Breeze's
   on KDE, faded as KWin fades popups and scaled by Plasma's animation speed.
   The desktop is read once from `XDG_CURRENT_DESKTOP`; elsewhere the kit's own.
-- zenity or kdialog provide the pickers and alerts. The XDG settings portal
+- The desktop portal provides the file pickers, zenity or kdialog the alerts,
+  and where neither can, Snowbound asks with the kit's own dialogs in the
+  window. No dialog waits on the event loop's thread. The XDG settings portal
   provides the colour scheme. Text conventions come from the C library's
   locale. Fontconfig is loaded at run time, so builds need no headers for it,
   and so is Enchant, which checks spelling with whatever dictionaries its

arc/ui.md+3-2

 @@ -48,8 +48,9 @@ look and move as the desktop's own (see [platforms](platforms.md)).
   project aims further (Windows, and old versions of OS X).
 The platform still owns what it's best at and what people expect to be
-native. That means file pickers, alerts and date pickers (AppKit on macOS,
+native. That means file pickers, alerts and date pickers (AppKit's sheets on
-zenity or kdialog on Linux), the caret and selection colours, each platform's
+macOS; the portal, zenity or kdialog on Linux, else the kit's own), none of
+which blocks the window, the caret and selection colours, each platform's
 editing chords, the keychain, the traffic lights and window frames. On iOS the
 split goes further (see [platforms](platforms.md)).

crates/snowbound/linux/README.md+2-1

...	@@ -42,7 +42,8 @@ Snowbound.	...	@@ -42,7 +42,8 @@ Snowbound.
42	- fontconfig, and X11 or Wayland with libxkbcommon.	42	- fontconfig, and X11 or Wayland with libxkbcommon.
43	- The desktop's portal (xdg-desktop-portal) for choosing, printing and opening	43	- The desktop's portal (xdg-desktop-portal) for choosing, printing and opening
44	files. Questions, alerts and the page date and time use zenity or kdialog	44	files. Questions, alerts and the page date and time use zenity or kdialog
45	where installed, and Snowbound's own dialogs otherwise.	45	where installed. Where none of these is, Snowbound asks, and chooses files,
		46	with its own dialogs.
46		47
47	## Known limits	48	## Known limits
48		49

crates/snowbound/src/attachment.rs+3-3

...	@@ -82,9 +82,9 @@ impl State {	...	@@ -82,9 +82,9 @@ impl State {
82	unstored();	82	unstored();
83	return Ok(());	83	return Ok(());
84	};	84	};
85	if let Some(path) = platform::pick_new("Save As", &file.filename, "Save", None) {	85	let bytes = bytes.clone();
86	notebook::fs::write(path, bytes)?;	86	let reply = self.reply(move \|_, path\| Ok(notebook::fs::write(path, bytes)?));
87	}	87	platform::pick_new("Save As", &file.filename, "Save", None, reply);
88	Ok(())	88	Ok(())
89	}	89	}
90	}	90	}

crates/snowbound/src/commands.rs+8-9

...	@@ -1558,17 +1558,16 @@ impl State {	...	@@ -1558,17 +1558,16 @@ impl State {
1558	return Ok(());	1558	return Ok(());
1559	}	1559	}
1560	Id::Picture => {	1560	Id::Picture => {
1561	let Some(path) = platform::pick_file("Insert Picture", &crate::PICTURE_TYPES)	1561	let reply = self.reply(\|state, path: std::path::PathBuf\| {
1562	else {	1562	state.insert_picture(notebook::fs::read(path)?, None)
1563	return Ok(());	1563	});
1564	};	1564	platform::pick_file("Insert Picture", &crate::PICTURE_TYPES, reply);
1565	return self.insert_picture(notebook::fs::read(path)?, None);	1565	return Ok(());
1566	}	1566	}
1567	Id::Attachment => {	1567	Id::Attachment => {
1568	let Some(path) = platform::pick_file("Attach File", &[]) else {	1568	let reply = self.reply(\|state, path: std::path::PathBuf\| state.attach(&path, None));
1569	return Ok(());	1569	platform::pick_file("Attach File", &[], reply);
1570	};	1570	return Ok(());
1571	return self.attach(&path, None);
1572	}	1571	}
1573	Id::ScreenClipping => {	1572	Id::ScreenClipping => {
1574	#[cfg(target_os = "macos")]	1573	#[cfg(target_os = "macos")]

crates/snowbound/src/desktop_linux.rs+18-4

 @@ -399,17 +399,31 @@ fn try_install() -> io::Result<()> {
 }
 /// After confirming, removes what Install wrote; notebooks stay where they are.
-pub fn uninstall() {
+pub fn uninstall(proxy: &winit::event_loop::EventLoopProxy<crate::UserEvent>) {
-    let (Some(data), Some(binary)) = (data_home(), binary()) else {
+    let Some(binary) = binary() else {
         return;
     };
     let detail = format!(
         "Snowbound leaves the app menu and {} is deleted. Your notebooks stay where they are.",
         binary.display()
     );
-    if !crate::platform::confirm("Uninstall Snowbound?", &detail, "Cancel", "Uninstall") {
+    let reply = crate::Reply::new(proxy, |_, ()| {
+        remove();
+        Ok(())
+    });
+    crate::platform::confirm(
+        "Uninstall Snowbound?",
+        &detail,
+        "Cancel",
+        "Uninstall",
+        reply,
+    );
+}
+fn remove() {
+    let (Some(data), Some(binary)) = (data_home(), binary()) else {
         return;
-    }
+    };
     let mut failed = None;
     let icons = SIZES.map(|side| theme_icon(&data, side));
     if let Some(staged) = crate::update::staging(&binary)

crates/snowbound/src/dialog_linux.rs+308-272

...	@@ -1,351 +1,387 @@	...	@@ -1,351 +1,387 @@
1	//! Snowbound's own message, question and entry dialogs, for desktops with neither zenity nor	1	//! Snowbound's own dialogs, drawn with the interface kit in the window, where no desktop
2	//! kdialog, as GNOME's image-based systems ship: the app runs itself as the dialog, which	2	//! portal, zenity or kdialog can ask, as on GNOME's image-based systems or a bare X11
3	//! answers on stdout and exits successfully once accepted.	3	//! desktop: messages, questions, a line of text, and a file chooser.
4		4
5	use draw::Renderer;	5	use crate::{Reply, State, UserEvent, art};
6	use std::{error::Error, ffi::OsString, process::Command, sync::Arc, time::Instant};	6	use accesskit::Role;
7	use ui::{Axis, Id, Spec, Ui, children, fill, fit, px};	7	use std::path::{Path, PathBuf};
8	use winit::{	8	use ui::{Anchor, Axis, Flags, Id, Spec, children, fill, px};
9	application::ApplicationHandler,	9	use winit::keyboard::NamedKey;
10	dpi::LogicalSize,
11	event::{ElementState, WindowEvent},
12	event_loop::{ActiveEventLoop, EventLoop},
13	keyboard::{Key, NamedKey},
14	window::{Window, WindowId},
15	};
16		10
17	/// The argument that runs the app as a dialog.	11	/// What a dialog asks, and where its answer goes; one dismissed drops its reply.
18	pub const DIALOG: &str = "--dialog";	12	pub enum Ask {
19
20	pub enum Ask<'a> {
21	/// A message with an OK button.	13	/// A message with an OK button.
22	Message,	14	Message,
23	/// Whether to go ahead: buttons for `cancel` and for `action`.	15	/// Whether to go ahead: buttons for `cancel` and for `action`.
24	Question { cancel: &'a str, action: &'a str },	16	Question {
25	/// A line of text, starting as `value`.	17	cancel: String,
26	Entry { value: &'a str },	18	action: String,
27	/// A user name, starting as `user`, and a password, answered as zenity does: `user\|password`.	19	reply: Reply<()>,
28	Login { user: &'a str },	20	},
		21	/// A line of text, starting as `text`.
		22	Entry { text: String, reply: Reply<String> },
		23	/// A file in `folder`: one of `types` (extensions) unless empty, to open; or with
		24	/// `save`, a new one named `name`.
		25	File {
		26	folder: PathBuf,
		27	types: Vec<String>,
		28	save: bool,
		29	name: String,
		30	reply: Reply<PathBuf>,
		31	},
29	}	32	}
30		33
31	/// Shows `title` and `detail` as `ask` asks, then waits: the answer, empty but for an entry,	34	/// A dialog waiting its turn, or shown.
32	/// or None when cancelled.	35	pub struct Dialog {
33	pub fn ask(title: &str, detail: &str, ask: Ask) -> Option<String> {	36	title: String,
34	let (kind, extra): (&str, &[&str]) = match &ask {	37	detail: String,
35	Ask::Message => ("message", &[]),	38	ask: Ask,
36	Ask::Question { cancel, action } => ("question", &[cancel, action]),	39	/// A file chooser's folder: its folders, then the files it offers, each with whether it
37	Ask::Entry { value } => ("entry", &[value]),	40	/// is a folder; or why the folder can't be read.
38	Ask::Login { user } => ("login", &[user]),	41	entries: Result<Vec<(String, bool)>, String>,
39	};	42	shown: bool,
40	let output = crate::loader::executable()
41	.and_then(\|exe\| {
42	Command::new(exe)
43	.args([DIALOG, kind, title, detail])
44	.args(extra)
45	.stderr(std::process::Stdio::inherit())
46	.output()
47	})
48	.inspect_err(\|error\| eprintln!("Cannot show {title:?}: {error}"))
49	.ok()?;
50	output
51	.status
52	.success()
53	.then(\|\| String::from_utf8_lossy(&output.stdout).into_owned())
54	}	43	}
55		44
56	/// The dialog `ask` would show, given the arguments after `DIALOG`.	45	/// Shows `ask`, titled `title` and explained by `detail`, once the dialogs before it are
57	pub fn run(mut args: impl Iterator<Item = OsString>) -> Result<(), Box<dyn Error>> {	46	/// answered. Any thread may ask.
58	let mut next = \|\| {	47	pub fn show(title: String, detail: String, ask: Ask) {
59	args.next()	48	let entries = match &ask {
60	.and_then(\|arg\| arg.into_string().ok())	49	Ask::File { folder, types, .. } => listing(folder, types),
61	.unwrap_or_default()	50	_ => Ok(Vec::new()),
62	};	51	};
63	let [kind, title, detail, first, second] = [(); 5].map(\|()\| next());	52	let dialog = Dialog {
64	let mut dialog = Dialog {
65	kind,
66	title,	53	title,
67	detail,	54	detail,
68	buttons: [first, second],	55	ask,
69	fields: Default::default(),	56	entries,
70	shown: None,	57	shown: false,
71	accepted: false,
72	};	58	};
73	if dialog.kind == "entry" \|\| dialog.kind == "login" {	59	if let Some(proxy) = crate::platform::PROXY.get() {
74	dialog.fields[0] = std::mem::take(&mut dialog.buttons[0]);	60	let _ = proxy.send_event(UserEvent::Then(Box::new(move \|state\| {
		61	state.asking.push_back(dialog);
		62	Ok(())
		63	})));
75	}	64	}
76	EventLoop::new()?.run_app(&mut dialog)?;
77	if !dialog.accepted {
78	std::process::exit(1);
79	}
80	let [first, second] = &dialog.fields;
81	match dialog.kind.as_str() {
82	"entry" => print!("{first}"),
83	"login" => print!("{first}\|{second}"),
84	_ => {}
85	}
86	Ok(())
87	}	65	}
88		66
89	struct Dialog {	67	/// The folder a file chooser starts in where it is given none.
90	kind: String,	68	pub fn start_folder() -> PathBuf {
91	title: String,	69	crate::platform::documents_dir()
92	detail: String,	70	.filter(\|folder\| folder.is_dir())
93	/// A question's cancel and action labels.	71	.or_else(\|\| std::env::var_os("HOME").map(PathBuf::from))
94	buttons: [String; 2],	72	.unwrap_or_else(\|\| "/".into())
95	/// An entry's text, or a login's user name and password.
96	fields: [String; 2],
97	shown: Option<Shown>,
98	accepted: bool,
99	}	73	}
100		74
101	struct Shown {	75	/// `folder`'s folders, then its files of `types` (extensions; all where empty), each by
102	window: Arc<Window>,	76	/// name without regard to case; hidden ones left out.
103	surface: crate::surface::Surface,	77	fn listing(folder: &Path, types: &[String]) -> Result<Vec<(String, bool)>, String> {
104	renderer: Renderer,	78	let mut entries: Vec<(String, bool)> = std::fs::read_dir(folder)
105	ui: Ui,	79	.map_err(\|error\| format!("Couldn't read {}: {error}", folder.display()))?
		80	.filter_map(\|entry\| {
		81	let entry = entry.ok()?;
		82	let name = entry.file_name().into_string().ok()?;
		83	let is_folder = entry.path().is_dir();
		84	let offered = is_folder
		85	\|\| types.is_empty()
		86	\|\| Path::new(&name)
		87	.extension()
		88	.and_then(\|extension\| extension.to_str())
		89	.is_some_and(\|extension\| {
		90	types
		91	.iter()
		92	.any(\|kind\| kind.eq_ignore_ascii_case(extension))
		93	});
		94	(offered && !name.starts_with('.')).then_some((name, is_folder))
		95	})
		96	.collect();
		97	entries.sort_by_cached_key(\|(name, is_folder)\| (!is_folder, name.to_lowercase()));
		98	Ok(entries)
106	}	99	}
107		100
108	fn field(index: usize) -> Id {	101	fn id() -> Id {
109	Id::ROOT.child(("field", index))	102	Id::ROOT.child("own dialog")
110	}	103	}
111		104
112	impl Dialog {	105	fn field() -> Id {
113	fn finish(&mut self, event_loop: &ActiveEventLoop, accepted: bool) {	106	id().child("field")
114	self.accepted = accepted;	107	}
115	// The window's resources end while the event loop still holds its display.	108
116	self.shown = None;	109	/// How the user answered a dialog this frame.
117	event_loop.exit();	110	enum Answer {
118	}	111	Cancel,
		112	Accept,
		113	/// A file chooser moves to this folder.
		114	Open(PathBuf),
		115	/// A file chooser's file to open, or the name to save as.
		116	Choose(String),
		117	}
119		118
120	/// Lays out and paints the dialog; Some once a button answers it.	119	impl State {
121	fn frame(&mut self) -> Result<Option<bool>, Box<dyn Error>> {	120	/// Builds the first dialog waiting, and answers it once the user does.
122	let Some(shown) = &mut self.shown else {	121	pub(crate) fn own_dialog(&mut self) {
123	return Ok(None);	122	let Some(dialog) = self.asking.front_mut() else {
		123	return;
124	};	124	};
125	let ui = &mut shown.ui;	125	let ui = &mut self.ui;
126	let scale = shown.window.scale_factor() as f32;	126	if !dialog.shown {
127	let size = shown.window.inner_size();	127	dialog.shown = true;
128	ui.begin(	128	ui.open_popup(id());
129	[size.width as f32 / scale, size.height as f32 / scale],	129	if let Ask::Entry { .. } \| Ask::File { save: true, .. } = dialog.ask {
130	scale,	130	ui.focus_all(field());
131	Instant::now(),	131	}
132	);	132	} else if !ui.popup_open(id()) {
		133	self.asking.pop_front();
		134	return;
		135	}
133	let theme = ui.theme.clone();	136	let theme = ui.theme.clone();
134	ui.open(	137	let row = theme.font_size * 2.0;
135	"dialog",	138	let entered = ui::popup::navigation(ui, &[id(), field()], &[NamedKey::Enter])
		139	.contains(&NamedKey::Enter);
		140	let file = matches!(dialog.ask, Ask::File { .. });
		141	ui.open_as(
		142	id(),
136	Spec {	143	Spec {
137	axis: Axis::Y,	144	axis: Axis::Y,
138	size: [fill(), fill()],	145	size: [px(if file { 480.0 } else { 420.0 }), children()],
139	fill: Some(theme.popup),	146	fill: Some(theme.popup),
140	pad: [20.0, 16.0],	147	border: Some(theme.chip),
141	gap: 10.0,	148	shadow: Some(theme.shadow),
142	role: Some(accesskit::Role::Dialog),	149	radius: 8.0,
		150	pad: [16.0, 12.0],
		151	gap: 6.0,
		152	anchor: Some(Anchor::Dialog),
		153	role: Some(Role::Dialog),
143	..Spec::default()	154	..Spec::default()
144	},	155	},
145	);	156	);
146	let text = \|ui: &mut Ui, part, text: &str, bold\| {	157	if let Some(node) = ui.access(id()) {
		158	node.set_label(dialog.title.as_str());
		159	}
		160	let text = \|ui: &mut ui::Ui, part, text: &str, bold: bool, color\| {
147	ui.leaf(	161	ui.leaf(
148	part,	162	part,
149	Spec {	163	Spec {
150	size: [fill(), fit()],	164	size: [fill(), ui::fit()],
151	text: Some(text),	165	text: Some(text),
152	bold,	166	bold,
		167	color,
153	overflow: ui::Overflow::Wrap,	168	overflow: ui::Overflow::Wrap,
		169	role: bold.then_some(Role::Heading),
154	..Spec::default()	170	..Spec::default()
155	},	171	},
156	);	172	);
157	};	173	};
158	text(ui, "title", &self.title, true);	174	text(ui, "title", &dialog.title, true, None);
159	if !self.detail.is_empty() {	175	if !dialog.detail.is_empty() {
160	text(ui, "detail", &self.detail, false);	176	text(ui, "detail", &dialog.detail, false, None);
161	}	177	}
162	let entry = Spec {	178	let field_spec = Spec {
163	size: [fill(), px(theme.font_size * 2.0)],	179	size: [fill(), px(row)],
164	fill: Some(theme.base),	180	fill: Some(theme.base),
165	border: Some(theme.accent),	181	border: Some(theme.accent),
166	radius: 4.0,	182	radius: 4.0,
167	pad: [6.0, 0.0],	183	pad: [6.0, 0.0],
168	..Spec::default()	184	..Spec::default()
169	};	185	};
170	let fields = match self.kind.as_str() {	186	// Return goes ahead, but for a question, whose safe answer is the default as
171	"entry" => 1,	187	// AppKit's and Windows' are.
172	"login" => 2,	188	let mut answer = entered.then_some(match dialog.ask {
173	_ => 0,	189	Ask::Question { .. } => Answer::Cancel,
174	};	190	_ => Answer::Accept,
175	if fields > 0 && ui.focused().is_none() {	191	});
176	ui.set_focus(Some(field(0)));	192	match &mut dialog.ask {
177	}	193	Ask::Entry { text, .. } => {
178	for (index, value) in self.fields.iter_mut().take(fields).enumerate() {	194	ui::text_field(ui, field(), text, "", field_spec);
179	if index == 1 {	195	crate::name(ui, field(), &dialog.title);
180	text(ui, "password label", "Password:", false);
181	ui::password_field(ui, field(index), value, "", entry.clone());
182	} else {
183	ui::text_field(ui, field(index), value, "", entry.clone());
184	}	196	}
		197	Ask::File {
		198	folder, save, name, ..
		199	} => {
		200	text(
		201	ui,
		202	"place",
		203	&folder.to_string_lossy(),
		204	false,
		205	Some(theme.text_dim),
		206	);
		207	let list = ui.open(
		208	"entries",
		209	Spec {
		210	flags: Flags::SCROLL \| Flags::CLIP,
		211	axis: Axis::Y,
		212	size: [fill(), px(row * 10.0 + 8.0)],
		213	fill: Some(theme.base),
		214	border: Some(theme.chip),
		215	radius: 4.0,
		216	pad: [4.0, 4.0],
		217	role: Some(Role::List),
		218	..Spec::default()
		219	},
		220	);
		221	if let Some(node) = ui.access(list) {
		222	node.set_label("Files");
		223	}
		224	match &dialog.entries {
		225	Ok(entries) => {
		226	for (entry, is_folder) in entries {
		227	let signal = ui.leaf(
		228	("entry", entry),
		229	Spec {
		230	flags: Flags::CLICKABLE,
		231	size: [fill(), px(row)],
		232	icon: Some(if *is_folder { art::FOLDER } else { art::PAGE }),
		233	text: Some(entry),
		234	fill: (!is_folder && entry == name).then_some(theme.chip),
		235	hover_fill: Some(theme.hover()),
		236	radius: 4.0,
		237	pad: [8.0, 0.0],
		238	gap: 6.0,
		239	role: Some(Role::ListItem),
		240	..Spec::default()
		241	},
		242	);
		243	if *is_folder && signal.clicked {
		244	answer = Some(Answer::Open(folder.join(entry)));
		245	} else if !is_folder && signal.pressed {
		246	// A double click opens or saves as the file.
		247	answer =
		248	Some(if signal.unit == draw::edit::SelectionUnit::Grapheme {
		249	Answer::Choose(entry.clone())
		250	} else {
		251	Answer::Accept
		252	});
		253	}
		254	}
		255	}
		256	Err(reason) => text(ui, "unread", reason, false, Some(theme.text_dim)),
		257	}
		258	ui.close();
		259	if *save {
		260	ui::text_field(ui, field(), name, "", field_spec);
		261	crate::name(ui, field(), "Name");
		262	}
		263	}
		264	Ask::Message \| Ask::Question { .. } => {}
185	}	265	}
186	ui.leaf(
187	"space",
188	Spec {
189	size: [fill(), fill()],
190	..Spec::default()
191	},
192	);
193	ui.open(	266	ui.open(
194	"buttons",	267	"buttons",
195	Spec {	268	Spec {
196	size: [fill(), children()],	269	size: [fill(), children()],
		270	pad: [0.0, 8.0],
197	gap: 8.0,	271	gap: 8.0,
198	..Spec::default()	272	..Spec::default()
199	},	273	},
200	);	274	);
		275	if let Ask::File { folder, .. } = &dialog.ask
		276	&& let Some(parent) = folder.parent()
		277	&& ui::button(ui, "up", "Up").clicked
		278	{
		279	answer = Some(Answer::Open(parent.to_owned()));
		280	}
201	ui.leaf(	281	ui.leaf(
202	"space",	282	"space",
203	Spec {	283	Spec {
204	size: [fill(), px(0.0)],	284	size: [fill(), px(1.0)],
205	..Spec::default()	285	..Spec::default()
206	},	286	},
207	);	287	);
208	let [cancel, action] = match self.kind.as_str() {	288	let (cancel, action) = match &dialog.ask {
209	"question" => [self.buttons[0].as_str(), self.buttons[1].as_str()],	289	Ask::Message => (None, "OK"),
210	"message" => ["", "OK"],	290	Ask::Question { cancel, action, .. } => (Some(cancel.as_str()), action.as_str()),
211	_ => ["Cancel", "OK"],	291	Ask::Entry { .. } => (Some("Cancel"), "OK"),
		292	Ask::File { save: false, .. } => (Some("Cancel"), "Open"),
		293	Ask::File { save: true, .. } => (Some("Cancel"), "Save"),
212	};	294	};
213	let mut answer = None;	295	if cancel.is_some_and(\|cancel\| ui::button(ui, "cancel", cancel).clicked) {
214	if !cancel.is_empty() && ui::button(ui, "cancel", cancel).clicked {	296	answer = Some(Answer::Cancel);
215	answer = Some(false);
216	}	297	}
217	if ui::button(ui, "action", action).clicked {	298	if ui::button(ui, "action", action).clicked {
218	answer = Some(true);	299	answer = Some(Answer::Accept);
219	}	300	}
220	ui.close();	301	ui.close();
221	ui.close();	302	ui.close();
222	ui.end();
223	shown.window.set_cursor(ui.cursor().unwrap_or_default());
224	if let Some(frame) = shown.surface.frame(&shown.renderer)? {
225	let interface = ui.layers();
226	let layers: Vec<_> = interface
227	.iter()
228	.filter_map(\|layer\| match layer {
229	ui::Layer::Primitives(primitives) => Some(primitives.layer(scale)),
230	ui::Layer::Custom { .. } => None,
231	})
232	.collect();
233	shown
234	.renderer
235	.draw(&frame.target, shown.surface.size, theme.popup, &layers)
236	.map_err(\|error\| format!("Dialog drawing failed: {error:?}"))?;
237	shown.surface.present(&shown.renderer, frame);
238	}
239	if ui.wants_frame() {
240	shown.window.request_redraw();
241	}
242	Ok(answer)
243	}
244	}
245
246	impl ApplicationHandler for Dialog {
247	fn resumed(&mut self, event_loop: &ActiveEventLoop) {
248	if self.shown.is_some() {
249	return;
250	}
251	let height = match self.kind.as_str() {
252	"login" => 260.0,
253	"entry" => 200.0,
254	_ => 170.0,
255	};
256	let shown = (\|\| -> Result<Shown, Box<dyn Error>> {
257	let window = Arc::new(
258	event_loop.create_window(
259	crate::platform::window_attributes()
260	.with_title(&self.title)
261	.with_inner_size(LogicalSize::new(440.0, height))
262	.with_resizable(false),
263	)?,
264	);
265	let (surface, renderer) =
266	pollster::block_on(crate::surface::Surface::new(window.clone(), false))?;
267	let appearance = crate::platform::appearance(&window);
268	window.set_theme(Some(appearance));
269	let ui = Ui::new(
270	crate::theme(appearance, false, false),
271	crate::platform::double_click_interval(),
272	);
273	Ok(Shown {
274	window,
275	surface,
276	renderer,
277	ui,
278	})
279	})();
280	match shown {
281	Ok(shown) => {
282	shown.window.request_redraw();
283	self.shown = Some(shown);
284	}
285	Err(error) => {
286	eprintln!("Cannot show {:?}: {error}", self.title);
287	self.finish(event_loop, false);
288	}
289	}
290	}
291		303
292	fn window_event(&mut self, event_loop: &ActiveEventLoop, _: WindowId, event: WindowEvent) {	304	if let Ask::File {
293	let Some(shown) = &mut self.shown else {	305	folder,
294	return;	306	types,
295	};	307	save,
296	let scale = shown.window.scale_factor() as f32;	308	name,
297	let input = match event {	309	..
298	WindowEvent::CloseRequested => return self.finish(event_loop, false),	310	} = &mut dialog.ask
299	WindowEvent::RedrawRequested => {	311	{
300	match self.frame() {	312	match answer {
301	Ok(Some(answer)) => self.finish(event_loop, answer),	313	Some(Answer::Open(to)) => {
302	Ok(None) => {}	314	dialog.entries = listing(&to, types);
303	Err(error) => {	315	*folder = to;
304	eprintln!("{error}");	316	if !*save {
305	self.finish(event_loop, false);	317	name.clear();
306	}	318	}
		319	return;
307	}	320	}
308	return;	321	Some(Answer::Choose(entry)) => {
309	}	322	*name = entry;
310	WindowEvent::Resized(size) => {	323	return;
311	shown.surface.size = [size.width, size.height];
312	shown.surface.configure(&shown.renderer);
313	return shown.window.request_redraw();
314	}
315	WindowEvent::KeyboardInput { event, .. } if event.state == ElementState::Pressed => {
316	match event.logical_key {
317	Key::Named(NamedKey::Enter) => return self.finish(event_loop, true),
318	Key::Named(NamedKey::Escape) => return self.finish(event_loop, false),
319	key => ui::Event::Key {
320	key,
321	text: event.text.map(\|text\| text.to_string()),
322	},
323	}
324	}
325	WindowEvent::ModifiersChanged(modifiers) => ui::Event::Modifiers(modifiers.state()),
326	WindowEvent::Ime(ime) => ui::Event::Ime(ime),
327	WindowEvent::CursorMoved { position, .. } => {
328	ui::Event::PointerMoved([position.x as f32 / scale, position.y as f32 / scale])
329	}
330	WindowEvent::CursorLeft { .. } => ui::Event::PointerLeft,
331	WindowEvent::MouseInput { state, button, .. } => {
332	// A press away from the controls moves the window, which has no title bar
333	// under winit's Adwaita frame.
334	if state == ElementState::Pressed
335	&& shown.ui.cursor().is_none()
336	&& let Err(error) = shown.window.drag_window()
337	{
338	eprintln!("{error}");
339	}	324	}
340	ui::Event::Button {	325	Some(Answer::Accept) if name.trim().is_empty() => return,
341	button,	326	// A folder typed in opens.
342	pressed: state == ElementState::Pressed,	327	Some(Answer::Accept) if folder.join(name.trim()).is_dir() => {
343	at: Instant::now(),	328	let to = folder.join(name.trim());
		329	dialog.entries = listing(&to, types);
		330	*folder = to;
		331	name.clear();
		332	return;
344	}	333	}
		334	_ => {}
345	}	335	}
346	_ => return,	336	}
		337	let Some(answer) = answer else {
		338	return;
347	};	339	};
348	shown.ui.event(input);	340	let dialog = self.asking.pop_front().expect("A dialog is shown");
349	shown.window.request_redraw();	341	self.ui.close_popup(id());
		342	if let Answer::Cancel = answer {
		343	return;
		344	}
		345	match dialog.ask {
		346	Ask::Message => {}
		347	Ask::Question { reply, .. } => reply.send(()),
		348	Ask::Entry { text, reply } => reply.send(text),
		349	Ask::File {
		350	folder,
		351	name,
		352	reply,
		353	..
		354	} => reply.send(folder.join(name.trim())),
		355	}
		356	}
		357	}
		358
		359	#[cfg(test)]
		360	mod tests {
		361	use super::*;
		362
		363	#[test]
		364	fn a_file_chooser_lists_folders_then_the_files_it_offers() {
		365	let folder = std::env::temp_dir().join(format!("snowbound-own-{}", std::process::id()));
		366	for name in ["b", "A", ".hidden"] {
		367	std::fs::create_dir_all(folder.join(name)).unwrap();
		368	}
		369	for name in ["z.one", "Notes.ONETOC2", "picture.png", ".x.one"] {
		370	std::fs::write(folder.join(name), b"").unwrap();
		371	}
		372	let types = ["one", "onetoc2"].map(String::from);
		373	let expected = [
		374	("A", true),
		375	("b", true),
		376	("Notes.ONETOC2", false),
		377	("z.one", false),
		378	];
		379	assert_eq!(
		380	listing(&folder, &types).unwrap(),
		381	expected.map(\|(name, is_folder)\| (name.to_owned(), is_folder))
		382	);
		383	assert_eq!(listing(&folder, &[]).unwrap().len(), 5);
		384	assert!(listing(&folder.join("missing"), &[]).is_err());
		385	std::fs::remove_dir_all(&folder).unwrap();
350	}	386	}
351	}	387	}

crates/snowbound/src/history.rs+21-4

 @@ -188,7 +188,7 @@ impl State {
     /// Delete All Versions in the section, its group or the notebook, once confirmed.
     pub(crate) fn delete_all_versions(&mut self, scope: Scope) -> Result<(), Box<dyn Error>> {
-        let session = self.session.as_mut().ok_or("No section is open")?;
+        let session = self.session.as_ref().ok_or("No section is open")?;
         let tab = &session.tabs[session.tab];
         let (open, section) = (tab.path.clone(), tab.name.clone());
         let folder = open
 @@ -203,14 +203,31 @@ impl State {
             ),
             Scope::Notebook => ("notebook", session.library.name.clone()),
         };
-        if !platform::confirm(
+        let asked = Arc::clone(&session.library);
+        platform::confirm(
             &format!("Do you want to delete all page versions in the {container} \"{name}\"?"),
             "You can't restore these versions afterward.",
             "Cancel",
             "Delete Versions",
-        ) {
+            self.reply(move |state, ()| state.clear_versions(scope, &asked, open, folder)),
+        );
+        Ok(())
+    }
+    /// Deletes every page version in `scope` around `open`, the section in `library` that
+    /// was shown when asked; nothing once another is shown.
+    fn clear_versions(
+        &mut self,
+        scope: Scope,
+        library: &Arc<Library>,
+        open: String,
+        folder: String,
+    ) -> Result<(), Box<dyn Error>> {
+        let Some(session) = self.session.as_mut().filter(|session| {
+            Arc::ptr_eq(&session.library, library) && session.tabs[session.tab].path == open
+        }) else {
             return Ok(());
-        }
+        };
         clear(&session.section)?;
         session.refresh_history()?;
         if session.version.is_some() {

crates/snowbound/src/linux.rs+197-150

...	@@ -3,13 +3,13 @@	...	@@ -3,13 +3,13 @@
3	//! the colour scheme from the settings portal, and text conventions from the C library's	3	//! the colour scheme from the settings portal, and text conventions from the C library's
4	//! locale.	4	//! locale.
5		5
6	use crate::dialog::Ask;	6	use crate::{Reply, dialog::Ask};
7	use canvas::date::DateField;	7	use canvas::date::DateField;
8	use std::{	8	use std::{
9	cell::UnsafeCell,	9	cell::UnsafeCell,
10	collections::HashMap,	10	collections::HashMap,
11	error::Error,	11	error::Error,
12	ffi::{CStr, CString, OsString, c_char, c_void},	12	ffi::{CStr, CString, OsStr, OsString, c_char, c_void},
13	os::unix::ffi::OsStringExt,	13	os::unix::ffi::OsStringExt,
14	path::PathBuf,	14	path::PathBuf,
15	process::Command,	15	process::Command,
...	@@ -42,7 +42,8 @@ const MINIMIZE: &[&str] = &[include_str!("../assets/icons/window-minimize.svg")]	...	@@ -42,7 +42,8 @@ const MINIMIZE: &[&str] = &[include_str!("../assets/icons/window-minimize.svg")]
42	const MAXIMIZE: &[&str] = &[include_str!("../assets/icons/window-maximize.svg")];	42	const MAXIMIZE: &[&str] = &[include_str!("../assets/icons/window-maximize.svg")];
43	const RESTORE: &[&str] = &[include_str!("../assets/icons/window-restore.svg")];	43	const RESTORE: &[&str] = &[include_str!("../assets/icons/window-restore.svg")];
44		44
45	static QUIT: OnceLock<EventLoopProxy<crate::UserEvent>> = OnceLock::new();	45	/// The event loop's, for signals and Snowbound's own dialogs.
		46	pub(crate) static PROXY: OnceLock<EventLoopProxy<crate::UserEvent>> = OnceLock::new();
46	/// Breeze's corner radius in units of the decoration's pixel grid, as `f32` bits; zero where	47	/// Breeze's corner radius in units of the decoration's pixel grid, as `f32` bits; zero where
47	/// KWin leaves windows square.	48	/// KWin leaves windows square.
48	static BREEZE_RADIUS: AtomicU32 = AtomicU32::new(0);	49	static BREEZE_RADIUS: AtomicU32 = AtomicU32::new(0);
...	@@ -77,7 +78,8 @@ pub fn event_loop(headless: bool) -> Result<EventLoop<crate::UserEvent>, Box<dyn	...	@@ -77,7 +78,8 @@ pub fn event_loop(headless: bool) -> Result<EventLoop<crate::UserEvent>, Box<dyn
77	if !headless {	78	if !headless {
78	crate::desktop::prepare(&event_loop);	79	crate::desktop::prepare(&event_loop);
79	}	80	}
80	QUIT.set(event_loop.create_proxy())	81	PROXY
		82	.set(event_loop.create_proxy())
81	.expect("Only one application event loop is created");	83	.expect("Only one application event loop is created");
82	watch_settings(event_loop.create_proxy());	84	watch_settings(event_loop.create_proxy());
83	if desktop() == Desktop::Kde {	85	if desktop() == Desktop::Kde {
...	@@ -649,7 +651,7 @@ pub fn window_controls(ui: &mut Ui, window: &Window) {	...	@@ -649,7 +651,7 @@ pub fn window_controls(ui: &mut Ui, window: &Window) {
649	"minimize" => window.set_minimized(true),	651	"minimize" => window.set_minimized(true),
650	"maximize" => zoom(window),	652	"maximize" => zoom(window),
651	_ => {	653	_ => {
652	if let Some(proxy) = QUIT.get() {	654	if let Some(proxy) = PROXY.get() {
653	let _ = proxy.send_event(crate::UserEvent::Quit);	655	let _ = proxy.send_event(crate::UserEvent::Quit);
654	}	656	}
655	}	657	}
...	@@ -1199,7 +1201,7 @@ pub fn smb_mount(path: &std::path::Path) -> Option<crate::library::Mount> {	...	@@ -1199,7 +1201,7 @@ pub fn smb_mount(path: &std::path::Path) -> Option<crate::library::Mount> {
1199	}	1201	}
1200		1202
1201	/// The password the Secret Service keeps for `mount`'s account, as GNOME's file manager	1203	/// The password the Secret Service keeps for `mount`'s account, as GNOME's file manager
1202	/// saves one, or what the user types when it keeps none.	1204	/// saves one; without one, Snowbound's sign-in asks.
1203	pub fn smb_login(mount: &crate::library::Mount) -> Result<crate::library::Login, String> {	1205	pub fn smb_login(mount: &crate::library::Mount) -> Result<crate::library::Login, String> {
1204	let user = mount.user.clone().unwrap_or_default();	1206	let user = mount.user.clone().unwrap_or_default();
1205	let mut lookup = Command::new("secret-tool");	1207	let mut lookup = Command::new("secret-tool");
...	@@ -1219,24 +1221,10 @@ pub fn smb_login(mount: &crate::library::Mount) -> Result<crate::library::Login,	...	@@ -1219,24 +1221,10 @@ pub fn smb_login(mount: &crate::library::Mount) -> Result<crate::library::Login,
1219	domain: mount.domain.clone(),	1221	domain: mount.domain.clone(),
1220	});	1222	});
1221	}	1223	}
1222	let title = format!("Sign in to {}", mount.server);	1224	Err(format!(
1223	let asked = dialog(	1225	"Enter the password for \u{201c}{user}\u{201d} on \u{201c}{}\u{201d}.",
1224	["--password", "--username", &format!("--title={title}")],	1226	mount.host()
1225	["--password", &title],	1227	))
1226	)
1227	.unwrap_or_else(\|_\| crate::dialog::ask(&title, "User name:", Ask::Login { user: &user }))
1228	.ok_or_else(\|\| "Signing in was canceled".to_owned())?;
1229	// zenity answers "user\|password"; kdialog only the password.
1230	let (typed, password) = asked
1231	.split_once('\|')
1232	.map_or((user.clone(), asked.clone()), \|(typed, password)\| {
1233	(typed.to_owned(), password.to_owned())
1234	});
1235	Ok(crate::library::Login {
1236	user: if typed.is_empty() { user } else { typed },
1237	password,
1238	domain: mount.domain.clone(),
1239	})
1240	}	1228	}
1241		1229
1242	/// What the sign-in offers for keeping a password, where the Secret Service's tool is	1230	/// What the sign-in offers for keeping a password, where the Secret Service's tool is
...	@@ -1402,61 +1390,75 @@ pub fn date_text(filetime: u64) -> [String; 2] {	...	@@ -1402,61 +1390,75 @@ pub fn date_text(filetime: u64) -> [String; 2] {
1402	date_labels(&local_time(filetime))	1390	date_labels(&local_time(filetime))
1403	}	1391	}
1404		1392
1405	/// Asks for the page's date or time with the desktop's dialog tool.	1393	/// Asks for the page's date or time with the desktop's dialog tool, or else as text in
		1394	/// Snowbound's own dialog.
1406	pub fn edit_date(	1395	pub fn edit_date(
1407	timestamp: u64,	1396	timestamp: u64,
1408	field: DateField,	1397	field: DateField,
1409	title: &str,	1398	title: &str,
1410	) -> Result<Option<(u64, [String; 2])>, &'static str> {	1399	reply: Reply<Result<(u64, [String; 2]), &'static str>>,
1411	let tm = local_time(timestamp);	1400	) {
1412	let answer = match field {	1401	let title = title.to_owned();
1413	DateField::Date => dialog(	1402	let reply = reply
1414	[	1403	.map(move \|answer: String\| changed_date(timestamp, local_time(timestamp), field, &answer));
1415	"--calendar",	1404	std::thread::spawn(move \|\| {
1416	&format!("--title={title}"),	1405	let tm = local_time(timestamp);
1417	"--text=",	1406	let (asked, detail, value) = match field {
1418	&format!("--day={}", tm.tm_mday),	1407	DateField::Date => (
1419	&format!("--month={}", tm.tm_mon + 1),	1408	dialog(
1420	&format!("--year={}", tm.tm_year + 1900),	1409	&[
1421	"--date-format=%Y-%m-%d",	1410	"--calendar",
1422	],	1411	&format!("--title={title}"),
1423	["--calendar", title, "--dateformat", "yyyy-MM-dd"],	1412	"--text=",
1424	)	1413	&format!("--day={}", tm.tm_mday),
1425	.unwrap_or_else(\|_\| {	1414	&format!("--month={}", tm.tm_mon + 1),
1426	let value = format(&tm, c"%Y-%m-%d");	1415	&format!("--year={}", tm.tm_year + 1900),
1427	crate::dialog::ask(	1416	"--date-format=%Y-%m-%d",
1428	title,	1417	],
		1418	&["--calendar", &title, "--dateformat", "yyyy-MM-dd"],
		1419	),
1429	"Date, as year-month-day:",	1420	"Date, as year-month-day:",
1430	Ask::Entry { value: &value },	1421	format(&tm, c"%Y-%m-%d"),
1431	)	1422	),
1432	}),	1423	DateField::Time => {
1433	DateField::Time => {	1424	let current = format(&tm, c"%H:%M");
1434	let current = format(&tm, c"%H:%M");	1425	let asked = dialog(
1435	dialog(	1426	&[
1436	[	1427	"--entry",
1437	"--entry",	1428	&format!("--title={title}"),
1438	&format!("--title={title}"),	1429	"--text=Time, as hours and minutes:",
1439	"--text=Time, as hours and minutes:",	1430	&format!("--entry-text={current}"),
1440	&format!("--entry-text={current}"),	1431	],
1441	],	1432	&["--inputbox", "Time, as hours and minutes:", &current],
1442	["--inputbox", "Time, as hours and minutes:", &current],	1433	);
1443	)	1434	(asked, "Time, as hours and minutes:", current)
1444	.unwrap_or_else(\|_\| {	1435	}
1445	let value = Ask::Entry { value: &current };	1436	};
1446	crate::dialog::ask(title, "Time, as hours and minutes:", value)	1437	match asked {
1447	})	1438	Ok(Some(answer)) => reply.send(answer),
		1439	Ok(None) => {}
		1440	Err(_) => {
		1441	let ask = Ask::Entry { text: value, reply };
		1442	crate::dialog::show(title, detail.to_owned(), ask);
		1443	}
1448	}	1444	}
1449	};	1445	});
1450	let Some(answer) = answer else {	1446	}
1451	return Ok(None);	1447
1452	};	1448	/// `timestamp` with `field` changed to what the user typed or chose, `answer`.
		1449	fn changed_date(
		1450	timestamp: u64,
		1451	tm: libc::tm,
		1452	field: DateField,
		1453	answer: &str,
		1454	) -> Result<(u64, [String; 2]), &'static str> {
1453	let numbers: Vec<i32> = answer	1455	let numbers: Vec<i32> = answer
1454	.split(\|c: char\| !c.is_ascii_digit())	1456	.split(\|c: char\| !c.is_ascii_digit())
1455	.filter(\|part\| !part.is_empty())	1457	.filter(\|part\| !part.is_empty())
1456	.map(\|part\| part.parse().unwrap_or(i32::MAX))	1458	.map(\|part\| part.parse().unwrap_or(i32::MAX))
1457	.collect();	1459	.collect();
1458	let afternoon = answer.to_lowercase().contains("pm");	1460	let afternoon = answer.to_lowercase().contains("pm");
1459	merge_date(timestamp, tm, field, &numbers, afternoon).map(Some)	1461	merge_date(timestamp, tm, field, &numbers, afternoon)
1460	}	1462	}
1461		1463
1462	fn merge_date(	1464	fn merge_date(
...	@@ -1497,36 +1499,24 @@ fn merge_date(	...	@@ -1497,36 +1499,24 @@ fn merge_date(
1497	Ok((updated, date_labels(&tm)))	1499	Ok((updated, date_labels(&tm)))
1498	}	1500	}
1499		1501
1500	/// Runs zenity, or kdialog where zenity is missing; the answer is None when cancelled, and an	1502	/// Runs zenity, or kdialog where zenity is missing, waiting for the answer: None when
1501	/// error when neither is installed.	1503	/// cancelled, and an error when neither is installed.
1502	fn dialog<const Z: usize, const K: usize>(	1504	fn dialog(
1503	zenity: [&str; Z],	1505	zenity: &[impl AsRef<OsStr>],
1504	kdialog: [&str; K],	1506	kdialog: &[impl AsRef<OsStr>],
1505	) -> Result<Option<String>, &'static str> {	1507	) -> std::io::Result<Option<String>> {
1506	let output = Command::new("zenity")	1508	let output = Command::new("zenity")
1507	.args(zenity)	1509	.args(zenity)
1508	.output()	1510	.output()
1509	.or_else(\|_\| Command::new("kdialog").args(kdialog).output())	1511	.or_else(\|_\| Command::new("kdialog").args(kdialog).output())?;
1510	.map_err(\|_\| "Install zenity or kdialog for Snowbound's dialogs.")?;
1511	Ok(output	1512	Ok(output
1512	.status	1513	.status
1513	.success()	1514	.success()
1514	.then(\|\| String::from_utf8_lossy(&output.stdout).trim().to_owned()))	1515	.then(\|\| String::from_utf8_lossy(&output.stdout).trim().to_owned()))
1515	}	1516	}
1516		1517
1517	/// The path a file dialog answered; none when cancelled or when no tool could ask.
1518	fn picked(asked: Result<Option<String>, &str>) -> Option<PathBuf> {
1519	asked
1520	.unwrap_or_else(\|error\| {
1521	eprintln!("{error}");
1522	None
1523	})
1524	.filter(\|path\| !path.is_empty())
1525	.map(PathBuf::from)
1526	}
1527
1528	/// Asks for a file to insert, one of `types` (extensions) unless empty, titled `title`.	1518	/// Asks for a file to insert, one of `types` (extensions) unless empty, titled `title`.
1529	pub fn pick_file(title: &str, types: &[&str]) -> Option<PathBuf> {	1519	pub fn pick_file(title: &str, types: &[&str], reply: Reply<PathBuf>) {
1530	let globs: Vec<_> = types.iter().map(\|kind\| format!("*.{kind}")).collect();	1520	let globs: Vec<_> = types.iter().map(\|kind\| format!("*.{kind}")).collect();
1531	let patterns = match types {	1521	let patterns = match types {
1532	[] => "*".to_owned(),	1522	[] => "*".to_owned(),
...	@@ -1536,17 +1526,26 @@ pub fn pick_file(title: &str, types: &[&str]) -> Option<PathBuf> {	...	@@ -1536,17 +1526,26 @@ pub fn pick_file(title: &str, types: &[&str]) -> Option<PathBuf> {
1536	if !globs.is_empty() {	1526	if !globs.is_empty() {
1537	options.insert("filters", filters(&patterns, &globs));	1527	options.insert("filters", filters(&patterns, &globs));
1538	}	1528	}
		1529	let types = types.iter().map(\|kind\| kind.to_string()).collect();
1539	choose(	1530	choose(
1540	title,	1531	title,
1541	"OpenFile",	1532	"OpenFile",
1542	options,	1533	options,
1543	[	1534	&[
1544	"--file-selection",	1535	"--file-selection",
1545	&format!("--title={title}"),	1536	&format!("--title={title}"),
1546	&format!("--file-filter={patterns}"),	1537	&format!("--file-filter={patterns}"),
1547	],	1538	],
1548	["--getopenfilename", ".", &patterns, "--title", title],	1539	&["--getopenfilename", ".", &patterns, "--title", title],
1549	)	1540	move \|reply\| Ask::File {
		1541	folder: crate::dialog::start_folder(),
		1542	types,
		1543	save: false,
		1544	name: String::new(),
		1545	reply,
		1546	},
		1547	reply,
		1548	);
1550	}	1549	}
1551		1550
1552	/// A file chooser's `filters` option: one filter, `name`, of `globs`.	1551	/// A file chooser's `filters` option: one filter, `name`, of `globs`.
...	@@ -1555,33 +1554,48 @@ fn filters(name: &str, globs: &[String]) -> Value<'static> {	...	@@ -1555,33 +1554,48 @@ fn filters(name: &str, globs: &[String]) -> Value<'static> {
1555	Value::from(vec![(name.to_owned(), globs)])	1554	Value::from(vec![(name.to_owned(), globs)])
1556	}	1555	}
1557		1556
1558	/// The file the file chooser portal answers `method` with, titled `title`, or where no portal	1557	/// Replies with the file the file chooser portal answers `method` with, titled `title`;
1559	/// answers, zenity's or kdialog's; None when cancelled.	1558	/// where no portal answers, zenity's or kdialog's, given their arguments; and where neither
1560	fn choose<const Z: usize, const K: usize>(	1559	/// is installed, Snowbound's `own`.
		1560	fn choose(
1561	title: &str,	1561	title: &str,
1562	method: &str,	1562	method: &'static str,
1563	mut options: HashMap<&str, Value>,	1563	mut options: HashMap<&'static str, Value<'static>>,
1564	zenity: [&str; Z],	1564	zenity: &[&str],
1565	kdialog: [&str; K],	1565	kdialog: &[&str],
1566	) -> Option<PathBuf> {	1566	own: impl FnOnce(Reply<PathBuf>) -> Ask + Send + 'static,
1567	let chosen = portal("org.freedesktop.portal.FileChooser")	1567	reply: Reply<PathBuf>,
1568	.map_err(Into::into)	1568	) {
1569	.and_then(\|chooser\| {	1569	let title = title.to_owned();
1570	portal_request(&chooser, \|token\| {	1570	let [zenity, kdialog]: [Vec<String>; 2] =
1571	options.insert("handle_token", Value::from(token.to_owned()));	1571	[zenity, kdialog].map(\|args\| args.iter().map(\|arg\| arg.to_string()).collect());
1572	chooser.call(method, &("", title, &options))	1572	std::thread::spawn(move \|\| {
1573	})	1573	let chosen = portal("org.freedesktop.portal.FileChooser")
1574	});	1574	.map_err(Into::into)
1575	let results = match chosen {	1575	.and_then(\|chooser\| {
1576	Ok(results) => results?,	1576	portal_request(&chooser, \|token\| {
1577	Err(error) => {	1577	options.insert("handle_token", Value::from(token.to_owned()));
1578	eprintln!("The file chooser portal failed: {error}");	1578	chooser.call(method, &("", &title, &options))
1579	return picked(dialog(zenity, kdialog));	1579	})
		1580	});
		1581	let path = match chosen {
		1582	Ok(results) => results.and_then(\|results\| {
		1583	let uris: Vec<String> = results.get("uris")?.try_clone().ok()?.try_into().ok()?;
		1584	let path = uris.first()?.strip_prefix("file://")?;
		1585	Some(OsString::from_vec(crate::paste::percent_decode(path)).into())
		1586	}),
		1587	Err(error) => {
		1588	eprintln!("The file chooser portal failed: {error}");
		1589	match dialog(&zenity, &kdialog) {
		1590	Ok(path) => path.filter(\|path\| !path.is_empty()).map(PathBuf::from),
		1591	Err(_) => return crate::dialog::show(title, String::new(), own(reply)),
		1592	}
		1593	}
		1594	};
		1595	if let Some(path) = path {
		1596	reply.send(path);
1580	}	1597	}
1581	};	1598	});
1582	let uris: Vec<String> = results.get("uris")?.try_clone().ok()?.try_into().ok()?;
1583	let path = uris.first()?.strip_prefix("file://")?;
1584	Some(std::ffi::OsString::from_vec(crate::paste::percent_decode(path)).into())
1585	}	1599	}
1586		1600
1587	/// The desktop portal's `interface`, whose calls give up after five seconds.	1601	/// The desktop portal's `interface`, whose calls give up after five seconds.
...	@@ -1678,45 +1692,65 @@ pub fn reveal(target: impl AsRef<std::ffi::OsStr>) {	...	@@ -1678,45 +1692,65 @@ pub fn reveal(target: impl AsRef<std::ffi::OsStr>) {
1678	}	1692	}
1679	}	1693	}
1680		1694
1681	/// Asks whether to go ahead with `action`, through zenity or kdialog where installed.	1695	/// Asks whether to go ahead with `action`, through zenity or kdialog where installed, or
1682	pub fn confirm(message: &str, detail: &str, cancel: &str, action: &str) -> bool {	1696	/// else Snowbound's own dialog.
1683	let status = Command::new("zenity")	1697	pub fn confirm(message: &str, detail: &str, cancel: &str, action: &str, reply: Reply<()>) {
1684	.args([	1698	let [message, detail, cancel, action] = [message, detail, cancel, action].map(str::to_owned);
1685	"--question",	1699	std::thread::spawn(move \|\| {
1686	&format!("--title={message}"),	1700	let status = Command::new("zenity")
1687	&format!("--text={detail}"),	1701	.args([
1688	&format!("--ok-label={action}"),	1702	"--question",
1689	&format!("--cancel-label={cancel}"),	1703	&format!("--title={message}"),
1690	])	1704	&format!("--text={detail}"),
1691	.status()	1705	&format!("--ok-label={action}"),
1692	.or_else(\|_\| {	1706	&format!("--cancel-label={cancel}"),
1693	Command::new("kdialog")	1707	])
1694	.args(["--warningcontinuecancel", detail, "--title", message])	1708	.status()
1695	.args(["--continue-label", action])	1709	.or_else(\|_\| {
1696	.status()	1710	Command::new("kdialog")
1697	});	1711	.args(["--warningcontinuecancel", &detail, "--title", &message])
1698	match status {	1712	.args(["--continue-label", &action])
1699	Ok(status) => status.success(),	1713	.status()
1700	Err(_) => crate::dialog::ask(message, detail, Ask::Question { cancel, action }).is_some(),	1714	});
1701	}	1715	match status {
		1716	Ok(status) if status.success() => reply.send(()),
		1717	Ok(_) => {}
		1718	Err(_) => {
		1719	let ask = Ask::Question {
		1720	cancel,
		1721	action,
		1722	reply,
		1723	};
		1724	crate::dialog::show(message, detail, ask);
		1725	}
		1726	}
		1727	});
1702	}	1728	}
1703		1729
1704	/// Asks for a notebook's table of contents or a section file, titled `title`; None when	1730	/// Asks for a notebook's table of contents or a section file, titled `title`.
1705	/// cancelled or when no tool can ask.	1731	pub fn pick_notebook(title: &str, reply: Reply<PathBuf>) {
1706	pub fn pick_notebook(title: &str) -> Option<PathBuf> {
1707	let name = "OneNote notebooks, sections and packages";	1732	let name = "OneNote notebooks, sections and packages";
1708	let globs = [".onetoc2", ".one", "*.onepkg"].map(String::from);	1733	let types = ["onetoc2", "one", "onepkg"];
		1734	let globs = types.map(\|kind\| format!("*.{kind}"));
1709	choose(	1735	choose(
1710	title,	1736	title,
1711	"OpenFile",	1737	"OpenFile",
1712	HashMap::from([("filters", filters(name, &globs))]),	1738	HashMap::from([("filters", filters(name, &globs))]),
1713	[	1739	&[
1714	"--file-selection",	1740	"--file-selection",
1715	&format!("--title={title}"),	1741	&format!("--title={title}"),
1716	&format!("--file-filter={name} \| {}", globs.join(" ")),	1742	&format!("--file-filter={name} \| {}", globs.join(" ")),
1717	],	1743	],
1718	["--getopenfilename", ".", &globs.join(" "), "--title", title],	1744	&["--getopenfilename", ".", &globs.join(" "), "--title", title],
1719	)	1745	move \|reply\| Ask::File {
		1746	folder: crate::dialog::start_folder(),
		1747	types: types.map(String::from).to_vec(),
		1748	save: false,
		1749	name: String::new(),
		1750	reply,
		1751	},
		1752	reply,
		1753	);
1720	}	1754	}
1721		1755
1722	/// Asks where to put something named `name` by default, in `folder` where given, with	1756	/// Asks where to put something named `name` by default, in `folder` where given, with
...	@@ -1726,29 +1760,42 @@ pub fn pick_new(	...	@@ -1726,29 +1760,42 @@ pub fn pick_new(
1726	name: &str,	1760	name: &str,
1727	action: &str,	1761	action: &str,
1728	folder: Option<&std::path::Path>,	1762	folder: Option<&std::path::Path>,
1729	) -> Option<PathBuf> {	1763	reply: Reply<PathBuf>,
		1764	) {
1730	use std::os::unix::ffi::OsStrExt;	1765	use std::os::unix::ffi::OsStrExt;
1731	let mut options = HashMap::from([	1766	let mut options = HashMap::from([
1732	("current_name", Value::from(name)),	1767	("current_name", Value::from(name.to_owned())),
1733	("accept_label", Value::from(action)),	1768	("accept_label", Value::from(action.to_owned())),
1734	]);	1769	]);
1735	if let Some(folder) = folder {	1770	if let Some(folder) = folder {
1736	let mut bytes = folder.as_os_str().as_bytes().to_vec();	1771	let mut bytes = folder.as_os_str().as_bytes().to_vec();
1737	bytes.push(0);	1772	bytes.push(0);
1738	options.insert("current_folder", Value::from(bytes));	1773	options.insert("current_folder", Value::from(bytes));
1739	}	1774	}
		1775	let (named, folder) = (
		1776	name.to_owned(),
		1777	folder.map_or_else(crate::dialog::start_folder, Into::into),
		1778	);
1740	choose(	1779	choose(
1741	title,	1780	title,
1742	"SaveFile",	1781	"SaveFile",
1743	options,	1782	options,
1744	[	1783	&[
1745	"--file-selection",	1784	"--file-selection",
1746	"--save",	1785	"--save",
1747	&format!("--title={title}"),	1786	&format!("--title={title}"),
1748	&format!("--filename={name}"),	1787	&format!("--filename={name}"),
1749	],	1788	],
1750	["--getsavefilename", name, "--title", title],	1789	&["--getsavefilename", name, "--title", title],
1751	)	1790	move \|reply\| Ask::File {
		1791	folder,
		1792	types: Vec::new(),
		1793	save: true,
		1794	name: named,
		1795	reply,
		1796	},
		1797	reply,
		1798	);
1752	}	1799	}
1753		1800
1754	/// Tells the user something they asked for could not be done: `message`, then what to do.	1801	/// Tells the user something they asked for could not be done: `message`, then what to do.
...	@@ -1779,7 +1826,7 @@ fn show([zenity, kdialog]: [&'static str; 2], message: &str, detail: &str) {	...	@@ -1779,7 +1826,7 @@ fn show([zenity, kdialog]: [&'static str; 2], message: &str, detail: &str) {
1779	.status()	1826	.status()
1780	});	1827	});
1781	if shown.is_err() {	1828	if shown.is_err() {
1782	crate::dialog::ask(&title, &text, Ask::Message);	1829	crate::dialog::show(title, text, Ask::Message);
1783	}	1830	}
1784	});	1831	});
1785	}	1832	}

crates/snowbound/src/macos.rs+93-30

 @@ -1,4 +1,4 @@
-use crate::commands;
+use crate::{Reply, commands};
 use canvas::date::DateField;
 use objc2::{
     ClassType, DeclaredClass, class,
 @@ -11,7 +11,8 @@ use objc2::{
 use objc2_app_kit::{
     NSAlert, NSAlertFirstButtonReturn, NSAlertSecondButtonReturn, NSApplication, NSColor,
     NSColorSpace, NSDatePicker, NSDatePickerElementFlags, NSDatePickerStyle, NSEvent,
-    NSEventSubtype, NSEventType, NSMenu, NSMenuItem,
+    NSEventSubtype, NSEventType, NSMenu, NSMenuItem, NSModalResponse, NSModalResponseCancel,
+    NSModalResponseOK, NSSavePanel, NSWindow,
 };
 use objc2_foundation::{
     MainThreadMarker, NSAttributedString, NSCalendar, NSCalendarUnit, NSDate, NSDateFormatter,
 @@ -92,6 +93,59 @@ pub(crate) fn ns_window(window: &Window) -> Retained<AnyObject> {
     unsafe { msg_send_id![&ns_view(window), window] }
 }
+thread_local! {
+    /// The window dialogs open on as sheets.
+    static WINDOW: RefCell<Option<Retained<NSWindow>>> = const { RefCell::new(None) };
+    /// The alert shown as a sheet, which Escape cancels.
+    static ALERT: RefCell<Option<Retained<NSWindow>>> = const { RefCell::new(None) };
+}
+/// Shows `alert` as a sheet on the window, then answers with the button pressed. Before
+/// 10.9, whose alerts have no such sheet, the alert waits as a modal one.
+fn begin_alert(alert: &NSAlert, answer: impl FnOnce(NSModalResponse) + 'static) {
+    unsafe {
+        let sheets: bool = msg_send![
+            alert,
+            respondsToSelector: sel!(beginSheetModalForWindow:completionHandler:)
+        ];
+        let Some(window) = WINDOW.with_borrow(Clone::clone).filter(|_| sheets) else {
+            return answer(alert.runModal());
+        };
+        ALERT.set(Some(alert.window()));
+        let answer = Cell::new(Some(answer));
+        let done = block2::RcBlock::new(move |response: NSModalResponse| {
+            ALERT.set(None);
+            if let Some(answer) = answer.take() {
+                answer(response);
+            }
+        });
+        let _: () = msg_send![alert, beginSheetModalForWindow: &*window, completionHandler: &*done];
+    }
+}
+/// Shows `panel` as a sheet on the window, then replies with the path chosen.
+fn begin_panel(panel: Retained<NSSavePanel>, reply: Reply<std::path::PathBuf>) {
+    let chosen = panel.clone();
+    let reply = Cell::new(Some(reply));
+    let done = block2::RcBlock::new(move |response: NSModalResponse| {
+        let path = unsafe { chosen.URL().and_then(|url| url.path()) };
+        if let (true, Some(path), Some(reply)) = (response == NSModalResponseOK, path, reply.take())
+        {
+            reply.send(path.to_string().into());
+        }
+    });
+    unsafe {
+        match WINDOW.with_borrow(Clone::clone) {
+            Some(window) => {
+                let _: () = msg_send![&panel, beginSheetModalForWindow: &*window, completionHandler: &*done];
+            }
+            None => {
+                let _: () = msg_send![&panel, beginWithCompletionHandler: &*done];
+            }
+        }
+    }
+}
 /// Room the traffic lights take at the title bar's leading edge.
 pub const LEADING: f32 = 78.0;
 /// The title bar's trailing margin, the gap the traffic lights leave before the toolbar.
 @@ -131,6 +185,7 @@ pub fn window_attributes() -> WindowAttributes {
 pub fn install_title_bar(window: &Window) {
     MainThreadMarker::new().expect("Windows belong to the main thread");
     let window = ns_window(window);
+    WINDOW.set(Some(unsafe { Retained::cast(window.clone()) }));
     let responds =
         |selector: Sel| -> bool { unsafe { msg_send![&window, respondsToSelector: selector] } };
     // Before 10.10 the title bar keeps its own line above the row.
 @@ -765,7 +820,7 @@ pub fn documents_dir() -> Option<std::path::PathBuf> {
 /// Asks for a notebook folder or a notebook file with the system's open panel, titled
 /// `title`.
-pub fn pick_notebook(title: &str) -> Option<std::path::PathBuf> {
+pub fn pick_notebook(title: &str, reply: Reply<std::path::PathBuf>) {
     let mtm = MainThreadMarker::new().expect("Panels belong to the main thread");
     unsafe {
         let panel = objc2_app_kit::NSOpenPanel::openPanel(mtm);
 @@ -774,11 +829,7 @@ pub fn pick_notebook(title: &str) -> Option<std::path::PathBuf> {
         panel.setCanCreateDirectories(true);
         panel.setTitle(Some(&NSString::from_str(title)));
         panel.setPrompt(Some(&NSString::from_str("Open")));
-        if panel.runModal() != objc2_app_kit::NSModalResponseOK {
+        begin_panel(Retained::into_super(panel), reply);
-            return None;
-        }
-        let path = panel.URLs().firstObject()?.path()?;
-        Some(path.to_string().into())
     }
 }
 @@ -789,10 +840,11 @@ pub fn pick_new(
     name: &str,
     action: &str,
     folder: Option<&std::path::Path>,
-) -> Option<std::path::PathBuf> {
+    reply: Reply<std::path::PathBuf>,
+) {
     let mtm = MainThreadMarker::new().expect("Panels belong to the main thread");
     unsafe {
-        let panel = objc2_app_kit::NSSavePanel::savePanel(mtm);
+        let panel = NSSavePanel::savePanel(mtm);
         if let Some(folder) = folder.and_then(std::path::Path::to_str) {
             panel.setDirectoryURL(Some(&objc2_foundation::NSURL::fileURLWithPath(
                 &NSString::from_str(folder),
 @@ -802,16 +854,13 @@ pub fn pick_new(
         panel.setTitle(Some(&NSString::from_str(title)));
         panel.setPrompt(Some(&NSString::from_str(action)));
         panel.setNameFieldStringValue(&NSString::from_str(name));
-        if panel.runModal() != objc2_app_kit::NSModalResponseOK {
+        begin_panel(panel, reply);
-            return None;
-        }
-        Some(panel.URL()?.path()?.to_string().into())
     }
 }
 /// Asks for a file to insert, one of `types` (extensions) unless empty, with the system's
 /// open panel titled `title`.
-pub fn pick_file(title: &str, types: &[&str]) -> Option<std::path::PathBuf> {
+pub fn pick_file(title: &str, types: &[&str], reply: Reply<std::path::PathBuf>) {
     let mtm = MainThreadMarker::new().expect("Panels belong to the main thread");
     unsafe {
         let panel = objc2_app_kit::NSOpenPanel::openPanel(mtm);
 @@ -822,11 +871,7 @@ pub fn pick_file(title: &str, types: &[&str]) -> Option<std::path::PathBuf> {
         }
         panel.setTitle(Some(&NSString::from_str(title)));
         panel.setPrompt(Some(&NSString::from_str("Insert")));
-        if panel.runModal() != objc2_app_kit::NSModalResponseOK {
+        begin_panel(Retained::into_super(panel), reply);
-            return None;
-        }
-        let path = panel.URLs().firstObject()?.path()?;
-        Some(path.to_string().into())
     }
 }
 @@ -1010,7 +1055,7 @@ pub fn alert(message: &str, detail: &str) {
         let alert = NSAlert::new(mtm);
         alert.setMessageText(&NSString::from_str(message));
         alert.setInformativeText(&NSString::from_str(detail));
-        alert.runModal();
+        begin_alert(&alert, |_| {});
     }
 }
 @@ -1086,7 +1131,8 @@ pub fn edit_date(
     timestamp: u64,
     field: DateField,
     title: &str,
-) -> Result<Option<(u64, [String; 2])>, &'static str> {
+    reply: Reply<Result<(u64, [String; 2]), &'static str>>,
+) {
     let mtm = MainThreadMarker::new().expect("Date controls belong to the main thread");
     unsafe {
         let calendar = NSCalendar::currentCalendar();
 @@ -1116,11 +1162,14 @@ pub fn edit_date(
         alert.addButtonWithTitle(&NSString::from_str("Cancel"));
         alert.layout();
         alert.window().makeFirstResponder(Some(&picker));
-        if alert.runModal() != NSAlertFirstButtonReturn {
+        let window = alert.window();
-            return Ok(None);
+        begin_alert(&alert, move |response| {
-        }
+            if response != NSAlertFirstButtonReturn {
-        alert.window().makeFirstResponder(None);
+                return;
-        merge_date(timestamp, &picker.dateValue(), field, &calendar).map(Some)
+            }
+            window.makeFirstResponder(None);
+            reply.send(merge_date(timestamp, &picker.dateValue(), field, &calendar));
+        });
     }
 }
 @@ -1402,8 +1451,19 @@ declare_class!(
                     .flatten()
                     .map(|text| text.to_string());
                 let modal = self.modalWindow();
+                let sheet = ALERT.with_borrow(Clone::clone).filter(|sheet| {
+                    self.keyWindow().is_some_and(|key| std::ptr::eq(&*key, &**sheet))
+                });
+                let sheet = sheet.zip(WINDOW.with_borrow(Clone::clone));
                 match (key.as_deref(), &modal) {
                     (Some("\u{1b}"), Some(_)) => self.stopModal(),
+                    (Some("\u{1b}"), None) if let Some((sheet, parent)) = &sheet => {
+                        let _: () = msg_send![
+                            parent,
+                            endSheet: &**sheet,
+                            returnCode: NSModalResponseCancel
+                        ];
+                    }
                     (Some("\r" | "\u{3}"), Some(modal)) if {
                         let responder: *mut AnyObject = msg_send![modal, firstResponder];
                         !responder.is_null()
 @@ -1511,16 +1571,19 @@ pub fn reveal(target: impl AsRef<std::ffi::OsStr>) {
 }
 /// Asks whether to go ahead with `action`, offering `cancel` first.
-pub fn confirm(message: &str, detail: &str, cancel: &str, action: &str) -> bool {
+pub fn confirm(message: &str, detail: &str, cancel: &str, action: &str, reply: Reply<()>) {
     let mtm = MainThreadMarker::new().expect("Window events run on the main thread");
-    // The alert and its strings stay on AppKit's main thread for the modal call.
     unsafe {
         let alert = NSAlert::new(mtm);
         alert.setMessageText(&NSString::from_str(message));
         alert.setInformativeText(&NSString::from_str(detail));
         alert.addButtonWithTitle(&NSString::from_str(cancel));
         alert.addButtonWithTitle(&NSString::from_str(action));
-        alert.runModal() == NSAlertSecondButtonReturn
+        begin_alert(&alert, |response| {
+            if response == NSAlertSecondButtonReturn {
+                reply.send(());
+            }
+        });
     }
 }

crates/snowbound/src/main.rs+117-46

 @@ -214,8 +214,48 @@ const DATE_OUT_OF_RANGE: &str = "This date is outside the notebook's supported r
 type Continuation = Box<dyn FnOnce(&mut State) -> Result<(), Box<dyn Error>> + Send>;
+/// What follows a dialog's answer, run on the event loop. Dialogs never wait on the event
+/// loop's thread, so the window keeps drawing and other apps can paste what it copied while
+/// one is open; one cancelled drops its reply unanswered.
+struct Reply<T>(Box<dyn FnOnce(T) + Send>);
+impl<T: Send + 'static> Reply<T> {
+    fn new(
+        proxy: &EventLoopProxy<UserEvent>,
+        then: impl FnOnce(&mut State, T) -> Result<(), Box<dyn Error>> + Send + 'static,
+    ) -> Self {
+        let proxy = proxy.clone();
+        Self(Box::new(move |answer| {
+            let _ = proxy.send_event(UserEvent::Then(Box::new(move |state| then(state, answer))));
+        }))
+    }
+    fn send(self, answer: T) {
+        (self.0)(answer);
+    }
+    /// The reply that sends `convert`'s answer here.
+    #[cfg(target_os = "linux")]
+    fn map<U>(self, convert: impl FnOnce(U) -> T + Send + 'static) -> Reply<U> {
+        Reply(Box::new(move |answer| self.send(convert(answer))))
+    }
+    /// Sends what `ask` answers, waiting on its dialog on a thread of its own.
+    #[cfg(windows)]
+    fn after(self, ask: impl FnOnce() -> Option<T> + Send + 'static) {
+        std::thread::spawn(move || {
+            if let Some(answer) = ask() {
+                self.send(answer);
+            }
+        });
+    }
+}
 enum UserEvent {
     Quit,
+    /// Quits without asking, as after the user agreed to discard a temporary page.
+    #[cfg(not(target_arch = "wasm32"))]
+    Exit,
     /// Text AppKit inserts outside key events, such as the character palette's.
     #[cfg_attr(not(target_os = "macos"), allow(dead_code))]
     InsertText(String),
 @@ -750,6 +790,9 @@ struct State {
     save_as: Option<save_as::Dialog>,
     /// Unpack Notebook while it is open.
     unpacking: Option<unpack::Dialog>,
+    /// Snowbound's own dialogs, first the one shown, where the desktop has none.
+    #[cfg(target_os = "linux")]
+    asking: std::collections::VecDeque<dialog::Dialog>,
     /// What has been read in each notebook, on this computer.
     reads: unread::Reads,
     /// Open Notebook from Server while it is open.
 @@ -1125,6 +1168,8 @@ impl State {
             symbols: None,
             save_as: None,
             unpacking: None,
+            #[cfg(target_os = "linux")]
+            asking: Default::default(),
             reads,
             server: None,
             new_icloud: None,
 @@ -1301,6 +1346,8 @@ impl State {
         self.save_as_dialog();
         self.unpack_dialog();
         self.password_dialog()?;
+        #[cfg(target_os = "linux")]
+        self.own_dialog();
         self.customize_tags();
         self.palette();
         self.sync_popup()?;
 @@ -3138,13 +3185,15 @@ impl State {
             Command::RestoreVersion { page, version } => self.restore_version(page, version)?,
             Command::DeletePageVersion { page, version } => self.delete_version(page, version)?,
             Command::DeleteAllVersions(scope) => self.delete_all_versions(scope)?,
-            Command::OpenNotebook => {
+            Command::OpenNotebook => platform::pick_notebook(
-                if let Some(path) = platform::pick_notebook("Open Notebook") {
+                "Open Notebook",
-                    self.open_path(&path);
+                self.reply(|state, path: PathBuf| {
-                }
+                    state.open_path(&path);
-            }
+                    Ok(())
+                }),
+            ),
             Command::OpenFromServer(location) => self.open_server(location.as_deref()),
-            Command::NewNotebook => self.new_notebook()?,
+            Command::NewNotebook => self.new_notebook(),
             Command::NewICloudNotebook => self.new_icloud_notebook(),
             Command::OpenGuide => self.open_guide()?,
             #[cfg(target_os = "linux")]
 @@ -3172,7 +3221,7 @@ impl State {
                 self.edited(Vec::new());
             }
             Command::Template(choice) => self.apply_template(choice)?,
-            Command::Page(Request::EditDate(field)) => self.edit_date(field)?,
+            Command::Page(Request::EditDate(field)) => self.edit_date(field),
             Command::Page(Request::Copy(clip)) => self.clipboard.set(clip)?,
             Command::Page(Request::Paste) => self.paste()?,
             Command::Page(Request::OpenLink(address)) => self.open_link(&address)?,
 @@ -3561,9 +3610,9 @@ impl State {
         }
     }
-    fn edit_date(&mut self, field: DateField) -> Result<(), Box<dyn Error>> {
+    fn edit_date(&mut self, field: DateField) {
         let Some(date) = self.view.editor.date() else {
-            return Ok(());
+            return;
         };
         let timestamp = date.timestamp();
         self.view.editor.finish_composition();
 @@ -3572,12 +3621,30 @@ impl State {
             DateField::Date => "Change Page Date",
             DateField::Time => "Change Page Time",
         };
-        if let Some((timestamp, text)) = platform::edit_date(timestamp, field, title)? {
+        let page = self.session.as_ref().map(|session| session.space);
-            let response = self.view.change_date(timestamp, text)?;
+        let reply = self.reply(
-            self.respond(response);
+            move |state, chosen: Result<(u64, [String; 2]), &'static str>| {
-            self.window.request_redraw();
+                let (changed, text) = chosen?;
-        }
+                // The answer belongs to the page that asked, unless another has opened since.
-        Ok(())
+                if state.session.as_ref().map(|session| session.space) != page
+                    || state.view.editor.date().map(|date| date.timestamp()) != Some(timestamp)
+                {
+                    return Ok(());
+                }
+                let response = state.view.change_date(changed, text)?;
+                state.respond(response);
+                Ok(())
+            },
+        );
+        platform::edit_date(timestamp, field, title, reply);
+    }
+    /// Where a dialog's answer goes: `then`, run with it on the event loop.
+    fn reply<T: Send + 'static>(
+        &self,
+        then: impl FnOnce(&mut State, T) -> Result<(), Box<dyn Error>> + Send + 'static,
+    ) -> Reply<T> {
+        Reply::new(&self.proxy, then)
     }
     /// The open conflict page's conflicting changes in page order: each text's outline,
 @@ -3970,7 +4037,7 @@ impl State {
         }
         if let Some(field) = self.accessibility.date_for_node(request.target_node) {
             if request.action == Action::Click {
-                self.edit_date(field)?;
+                self.edit_date(field);
             }
             return Ok(());
         }
 @@ -5491,6 +5558,8 @@ impl State {
         match event {
             // The event loop quits; a page stays open.
             UserEvent::Quit | UserEvent::Replay(Replay::Quit) => {}
+            #[cfg(not(target_arch = "wasm32"))]
+            UserEvent::Exit => {}
             UserEvent::Picture(bytes) => {
                 if let Err(error) = self.insert_picture(bytes, None) {
                     eprintln!("{error}");
 @@ -5607,35 +5676,44 @@ impl State {
 #[cfg(not(target_arch = "wasm32"))]
 impl App {
     fn close(&self, event_loop: &ActiveEventLoop) {
-        if self.state.as_ref().is_none_or(|state| {
+        let Some(state) = self.state.as_ref().filter(|state| {
             let editor = &state.view.editor;
-            state.session.is_some()
+            let unchanged = editor.caret_outline().is_none_or(TextOutline::is_empty)
-                || editor.caret_outline().is_none_or(TextOutline::is_empty)
+                && state.initial_date == editor.date().map(|date| date.timestamp())
-                    && state.initial_date == editor.date().map(|date| date.timestamp())
+                && state
-                    && state
+                    .initial_layouts
-                        .initial_layouts
+                    .iter()
-                        .iter()
+                    .map(|(id, layout)| (*id, layout))
-                        .map(|(id, layout)| (*id, layout))
+                    .eq(editor.object_layouts())
-                        .eq(editor.object_layouts())
+                && state
-                    && state
+                    .initial
-                        .initial
+                    .iter()
+                    .map(|(id, document)| (id, document))
+                    .eq(editor
+                        .outlines()
                         .iter()
-                        .map(|(id, document)| (id, document))
+                        .map(|outline| (&outline.id, outline.document())));
-                        .eq(editor
+            state.session.is_none() && !unchanged
-                            .outlines()
+        }) else {
-                            .iter()
+            return self.exit(event_loop);
-                            .map(|outline| (&outline.id, outline.document())))
+        };
-        }) || platform::confirm(
+        platform::confirm(
             "Discard this page?",
             "This temporary page has no saved copy. Closing it will discard your edits.",
             "Keep Editing",
             "Discard Changes",
-        ) {
+            state.reply(|state, ()| {
-            if let Some(state) = &self.state {
+                let _ = state.proxy.send_event(UserEvent::Exit);
-                state.publish_now(QUIT_PUBLISH);
+                Ok(())
-            }
+            }),
-            event_loop.exit();
+        );
+    }
+    fn exit(&self, event_loop: &ActiveEventLoop) {
+        if let Some(state) = &self.state {
+            state.publish_now(QUIT_PUBLISH);
         }
+        event_loop.exit();
     }
 }
 @@ -5658,6 +5736,7 @@ impl ApplicationHandler<UserEvent> for App {
         };
         match event {
             UserEvent::Quit | UserEvent::Replay(Replay::Quit) => self.close(event_loop),
+            UserEvent::Exit => self.exit(event_loop),
             event => state.user_event(event),
         }
     }
 @@ -5996,14 +6075,6 @@ fn main() -> Result<(), Box<dyn Error>> {
     }
     #[cfg(target_os = "linux")]
     loader::preload();
-    // Before the crash log, which the app showing the dialog keeps writing.
-    #[cfg(target_os = "linux")]
-    if std::env::args_os()
-        .nth(1)
-        .is_some_and(|arg| arg == dialog::DIALOG)
-    {
-        return dialog::run(std::env::args_os().skip(2));
-    }
     platform::with_pool(launch)
 }

crates/snowbound/src/manage.rs+9-7

...	@@ -261,14 +261,16 @@ impl State {	...	@@ -261,14 +261,16 @@ impl State {
261		261
262	/// Asks where to create a notebook and creates it, as File, New does in OneNote; the	262	/// Asks where to create a notebook and creates it, as File, New does in OneNote; the
263	/// panel starts in iCloud Drive, as Notes keeps notes there.	263	/// panel starts in iCloud Drive, as Notes keeps notes there.
264	pub(crate) fn new_notebook(&mut self) -> Result<(), Box<dyn Error>> {	264	pub(crate) fn new_notebook(&mut self) {
265	let icloud = crate::icloud::folder().or_else(crate::icloud::drive);	265	let icloud = crate::icloud::folder().or_else(crate::icloud::drive);
266	let Some(root) =	266	let reply = self.reply(\|state, root\| state.create_notebook(root));
267	platform::pick_new("New Notebook", "My Notebook", "Create", icloud.as_deref())	267	platform::pick_new(
268	else {	268	"New Notebook",
269	return Ok(());	269	"My Notebook",
270	};	270	"Create",
271	self.create_notebook(root)	271	icloud.as_deref(),
		272	reply,
		273	);
272	}	274	}
273		275
274	/// New iCloud Notebook: asks for a name, the first free of "iCloud Notebook", "iCloud	276	/// New iCloud Notebook: asks for a name, the first free of "iCloud Notebook", "iCloud

crates/snowbound/src/menus.rs+40-16

 @@ -649,24 +649,45 @@ impl State {
                 });
                 None
             }
-            (Target::Section { library, path }, Action::Delete) => platform::confirm(
+            (Target::Section { library, path }, Action::Delete) => {
-                "Are you sure you want to move this section to this notebook's Recycle Bin?",
+                platform::confirm(
-                &path,
+                    "Are you sure you want to move this section to this notebook's Recycle Bin?",
-                "Cancel",
+                    &path.clone(),
-                "Delete",
+                    "Cancel",
-            )
+                    "Delete",
-            .then(|| Command::Structure(library, Structure::Delete { path })),
+                    self.reply(|state, ()| {
-            (Target::Group { library, path }, Action::Delete) => platform::confirm(
+                        let change = Structure::Delete { path };
-                "Are you sure you want to move the sections in this section group to this notebook's Recycle Bin?",
+                        state.commands.push(Command::Structure(library, change));
-                path.rsplit('/').next().unwrap_or_default(),
+                        Ok(())
-                "Cancel",
+                    }),
-                "Delete",
+                );
-            )
+                None
-            .then(|| Command::Structure(library, Structure::Delete { path })),
+            }
+            (Target::Group { library, path }, Action::Delete) => {
+                platform::confirm(
+                    "Are you sure you want to move the sections in this section group to this notebook's Recycle Bin?",
+                    path.rsplit('/')
+                        .next()
+                        .unwrap_or_default()
+                        .to_owned()
+                        .as_str(),
+                    "Cancel",
+                    "Delete",
+                    self.reply(|state, ()| {
+                        let change = Structure::Delete { path };
+                        state.commands.push(Command::Structure(library, change));
+                        Ok(())
+                    }),
+                );
+                None
+            }
             (
                 Target::Section { library, path } | Target::Group { library, path },
                 Action::MoveTo(folder),
-            ) => Some(Command::Structure(library, Structure::Move { path, folder })),
+            ) => Some(Command::Structure(
+                library,
+                Structure::Move { path, folder },
+            )),
             (Target::Section { library, path }, Action::Theme) => {
                 if let Some(identity) = library.section_identity(&path) {
                     let scope = notebook::sidecar::themes::Scope::section(identity);
 @@ -710,7 +731,10 @@ impl State {
                 {
                     session.section.wake();
                 }
-                library.background.iter().for_each(|background| background.wake());
+                library
+                    .background
+                    .iter()
+                    .for_each(|background| background.wake());
                 None
             }
             (Target::Notebook(library), Action::CopyLink) => {

crates/snowbound/src/options.rs+1-1

...	@@ -871,7 +871,7 @@ fn installed(state: &mut State, _: &mut Options) {	...	@@ -871,7 +871,7 @@ fn installed(state: &mut State, _: &mut Options) {
871	if crate::desktop::uninstallable() {	871	if crate::desktop::uninstallable() {
872	path(ui, &crate::desktop::binary().unwrap_or_default());	872	path(ui, &crate::desktop::binary().unwrap_or_default());
873	if ui::button(ui, "uninstall", "Uninstall…").clicked {	873	if ui::button(ui, "uninstall", "Uninstall…").clicked {
874	crate::desktop::uninstall();	874	crate::desktop::uninstall(&state.proxy);
875	}	875	}
876	} else if crate::desktop::installable() {	876	} else if crate::desktop::installable() {
877	path(ui, std::path::Path::new("Not in the app menu"));	877	path(ui, std::path::Path::new("Not in the app menu"));

crates/snowbound/src/print.rs+14-13

 @@ -308,18 +308,6 @@ impl State {
             Scope::Section => tab.name.clone(),
             Scope::Notebook => session.library.name.clone(),
         };
-        let destination = if export {
-            let name = format!("{}.pdf", file_name(&title));
-            let Some(mut path) = platform::pick_new("Export as PDF", &name, "Export", None) else {
-                return Ok(());
-            };
-            if path.extension().is_none() {
-                path.set_extension("pdf");
-            }
-            Some(path)
-        } else {
-            None
-        };
         // Other sections are opened on the thread, in the notebook's order.
         let others = match setup.scope {
             Scope::Notebook => notebook_tabs(&session.library),
 @@ -343,7 +331,8 @@ impl State {
             footer: setup.footer,
         };
         let whole = matches!(setup.scope, Scope::Section | Scope::Notebook);
-        crate::spawn(move || {
+        let name = format!("{}.pdf", file_name(&title));
+        let print = move |destination: Option<std::path::PathBuf>| {
             let made = (|| -> Result<Vec<u8>, Box<dyn Error>> {
                 let mut open = Some(open);
                 let this = spaces
 @@ -399,7 +388,19 @@ impl State {
                 }
                 .inspect_err(|error| platform::alert(failed, &error.to_string()))
             })));
+        };
+        if !export {
+            crate::spawn(move || print(None));
+            return Ok(());
+        }
+        let reply = self.reply(|_, mut path: std::path::PathBuf| {
+            if path.extension().is_none() {
+                path.set_extension("pdf");
+            }
+            crate::spawn(move || print(Some(path)));
+            Ok(())
         });
+        platform::pick_new("Export as PDF", &name, "Export", None, reply);
         Ok(())
     }
 }

crates/snowbound/src/recycle.rs+35-16

 @@ -65,35 +65,54 @@ impl State {
     /// Empty Recycle Bin on `library`, once confirmed as OneNote asks.
     pub(crate) fn empty_recycle_bin(&mut self, library: Arc<Library>) {
-        if crate::platform::confirm(
+        crate::platform::confirm(
             "Are you sure you want to empty the Recycle Bin for this notebook?",
             "Its pages and sections are deleted for good.",
             "Cancel",
             "Empty Recycle Bin",
-        ) {
+            self.reply(|state, ()| {
-            let change = crate::manage::Structure::EmptyRecycleBin;
+                let change = crate::manage::Structure::EmptyRecycleBin;
-            self.commands.push(Command::Structure(library, change));
+                state.commands.push(Command::Structure(library, change));
-        }
+                Ok(())
+            }),
+        );
+    }
+    /// Does `request` to the bin's open section, a purge once confirmed.
+    pub(crate) fn recycle(&mut self, request: Request) -> Result<(), Box<dyn Error>> {
+        let Request::Purge(spaces) = &request else {
+            return self.recycle_now(request);
+        };
+        let spaces = spaces.clone();
+        crate::platform::confirm(
+            "Are you sure you want to delete this page for good?",
+            "It can't be restored.",
+            "Cancel",
+            "Delete",
+            self.reply(move |state, ()| {
+                // The pages asked about, unless their section closed meanwhile.
+                let open = state.session.as_ref().is_some_and(|session| {
+                    (spaces.iter())
+                        .all(|space| session.pages.iter().any(|(page, ..)| page == space))
+                });
+                if open {
+                    state.recycle_now(request)
+                } else {
+                    Ok(())
+                }
+            }),
+        );
+        Ok(())
     }
     /// Does `request` to the bin's open section on a thread of its own, then shows the page
     /// after the ones gone, or the notebook once the section holds none.
-    pub(crate) fn recycle(&mut self, request: Request) -> Result<(), Box<dyn Error>> {
+    fn recycle_now(&mut self, request: Request) -> Result<(), Box<dyn Error>> {
         let gone = match &request {
             Request::Restore { copy: true, .. } => Vec::new(),
             Request::Restore { space, .. } => vec![*space],
             Request::Purge(spaces) => spaces.clone(),
         };
-        if matches!(request, Request::Purge(_))
-            && !crate::platform::confirm(
-                "Are you sure you want to delete this page for good?",
-                "It can't be restored.",
-                "Cancel",
-                "Delete",
-            )
-        {
-            return Ok(());
-        }
         let session = self.session.as_ref().ok_or("No section is open")?;
         let replica = Arc::clone(session.section.replica());
         let library = Arc::clone(&session.library);

crates/snowbound/src/save_as.rs+42-41

...	@@ -175,54 +175,55 @@ impl State {	...	@@ -175,54 +175,55 @@ impl State {
175	Scope::Notebook => library.name.clone(),	175	Scope::Notebook => library.name.clone(),
176	};	176	};
177	let name = format!("{}.{extension}", print::file_name(&title));	177	let name = format!("{}.{extension}", print::file_name(&title));
178	let Some(mut path) = platform::pick_new("Save As", &name, "Save", None) else {
179	return Ok(());
180	};
181	if path.extension().is_none() {
182	path.set_extension(extension);
183	}
184	let (scope, author, proxy) = (dialog.scope, self.author.clone(), self.proxy.clone());	178	let (scope, author, proxy) = (dialog.scope, self.author.clone(), self.proxy.clone());
185	let color = (library	179	let color = (library
186	.tabs(crate::menus::folder(&section).as_str())	180	.tabs(crate::menus::folder(&section).as_str())
187	.into_iter())	181	.into_iter())
188	.find(\|tab\| tab.path == section)	182	.find(\|tab\| tab.path == section)
189	.and_then(\|tab\| tab.color);	183	.and_then(\|tab\| tab.color);
190	crate::spawn(move \|\| {	184	let reply = self.reply(move \|_, mut path: std::path::PathBuf\| {
191	let written = (\|\| -> Result<(), Box<dyn Error>> {	185	if path.extension().is_none() {
192	let image = \|path: &str\| {	186	path.set_extension(extension);
193	let (_, replica, _) = open.as_ref().filter(\|(open, ..)\| open == path)?;	187	}
194	replica.snapshot().ok()	188	crate::spawn(move \|\| {
195	};	189	let written = (\|\| -> Result<(), Box<dyn Error>> {
196	let bytes = match scope {	190	let image = \|path: &str\| {
197	Scope::Page => {	191	let (_, replica, _) = open.as_ref().filter(\|(open, ..)\| open == path)?;
198	let (_, replica, space) = open.as_ref().ok_or("No page is open")?;	192	replica.snapshot().ok()
199	let page = replica.page(*space)?;	193	};
200	let file = file_name(&path);	194	let bytes = match scope {
201	package::page_section(&page, &file, color, &author)?	195	Scope::Page => {
202	}	196	let (_, replica, space) = open.as_ref().ok_or("No page is open")?;
203	Scope::Section => {	197	let page = replica.page(*space)?;
204	let stored = match image(&section) {	198	let file = file_name(&path);
205	Some(image) => image,	199	package::page_section(&page, &file, color, &author)?
206	None => library.reopen()?.read_section(&section)?,	200	}
207	};	201	Scope::Section => {
208	package::section_copy(stored)?	202	let stored = match image(&section) {
209	}	203	Some(image) => image,
210	Scope::Notebook => {	204	None => library.reopen()?.read_section(&section)?,
211	let notebook = library.reopen()?;	205	};
212	package::pack(package::notebook_files(&notebook, image)?)?	206	package::section_copy(stored)?
213	}	207	}
214	};	208	Scope::Notebook => {
215	notebook::fs::write(&path, bytes)?;	209	let notebook = library.reopen()?;
216	Ok(())	210	package::pack(package::notebook_files(&notebook, image)?)?
217	})();	211	}
218	let written = written.map_err(\|error\| error.to_string());	212	};
219	let _ = proxy.send_event(UserEvent::Then(Box::new(move \|_\| {	213	notebook::fs::write(&path, bytes)?;
220	written.map_err(\|error\| {	214	Ok(())
221	platform::alert("Couldn't save", &error);	215	})();
222	error.into()	216	let written = written.map_err(\|error\| error.to_string());
223	})	217	let _ = proxy.send_event(UserEvent::Then(Box::new(move \|_\| {
224	})));	218	written.map_err(\|error\| {
		219	platform::alert("Couldn't save", &error);
		220	error.into()
		221	})
		222	})));
		223	});
		224	Ok(())
225	});	225	});
		226	platform::pick_new("Save As", &name, "Save", None, reply);
226	Ok(())	227	Ok(())
227	}	228	}
228	}	229	}

crates/snowbound/src/tags.rs+9-3

 @@ -589,12 +589,18 @@ impl State {
     /// Asks for a picture, a PNG or SVG, for the tag New Tag or Modify Tag edits, which then
     /// draws with it; OneNote shows the tag's symbol, or a blue circle where it has none.
     pub(crate) fn pick_tag_picture(&mut self) {
+        let reply = self.reply(|state, path| {
+            state.use_tag_picture(path);
+            Ok(())
+        });
+        platform::pick_file("Custom Image", &["png", "svg"], reply);
+    }
+    /// Draws the tag New Tag or Modify Tag edits with the picture at `path`, while it does.
+    fn use_tag_picture(&mut self, path: std::path::PathBuf) {
         let Some((tag, _)) = self.tag_list.as_mut().and_then(|list| list.editor.as_mut()) else {
             return;
         };
-        let Some(path) = platform::pick_file("Custom Image", &["png", "svg"]) else {
-            return;
-        };
         let kept = notebook::fs::read(&path)
             .ok()
             .and_then(|bytes| canvas::gpu::import_tag_art(&bytes));

crates/snowbound/src/unpack.rs+19-10

 @@ -172,16 +172,25 @@ impl State {
         let create = ui::button(ui, "create", "Create").clicked || entered;
         ui.close();
         ui.close();
-        if browse
+        if browse {
-            && let Some(chosen) =
+            let reply = crate::Reply::new(&self.proxy, |state, chosen: PathBuf| {
-                platform::pick_new(TITLE, dialog.name.trim(), "Choose", Some(&dialog.folder))
+                if let Some(dialog) = &mut state.unpacking {
-        {
+                    if let Some(name) = chosen.file_name() {
-            if let Some(name) = chosen.file_name() {
+                        dialog.name = name.to_string_lossy().into_owned();
-                dialog.name = name.to_string_lossy().into_owned();
+                    }
-            }
+                    if let Some(parent) = chosen.parent() {
-            if let Some(parent) = chosen.parent() {
+                        dialog.folder = parent.to_owned();
-                dialog.folder = parent.to_owned();
+                    }
-            }
+                }
+                Ok(())
+            });
+            platform::pick_new(
+                TITLE,
+                dialog.name.trim(),
+                "Choose",
+                Some(&dialog.folder),
+                reply,
+            );
         }
         let name = dialog.name.trim();
         let valid =

crates/snowbound/src/update.rs+25-25

...	@@ -642,32 +642,32 @@ impl State {	...	@@ -642,32 +642,32 @@ impl State {
642	return;	642	return;
643	};	643	};
644	match status {	644	match status {
645	Status::Ready(version, _, changes) => {	645	Status::Ready(version, _, changes) => platform::confirm(
646	if platform::confirm(	646	"Update ready",
647	"Update ready",	647	&described(
648	&described(	648	format!("Snowbound {version} is ready to install."),
649	format!("Snowbound {version} is ready to install."),	649	&changes,
650	&changes,	650	),
651	),	651	"Later",
652	"Later",	652	"Restart to Update",
653	"Restart to Update",	653	self.reply(\|state, ()\| {
654	) {	654	state.restart_to_update();
655	self.restart_to_update();	655	Ok(())
656	}	656	}),
657	}	657	),
658	Status::Available(version, changes) => {	658	Status::Available(version, changes) => platform::confirm(
659	if platform::confirm(	659	"Update available",
660	"Update available",	660	&described(
661	&described(	661	format!("Download Snowbound {version} from its build folder."),
662	format!("Download Snowbound {version} from its build folder."),	662	&changes,
663	&changes,	663	),
664	),	664	"Later",
665	"Later",	665	"Open Build Folder",
666	"Open Build Folder",	666	self.reply(move \|_, ()\| {
667	) {
668	show_build(&version);	667	show_build(&version);
669	}	668	Ok(())
670	}	669	}),
		670	),
671	Status::UpToDate => platform::alert(	671	Status::UpToDate => platform::alert(
672	"Snowbound is up to date",	672	"Snowbound is up to date",
673	&format!("You have {}.", describe_running()),	673	&format!("You have {}.", describe_running()),

crates/snowbound/src/web.rs+61-30

 @@ -3,7 +3,7 @@
 //! event loop are stand-ins with the calls `State` makes of winit's; menus are the kit's own,
 //! as on Linux; the browser's chords stay the browser's. See arc/platforms.md.
-use crate::{State, UserEvent, commands, page, settings};
+use crate::{Reply, State, UserEvent, commands, page, settings};
 use canvas::date::DateField;
 use std::{
     cell::{Cell, RefCell},
 @@ -60,12 +60,14 @@ extern "C" {
     fn date_strings(ms: f64) -> Vec<String>;
     #[wasm_bindgen(js_name = shortDate)]
     fn short_date_string(ms: f64) -> String;
+    /// Resolves to whether the user chose `action` over `cancel`.
     #[wasm_bindgen(js_name = askConfirm)]
-    fn ask_confirm(message: &str) -> bool;
+    fn ask_confirm(message: &str, detail: &str, cancel: &str, action: &str) -> js_sys::Promise;
+    /// Resolves to the text the user enters, starting as `value`; undefined when cancelled.
     #[wasm_bindgen(js_name = askText)]
-    fn ask_text(message: &str, value: &str) -> Option<String>;
+    fn ask_text(message: &str, value: &str) -> js_sys::Promise;
     #[wasm_bindgen(js_name = tell)]
-    fn tell(message: &str);
+    fn tell(message: &str, detail: &str);
     #[wasm_bindgen(js_name = openLink)]
     fn open_link(url: &str);
     /// Writes changes out: `[path]` removed, `[path, null]` a folder, and `[path, length,
 @@ -644,14 +646,23 @@ pub fn date_text(filetime: u64) -> [String; 2] {
     ]
 }
+/// Runs `then` with what the glue's dialog resolves `asked` to, once the user answers.
+fn answered(asked: js_sys::Promise, then: impl FnOnce(JsValue) + 'static) {
+    wasm_bindgen_futures::spawn_local(async move {
+        if let Ok(answer) = wasm_bindgen_futures::JsFuture::from(asked).await {
+            then(answer);
+        }
+    });
+}
 /// Asks for the page's date as `YYYY-MM-DD`, or its time as `HH:MM`.
 pub fn edit_date(
     timestamp: u64,
     field: DateField,
     title: &str,
-) -> Result<Option<(u64, [String; 2])>, &'static str> {
+    reply: Reply<Result<(u64, [String; 2]), &'static str>>,
-    let ms = unix_ms(timestamp);
+) {
-    let date = js_sys::Date::new(&ms.into());
+    let date = js_sys::Date::new(&unix_ms(timestamp).into());
     let current = match field {
         DateField::Date => format!(
             "{:04}-{:02}-{:02}",
 @@ -661,9 +672,20 @@ pub fn edit_date(
         ),
         DateField::Time => format!("{:02}:{:02}", date.get_hours(), date.get_minutes()),
     };
-    let Some(answer) = ask_text(title, &current) else {
+    answered(ask_text(title, &current), move |answer| {
-        return Ok(None);
+        if let Some(answer) = answer.as_string() {
-    };
+            reply.send(changed_date(timestamp, field, &answer));
+        }
+    });
+}
+/// `timestamp` with `field` changed to what the user typed, `answer`.
+fn changed_date(
+    timestamp: u64,
+    field: DateField,
+    answer: &str,
+) -> Result<(u64, [String; 2]), &'static str> {
+    let date = js_sys::Date::new(&unix_ms(timestamp).into());
     let numbers: Vec<u32> = answer
         .split(|c: char| !c.is_ascii_digit())
         .filter(|part| !part.is_empty())
 @@ -686,44 +708,53 @@ pub fn edit_date(
         .checked_mul(10_000_000)
         .and_then(|ticks| ticks.checked_add(timestamp % 10_000_000))
         .ok_or(crate::DATE_OUT_OF_RANGE)?;
-    Ok(Some((updated, date_text(updated))))
+    Ok((updated, date_text(updated)))
 }
 /// Asks for a file to insert; once chosen it goes to the caret, as a dropped file does.
-pub fn pick_file(_: &str, types: &[&str]) -> Option<PathBuf> {
+pub fn pick_file(_: &str, types: &[&str], _: Reply<PathBuf>) {
     let accept: Vec<String> = types.iter().map(|kind| format!(".{kind}")).collect();
     pick_files("place", &accept.join(","));
-    None
 }
 /// Asks for notebooks, sections or packages to open; they open once read.
-pub fn pick_notebook(_: &str) -> Option<PathBuf> {
+pub fn pick_notebook(_: &str, _: Reply<PathBuf>) {
     pick_notebook_files();
-    None
 }
 /// A new notebook goes in the browser's notebooks, under a name not yet taken; anything else
 /// asked a place goes there too, then downloads.
-pub fn pick_new(title: &str, name: &str, _: &str, _: Option<&Path>) -> Option<PathBuf> {
+pub fn pick_new(title: &str, name: &str, _: &str, _: Option<&Path>, reply: Reply<PathBuf>) {
-    let name = ask_text(title, name)?;
+    answered(ask_text(title, name), move |answer| {
-    let name = name.trim().replace(['/', '\\'], " ");
+        let Some(name) = answer.as_string() else {
-    let folder = Path::new(NOTEBOOKS);
+            return;
-    let _ = notebook::fs::create_dir_all(folder);
+        };
-    let mut path = folder.join(&name);
+        let name = name.trim().replace(['/', '\\'], " ");
-    let mut number = 2;
+        let folder = Path::new(NOTEBOOKS);
-    while notebook::fs::metadata(&path).is_ok() {
+        let _ = notebook::fs::create_dir_all(folder);
-        path = folder.join(format!("{name} {number}"));
+        let mut path = folder.join(&name);
-        number += 1;
+        let mut number = 2;
-    }
+        while notebook::fs::metadata(&path).is_ok() {
-    Some(path)
+            path = folder.join(format!("{name} {number}"));
+            number += 1;
+        }
+        reply.send(path);
+    });
 }
-pub fn confirm(message: &str, detail: &str, _: &str, _: &str) -> bool {
+pub fn confirm(message: &str, detail: &str, cancel: &str, action: &str, reply: Reply<()>) {
-    ask_confirm(&format!("{message}\n\n{detail}"))
+    answered(
+        ask_confirm(message, detail, cancel, action),
+        move |chosen| {
+            if chosen.is_truthy() {
+                reply.send(());
+            }
+        },
+    );
 }
 pub fn alert(message: &str, detail: &str) {
-    tell(&format!("{message}\n\n{detail}"));
+    tell(message, detail);
 }
 pub fn inform(message: &str, detail: &str) {

crates/snowbound/src/windows.rs+103-121

 @@ -5,6 +5,7 @@
 //! Anything newer than Windows 7 is looked up at run time, so one executable starts on all
 //! of them.
+use crate::Reply;
 use canvas::date::DateField;
 use std::{
     ffi::c_void,
 @@ -1372,8 +1373,8 @@ fn credential_target(mount: &crate::library::Mount) -> Vec<u16> {
     wide(format!("Snowbound/smb/{}", mount.host()))
 }
-/// The password the Credential Manager keeps for `mount`'s server, or what the user types
+/// The password the Credential Manager keeps for `mount`'s server; without one, Snowbound's
-/// into the system's sign-in dialog when it keeps none.
+/// sign-in asks.
 pub fn smb_login(mount: &crate::library::Mount) -> Result<crate::library::Login, String> {
     use windows_sys::Win32::Security::Credentials as cred;
     let target = credential_target(mount);
 @@ -1406,51 +1407,11 @@ pub fn smb_login(mount: &crate::library::Mount) -> Result<crate::library::Login,
             domain: mount.domain.clone(),
         });
     }
-    let caption = wide("Snowbound");
+    Err(format!(
-    let message = wide(format!("Sign in to {}", mount.server));
+        "Enter the password for \u{201c}{}\u{201d} on \u{201c}{}\u{201d}.",
-    let info = cred::CREDUI_INFOW {
+        mount.user.as_deref().unwrap_or_default(),
-        cbSize: size_of::<cred::CREDUI_INFOW>() as u32,
+        mount.host()
-        hwndParent: owner(),
+    ))
-        pszMessageText: message.as_ptr(),
-        pszCaptionText: caption.as_ptr(),
-        hbmBanner: std::ptr::null_mut(),
-    };
-    let mut user = [0u16; cred::CREDUI_MAX_USERNAME_LENGTH as usize + 1];
-    for (slot, unit) in user
-        .iter_mut()
-        .zip(mount.user.clone().unwrap_or_default().encode_utf16())
-    {
-        *slot = unit;
-    }
-    let mut password = [0u16; 257];
-    let mut save: BOOL = 0;
-    let server = wide(&mount.server);
-    let result = unsafe {
-        cred::CredUIPromptForCredentialsW(
-            &info,
-            server.as_ptr(),
-            std::ptr::null_mut(),
-            0,
-            user.as_mut_ptr(),
-            user.len() as u32,
-            password.as_mut_ptr(),
-            password.len() as u32,
-            &mut save,
-            cred::CREDUI_FLAGS_GENERIC_CREDENTIALS
-                | cred::CREDUI_FLAGS_DO_NOT_PERSIST
-                | cred::CREDUI_FLAGS_ALWAYS_SHOW_UI,
-        )
-    };
-    let login = crate::library::Login {
-        user: narrow(&user),
-        password: narrow(&password),
-        domain: mount.domain.clone(),
-    };
-    password.fill(0);
-    match result {
-        0 => Ok(login),
-        _ => Err("Signing in was canceled".to_owned()),
-    }
 }
 /// What the sign-in offers for keeping a password, which the Credential Manager keeps.
 @@ -1613,41 +1574,41 @@ pub fn edit_date(
     timestamp: u64,
     field: DateField,
     title: &str,
-) -> Result<Option<(u64, [String; 2])>, &'static str> {
+    reply: Reply<Result<(u64, [String; 2]), &'static str>>,
-    let before = local_time(timestamp);
+) {
-    let Some(chosen) = picker::pick(&before, field, title) else {
+    let title = title.to_owned();
-        return Ok(None);
+    reply.after(move || {
-    };
+        let before = local_time(timestamp);
-    let mut time = before;
+        let chosen = picker::pick(&before, field, &title)?;
-    match field {
+        let mut time = before;
-        DateField::Date => {
+        match field {
-            (time.wYear, time.wMonth, time.wDay) = (chosen.wYear, chosen.wMonth, chosen.wDay);
+            DateField::Date => {
-        }
+                (time.wYear, time.wMonth, time.wDay) = (chosen.wYear, chosen.wMonth, chosen.wDay);
-        DateField::Time => {
+            }
-            (time.wHour, time.wMinute) = (chosen.wHour, chosen.wMinute);
+            DateField::Time => {
+                (time.wHour, time.wMinute) = (chosen.wHour, chosen.wMinute);
+            }
         }
-    }
+        let updated = filetime(&time).ok_or(crate::DATE_OUT_OF_RANGE);
-    let updated = filetime(&time).ok_or(crate::DATE_OUT_OF_RANGE)?;
+        // FILETIME's sub-second ticks stay as they were.
-    // FILETIME's sub-second ticks stay as they were.
+        Some(updated.map(|updated| {
-    let updated = updated / 10_000_000 * 10_000_000 + timestamp % 10_000_000;
+            let updated = updated / 10_000_000 * 10_000_000 + timestamp % 10_000_000;
-    Ok(Some((updated, date_labels(&local_time(updated)))))
+            (updated, date_labels(&local_time(updated)))
+        }))
+    });
 }
 /// Asks for a notebook's table of contents or a section file, titled `title`.
-pub fn pick_notebook(title: &str) -> Option<PathBuf> {
+pub fn pick_notebook(title: &str, reply: Reply<PathBuf>) {
-    pick(
+    let filter = (
-        title,
+        "OneNote notebooks, sections and packages",
-        &[(
+        "*.onetoc2;*.one;*.onepkg",
-            "OneNote notebooks, sections and packages",
+    );
-            "*.onetoc2;*.one;*.onepkg",
+    pick(title, &[filter], None, false, reply);
-        )],
-        None,
-        false,
-    )
 }
 /// Asks for a file to insert, one of `types` (extensions) unless empty, titled `title`.
-pub fn pick_file(title: &str, types: &[&str]) -> Option<PathBuf> {
+pub fn pick_file(title: &str, types: &[&str], reply: Reply<PathBuf>) {
     let patterns = types
         .iter()
         .map(|kind| format!("*.{kind}"))
 @@ -1658,7 +1619,7 @@ pub fn pick_file(title: &str, types: &[&str]) -> Option<PathBuf> {
     } else {
         vec![("Supported files", patterns.as_str()), ("All files", "*.*")]
     };
-    pick(title, &filters, None, false)
+    pick(title, &filters, None, false, reply);
 }
 /// Asks where to put something named `name` by default; the dialog names its own button.
 @@ -1667,19 +1628,26 @@ pub fn pick_new(
     name: &str,
     _action: &str,
     folder: Option<&std::path::Path>,
-) -> Option<PathBuf> {
+    reply: Reply<PathBuf>,
-    pick(title, &[("All files", "*.*")], Some((name, folder)), true)
+) {
+    pick(
+        title,
+        &[("All files", "*.*")],
+        Some((name, folder)),
+        true,
+        reply,
+    );
 }
-/// The common file dialog: an open dialog over `filters` (name and `;`-separated
+/// The common file dialog, on a thread of its own: an open dialog over `filters` (name and
-/// patterns), or with `new`, a save dialog suggesting a name in a folder.
+/// `;`-separated patterns), or with `new`, a save dialog suggesting a name in a folder.
 fn pick(
     title: &str,
     filters: &[(&str, &str)],
     new: Option<(&str, Option<&std::path::Path>)>,
     save: bool,
-) -> Option<PathBuf> {
+    reply: Reply<PathBuf>,
-    use windows_sys::Win32::UI::Controls::Dialogs as dialogs;
+) {
     let mut filter: Vec<u16> = Vec::new();
     for (name, patterns) in filters {
         filter.extend(name.encode_utf16().chain([0]));
 @@ -1694,54 +1662,68 @@ fn pick(
     }
     let folder = new.and_then(|(_, folder)| folder).map(wide);
     let title = wide(title);
-    let mut dialog = dialogs::OPENFILENAMEW {
+    reply.after(move || {
-        lStructSize: size_of::<dialogs::OPENFILENAMEW>() as u32,
+        use windows_sys::Win32::{System::Com, UI::Controls::Dialogs as dialogs};
-        hwndOwner: owner(),
+        let mut dialog = dialogs::OPENFILENAMEW {
-        lpstrFilter: filter.as_ptr(),
+            lStructSize: size_of::<dialogs::OPENFILENAMEW>() as u32,
-        lpstrFile: file.as_mut_ptr(),
+            hwndOwner: owner(),
-        nMaxFile: file.len() as u32,
+            lpstrFilter: filter.as_ptr(),
-        lpstrTitle: title.as_ptr(),
+            lpstrFile: file.as_mut_ptr(),
-        lpstrInitialDir: folder
+            nMaxFile: file.len() as u32,
-            .as_ref()
+            lpstrTitle: title.as_ptr(),
-            .map_or(std::ptr::null(), |folder| folder.as_ptr()),
+            lpstrInitialDir: folder
-        Flags: dialogs::OFN_EXPLORER
+                .as_ref()
-            | dialogs::OFN_NOCHANGEDIR
+                .map_or(std::ptr::null(), |folder| folder.as_ptr()),
-            | if save {
+            Flags: dialogs::OFN_EXPLORER
-                dialogs::OFN_OVERWRITEPROMPT
+                | dialogs::OFN_NOCHANGEDIR
+                | if save {
+                    dialogs::OFN_OVERWRITEPROMPT
+                } else {
+                    dialogs::OFN_FILEMUSTEXIST
+                },
+            ..unsafe { std::mem::zeroed() }
+        };
+        // The Explorer-style dialog hosts the shell's COM objects, which want an apartment.
+        unsafe { Com::CoInitializeEx(std::ptr::null(), Com::COINIT_APARTMENTTHREADED as u32) };
+        let chosen = unsafe {
+            if save {
+                dialogs::GetSaveFileNameW(&mut dialog)
             } else {
-                dialogs::OFN_FILEMUSTEXIST
+                dialogs::GetOpenFileNameW(&mut dialog)
-            },
+            }
-        ..unsafe { std::mem::zeroed() }
+        };
-    };
+        unsafe { Com::CoUninitialize() };
-    let chosen = unsafe {
+        if chosen == 0 {
-        if save {
+            // Zero where the user cancelled.
-            dialogs::GetSaveFileNameW(&mut dialog)
+            let error = unsafe { dialogs::CommDlgExtendedError() };
-        } else {
+            if error != 0 {
-            dialogs::GetOpenFileNameW(&mut dialog)
+                eprintln!("The file dialog failed: {error:#x}");
-        }
+            }
-    };
+            return None;
-    if chosen == 0 {
-        // Zero where the user cancelled.
-        let error = unsafe { dialogs::CommDlgExtendedError() };
-        if error != 0 {
-            eprintln!("The file dialog failed: {error:#x}");
         }
-        return None;
+        Some(PathBuf::from(narrow(&file)))
-    }
+    });
-    Some(PathBuf::from(narrow(&file)))
 }
 /// Tells the user something they asked for could not be done: `message`, then what to do.
 pub fn alert(message: &str, detail: &str) {
     let text = wide(format!("{message}\n\n{detail}"));
-    let caption = wide("Snowbound");
+    std::thread::spawn(move || {
-    let style = wm::MB_OK | wm::MB_ICONWARNING;
+        let caption = wide("Snowbound");
-    unsafe { wm::MessageBoxW(owner(), text.as_ptr(), caption.as_ptr(), style) };
+        let style = wm::MB_OK | wm::MB_ICONWARNING;
+        unsafe { wm::MessageBoxW(owner(), text.as_ptr(), caption.as_ptr(), style) };
+    });
+}
+/// Asks whether to go ahead with `action`, offering `cancel` too.
+pub fn confirm(message: &str, detail: &str, cancel: &str, action: &str, reply: Reply<()>) {
+    let [message, detail, cancel, action] = [message, detail, cancel, action].map(str::to_owned);
+    reply.after(move || ask(&message, &detail, &cancel, &action).then_some(()));
 }
-/// Asks whether to go ahead with `action`, offering `cancel` too: a task dialog with those
+/// Whether the user goes ahead with `action`: a task dialog with buttons for it and `cancel`
-/// buttons where the common controls have one, as from Windows Vista, else OK and Cancel.
+/// where the common controls have one, as from Windows Vista, else OK and Cancel.
-pub fn confirm(message: &str, detail: &str, cancel: &str, action: &str) -> bool {
+fn ask(message: &str, detail: &str, cancel: &str, action: &str) -> bool {
     use windows_sys::Win32::UI::Controls as controls;
     type Indirect = unsafe extern "system" fn(
         *const controls::TASKDIALOGCONFIG,

crates/snowbound/web/glue.js+31-5

...	@@ -362,16 +362,42 @@ export function shortDate(ms) {	...	@@ -362,16 +362,42 @@ export function shortDate(ms) {
362	return new Date(ms).toLocaleDateString();	362	return new Date(ms).toLocaleDateString();
363	}	363	}
364		364
365	export function askConfirm(message) {	365	/** Shows `message` and `detail` in a dialog over the page, with a field holding `value`
366	return confirm(message);	366	* unless that is undefined, and `buttons`, the first the default. Resolves to the index of
		367	* the button pressed, -1 when dismissed, and the field's text. */
		368	function ask(message, detail, buttons, value) {
		369	const dialog = Object.assign(document.createElement("dialog"), { className: "ask" });
		370	const form = Object.assign(document.createElement("form"), { method: "dialog" });
		371	const field = value === undefined ? null : Object.assign(document.createElement("input"), { value });
		372	const row = document.createElement("div");
		373	row.append(...buttons.map((label, index) =>
		374	Object.assign(document.createElement("button"), { value: index, textContent: label })));
		375	form.append(...[field, row].filter(Boolean));
		376	dialog.append(Object.assign(document.createElement("h1"), { textContent: message }));
		377	if (detail) dialog.append(Object.assign(document.createElement("p"), { textContent: detail }));
		378	dialog.append(form);
		379	document.body.append(dialog);
		380	dialog.showModal();
		381	return new Promise((resolve) =>
		382	dialog.addEventListener("close", () => {
		383	dialog.remove();
		384	resolve([dialog.returnValue === "" ? -1 : Number(dialog.returnValue), field?.value]);
		385	}),
		386	);
		387	}
		388
		389	export function askConfirm(message, detail, cancel, action) {
		390	return ask(message, detail, [action, cancel]).then(([pressed]) => pressed === 0);
367	}	391	}
368		392
369	export function askText(message, value) {	393	export function askText(message, value) {
370	return prompt(message, value) ?? undefined;	394	return ask(message, "", ["OK", "Cancel"], value).then(([pressed, text]) =>
		395	pressed === 0 ? text : undefined,
		396	);
371	}	397	}
372		398
373	export function tell(message) {	399	export function tell(message, detail) {
374	alert(message);	400	ask(message, detail, ["OK"]);
375	}	401	}
376		402
377	export function openLink(url) {	403	export function openLink(url) {

crates/snowbound/web/index.html+10

...	@@ -23,6 +23,16 @@	...	@@ -23,6 +23,16 @@
23	position: fixed; left: 50%; bottom: 16px; transform: translateX(-50%);	23	position: fixed; left: 50%; bottom: 16px; transform: translateX(-50%);
24	font: 14px system-ui, sans-serif; padding: 6px 14px;	24	font: 14px system-ui, sans-serif; padding: 6px 14px;
25	}	25	}
		26	/* Dialogs (`ask` in glue.js); the default button is first in order and last in the row. */
		27	dialog.ask {
		28	color-scheme: light dark; width: min(420px, 90vw); box-sizing: border-box; padding: 20px;
		29	border: 0; border-radius: 10px; box-shadow: 0 8px 32px #0004; font: 14px system-ui, sans-serif;
		30	}
		31	dialog.ask::backdrop { background: #0002; }
		32	dialog.ask h1 { margin: 0 0 8px; font-size: 15px; }
		33	dialog.ask p { margin: 0; white-space: pre-line; }
		34	dialog.ask input { box-sizing: border-box; width: 100%; font: inherit; }
		35	dialog.ask div { display: flex; flex-direction: row-reverse; gap: 8px; margin-top: 16px; }
26	#status {	36	#status {
27	position: fixed; inset: 0; display: grid; place-items: center;	37	position: fixed; inset: 0; display: grid; place-items: center;
28	font: 15px system-ui, sans-serif; color: #666; pointer-events: none;	38	font: 15px system-ui, sans-serif; color: #666; pointer-events: none;

author	clover caruso <git@paperclover.net> 2026-10-01 23:42:05-07:00
committer	clover caruso <git@paperclover.net> 2026-10-02 01:19:52-07:00
log	42499fefe59cff82e17b0f6ec64b92bf090a6a78
tree	a6df23a2c16090f99be8a85aa3421707efe018a9
parent	a7388496fddd44f7037f7224f6300a31b9a784ea
signature	Signed by SSH key SHA256:52mNGHRsVFBDED9IAX5pe+LRWUefqTbxEReunq21QvU

fix: dialogs never block the window