Commit 1c5ad4e548ef0556a3810f749c2cee0e5e51f289 | snowbound

Cargo.lock+17

 @@ -625,6 +625,7 @@ dependencies = [
  "accesskit_consumer",
  "color_quant",
  "draw",
+ "icu_normalizer",
  "image",
  "onestore",
  "parley",
 @@ -1468,6 +1469,9 @@ dependencies = [
  "icu_properties",
  "icu_provider",
  "smallvec",
+ "utf16_iter",
+ "utf8_iter",
+ "write16",
  "zerovec",
 ]
 @@ -1886,6 +1890,7 @@ dependencies = [
  "pollster",
  "serde",
  "serde_json",
+ "tempfile",
  "wgpu",
 ]
 @@ -3666,6 +3671,12 @@ dependencies = [
  "tiny-skia-path 0.12.0",
 ]
+[[package]]
+name = "utf16_iter"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8232dd3cdaed5356e0f716d285e4b40b932ac434100fe9b7e0e8e935b9e6246"
 [[package]]
 name = "utf8_iter"
 version = "1.0.4"
 @@ -4460,6 +4471,12 @@ version = "0.57.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e"
+[[package]]
+name = "write16"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d1890f4022759daae28ed4fe62859b1236caebfc61ede2f63ed4e695f3f6d936"
 [[package]]
 name = "writeable"
 version = "0.6.4"

crates/canvas/Cargo.toml+1

...	@@ -15,6 +15,7 @@ onestore = { path = "../onestore" }	...	@@ -15,6 +15,7 @@ onestore = { path = "../onestore" }
15	parley.workspace = true	15	parley.workspace = true
16	serde = { version = "1.0.229", features = ["derive"] }	16	serde = { version = "1.0.229", features = ["derive"] }
17	serde_json = "1.0.151"	17	serde_json = "1.0.151"
		18	icu_normalizer = "2.3"
18	skrifa = "0.44.0"	19	skrifa = "0.44.0"
19		20
20	accesskit = { version = "0.25.0", optional = true }	21	accesskit = { version = "0.25.0", optional = true }

crates/canvas/src/conflict.rs created+43

...	@@ -0,0 +1,43 @@
1	//! Conflict pages as OneNote shows them.
2
3	use onestore::{
4	ExGuid,
5	page::{Page, PageObject, PageParagraph, ParagraphContent},
6	};
7
8	/// OneNote's highlight for conflicting changes on a conflict page, COLORREF.
9	pub const CONFLICTING: u32 = 0xd6d6ff;
10
11	/// `page` with its conflict `objects` marked as OneNote shows a conflict page's: a band
12	/// across each conflicting paragraph.
13	pub fn highlighted(mut page: Page, objects: &[ExGuid]) -> Page {
14	fn mark(paragraphs: &mut [PageParagraph], objects: &[ExGuid]) {
15	for paragraph in paragraphs {
16	match &mut paragraph.content {
17	ParagraphContent::Table(table) => {
18	for cell in table.rows.iter_mut().flat_map(\|row\| &mut row.cells) {
19	mark(&mut cell.paragraphs, objects);
20	}
21	}
22	ParagraphContent::Text(text)
23	if objects.contains(&paragraph.id) \|\| objects.contains(&text.id) =>
24	{
25	paragraph.format.highlight = Some(CONFLICTING);
26	}
27	_ => {}
28	}
29	}
30	}
31	for object in &mut page.objects {
32	match object {
33	PageObject::Outline(outline) => mark(&mut outline.paragraphs, objects),
34	PageObject::Title(title) => {
35	for outline in &mut title.outlines {
36	mark(&mut outline.paragraphs, objects);
37	}
38	}
39	_ => {}
40	}
41	}
42	page
43	}

crates/canvas/src/editor.rs+40

...	@@ -1095,6 +1095,11 @@ impl CanvasEditor {	...	@@ -1095,6 +1095,11 @@ impl CanvasEditor {
1095	]	1095	]
1096	}	1096	}
1097		1097
		1098	/// The page's colour (View, Page Color), COLORREF.
		1099	pub fn page_color(&self) -> Option<u32> {
		1100	self.header.color
		1101	}
		1102
1098	/// Where the page's first body line starts, in points, under its title.	1103	/// Where the page's first body line starts, in points, under its title.
1099	pub fn body_start(&self) -> Option<[f32; 2]> {	1104	pub fn body_start(&self) -> Option<[f32; 2]> {
1100	let title = self	1105	let title = self
...	@@ -1759,6 +1764,41 @@ impl CanvasEditor {	...	@@ -1759,6 +1764,41 @@ impl CanvasEditor {
1759	Ok(true)	1764	Ok(true)
1760	}	1765	}
1761		1766
		1767	/// Puts `image` in the active outline's flow after the caret's paragraph, as OneNote
		1768	/// inserts a picture into an outline; the caret stays.
		1769	pub fn insert_picture(
		1770	&mut self,
		1771	engine: &mut TextEngine,
		1772	image: onestore::page::Image,
		1773	) -> Result<(), EditorError> {
		1774	let selection = self.selection();
		1775	let caret = selection.positions[0].max(selection.positions[1]);
		1776	let (container, index, node) = self
		1777	.active_outline()
		1778	.document
		1779	.leaf(caret.paragraph)
		1780	.ok_or(EditError::InvalidRange)?;
		1781	let picture = PageParagraph {
		1782	id: onestore::page::text::new_id()?,
		1783	content: ParagraphContent::Image(image),
		1784	style: None,
		1785	lists: Vec::new(),
		1786	tags: Vec::new(),
		1787	collapsed: false,
		1788	..node.clone()
		1789	};
		1790	self.commit(
		1791	engine,
		1792	DocumentEdit {
		1793	columns: BTreeMap::new(),
		1794	container,
		1795	range: index + 1..index + 1,
		1796	replacement: vec![picture],
		1797	},
		1798	selection,
		1799	)
		1800	}
		1801
1762	pub fn remove_image(&mut self, engine: &mut TextEngine, id: ExGuid) -> Result<(), EditorError> {	1802	pub fn remove_image(&mut self, engine: &mut TextEngine, id: ExGuid) -> Result<(), EditorError> {
1763	if self.outline_picture(id).is_some() {	1803	if self.outline_picture(id).is_some() {
1764	return self.edit_outline_picture(engine, id, None);	1804	return self.edit_outline_picture(engine, id, None);

crates/canvas/src/gpu/mod.rs+34

...	@@ -52,6 +52,20 @@ impl Paper {	...	@@ -52,6 +52,20 @@ impl Paper {
52	ink: [0.0, 0.0, 0.0, 1.0],	52	ink: [0.0, 0.0, 0.0, 1.0],
53	};	53	};
54		54
		55	/// This paper under a page coloured `color` (COLORREF, OneNote's View, Page Color): the
		56	/// colour as OneNote paints it on white paper, moved onto this paper as a fill is, so
		57	/// dark paper takes the colour's hue at its own depth. Text keeps its ink; template art
		58	/// lies over the colour.
		59	pub fn colored(self, color: Option<u32>) -> Self {
		60	match color {
		61	Some(color) => Self {
		62	color: self.tint(colorref(color)),
		63	..self
		64	},
		65	None => self,
		66	}
		67	}
		68
55	/// A fill OneNote draws on white paper, moved onto this paper: as far from it in	69	/// A fill OneNote draws on white paper, moved onto this paper: as far from it in
56	/// OKLab lightness as from white, in the same hue and chroma, so text keeps its	70	/// OKLab lightness as from white, in the same hue and chroma, so text keeps its
57	/// contrast on it.	71	/// contrast on it.
...	@@ -171,6 +185,26 @@ mod tests {	...	@@ -171,6 +185,26 @@ mod tests {
171	use onestore::page::text::Paragraph;	185	use onestore::page::text::Paragraph;
172	use std::time::Duration;	186	use std::time::Duration;
173		187
		188	/// A page colour paints as OneNote paints it on white paper, and on dark paper as a
		189	/// dark paper of its hue; no colour leaves the paper as it was.
		190	#[test]
		191	fn page_colours_colour_the_paper() {
		192	let teal = 0x00f2f9d4;
		193	assert_eq!(Paper::WHITE.colored(Some(teal)).color.map(\|c\| (c * 1000.0).round()), colorref(teal).map(\|c\| (c * 1000.0).round()));
		194	let dark = Paper {
		195	color: draw::srgb(0x1f, 0x20, 0x22),
		196	ink: draw::srgb(0xe6, 0xe6, 0xe6),
		197	};
		198	let colored = dark.colored(Some(teal));
		199	let [lightness, a, b] = draw::oklab(colored.color);
		200	let [paper, ..] = draw::oklab(dark.color);
		201	let [_, ta, tb] = draw::oklab(colorref(teal));
		202	assert!(lightness > paper && lightness < 0.5);
		203	assert!((a - ta).abs() < 1e-3 && (b - tb).abs() < 1e-3);
		204	assert_eq!(colored.ink, dark.ink);
		205	assert_eq!(dark.colored(None).color, dark.color);
		206	}
		207
174	#[test]	208	#[test]
175	fn runs_carry_their_highlight_as_what_lies_behind_them() {	209	fn runs_carry_their_highlight_as_what_lies_behind_them() {
176	let run = \|highlight, color\| {	210	let run = \|highlight, color\| {

crates/canvas/src/interaction/mod.rs+25-6

 @@ -199,6 +199,9 @@ pub struct PageView {
     /// Input is by finger: the focused outline's grips reach further, and outline chrome
     /// shows only while the view is focused, as there is no hover to reveal it.
     pub touch: bool,
+    /// A platform scroll view owns the viewport: changes neither clamp it nor reveal the
+    /// caret, which the host does knowing its bars and keyboard.
+    pub host_viewport: bool,
     /// The caret's opacity in its blink.
     caret: f32,
     /// When the caret last moved, which restarts its blink.
 @@ -256,6 +259,7 @@ impl PageView {
             modifiers: Modifiers::default(),
             focused: true,
             touch: false,
+            host_viewport: false,
             caret: 1.0,
             blink_from: Instant::now(),
         };
 @@ -403,7 +407,12 @@ impl PageView {
     fn hit_test(&self, point: [f32; 2]) -> Option<Hit> {
         if let Some(ObjectFocus::Image(id)) = self.object_focus
             && let Some((origin, size)) = self.editor.image_placement(id)
-            && let Some(handle) = image_handle_at(image_rect(origin, size), self.pixel(), point)
+            && let Some(handle) = image_handle_at(
+                image_rect(origin, size),
+                self.pixel(),
+                point,
+                if self.touch { TOUCH_REACH } else { 0.0 },
+            )
         {
             return Some(Hit::Image { id, handle });
         }
 @@ -456,14 +465,18 @@ impl PageView {
     /// Keeps the view in bounds and restarts the caret blink after a change.
     fn changed(&mut self) -> Result<Response> {
-        self.scroll().clamp(&mut self.viewport);
+        if !self.host_viewport {
+            self.scroll().clamp(&mut self.viewport);
+        }
         self.caret = 1.0;
         self.blink_from = Instant::now();
         Ok(Response::changed())
     }
     fn moved(&mut self) -> Result<Response> {
-        self.scroll().clamp(&mut self.viewport);
+        if !self.host_viewport {
+            self.scroll().clamp(&mut self.viewport);
+        }
         Ok(Response {
             moved: true,
             redraw: true,
 @@ -563,7 +576,9 @@ impl PageView {
     /// Reveals the caret or focused object after an edit, then reports the change.
     fn edited(&mut self) -> Result<Response> {
-        self.reveal_focus()?;
+        if !self.host_viewport {
+            self.reveal_focus()?;
+        }
         self.changed()
     }
 @@ -1641,9 +1656,13 @@ fn image_handles(rect: [f32; 4], pixel: f32) -> impl Iterator<Item = ([i8; 2], [
         })
 }
-fn image_handle_at(rect: [f32; 4], pixel: f32, point: [f32; 2]) -> Option<[i8; 2]> {
+/// The handle of a picture at `rect` under `point`, each reaching `reach` pixels beyond its
+/// drawn square.
+fn image_handle_at(rect: [f32; 4], pixel: f32, point: [f32; 2], reach: f32) -> Option<[i8; 2]> {
     image_handles(rect, pixel)
-        .find(|(_, center)| (0..2).all(|axis| (point[axis] - center[axis]).abs() <= 5.0 * pixel))
+        .find(|(_, center)| {
+            (0..2).all(|axis| (point[axis] - center[axis]).abs() <= (5.0 + reach) * pixel)
+        })
         .map(|(handle, _)| handle)
 }

crates/canvas/src/interaction/tests.rs+3-3

...	@@ -691,14 +691,14 @@ fn picture_handles_resize_as_onenote_does() {	...	@@ -691,14 +691,14 @@ fn picture_handles_resize_as_onenote_does() {
691	let pixel = 0.75;	691	let pixel = 0.75;
692	let rect = image_rect(origin, size);	692	let rect = image_rect(origin, size);
693	assert_eq!(	693	assert_eq!(
694	image_handle_at(rect, pixel, [468.0 - 3.75, 86.4 - 3.75]),	694	image_handle_at(rect, pixel, [468.0 - 3.75, 86.4 - 3.75], 0.0),
695	Some([-1, -1])	695	Some([-1, -1])
696	);	696	);
697	assert_eq!(	697	assert_eq!(
698	image_handle_at(rect, pixel, [468.0 + 166.5, 286.5 + 3.75]),	698	image_handle_at(rect, pixel, [468.0 + 166.5, 286.5 + 3.75], 0.0),
699	Some([0, 1])	699	Some([0, 1])
700	);	700	);
701	assert_eq!(image_handle_at(rect, pixel, [600.0, 150.0]), None);	701	assert_eq!(image_handle_at(rect, pixel, [600.0, 150.0], 0.0), None);
702	}	702	}
703		703
704	const DEFAULT_MARGIN: [f32; 2] = [36.0, 14.4];	704	const DEFAULT_MARGIN: [f32; 2] = [36.0, 14.4];

crates/canvas/src/lib.rs+2

 @@ -1,9 +1,11 @@
+pub mod conflict;
 pub mod document;
 pub mod editor;
 pub mod language;
 pub mod layout;
 pub mod math;
 pub mod outline;
+pub mod search;
 pub mod template;
 pub mod date;

crates/canvas/src/search.rs created+417

...	@@ -0,0 +1,417 @@
1	//! Search as OneNote 2010 searches: each query word matches the start of a word, ignoring
2	//! case and diacritics; a page matches when all its words appear in its title or text, and
3	//! pages whose titles hold every word come first, then the most recently modified.
4
5	use crate::document::TextPosition;
6	use crate::editor::{CanvasEditor, Selection};
7	use icu_normalizer::DecomposingNormalizerBorrowed;
8	use onestore::ExGuid;
9	use onestore::page::{Page, PageObject, PageParagraph, ParagraphContent, text::Paragraph};
10	use std::ops::Range;
11
12	/// Characters around a hit a snippet shows before it, and in all.
13	const BEFORE: usize = 24;
14	const SNIPPET: usize = 90;
15
16	/// A query's words, lowered and stripped of diacritics; a quoted phrase is one word.
17	#[derive(Clone, Debug, Default, PartialEq)]
18	pub struct Query {
19	terms: Vec<String>,
20	}
21
22	impl Query {
23	pub fn new(text: &str) -> Self {
24	let mut terms = Vec::new();
25	for (index, part) in text.split('"').enumerate() {
26	if index % 2 == 1 {
27	terms.push(fold(part).split_whitespace().collect::<Vec<_>>().join(" "));
28	} else {
29	terms.extend(fold(part).split_whitespace().map(str::to_owned));
30	}
31	}
32	terms.retain(\|term\| !term.is_empty());
33	Self { terms }
34	}
35
36	pub fn is_empty(&self) -> bool {
37	self.terms.is_empty()
38	}
39
40	/// Where the words start words of `folded`, as `fold` leaves text, in order and merged
41	/// where they overlap.
42	fn hits(&self, folded: &str) -> Vec<Range<usize>> {
43	let mut hits: Vec<Range<usize>> = self
44	.terms
45	.iter()
46	.flat_map(\|term\| {
47	folded
48	.match_indices(term.as_str())
49	.filter(\|(at, _)\| word_start(folded, *at))
50	.map(\|(at, term)\| at..at + term.len())
51	})
52	.collect();
53	hits.sort_by_key(\|hit\| (hit.start, std::cmp::Reverse(hit.end)));
54	let mut merged: Vec<Range<usize>> = Vec::with_capacity(hits.len());
55	for hit in hits {
56	match merged.last_mut() {
57	Some(last) if hit.start <= last.end => last.end = last.end.max(hit.end),
58	_ => merged.push(hit),
59	}
60	}
61	merged
62	}
63
64	fn all_in(&self, folded: &str) -> bool {
65	self.terms.iter().all(\|term\| starts_word(term, folded))
66	}
67
68	/// Where the query's words start words of `text`, as byte ranges of it.
69	pub fn find(&self, text: &str) -> Vec<Range<usize>> {
70	let (folded, source) = fold_mapped(text);
71	self.hits(&folded)
72	.into_iter()
73	.map(\|hit\| source_range(text, &source, hit))
74	.collect()
75	}
76	}
77
78	/// Ideographs and kana are words of their own, as their text has no spaces between words.
79	fn ideographic(character: char) -> bool {
80	matches!(u32::from(character),
81	0x3040..=0x30ff \| 0x3400..=0x4dbf \| 0x4e00..=0x9fff \| 0xf900..=0xfaff \| 0x20000..=0x3ffff)
82	}
83
84	fn starts_word(term: &str, folded: &str) -> bool {
85	folded
86	.match_indices(term)
87	.any(\|(at, _)\| word_start(folded, at))
88	}
89
90	fn word_start(text: &str, at: usize) -> bool {
91	match text[..at].chars().next_back() {
92	None => true,
93	Some(before) => {
94	!before.is_alphanumeric()
95	\|\| ideographic(before)
96	\|\| text[at..].chars().next().is_some_and(ideographic)
97	}
98	}
99	}
100
101	fn diacritic(character: char) -> bool {
102	matches!(u32::from(character),
103	0x300..=0x36f \| 0x1ab0..=0x1aff \| 0x1dc0..=0x1dff \| 0x20d0..=0x20ff \| 0xfe20..=0xfe2f)
104	}
105
106	/// Appends `character` lowered and without diacritics; line breaks stay and other spaces
107	/// become one space each.
108	fn fold_char(character: char, out: &mut String) {
109	const DECOMPOSE: DecomposingNormalizerBorrowed = DecomposingNormalizerBorrowed::new_nfd();
110	if character.is_ascii() {
111	out.push(match character {
112	'\n' => '\n',
113	space if space.is_ascii_whitespace() => ' ',
114	other => other.to_ascii_lowercase(),
115	});
116	return;
117	}
118	match character {
119	'\u{2018}' \| '\u{2019}' \| '\u{02bc}' => out.push('\''),
120	'\u{201c}' \| '\u{201d}' => out.push('"'),
121	'ß' => out.push_str("ss"),
122	'æ' \| 'Æ' => out.push_str("ae"),
123	'œ' \| 'Œ' => out.push_str("oe"),
124	'ø' \| 'Ø' => out.push('o'),
125	'ł' \| 'Ł' => out.push('l'),
126	'đ' \| 'Đ' => out.push('d'),
127	'ı' => out.push('i'),
128	space if space.is_whitespace() => out.push(' '),
129	other => out.extend(
130	DECOMPOSE
131	.normalize_iter(other.to_lowercase())
132	.filter(\|part\| !diacritic(*part)),
133	),
134	}
135	}
136
137	/// `text` as search compares it: lowered and without diacritics.
138	pub fn fold(text: &str) -> String {
139	let mut out = String::with_capacity(text.len());
140	for character in text.chars() {
141	fold_char(character, &mut out);
142	}
143	out
144	}
145
146	/// `fold`, with the byte of `text` each folded byte came from.
147	fn fold_mapped(text: &str) -> (String, Vec<usize>) {
148	let mut out = String::with_capacity(text.len());
149	let mut source = Vec::with_capacity(text.len());
150	for (at, character) in text.char_indices() {
151	fold_char(character, &mut out);
152	source.resize(out.len(), at);
153	}
154	(out, source)
155	}
156
157	/// The bytes of `text` a range of its folding came from, whole characters.
158	fn source_range(text: &str, source: &[usize], hit: Range<usize>) -> Range<usize> {
159	let start = source[hit.start];
160	let last = source[hit.end - 1];
161	let end = last + text[last..].chars().next().map_or(0, char::len_utf8);
162	start..end
163	}
164
165	/// The text a paragraph shows, without hidden field codes.
166	pub fn shown(paragraph: &Paragraph) -> String {
167	let mut start = 0;
168	paragraph
169	.spans()
170	.iter()
171	.filter_map(\|span\| {
172	let run = &paragraph.text()[start..span.end];
173	start = span.end;
174	(span.format.hidden != Some(true)).then_some(run)
175	})
176	.collect()
177	}
178
179	/// A page's text outside its title, a paragraph to a line: outlines in page order, tables
180	/// cell by cell.
181	pub fn page_text(page: &Page) -> String {
182	fn walk(paragraphs: &[PageParagraph], out: &mut Vec<String>) {
183	for paragraph in paragraphs {
184	match &paragraph.content {
185	ParagraphContent::Text(text) => out.push(shown(&text.text)),
186	ParagraphContent::Table(table) => {
187	for cell in table.rows.iter().flat_map(\|row\| &row.cells) {
188	walk(&cell.paragraphs, out);
189	}
190	}
191	_ => {}
192	}
193	}
194	}
195	let mut out = Vec::new();
196	for object in &page.objects {
197	if let PageObject::Outline(outline) = object {
198	walk(&outline.paragraphs, &mut out);
199	}
200	}
201	out.retain(\|line\| !line.trim().is_empty());
202	out.join("\n")
203	}
204
205	/// A page as search knows it.
206	pub struct Entry {
207	/// The section's key, which the host chooses.
208	pub section: String,
209	pub space: ExGuid,
210	pub title: String,
211	/// When the page last changed, in any unit that orders.
212	pub modified: u64,
213	text: String,
214	folded_title: String,
215	folded_text: String,
216	}
217
218	/// A page matching a query.
219	#[derive(Clone, Debug, PartialEq)]
220	pub struct Found {
221	pub section: String,
222	pub space: ExGuid,
223	pub title: String,
224	/// Every word is in the title, as OneNote's "Title contains" lists it.
225	pub in_title: bool,
226	/// Byte ranges of the title the words match.
227	pub title_hits: Vec<Range<usize>>,
228	/// The line around the first match in the page's text, or its first line.
229	pub snippet: String,
230	pub snippet_hits: Vec<Range<usize>>,
231	}
232
233	/// Pages of any number of sections, searchable together.
234	#[derive(Default)]
235	pub struct Index {
236	entries: Vec<Entry>,
237	}
238
239	impl Index {
240	pub fn len(&self) -> usize {
241	self.entries.len()
242	}
243
244	pub fn is_empty(&self) -> bool {
245	self.entries.is_empty()
246	}
247
248	/// Adds or replaces page `space` of `section` as `page` shows it.
249	pub fn set(&mut self, section: &str, space: ExGuid, page: &Page, modified: u64) {
250	let text = page_text(page);
251	let entry = Entry {
252	section: section.to_owned(),
253	space,
254	folded_title: fold(&page.title),
255	folded_text: fold(&text),
256	title: page.title.clone(),
257	modified,
258	text,
259	};
260	match self
261	.entries
262	.iter_mut()
263	.find(\|entry\| entry.space == space && entry.section == section)
264	{
265	Some(old) => *old = entry,
266	None => self.entries.push(entry),
267	}
268	}
269
270	/// Keeps the pages whose section `keep` accepts.
271	pub fn retain(&mut self, mut keep: impl FnMut(&Entry) -> bool) {
272	self.entries.retain(\|entry\| keep(entry));
273	}
274
275	/// The page `space` of `section`, when indexed.
276	pub fn get(&self, section: &str, space: ExGuid) -> Option<&Entry> {
277	self.entries
278	.iter()
279	.find(\|entry\| entry.space == space && entry.section == section)
280	}
281
282	/// Pages of the sections `scope` accepts that hold every word of `query`, title hits
283	/// first, then the most recently modified.
284	pub fn search(&self, query: &Query, scope: impl Fn(&str) -> bool) -> Vec<Found> {
285	if query.is_empty() {
286	return Vec::new();
287	}
288	let mut found: Vec<(&Entry, bool)> = self
289	.entries
290	.iter()
291	.filter(\|entry\| scope(&entry.section))
292	.filter_map(\|entry\| {
293	let in_title = query.all_in(&entry.folded_title);
294	let matches = in_title
295	\|\| query.terms.iter().all(\|term\| {
296	starts_word(term, &entry.folded_title)
297	\|\| starts_word(term, &entry.folded_text)
298	});
299	matches.then_some((entry, in_title))
300	})
301	.collect();
302	found.sort_by_key(\|(entry, in_title)\| (!in_title, std::cmp::Reverse(entry.modified)));
303	found
304	.into_iter()
305	.map(\|(entry, in_title)\| {
306	let (snippet, snippet_hits) = snippet(entry, query);
307	Found {
308	section: entry.section.clone(),
309	space: entry.space,
310	title: entry.title.clone(),
311	in_title,
312	title_hits: query.find(&entry.title),
313	snippet,
314	snippet_hits,
315	}
316	})
317	.collect()
318	}
319	}
320
321	/// Part of the line holding the first match in the entry's text, the matches within it;
322	/// the text's first line when nothing there matches.
323	fn snippet(entry: &Entry, query: &Query) -> (String, Vec<Range<usize>>) {
324	let first = query.hits(&entry.folded_text).first().map(\|hit\| hit.start);
325	let line = first.map_or(0, \|at\| {
326	entry.folded_text[..at].bytes().filter(\|byte\| *byte == b'\n').count()
327	});
328	let text = entry.text.split('\n').nth(line).unwrap_or_default();
329	let hits = query.find(text);
330	let chars: Vec<(usize, char)> = text.char_indices().collect();
331	let at = hits.first().map_or(0, \|hit\| {
332	chars.partition_point(\|(byte, _)\| *byte < hit.start)
333	});
334	let mut start = at.saturating_sub(BEFORE);
335	let mut end = (start + SNIPPET).min(chars.len());
336	// Cut ends fall back to the nearest space, so no word shows in part.
337	if start > 0
338	&& let Some(space) = chars[start..at].iter().position(\|(_, char)\| char.is_whitespace())
339	{
340	start += space + 1;
341	}
342	if end < chars.len()
343	&& let Some(space) = chars[at..end].iter().rposition(\|(_, char)\| char.is_whitespace())
344	{
345	end = at + space;
346	}
347	let byte = \|index: usize\| chars.get(index).map_or(text.len(), \|(byte, _)\| *byte);
348	let [from, to] = [byte(start), byte(end)];
349	let lead = if start > 0 { "…" } else { "" };
350	let shown = format!(
351	"{lead}{}{}",
352	text[from..to].trim_end(),
353	if end < chars.len() { "…" } else { "" }
354	);
355	let hits = hits
356	.into_iter()
357	.filter(\|hit\| hit.start >= from && hit.end <= to)
358	.map(\|hit\| hit.start - from + lead.len()..hit.end - from + lead.len())
359	.filter(\|hit\| hit.end <= shown.len())
360	.collect();
361	(shown, hits)
362	}
363
364	/// A match on a page: the outline it is in and its range there.
365	pub type PageMatch = (ExGuid, Selection);
366
367	/// Where `query` matches the page `editor` shows, from the page's top: outlines by where
368	/// they stand, then their shown paragraphs in order.
369	pub fn page_matches(editor: &CanvasEditor, query: &Query) -> Vec<PageMatch> {
370	if query.is_empty() {
371	return Vec::new();
372	}
373	let mut outlines: Vec<_> = editor.outlines().iter().collect();
374	outlines.sort_by(\|a, b\| {
375	let [ax, ay] = a.origin();
376	let [bx, by] = b.origin();
377	ay.total_cmp(&by).then(ax.total_cmp(&bx))
378	});
379	let mut matches = Vec::new();
380	for outline in outlines {
381	for (index, _) in outline.layouts() {
382	let Some(paragraph) = outline.document().paragraph(index) else {
383	continue;
384	};
385	// Hidden field codes are left out, and each shown byte keeps its source byte.
386	let mut shown = String::new();
387	let mut source = Vec::new();
388	let mut start = 0;
389	for span in paragraph.spans() {
390	if span.format.hidden != Some(true) {
391	shown.push_str(&paragraph.text()[start..span.end]);
392	source.extend(start..span.end);
393	}
394	start = span.end;
395	}
396	for hit in query.find(&shown) {
397	let end = source[hit.end - 1]
398	+ paragraph.text()[source[hit.end - 1]..]
399	.chars()
400	.next()
401	.map_or(0, char::len_utf8);
402	let (Ok(from), Ok(to)) = (
403	paragraph.utf16_offset(source[hit.start]),
404	paragraph.utf16_offset(end),
405	) else {
406	continue;
407	};
408	let at = \|offset\| TextPosition {
409	paragraph: index,
410	offset,
411	};
412	matches.push((outline.id, [at(from), at(to)].into()));
413	}
414	}
415	}
416	matches
417	}

crates/canvas/src/template.rs+1-1

...	@@ -603,7 +603,7 @@ pub const TEMPLATES: &[Template] = &[	...	@@ -603,7 +603,7 @@ pub const TEMPLATES: &[Template] = &[
603		603
604	/// OneNote 2010's page colours in its View, Page Color menu order, with the names its	604	/// OneNote 2010's page colours in its View, Page Color menu order, with the names its
605	/// tooltips give them; COLORREF, as the page XML reports each	605	/// tooltips give them; COLORREF, as the page XML reports each
606	/// (evidence/notebook-management/page-colors).	606	/// (`corpus/notebook-management/native/page-color`).
607	pub const PAGE_COLORS: &[(&str, u32)] = &[	607	pub const PAGE_COLORS: &[(&str, u32)] = &[
608	("Blue", 0xfef5ed),	608	("Blue", 0xfef5ed),
609	("Red", 0xefeeff),	609	("Red", 0xefeeff),

crates/snowbound/Cargo.toml+2-1

...	@@ -10,7 +10,7 @@ draw = { path = "../draw" }	...	@@ -10,7 +10,7 @@ draw = { path = "../draw" }
10	ui = { path = "../ui" }	10	ui = { path = "../ui" }
11	png = "0.18"	11	png = "0.18"
12	onestore = { path = "../onestore" }	12	onestore = { path = "../onestore" }
13	notebook = { path = "../notebook" }	13	notebook = { path = "../notebook", features = ["smb"] }
14	serde = { version = "1", features = ["derive"] }	14	serde = { version = "1", features = ["derive"] }
15	serde_json = "1"	15	serde_json = "1"
16	pollster = "0.4"	16	pollster = "0.4"
...	@@ -22,6 +22,7 @@ accesskit = "0.25.0"	...	@@ -22,6 +22,7 @@ accesskit = "0.25.0"
22	accesskit_winit = { version = "0.34.0", default-features = false, features = ["rwh_06"] }	22	accesskit_winit = { version = "0.34.0", default-features = false, features = ["rwh_06"] }
23		23
24	[target.'cfg(target_os = "macos")'.dependencies]	24	[target.'cfg(target_os = "macos")'.dependencies]
		25	libc = "0.2"
25	objc2 = "0.5.2"	26	objc2 = "0.5.2"
26	objc2-app-kit = { version = "0.2.2", default-features = false, features = ["NSAlert", "NSButton", "NSControl", "NSView", "NSResponder", "NSWindow", "NSApplication", "NSEvent", "NSColor", "NSColorSpace", "NSDatePicker", "NSDatePickerCell", "NSOpenPanel", "NSPanel", "NSSavePanel"] }	27	objc2-app-kit = { version = "0.2.2", default-features = false, features = ["NSAlert", "NSButton", "NSControl", "NSView", "NSResponder", "NSWindow", "NSApplication", "NSEvent", "NSColor", "NSColorSpace", "NSDatePicker", "NSDatePickerCell", "NSOpenPanel", "NSPanel", "NSSavePanel"] }
27	objc2-foundation = { version = "0.2.2", default-features = false, features = ["NSString", "NSThread", "NSAttributedString", "NSDate", "NSCalendar", "NSDateFormatter", "NSGeometry", "NSLocale", "NSPathUtilities", "NSTimeZone", "NSURL", "NSArray"] }	28	objc2-foundation = { version = "0.2.2", default-features = false, features = ["NSString", "NSThread", "NSAttributedString", "NSDate", "NSCalendar", "NSDateFormatter", "NSGeometry", "NSLocale", "NSPathUtilities", "NSTimeZone", "NSURL", "NSArray"] }

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

...	@@ -21,8 +21,13 @@ Edits save to the notebook folder as you type. Settings live in	...	@@ -21,8 +21,13 @@ Edits save to the notebook folder as you type. Settings live in
21	puts the latter elsewhere.	21	puts the latter elsewhere.
22		22
23	Run `./install.sh` to add Snowbound to your app launcher; it copies the app	23	Run `./install.sh` to add Snowbound to your app launcher; it copies the app
24	into `~/.local`. On Wayland the taskbar finds Snowbound's icon only through	24	into `~/.local`. On Wayland the taskbar, dock and KDE's title bar find
25	this launcher entry, so without it the taskbar shows a generic icon.	25	Snowbound's icon only through this launcher entry, so without it they show a
		26	generic icon.
		27
		28	The window's title bar is your desktop's own: KDE's on KDE, and on GNOME and
		29	other desktops without server-side decorations an Adwaita-style one drawn by
		30	Snowbound.
26	`./install.sh ~/Notebooks/MyNotebook` makes the launcher open that notebook as	31	`./install.sh ~/Notebooks/MyNotebook` makes the launcher open that notebook as
27	well.	32	well.
28		33

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

...	@@ -254,7 +254,7 @@ fn conflict_views_offer_the_versions_and_render_offscreen() {	...	@@ -254,7 +254,7 @@ fn conflict_views_offer_the_versions_and_render_offscreen() {
254	let highlighted = kept.objects.iter().any(\|object\| match object {	254	let highlighted = kept.objects.iter().any(\|object\| match object {
255	onestore::page::PageObject::Outline(outline) => outline.paragraphs.iter().any(\|paragraph\| {	255	onestore::page::PageObject::Outline(outline) => outline.paragraphs.iter().any(\|paragraph\| {
256	paragraph.text().is_some_and(\|text\| marked.contains(&text.id))	256	paragraph.text().is_some_and(\|text\| marked.contains(&text.id))
257	&& paragraph.format.highlight == Some(CONFLICTING)	257	&& paragraph.format.highlight == Some(canvas::conflict::CONFLICTING)
258	}),	258	}),
259	_ => false,	259	_ => false,
260	});	260	});

crates/snowbound/src/library.rs+452-9

...	@@ -2,11 +2,117 @@	...	@@ -2,11 +2,117 @@
2		2
3	use notebook::discover::{Folder, SectionState};	3	use notebook::discover::{Folder, SectionState};
4	use notebook::session::{Notebook, Section};	4	use notebook::session::{Notebook, Section};
		5	use notebook::smb::{Client, Credentials};
5	use std::{	6	use std::{
6	error::Error,	7	error::Error,
		8	io,
7	path::{Path, PathBuf},	9	path::{Path, PathBuf},
		10	sync::Arc,
		11	time::Duration,
8	};	12	};
9		13
		14	/// How long an SMB request may take before the share counts as unreachable.
		15	const TIMEOUT: Duration = Duration::from_secs(10);
		16	/// The largest section file read whole over SMB.
		17	const LIMIT: usize = 256 * 1024 * 1024;
		18
		19	/// A folder on a mounted SMB share: where the embedded client finds it.
		20	#[derive(Clone, Debug, PartialEq)]
		21	pub struct Mount {
		22	pub server: String,
		23	pub share: String,
		24	/// The account the mount signed in as, where the mount names one.
		25	pub user: Option<String>,
		26	pub domain: String,
		27	/// The folder within the share, `/`-separated.
		28	pub root: String,
		29	}
		30
		31	impl Mount {
		32	/// The mount of `source` (`//[domain;][user[:…]@]server/share[/folder]`), holding the
		33	/// folder `within` its mount point; `options` are the mount's (`username=`, `user=`,
		34	/// `domain=`), where the source names no account.
		35	pub fn parse(source: &str, within: &str, options: &str) -> Option<Self> {
		36	let source = source.strip_prefix("//")?;
		37	let (account, rest) = match source.rsplit_once('@') {
		38	Some((account, rest)) => (Some(account), rest),
		39	None => (None, source),
		40	};
		41	let mut parts = rest.split('/').filter(\|part\| !part.is_empty());
		42	let (server, share) = (parts.next()?, parts.next()?);
		43	let option = \|names: &[&str]\| {
		44	options.split(',').find_map(\|option\| {
		45	let (name, value) = option.split_once('=')?;
		46	names.contains(&name).then(\|\| value.to_owned())
		47	})
		48	};
		49	let (domain, user) = match account {
		50	Some(account) => {
		51	let account = account.split(':').next().unwrap_or_default();
		52	match account.split_once(';') {
		53	Some((domain, user)) => (Some(domain.to_owned()), user.to_owned()),
		54	None => (None, account.to_owned()),
		55	}
		56	}
		57	None => (None, option(&["username", "user"]).unwrap_or_default()),
		58	};
		59	let root: Vec<&str> = parts
		60	.chain(within.split('/'))
		61	.filter(\|part\| !part.is_empty())
		62	.collect();
		63	Some(Self {
		64	server: server.to_owned(),
		65	share: share.to_owned(),
		66	// "GUEST" is how macOS names a guest mount.
		67	user: (!user.is_empty() && !user.eq_ignore_ascii_case("guest")).then_some(user),
		68	domain: domain
		69	.or_else(\|\| option(&["domain", "dom"]))
		70	.unwrap_or_default(),
		71	root: root.join("/"),
		72	})
		73	}
		74	}
		75
		76	/// An account on an SMB server.
		77	#[derive(Clone)]
		78	pub struct Login {
		79	pub user: String,
		80	pub password: String,
		81	pub domain: String,
		82	}
		83
		84	impl Login {
		85	/// The guest account a mount without one signed in as.
		86	pub fn guest(mount: &Mount) -> Self {
		87	Self {
		88	user: String::new(),
		89	password: String::new(),
		90	domain: mount.domain.clone(),
		91	}
		92	}
		93	}
		94
		95	/// A share and the account that reaches it, kept to reconnect.
		96	struct Server {
		97	mount: Mount,
		98	login: Login,
		99	}
		100
		101	impl Server {
		102	fn connect(&self) -> io::Result<Client> {
		103	Client::connect(
		104	&self.mount.server,
		105	&self.mount.share,
		106	Credentials {
		107	username: &self.login.user,
		108	password: &self.login.password,
		109	domain: &self.login.domain,
		110	},
		111	TIMEOUT,
		112	)
		113	}
		114	}
		115
10	/// A section tab: where the section opens from and how it is labelled.	116	/// A section tab: where the section opens from and how it is labelled.
11	pub struct Tab {	117	pub struct Tab {
12	/// The notebook catalog path, or the file of a section opened on its own.	118	/// The notebook catalog path, or the file of a section opened on its own.
...	@@ -24,28 +130,95 @@ pub struct Library {	...	@@ -24,28 +130,95 @@ pub struct Library {
24	pub name: String,	130	pub name: String,
25	/// `Err` holds why a notebook listed as open could not be read this time.	131	/// `Err` holds why a notebook listed as open could not be read this time.
26	pub notebook: Result<Option<Notebook>, String>,	132	pub notebook: Result<Option<Notebook>, String>,
		133	/// The share a notebook on a mounted SMB share opens through, by the embedded client.
		134	server: Option<Arc<Server>>,
		135	/// Why a notebook on a mounted SMB share opened through the mount instead.
		136	pub notice: Option<String>,
27	cache: PathBuf,	137	cache: PathBuf,
28	}	138	}
29		139
30	impl Library {	140	impl Library {
31	/// The notebook in the folder at `location`, or why it cannot be read.	141	/// The notebook in the folder at `location`, or why it cannot be read. A folder on a
		142	/// mounted SMB share opens through Snowbound's own SMB client, signed in with the
		143	/// account the system keeps for the mount, as OneNote's own client coordinates with
		144	/// OneNote; without that account it opens through the mount.
32	pub fn notebook(location: &str, cache: &Path) -> Self {	145	pub fn notebook(location: &str, cache: &Path) -> Self {
		146	let mut notice = None;
		147	if let Some(mount) = crate::platform::smb_mount(Path::new(location)) {
		148	match crate::platform::smb_login(&mount)
		149	.and_then(\|login\| Self::on_share(location, mount, login, cache))
		150	{
		151	Ok(library) => return library,
		152	Err(reason) => {
		153	eprintln!("{location}: opening through the mounted share: {reason}");
		154	notice = Some(reason);
		155	}
		156	}
		157	}
33	Self {	158	Self {
34	location: location.to_owned(),	159	location: location.to_owned(),
35	name: file_name(Path::new(location)),	160	name: file_name(Path::new(location)),
36	notebook: Notebook::open(location, cache)	161	notebook: Notebook::open(location, cache)
37	.map(Some)	162	.map(Some)
38	.map_err(\|error\| error.to_string()),	163	.map_err(\|error\| error.to_string()),
		164	server: None,
		165	notice,
39	cache: cache.to_owned(),	166	cache: cache.to_owned(),
40	}	167	}
41	}	168	}
42		169
43	/// `notebook`, open at `location`.	170	/// The notebook at `location`, which `mount` names on its server, opened through the
44	pub fn open_notebook(location: &str, notebook: Notebook, cache: &Path) -> Self {	171	/// embedded client signed in as `login`.
		172	pub fn on_share(
		173	location: &str,
		174	mount: Mount,
		175	login: Login,
		176	cache: &Path,
		177	) -> Result<Self, String> {
		178	let server = Arc::new(Server { mount, login });
		179	let client = server.connect().map_err(\|error\| error.to_string())?;
		180	let notebook = Notebook::open_smb(Arc::new(client), &server.mount.root, cache)
		181	.map_err(\|error\| error.to_string())?;
		182	Ok(Self {
		183	location: location.to_owned(),
		184	name: file_name(Path::new(location)),
		185	notebook: Ok(Some(notebook)),
		186	server: Some(server),
		187	notice: None,
		188	cache: cache.to_owned(),
		189	})
		190	}
		191
		192	/// This notebook read again, the way it was opened, for changing its structure.
		193	pub fn reopen(&self) -> Result<Notebook, Box<dyn Error>> {
		194	Ok(match &self.server {
		195	Some(server) => {
		196	Notebook::open_smb(Arc::new(server.connect()?), &server.mount.root, &self.cache)?
		197	}
		198	None => Notebook::open(&self.location, &self.cache)?,
		199	})
		200	}
		201
		202	/// This notebook as `notebook`, read again after a change.
		203	pub fn with(&self, notebook: Notebook) -> Self {
		204	Self {
		205	location: self.location.clone(),
		206	name: self.name.clone(),
		207	notebook: Ok(Some(notebook)),
		208	server: self.server.clone(),
		209	notice: self.notice.clone(),
		210	cache: self.cache.clone(),
		211	}
		212	}
		213
		214	/// A notebook `Notebook::create` just made in the folder at `location`.
		215	pub fn created(location: &str, notebook: Notebook, cache: &Path) -> Self {
45	Self {	216	Self {
46	location: location.to_owned(),	217	location: location.to_owned(),
47	name: file_name(Path::new(location)),	218	name: file_name(Path::new(location)),
48	notebook: Ok(Some(notebook)),	219	notebook: Ok(Some(notebook)),
		220	server: None,
		221	notice: None,
49	cache: cache.to_owned(),	222	cache: cache.to_owned(),
50	}	223	}
51	}	224	}
...	@@ -56,19 +229,65 @@ impl Library {	...	@@ -56,19 +229,65 @@ impl Library {
56	location: file.to_string_lossy().into_owned(),	229	location: file.to_string_lossy().into_owned(),
57	name: file_name(file.parent().unwrap_or(file)),	230	name: file_name(file.parent().unwrap_or(file)),
58	notebook: Ok(None),	231	notebook: Ok(None),
		232	server: None,
		233	notice: None,
59	cache: cache.to_owned(),	234	cache: cache.to_owned(),
60	}	235	}
61	}	236	}
62		237
63	/// Opens the section at catalog `path`.	238	/// Opens the section at catalog `path`; on a share, through a replica named by its
64	pub fn open(&self, path: &str, notify: impl Fn() + Send + 'static) -> Result<Section, Box<dyn Error>> {	239	/// file identity that publishes over the embedded client.
65	Ok(match &self.notebook {	240	pub fn open(
66	Ok(Some(notebook)) => notebook.section(path, notify)?,	241	&self,
67	Ok(None) => Section::open(path, &self.cache, notify)?,	242	path: &str,
68	Err(error) => return Err(error.clone().into()),	243	notify: impl Fn() + Send + 'static,
		244	) -> Result<Section, Box<dyn Error>> {
		245	Ok(match (&self.notebook, &self.server) {
		246	(Ok(Some(notebook)), Some(server)) => {
		247	let identity = self
		248	.catalog_section(notebook.catalog(), path)
		249	.ok_or("The notebook doesn’t list this section")?;
		250	let file = match server.mount.root.as_str() {
		251	"" => path.to_owned(),
		252	root => format!("{root}/{path}"),
		253	};
		254	let cache = self.cache.join("smb").join(format!("{identity}.sqlite"));
		255	std::fs::create_dir_all(self.cache.join("smb"))?;
		256	let replica = if cache.exists() {
		257	notebook::Replica::open(&cache)?
		258	} else {
		259	notebook::Replica::create(
		260	&cache,
		261	&server.connect()?.read_storage(&file, LIMIT)?,
		262	)?
		263	};
		264	let server = Arc::clone(server);
		265	Section::resume_smb(file, replica, LIMIT, move \|\| server.connect(), notify)?
		266	}
		267	(Ok(Some(notebook)), None) => notebook.section(path, notify)?,
		268	(Ok(None), _) => Section::open(path, &self.cache, notify)?,
		269	(Err(error), _) => return Err(error.clone().into()),
69	})	270	})
70	}	271	}
71		272
		273	/// The file identity, in hex, of the section at catalog `path`.
		274	fn catalog_section(&self, catalog: &Folder, path: &str) -> Option<String> {
		275	let mut folders = vec![catalog];
		276	while let Some(folder) = folders.pop() {
		277	if let Some(section) = folder.sections.iter().find(\|section\| section.path == path) {
		278	return Some(
		279	section
		280	.file_id
		281	.iter()
		282	.map(\|byte\| format!("{byte:02x}"))
		283	.collect(),
		284	);
		285	}
		286	folders.extend(&folder.groups);
		287	}
		288	None
		289	}
		290
72	/// Names the section at catalog `path` across every open notebook, for remembering	291	/// Names the section at catalog `path` across every open notebook, for remembering
73	/// its pages.	292	/// its pages.
74	pub fn key(&self, path: &str) -> String {	293	pub fn key(&self, path: &str) -> String {
...	@@ -177,3 +396,227 @@ fn tabs(catalog: &Folder) -> Vec<Tab> {	...	@@ -177,3 +396,227 @@ fn tabs(catalog: &Folder) -> Vec<Tab> {
177	})	396	})
178	.collect()	397	.collect()
179	}	398	}
		399
		400	/// What a path chosen to open opens.
		401	#[derive(Debug, PartialEq)]
		402	pub enum Located {
		403	/// The notebook in folder `root`, at the section at catalog path `section`.
		404	Notebook {
		405	root: PathBuf,
		406	section: Option<String>,
		407	},
		408	/// A section file outside any notebook.
		409	Section(PathBuf),
		410	Nothing,
		411	}
		412
		413	/// Whether `folder` holds a table of contents, as a notebook's or a section group's does.
		414	fn has_toc(folder: &Path) -> bool {
		415	std::fs::read_dir(folder).is_ok_and(\|entries\| {
		416	entries.flatten().any(\|entry\| {
		417	entry
		418	.path()
		419	.extension()
		420	.is_some_and(\|extension\| extension.eq_ignore_ascii_case("onetoc2"))
		421	})
		422	})
		423	}
		424
		425	/// What `path` opens: a folder is a notebook; a table of contents opens its folder's; a
		426	/// section opens in the notebook the folders above it with tables of contents make up,
		427	/// section groups included, or alone.
		428	pub fn locate(path: &Path) -> Located {
		429	let extension = path
		430	.extension()
		431	.map(\|extension\| extension.to_string_lossy().to_ascii_lowercase());
		432	match extension.as_deref() {
		433	_ if path.is_dir() => Located::Notebook {
		434	root: path.to_owned(),
		435	section: None,
		436	},
		437	Some("onetoc2") => match path.parent() {
		438	Some(root) => Located::Notebook {
		439	root: root.to_owned(),
		440	section: None,
		441	},
		442	None => Located::Nothing,
		443	},
		444	Some("one") => {
		445	let mut root = None;
		446	let mut folder = path.parent();
		447	while let Some(candidate) = folder.filter(\|folder\| has_toc(folder)) {
		448	root = Some(candidate);
		449	folder = candidate.parent();
		450	}
		451	match root {
		452	Some(root) => Located::Notebook {
		453	root: root.to_owned(),
		454	section: path.strip_prefix(root).ok().map(\|relative\| {
		455	relative
		456	.components()
		457	.map(\|part\| part.as_os_str().to_string_lossy())
		458	.collect::<Vec<_>>()
		459	.join("/")
		460	}),
		461	},
		462	None => Located::Section(path.to_owned()),
		463	}
		464	}
		465	_ => Located::Nothing,
		466	}
		467	}
		468
		469	#[cfg(test)]
		470	mod tests {
		471	use super::*;
		472
		473	/// A notebook on a share opens, edits and publishes through the embedded client, as a
		474	/// mounted share's notebook does: `ONESTORE_SMB_LAB=127.0.0.1:PORT` (a disposable Samba
		475	/// share `agent`, guest access; `tools/w7/linux_vm.py up NAME`).
		476	#[test]
		477	#[ignore = "requires an owned Samba share at ONESTORE_SMB_LAB"]
		478	fn a_notebook_on_a_share_opens_through_the_embedded_client() {
		479	let address = std::env::var("ONESTORE_SMB_LAB").unwrap();
		480	let root = format!("snowbound-{}", std::process::id());
		481	let mount = Mount {
		482	server: address,
		483	share: "agent".into(),
		484	user: None,
		485	domain: String::new(),
		486	root: root.clone(),
		487	};
		488	let login = Login::guest(&mount);
		489	let server = Server {
		490	mount: mount.clone(),
		491	login: login.clone(),
		492	};
		493	let client = Arc::new(server.connect().unwrap());
		494	client.create_directory(&root).unwrap();
		495	let cache = std::env::temp_dir().join(format!("snowbound-share-{}", std::process::id()));
		496	let page = onestore::PageCreation::new(None, Some(""), "Rust Author").unwrap();
		497	Notebook::open_smb(Arc::clone(&client), &root, &cache)
		498	.unwrap()
		499	.create_section("", "New Section 1", &page)
		500	.unwrap();
		501	let library = Library::on_share("/Volumes/agent/lab", mount, login, &cache).unwrap();
		502	let path = library.first_section().unwrap();
		503	let section = library.open(&path, \|\| {}).unwrap();
		504	let (space, ..) = section.pages().unwrap()[0].clone();
		505	let stored = section.page(space).unwrap();
		506	let title = stored
		507	.objects
		508	.iter()
		509	.find_map(\|object\| match object {
		510	onestore::page::PageObject::Title(title) => {
		511	title.outlines[0].paragraphs[0].text().map(\|text\| text.id)
		512	}
		513	_ => None,
		514	})
		515	.unwrap();
		516	section
		517	.apply(
		518	"Rust Author",
		519	onestore::op::Edit {
		520	at: crate::filetime(),
		521	ops: vec![onestore::op::Op::Page {
		522	space,
		523	op: onestore::op::PageOp::Text {
		524	text: title,
		525	range: 0..0,
		526	with: "Over SMB".into(),
		527	},
		528	}],
		529	},
		530	)
		531	.unwrap();
		532	let deadline = std::time::Instant::now() + Duration::from_secs(60);
		533	let file = format!("{root}/{path}");
		534	loop {
		535	let bytes = client.read_storage(&file, LIMIT).unwrap();
		536	let arena = onestore::Arena::default();
		537	let titles = onestore::Section::open(&arena, bytes)
		538	.unwrap()
		539	.pages()
		540	.unwrap();
		541	if titles.iter().any(\|(_, title, _)\| title == "Over SMB") {
		542	break;
		543	}
		544	assert!(std::time::Instant::now() < deadline, "{titles:?}");
		545	section.wake();
		546	std::thread::sleep(Duration::from_millis(200));
		547	}
		548	section.close().unwrap();
		549	let _ = std::fs::remove_dir_all(&cache);
		550	}
		551
		552	#[test]
		553	fn mounts_name_their_server_share_account_and_folder() {
		554	assert_eq!(
		555	Mount::parse("//WORK;clover@nas.local/notes", "Personal/Garden", ""),
		556	Some(Mount {
		557	server: "nas.local".into(),
		558	share: "notes".into(),
		559	user: Some("clover".into()),
		560	domain: "WORK".into(),
		561	root: "Personal/Garden".into(),
		562	})
		563	);
		564	assert_eq!(
		565	Mount::parse(
		566	"//nas/notes/sub",
		567	"Personal",
		568	"rw,vers=3.0,username=amy,domain=HOME"
		569	),
		570	Some(Mount {
		571	server: "nas".into(),
		572	share: "notes".into(),
		573	user: Some("amy".into()),
		574	domain: "HOME".into(),
		575	root: "sub/Personal".into(),
		576	})
		577	);
		578	let guest = Mount::parse("//GUEST:@nas/public", "", "").unwrap();
		579	assert_eq!((guest.user, guest.root), (None, String::new()));
		580	assert_eq!(Mount::parse("/dev/disk1", "", ""), None);
		581	}
		582
		583	#[test]
		584	fn chosen_paths_open_their_notebook_or_section() {
		585	let root = std::env::temp_dir().join(format!("snowbound-locate-{}", std::process::id()));
		586	let _ = std::fs::remove_dir_all(&root);
		587	let notebook = root.join("Notebook");
		588	std::fs::create_dir_all(notebook.join("Group")).unwrap();
		589	for file in [
		590	"Open Notebook.onetoc2",
		591	"Group/Open Notebook.onetoc2",
		592	"Group/Inner.one",
		593	"Top.one",
		594	] {
		595	std::fs::write(notebook.join(file), b"").unwrap();
		596	}
		597	std::fs::write(root.join("Loose.one"), b"").unwrap();
		598	let at = \|root: &Path, section: Option<&str>\| Located::Notebook {
		599	root: root.to_owned(),
		600	section: section.map(str::to_owned),
		601	};
		602	assert_eq!(locate(&notebook), at(&notebook, None));
		603	assert_eq!(
		604	locate(&notebook.join("Open Notebook.onetoc2")),
		605	at(&notebook, None)
		606	);
		607	assert_eq!(
		608	locate(&notebook.join("Group/Inner.one")),
		609	at(&notebook, Some("Group/Inner.one"))
		610	);
		611	assert_eq!(
		612	locate(&notebook.join("Top.one")),
		613	at(&notebook, Some("Top.one"))
		614	);
		615	assert_eq!(
		616	locate(&root.join("Loose.one")),
		617	Located::Section(root.join("Loose.one"))
		618	);
		619	assert_eq!(locate(&root.join("missing.txt")), Located::Nothing);
		620	std::fs::remove_dir_all(&root).unwrap();
		621	}
		622	}

crates/snowbound/src/linux.rs+58

...	@@ -221,6 +221,64 @@ pub fn cache_dir() -> Option<PathBuf> {	...	@@ -221,6 +221,64 @@ pub fn cache_dir() -> Option<PathBuf> {
221	xdg_dir("XDG_CACHE_HOME", ".cache")	221	xdg_dir("XDG_CACHE_HOME", ".cache")
222	}	222	}
223		223
		224	/// The share holding `path` where it is mounted from an SMB server (CIFS or SMB 3).
		225	pub fn smb_mount(path: &std::path::Path) -> Option<crate::library::Mount> {
		226	let mounts = std::fs::read_to_string("/proc/self/mounts").ok()?;
		227	// The mount holding the path is the one at its longest ancestor.
		228	let (source, point, options) = mounts
		229	.lines()
		230	.filter_map(\|line\| {
		231	let mut fields = line.split_whitespace();
		232	let (source, point, kind, options) =
		233	(fields.next()?, fields.next()?, fields.next()?, fields.next()?);
		234	let point = point.replace("\\040", " ");
		235	(matches!(kind, "cifs" \| "smb3") && path.starts_with(&point))
		236	.then(\|\| (source.replace("\\040", " "), point, options.to_owned()))
		237	})
		238	.max_by_key(\|(_, point, _)\| point.len())?;
		239	let within = path.strip_prefix(&point).ok()?.to_string_lossy().into_owned();
		240	crate::library::Mount::parse(&source, &within, &options)
		241	}
		242
		243	/// The password the Secret Service keeps for `mount`'s account, as GNOME's file manager
		244	/// saves one, or what the user types when it keeps none.
		245	pub fn smb_login(mount: &crate::library::Mount) -> Result<crate::library::Login, String> {
		246	let user = mount.user.clone().unwrap_or_default();
		247	let mut lookup = Command::new("secret-tool");
		248	lookup.args(["lookup", "protocol", "smb", "server", &mount.server]);
		249	if !user.is_empty() {
		250	lookup.args(["user", &user]);
		251	}
		252	if let Ok(output) = lookup.output()
		253	&& output.status.success()
		254	&& !output.stdout.is_empty()
		255	{
		256	return Ok(crate::library::Login {
		257	user,
		258	password: String::from_utf8_lossy(&output.stdout).trim_end_matches('\n').to_owned(),
		259	domain: mount.domain.clone(),
		260	});
		261	}
		262	let title = format!("Sign in to {}", mount.server);
		263	let asked = dialog(
		264	["--password", "--username", &format!("--title={title}")],
		265	["--password", &title],
		266	)
		267	.map_err(str::to_owned)?
		268	.ok_or_else(\|\| "Signing in was cancelled".to_owned())?;
		269	// zenity answers "user\|password"; kdialog only the password.
		270	let (typed, password) = asked
		271	.split_once('\|')
		272	.map_or((user.clone(), asked.clone()), \|(typed, password)\| {
		273	(typed.to_owned(), password.to_owned())
		274	});
		275	Ok(crate::library::Login {
		276	user: if typed.is_empty() { user } else { typed },
		277	password,
		278	domain: mount.domain.clone(),
		279	})
		280	}
		281
224	pub fn settings_dir() -> Option<PathBuf> {	282	pub fn settings_dir() -> Option<PathBuf> {
225	xdg_dir("XDG_CONFIG_HOME", ".config")	283	xdg_dir("XDG_CONFIG_HOME", ".config")
226	}	284	}

crates/snowbound/src/macos.rs+86

...	@@ -117,6 +117,92 @@ pub fn cache_dir() -> Option<std::path::PathBuf> {	...	@@ -117,6 +117,92 @@ pub fn cache_dir() -> Option<std::path::PathBuf> {
117	Some(std::path::PathBuf::from(std::env::var_os("HOME")?).join("Library/Caches/snowbound"))	117	Some(std::path::PathBuf::from(std::env::var_os("HOME")?).join("Library/Caches/snowbound"))
118	}	118	}
119		119
		120	/// The share holding `path` where macOS mounted it from an SMB server.
		121	pub fn smb_mount(path: &std::path::Path) -> Option<crate::library::Mount> {
		122	use std::os::unix::ffi::OsStrExt;
		123	let name = std::ffi::CString::new(path.as_os_str().as_bytes()).ok()?;
		124	let mut mount: libc::statfs = unsafe { std::mem::zeroed() };
		125	if unsafe { libc::statfs(name.as_ptr(), &mut mount) } != 0 {
		126	return None;
		127	}
		128	let text = \|chars: &[libc::c_char]\| {
		129	unsafe { std::ffi::CStr::from_ptr(chars.as_ptr()) }
		130	.to_string_lossy()
		131	.into_owned()
		132	};
		133	if text(&mount.f_fstypename) != "smbfs" {
		134	return None;
		135	}
		136	let within = path.strip_prefix(text(&mount.f_mntonname)).ok()?;
		137	crate::library::Mount::parse(&text(&mount.f_mntfromname), &within.to_string_lossy(), "")
		138	}
		139
		140	#[link(name = "Security", kind = "framework")]
		141	unsafe extern "C" {
		142	fn SecKeychainFindInternetPassword(
		143	keychain: *const std::ffi::c_void,
		144	server_length: u32,
		145	server: *const u8,
		146	domain_length: u32,
		147	domain: *const u8,
		148	account_length: u32,
		149	account: *const u8,
		150	path_length: u32,
		151	path: *const u8,
		152	port: u16,
		153	protocol: u32,
		154	authentication: u32,
		155	password_length: *mut u32,
		156	password: mut mut std::ffi::c_void,
		157	item: mut const std::ffi::c_void,
		158	) -> i32;
		159	fn SecKeychainItemFreeContent(list: const std::ffi::c_void, data: mut std::ffi::c_void) -> i32;
		160	}
		161
		162	/// The password the keychain keeps for `mount`'s account on its server, as macOS saved it
		163	/// when the share was mounted; the system asks the user to allow the app to read it.
		164	pub fn smb_login(mount: &crate::library::Mount) -> Result<crate::library::Login, String> {
		165	let Some(user) = &mount.user else {
		166	return Ok(crate::library::Login::guest(mount));
		167	};
		168	// kSecProtocolTypeSMB is 'smb '.
		169	const SMB: u32 = u32::from_be_bytes(*b"smb ");
		170	let (mut length, mut data) = (0, std::ptr::null_mut());
		171	let status = unsafe {
		172	SecKeychainFindInternetPassword(
		173	std::ptr::null(),
		174	mount.server.len() as u32,
		175	mount.server.as_ptr(),
		176	0,
		177	std::ptr::null(),
		178	user.len() as u32,
		179	user.as_ptr(),
		180	0,
		181	std::ptr::null(),
		182	0,
		183	SMB,
		184	0,
		185	&mut length,
		186	&mut data,
		187	std::ptr::null_mut(),
		188	)
		189	};
		190	if status != 0 {
		191	return Err(format!(
		192	"The keychain has no password for {user} on {} ({status})",
		193	mount.server
		194	));
		195	}
		196	let password = unsafe { std::slice::from_raw_parts(data.cast::<u8>(), length as usize) };
		197	let password = String::from_utf8_lossy(password).into_owned();
		198	unsafe { SecKeychainItemFreeContent(std::ptr::null(), data) };
		199	Ok(crate::library::Login {
		200	user: user.clone(),
		201	password,
		202	domain: mount.domain.clone(),
		203	})
		204	}
		205
120	pub fn settings_dir() -> Option<std::path::PathBuf> {	206	pub fn settings_dir() -> Option<std::path::PathBuf> {
121	Some(	207	Some(
122	std::path::PathBuf::from(std::env::var_os("HOME")?)	208	std::path::PathBuf::from(std::env::var_os("HOME")?)

crates/snowbound/src/main.rs+180-94

 @@ -3,6 +3,7 @@ mod art;
 mod conflict_render;
 mod library;
 mod manage;
+mod meeting;
 mod menus;
 #[cfg_attr(target_os = "linux", path = "linux.rs")]
 #[cfg_attr(target_os = "macos", path = "macos.rs")]
 @@ -80,8 +81,6 @@ const FONT_COLORS: [u32; 20] = [
 /// while the gaps still take the pointer.
 const ROW: f32 = 29.0;
 const ROW_GAP: f32 = 3.0;
-/// OneNote's highlight for conflicting changes on a conflict page, COLORREF.
-const CONFLICTING: u32 = 0xd6d6ff;
 /// Space between the page and a page tab that isn't open.
 const PILL_MARGIN: f32 = 3.0;
 /// Rounding where the open page tab meets the page, concentric with its neighbours'.
 @@ -122,6 +121,7 @@ enum Replay {
     /// A frame during a wait, as a visible window's display would ask for.
     Tick,
     Appearance(winit::window::Theme),
+    Quit,
 }
 impl From<accesskit_winit::Event> for UserEvent {
 @@ -165,9 +165,8 @@ struct App {
     interface_font: Vec<Vec<u8>>,
     /// Where `--screenshot` writes its PNGs, drawn from a window never shown.
     screenshot: Option<PathBuf>,
-    /// Where settings are saved, and what they held at launch, until the window opens.
+    /// What the window starts from besides its input, until it opens.
-    settings: Option<(Option<PathBuf>, settings::Settings)>,
+    launch: Option<settings::Launch>,
-    cache: PathBuf,
     state: Option<State>,
     startup_error: Option<Box<dyn Error>>,
 }
 @@ -226,6 +225,16 @@ enum Bar {
 }
 impl Session {
+    /// Saving's state, and that the notebook opened through the system's mount of its
+    /// share where Snowbound's own SMB client could not sign in.
+    fn status(&self) -> String {
+        match (&self.library.notice, self.status) {
+            (None, status) => status.to_owned(),
+            (Some(_), "") => "Via mounted share".to_owned(),
+            (Some(_), status) => format!("{status} · Via mounted share"),
+        }
+    }
     fn title(&self) -> &str {
         match self.conflict(self.space) {
             Some((_, version)) => &version.title,
 @@ -285,26 +294,35 @@ impl Session {
         move || {
             let page = replica.page(space)?;
             Ok(match objects {
-                Some(objects) => highlighted(page, &objects),
+                Some(objects) => canvas::conflict::highlighted(page, &objects),
                 None => page,
             })
         }
     }
 }
-/// What a loader thread opened: a section, or another page of the open one.
+/// What a loader thread read: a section and its page to show, another page of the open
+/// section, or a notebook read again after a change, with the catalog path the open
+/// section has in it.
 enum Loaded {
+    Section(Box<Session>, Page),
+    Page(ExGuid, Page),
+    Library(Arc<Library>, String),
+}
+/// What an opening page replaces: the section, or the page of the open one.
+enum Shown {
     Section(Box<Session>),
     Page(ExGuid),
 }
-/// A loader thread's request number, what it opened and the page it read.
+/// A loader thread's request number and what it read.
-type Read = (u64, Result<(Loaded, Page), String>);
+type Read = (u64, Result<Loaded, String>);
 /// The newest page read, laid out and waiting for the pictures it shows first, so it
 /// never appears without them.
 struct Opening {
-    loaded: Loaded,
+    loaded: Shown,
     scene: (PageScene, [f32; 2]),
     editor: CanvasEditor,
     since: Instant,
 @@ -325,13 +343,15 @@ enum Command {
     CloseNotebook(Arc<Library>),
     /// Changes a notebook's sections and groups.
     Structure(Arc<Library>, manage::Structure),
-    /// Adds a page at the end of the open section, or a subpage after the open page, and
+    /// Adds a page at the end of the open section, or a subpage of a page, and edits its
-    /// edits its title.
+    /// title.
-    NewPage { subpage: bool },
+    NewPage { under: Option<ExGuid> },
     /// Deletes pages of the open section to the notebook's recycle bin.
     DeletePages(Vec<ExGuid>),
     /// Moves or indents pages of the open section.
     Pages(Vec<onestore::PageEdit>),
+    /// Moves a page of the open section to the end of another section of its folder.
+    MovePage { space: ExGuid, path: String },
     /// Gives the open page a template's background or colour.
     Template(templates::Choice),
     OpenPage(ExGuid),
 @@ -386,10 +406,8 @@ struct State {
     menu: Option<(menus::Target, [f32; 2])>,
     /// A section or group being renamed in the sidebar.
     renaming: Option<sidebar::Renaming>,
-    /// The page whose tab is being dragged.
+    /// What the pointer is dragging: a page's tab, a section tab or a sidebar row.
-    dragging: Option<ExGuid>,
+    drag: Option<menus::Drag>,
-    /// The section or group whose sidebar row is being dragged.
-    dragging_entry: Option<sidebar::Entry>,
     /// Pages whose template strip was dismissed this run.
     dismissed: HashSet<ExGuid>,
     /// A page just created, whose title takes the caret once it opens.
 @@ -461,8 +479,11 @@ impl State {
         substitutes: &[PathBuf],
         interface_font: Vec<Vec<u8>>,
         visible: bool,
-        (settings, stored): (Option<PathBuf>, settings::Settings),
+        settings::Launch {
-        cache: PathBuf,
+            file: settings,
+            saved: stored,
+            cache,
+        }: settings::Launch,
     ) -> Result<Self, Box<dyn Error>> {
         let window = Arc::new(
             event_loop.create_window(
 @@ -652,8 +673,7 @@ impl State {
             title_focus: None,
             menu: None,
             renaming: None,
-            dragging: None,
+            drag: None,
-            dragging_entry: None,
             templates: templates::View::Strip,
             thumbnails: templates::Thumbnails::default(),
             filter: String::new(),
 @@ -795,7 +815,9 @@ impl State {
                 self.ui.theme.inactive_selection,
             ] = platform::text_colors(&self.window);
         }
-        let theme = self.ui.theme.clone();
+        // The page, and the open page's tab joined to it, take the page's colour.
+        let mut theme = self.ui.theme.clone();
+        theme.paper = self.paper().color;
         if !platform::system_titlebar(&self.window) {
             self.title_bar(&theme);
         }
 @@ -820,7 +842,7 @@ impl State {
                 ..Spec::default()
             },
         );
-        self.ui.open(
+        let tab_row = self.ui.open(
             "tabs",
             Spec {
                 size: [fill(), px(TAB_ROW)],
 @@ -836,6 +858,7 @@ impl State {
                 ..Spec::default()
             },
         );
+        let row = self.ui.id("sections");
         let (clicked, open_tab) = match &self.session {
             Some(session) => {
                 let tabs: Vec<_> = session
 @@ -843,14 +866,26 @@ impl State {
                     .iter()
                     .map(|tab| (tab.name.as_str(), section_color(tab.color)))
                     .collect();
-                let (clicked, context, open_tab) = ui::shell::section_tabs(
+                let lit = self.page_drop(row);
+                let ui::shell::Tabs {
+                    clicked,
+                    context,
+                    held,
+                    open: open_tab,
+                } = ui::shell::section_tabs(
                     &mut self.ui,
                     "sections",
                     &tabs,
                     session.tab,
+                    lit,
                     &section,
                     TAB_ROW,
                 );
+                let bar = self.ui.rect(tab_row).unwrap_or_default();
+                self.drag_tabs(held, row, bar, section.accent);
+                let Some(session) = &self.session else {
+                    unreachable!("The tabs are the session's")
+                };
                 let open = |tab: usize| {
                     Command::OpenSection(Arc::clone(&session.library), session.tabs[tab].path.clone())
                 };
 @@ -869,8 +904,16 @@ impl State {
             None => {
                 let tabs = [("Temporary page", section_color(None))];
                 let shown = if self.temporary { &tabs[..] } else { &[] };
-                let (_, _, open_tab) =
+                let open_tab = ui::shell::section_tabs(
-                    ui::shell::section_tabs(&mut self.ui, "sections", shown, 0, &section, TAB_ROW);
+                    &mut self.ui,
+                    "sections",
+                    shown,
+                    0,
+                    None,
+                    &section,
+                    TAB_ROW,
+                )
+                .open;
                 (None, open_tab)
             }
         };
 @@ -949,7 +992,7 @@ impl State {
         }
         self.page_events(signal.events)?;
         self.ui.close();
-        let open_page = self.page_list(&theme, &section);
+        let open_page = self.page_list(&theme, &section, row);
         self.ui.close();
         self.ui.close();
         self.ui.close();
 @@ -1008,7 +1051,7 @@ impl State {
         }
         outline.push(([left, bottom], ROUNDING));
         let height = (frame[3] - frame[1]).max(1.0);
-        let paper = self.ui.theme.paper;
+        let paper = self.paper().color;
         self.ui.round_corners(&outline, paper, |y| {
             ui::mix(section.frame[0], section.frame[1], (y - frame[1]) / height)
         });
 @@ -1092,7 +1135,7 @@ impl State {
                 "status",
                 Spec {
                     size: [fit(), px(TITLE)],
-                    text: Some(session.status),
+                    text: Some(&session.status()),
                     color: Some(theme.text_dim),
                     pad: [12.0, 0.0],
                     ..Spec::default()
 @@ -1126,7 +1169,7 @@ impl State {
         let engine = &self.view.engine;
         // Under the system's title bar the save status joins the toolbar.
         let status = platform::system_titlebar(&self.window)
-            .then(|| self.session.as_ref().map(|session| session.status))
+            .then(|| self.session.as_ref().map(Session::status))
             .flatten();
         let ui = &mut self.ui;
         let text = theme.text;
 @@ -1446,8 +1489,8 @@ impl State {
             ui.leaf(
                 "status",
                 Spec {
-                    size: [fit(), fill()],
+                    size: [fit(), px(ui::shell::TOOL)],
-                    text: Some(status),
+                    text: Some(&status),
                     color: Some(theme.text_dim),
                     center: true,
                     ..Spec::default()
 @@ -1579,7 +1622,7 @@ impl State {
             }
         }
         if ui::shell::tool_button(&mut self.ui, "new", art::PLUS, theme.text, false).clicked {
-            self.commands.push(Command::NewPage { subpage: false });
+            self.commands.push(Command::NewPage { under: None });
         }
         let toggle = if self.pages_open {
             art::SIDEBAR_COLLAPSE
 @@ -1594,7 +1637,7 @@ impl State {
     /// The section's pages as tabs down the frame's right side, returning the open page's
     /// tab, which is the page's colour and joins it.
-    fn page_list(&mut self, theme: &Theme, section: &ui::Section) -> Option<Id> {
+    fn page_list(&mut self, theme: &Theme, section: &ui::Section, tabs: Id) -> Option<Id> {
         let session = self.session.as_ref()?;
         let panel = self.ui.id("panel");
         let width = self
 @@ -1616,7 +1659,7 @@ impl State {
             self.ui.open_popup(menus::id());
         }
         let rect = self.ui.rect(panel).unwrap_or_default();
-        self.drag_pages(rows.held, section, rect);
+        self.drag_pages(rows.held, section, rect, tabs);
         self.ui.close();
         rows.open
     }
 @@ -1681,6 +1724,13 @@ impl State {
                         self.ui.set_focus(Some(filter()));
                         continue;
                     }
+                    // OneNote's New Page is Ctrl+N.
+                    let new = matches!(&key, Key::Character(character)
+                        if character.eq_ignore_ascii_case("n"));
+                    if modifiers.command && !modifiers.shift && new && self.session.is_some() {
+                        self.commands.push(Command::NewPage { under: None });
+                        continue;
+                    }
                     self.view.key(&ui::edit_key(&key), text.as_deref())?
                 }
                 ui::Event::Ime(Ime::Preedit(text, cursor)) => self.view.compose(text, cursor)?,
 @@ -1715,13 +1765,13 @@ impl State {
                 self.load(move || {
                     let section = library.open(&path, notify)?;
                     let (session, page) = read_session(section, library, path, last)?;
-                    Ok((Loaded::Section(Box::new(session)), page))
+                    Ok(Loaded::Section(Box::new(session), page))
                 });
             }
             Command::OpenPage(space) => {
                 let session = self.session.as_ref().ok_or("No section is open")?;
                 let read = session.reader(space);
-                self.load(move || Ok((Loaded::Page(space), read()?)));
+                self.load(move || Ok(Loaded::Page(space, read()?)));
             }
             Command::Versions { page, show } => {
                 let session = self.session.as_mut().ok_or("No section is open")?;
 @@ -1769,9 +1819,10 @@ impl State {
             Command::NewNotebook => self.new_notebook()?,
             Command::CloseNotebook(library) => self.close_notebook(&library),
             Command::Structure(library, change) => self.restructure(library, change),
-            Command::NewPage { subpage } => self.new_page(subpage)?,
+            Command::NewPage { under } => self.new_page(under)?,
             Command::DeletePages(pages) => self.delete_pages(pages)?,
             Command::Pages(edits) => self.edit_pages(edits)?,
+            Command::MovePage { space, path } => self.move_page(space, path)?,
             Command::Template(choice) => self.apply_template(choice)?,
             Command::Page(Request::EditDate(field)) => self.edit_date(field)?,
             Command::Page(Request::Copy(text)) => self.clipboard.set_text(text)?,
 @@ -1790,7 +1841,7 @@ impl State {
     /// read was asked for meanwhile.
     fn load(
         &mut self,
-        read: impl FnOnce() -> Result<(Loaded, Page), Box<dyn Error>> + Send + 'static,
+        read: impl FnOnce() -> Result<Loaded, Box<dyn Error>> + Send + 'static,
     ) {
         self.loading += 1;
         let (id, sender, redraw) = (self.loading, self.loads.0.clone(), self.redraw.clone());
 @@ -1803,13 +1854,20 @@ impl State {
     /// Lays out the newest page read, and shows it once the pictures it shows first are
     /// drawn, or after `HOLD`.
     fn open_loaded(&mut self) -> Result<(), Box<dyn Error>> {
-        for (id, loaded) in self.loads.1.try_iter() {
+        let reads: Vec<Read> = self.loads.1.try_iter().collect();
+        for (id, loaded) in reads {
             if id != self.loading {
                 continue;
             }
             let (loaded, page) = match loaded {
-                Ok(loaded) => loaded,
+                Ok(Loaded::Section(session, page)) => (Shown::Section(session), page),
+                Ok(Loaded::Page(space, page)) => (Shown::Page(space), page),
+                Ok(Loaded::Library(library, path)) => {
+                    self.adopt(library, &path)?;
+                    continue;
+                }
                 Err(error) => {
+                    eprintln!("{error}");
                     platform::alert("Couldn't open", &error);
                     continue;
                 }
 @@ -1828,7 +1886,8 @@ impl State {
         let paper = canvas::gpu::Paper {
             color: self.ui.theme.paper,
             ink: self.ui.theme.paper_ink,
-        };
+        }
+        .colored(opening.editor.page_color());
         if !self
             .view
             .prepare(&mut opening.scene, &opening.editor, paper, &self.redraw)
 @@ -1845,7 +1904,7 @@ impl State {
             self.last_pages.insert(key, session.space);
         }
         match opening.loaded {
-            Loaded::Section(session) => {
+            Shown::Section(session) => {
                 // A notebook read again after a change replaces the one it was.
                 match self
                     .notebooks
 @@ -1859,7 +1918,7 @@ impl State {
                 self.filter.clear();
                 self.save_settings();
             }
-            Loaded::Page(space) => {
+            Shown::Page(space) => {
                 let session = self.session.as_mut().ok_or("No section is open")?;
                 session.space = space;
                 session.change = None;
 @@ -1886,6 +1945,46 @@ impl State {
         Ok(())
     }
+    /// Takes `library`, a notebook read again after a change, in place of the one it was;
+    /// the open section, now at catalog `path` in it, stays open, reopened where it moved.
+    fn adopt(&mut self, library: Arc<Library>, path: &str) -> Result<(), Box<dyn Error>> {
+        match self
+            .notebooks
+            .iter_mut()
+            .find(|open| open.location == library.location)
+        {
+            Some(open) => *open = Arc::clone(&library),
+            None => self.notebooks.push(Arc::clone(&library)),
+        }
+        let Some(session) = &mut self.session else {
+            return Ok(());
+        };
+        let folder = path.rsplit_once('/').map_or("", |(folder, _)| folder);
+        let space = session.space;
+        if session.tabs[session.tab].path == path {
+            session.tabs = library.tabs(folder);
+            session.tab = session
+                .tabs
+                .iter()
+                .position(|tab| tab.path == path)
+                .ok_or("The section is not in its notebook")?;
+            session.library = library;
+        } else {
+            // Its file moved: the replica it holds reopens on the file's new path.
+            self.persist()?;
+            if let Some(session) = self.session.take() {
+                session.section.close()?;
+            }
+            let section = library.open(path, notify(self.proxy.clone()))?;
+            let (session, page) = read_session(section, library, path.to_owned(), Some(space))?;
+            self.session = Some(session);
+            let response = self.view.refresh(page)?;
+            self.respond(response);
+        }
+        self.save_settings();
+        Ok(())
+    }
     /// Follows a page shown in place of another.
     fn opened(&mut self) -> Result<(), Box<dyn Error>> {
         self.ui.set_focus(Some(page()));
 @@ -2064,6 +2163,10 @@ impl State {
             },
         )?;
         session.status = "Saving";
+        // The page list shows the title as it is typed.
+        if self.view.editor.active_outline().title {
+            session.pages = session.section.pages()?;
+        }
         Ok(())
     }
 @@ -2316,13 +2419,19 @@ impl State {
         Ok(())
     }
+    /// The paper the open page lies on: the theme's, in the page's colour.
+    fn paper(&self) -> canvas::gpu::Paper {
+        canvas::gpu::Paper {
+            color: self.ui.theme.paper,
+            ink: self.ui.theme.paper_ink,
+        }
+        .colored(self.view.editor.page_color())
+    }
     /// Paints the interface with the page in its box.
     fn paint(&mut self, target: &wgpu::TextureView) -> Result<(), Box<dyn Error>> {
         let start = Instant::now();
-        let paper = canvas::gpu::Paper {
+        let paper = self.paper();
-            color: self.ui.theme.paper,
-            ink: self.ui.theme.paper_ink,
-        };
         self.view.update_pictures(paper, &self.redraw);
         let theme = &self.ui.theme;
         let page_primitives = self.view.primitives(TextColors {
 @@ -2356,7 +2465,7 @@ impl State {
                         viewport.origin[1] + corner[1] * scale,
                     ],
                     clip: Some(rect.map(|value| value * scale)),
-                    backdrop: Some(self.ui.theme.paper),
+                    backdrop: Some(paper.color),
                     primitives: &page_primitives,
                 },
             })
 @@ -2790,41 +2899,6 @@ fn page_tab(
     ui.signal(row)
 }
-/// `page` with its conflict objects marked as OneNote shows a conflict page's: a band
-/// across each conflicting paragraph's outline.
-fn highlighted(mut page: Page, objects: &[ExGuid]) -> Page {
-    use onestore::page::{PageObject, PageParagraph, ParagraphContent};
-    fn mark(paragraphs: &mut [PageParagraph], objects: &[ExGuid]) {
-        for paragraph in paragraphs {
-            match &mut paragraph.content {
-                ParagraphContent::Table(table) => {
-                    for cell in table.rows.iter_mut().flat_map(|row| &mut row.cells) {
-                        mark(&mut cell.paragraphs, objects);
-                    }
-                }
-                ParagraphContent::Text(text)
-                    if objects.contains(&paragraph.id) || objects.contains(&text.id) =>
-                {
-                    paragraph.format.highlight = Some(CONFLICTING);
-                }
-                _ => {}
-            }
-        }
-    }
-    for object in &mut page.objects {
-        match object {
-            PageObject::Outline(outline) => mark(&mut outline.paragraphs, objects),
-            PageObject::Title(title) => {
-                for outline in &mut title.outlines {
-                    mark(&mut outline.paragraphs, objects);
-                }
-            }
-            _ => {}
-        }
-    }
-    page
-}
 /// The pages whose titles contain `filter`, ignoring case.
 fn matching<'a>(
     pages: &'a [(ExGuid, String, u32)],
 @@ -3025,6 +3099,10 @@ impl ApplicationHandler<UserEvent> for App {
                             state.window.set_theme(Some(appearance));
                             state.ui.theme = theme(appearance);
                         }
+                        Replay::Quit => {
+                            self.close(event_loop);
+                            return;
+                        }
                     }
                     // A covered window gets no redraws, so each step draws its own frame.
                     if let Err(error) = state.frame() {
 @@ -3072,15 +3150,15 @@ impl ApplicationHandler<UserEvent> for App {
             &self.substitutes,
             std::mem::take(&mut self.interface_font),
             self.screenshot.is_none(),
-            self.settings.take().unwrap_or_default(),
+            self.launch.take().expect("The window opens once"),
-            self.cache.clone(),
         )) {
             Ok(mut state) => match &self.screenshot {
-                Some(prefix) => {
+                // A replay drives the hidden window instead, its snapshots capturing it.
+                Some(prefix) if std::env::var_os("SNOWBOUND_REPLAY").is_none() => {
                     self.startup_error = state.screenshot(prefix).err();
                     event_loop.exit();
                 }
-                None => self.state = Some(state),
+                _ => self.state = Some(state),
             },
             Err(error) => {
                 self.startup_error = Some(error);
 @@ -3217,9 +3295,9 @@ impl ApplicationHandler<UserEvent> for App {
 }
 /// Feeds a development script to the window from another thread, one command per line
-/// in logical pixels: `move X Y`, `press`, `release`, `wheel DX DY`, `key NAME`, `type
+/// in logical pixels: `move X Y`, `press [right]`, `release [right]`, `wheel DX DY`, `key NAME`, `type
-/// TEXT`, `modifiers [shift] [command]`, `wait MILLISECONDS`, `snapshot PNG_PATH` and
+/// TEXT`, `modifiers [shift] [command]`, `wait MILLISECONDS`, `snapshot PNG_PATH`,
-/// `appearance light|dark`.
+/// `appearance light|dark` and `quit`.
 fn replay(script: String, proxy: EventLoopProxy<UserEvent>) -> Result<(), Box<dyn Error>> {
     let mut steps = Vec::new();
     for line in script.lines().filter(|line| !line.trim().is_empty()) {
 @@ -3228,7 +3306,11 @@ fn replay(script: String, proxy: EventLoopProxy<UserEvent>) -> Result<(), Box<dy
             rest.split_whitespace().map(str::parse).collect()
         };
         let button = |pressed| ui::Event::Button {
-            button: MouseButton::Left,
+            button: if rest == "right" {
+                MouseButton::Right
+            } else {
+                MouseButton::Left
+            },
             pressed,
             at: Instant::now(),
         };
 @@ -3269,6 +3351,7 @@ fn replay(script: String, proxy: EventLoopProxy<UserEvent>) -> Result<(), Box<dy
                     .try_fold(ModifiersState::empty(), |all, one| one.map(|one| all | one))?,
             ))),
             "wait" => Err(std::time::Duration::from_millis(rest.parse()?)),
+            "quit" => Ok(Replay::Quit),
             "snapshot" => Ok(Replay::Snapshot(rest.into())),
             "appearance" => Ok(Replay::Appearance(match rest {
                 "light" => winit::window::Theme::Light,
 @@ -3467,8 +3550,11 @@ fn main() -> Result<(), Box<dyn Error>> {
         proxy: event_loop.create_proxy(),
         input: Some(input),
         // A screenshot leaves the settings as it found them.
-        settings: Some((settings_file.filter(|_| screenshot.is_none()), saved)),
+        launch: Some(settings::Launch {
-        cache,
+            file: settings_file.filter(|_| screenshot.is_none()),
+            saved,
+            cache,
+        }),
         substitutes,
         interface_font,
         screenshot,

crates/snowbound/src/manage.rs+489-90

...	@@ -12,19 +12,35 @@ use std::{error::Error, sync::Arc};	...	@@ -12,19 +12,35 @@ use std::{error::Error, sync::Arc};
12		12
13	/// A change to a notebook's sections and groups, by catalog path.	13	/// A change to a notebook's sections and groups, by catalog path.
14	pub enum Structure {	14	pub enum Structure {
15	NewSection { folder: String },	15	NewSection {
16	NewGroup { folder: String },	16	folder: String,
17	Rename { path: String, name: String },	17	},
		18	NewGroup {
		19	folder: String,
		20	},
		21	Rename {
		22	path: String,
		23	name: String,
		24	},
18	/// Moves a section or group to the recycle bin.	25	/// Moves a section or group to the recycle bin.
19	Delete { path: String },	26	Delete {
		27	path: String,
		28	},
20	/// Moves a section or group into another folder.	29	/// Moves a section or group into another folder.
21	Move { path: String, folder: String },	30	Move {
		31	path: String,
		32	folder: String,
		33	},
22	/// Orders a folder's sections and groups.	34	/// Orders a folder's sections and groups.
23	Reorder { folder: String, paths: Vec<String> },	35	Reorder {
		36	folder: String,
		37	paths: Vec<String>,
		38	},
24	}	39	}
25		40
26	/// Notebook colours for new notebooks, in turn: OneNote 2010's section colours.	41	/// The colour OneNote 2010 gave each new notebook beside its default one, COLORREF
27	const NOTEBOOK_COLORS: [u32; 3] = [0x00e4a88a, 0x0078b0f6, 0x00bba4d5];	42	/// (`corpus/notebook-management/native/new-notebook`).
		43	const NOTEBOOK_COLOR: u32 = 0x00aeba91;
28		44
29	/// `current`, the path of a section, after `from` moved to `to`: a section moved itself,	45	/// `current`, the path of a section, after `from` moved to `to`: a section moved itself,
30	/// or one inside a moved group.	46	/// or one inside a moved group.
...	@@ -56,18 +72,18 @@ impl State {	...	@@ -56,18 +72,18 @@ impl State {
56	Ok(creation.dated(&date, &time)?)	72	Ok(creation.dated(&date, &time)?)
57	}	73	}
58		74
59	/// Adds a page at the end of the open section, or a subpage after the open page, and	75	/// Adds a page at the end of the open section, or a subpage of page `under`, and opens
60	/// opens it with its title ready for typing, as OneNote's New Page and New Subpage do.	76	/// it with its title ready for typing, as OneNote's New Page and New Subpage do.
61	pub(crate) fn new_page(&mut self, subpage: bool) -> Result<(), Box<dyn Error>> {	77	pub(crate) fn new_page(&mut self, under: Option<ExGuid>) -> Result<(), Box<dyn Error>> {
62	self.persist()?;	78	self.persist()?;
63	let session = self.session.as_ref().ok_or("No section is open")?;	79	let session = self.session.as_ref().ok_or("No section is open")?;
64	// A subpage follows the open page and the subpages already under it.	80	// A subpage follows its page and the subpages already under it.
65	let (before, level) = if subpage {	81	let (before, level) = if let Some(under) = under {
66	let at = session	82	let at = session
67	.pages	83	.pages
68	.iter()	84	.iter()
69	.position(\|(space, ..)\| *space == session.space)	85	.position(\|(space, ..)\| *space == under)
70	.ok_or("The open page is not listed")?;	86	.ok_or("That page is not listed")?;
71	let level = session.pages[at].2;	87	let level = session.pages[at].2;
72	let next = session.pages[at + 1..]	88	let next = session.pages[at + 1..]
73	.iter()	89	.iter()
...	@@ -80,7 +96,7 @@ impl State {	...	@@ -80,7 +96,7 @@ impl State {
80	let creation = self.dated_page(None)?;	96	let creation = self.dated_page(None)?;
81	let space = creation.space();	97	let space = creation.space();
82	let mut ops = vec![Op::Section(SectionOp::Create(creation))];	98	let mut ops = vec![Op::Section(SectionOp::Create(creation))];
83	if subpage {	99	if under.is_some() {
84	ops.push(Op::Section(SectionOp::Pages(vec![PageEdit::move_to(	100	ops.push(Op::Section(SectionOp::Pages(vec![PageEdit::move_to(
85	space, before, level,	101	space, before, level,
86	)?])));	102	)?])));
...	@@ -105,59 +121,12 @@ impl State {	...	@@ -105,59 +121,12 @@ impl State {
105	&mut self,	121	&mut self,
106	choice: crate::templates::Choice,	122	choice: crate::templates::Choice,
107	) -> Result<(), Box<dyn Error>> {	123	) -> Result<(), Box<dyn Error>> {
108	use crate::templates::Choice;
109	self.persist()?;	124	self.persist()?;
110	let session = self.session.as_ref().ok_or("No section is open")?;	125	let session = self.session.as_ref().ok_or("No section is open")?;
111	let space = session.space;	126	let space = session.space;
112	let page = session.section.page(space)?;	127	let ops = template_ops(&session.section.page(space)?, choice)?;
113	let mut ops: Vec<PageOp> = page	128	if ops.is_empty() {
114	.objects	129	return Ok(());
115	.iter()
116	.filter(\|object\| matches!(object, PageObject::Image(image) if image.background))
117	.map(\|object\| PageOp::Delete {
118	object: object.id(),
119	})
120	.collect();
121	match choice {
122	Choice::Template(name) => {
123	let template =
124	canvas::template::find(name).ok_or("That template is not available")?;
125	if page.color.is_some() {
126	ops.push(PageOp::Color(None));
127	}
128	// Art lies under everything else on the page, first in its order.
129	let under = page
130	.objects
131	.iter()
132	.find(\|object\| !matches!(object, PageObject::Image(image) if image.background))
133	.map(PageObject::id);
134	for art in template.art {
135	let bytes = canvas::gpu::page::template_picture(art.art)
136	.ok_or("That template's art is missing")?;
137	ops.push(PageOp::Add {
138	object: PageObject::Image(Image {
139	id: onestore::page::text::new_id()?,
140	layout: onestore::document::Layout {
141	x: Some(art.position[0]),
142	y: Some(art.position[1]),
143	max_width: art.size.map(\|size\| size[0]),
144	max_height: art.size.map(\|size\| size[1]),
145	width_set_by_user: art.size.map(\|_\| true),
146	..Default::default()
147	},
148	size: art.size,
149	bytes: Some(bytes.into()),
150	alt: None,
151	background: true,
152	}),
153	before: under,
154	});
155	}
156	}
157	Choice::Color(index) => {
158	ops.push(PageOp::Color(Some(canvas::template::PAGE_COLORS[index].1)))
159	}
160	Choice::More \| Choice::Dismiss \| Choice::Colors => return Ok(()),
161	}	130	}
162	session.section.apply(	131	session.section.apply(
163	&self.author,	132	&self.author,
...	@@ -175,18 +144,17 @@ impl State {	...	@@ -175,18 +144,17 @@ impl State {
175	return Ok(());	144	return Ok(());
176	};	145	};
177	let page = self.dated_page(None)?;	146	let page = self.dated_page(None)?;
178	let color = NOTEBOOK_COLORS[self.notebooks.len() % NOTEBOOK_COLORS.len()];
179	let (cache, notify) = (self.cache.clone(), notify(self.proxy.clone()));	147	let (cache, notify) = (self.cache.clone(), notify(self.proxy.clone()));
180	self.load(move \|\| {	148	self.load(move \|\| {
181	let location = std::path::absolute(&root)?.to_string_lossy().into_owned();	149	let location = std::path::absolute(&root)?.to_string_lossy().into_owned();
182	let notebook = Notebook::create(&location, &cache, color, &page)?;	150	let notebook = Notebook::create(&location, &cache, NOTEBOOK_COLOR, &page)?;
183	let library = Arc::new(Library::open_notebook(&location, notebook, &cache));	151	let library = Arc::new(Library::created(&location, notebook, &cache));
184	let path = library	152	let path = library
185	.first_section()	153	.first_section()
186	.ok_or("The new notebook has no section")?;	154	.ok_or("The new notebook has no section")?;
187	let section = library.open(&path, notify)?;	155	let section = library.open(&path, notify)?;
188	let (session, page) = read_session(section, library, path, None)?;	156	let (session, page) = read_session(section, library, path, None)?;
189	Ok((Loaded::Section(Box::new(session)), page))	157	Ok(Loaded::Section(Box::new(session), page))
190	});	158	});
191	Ok(())	159	Ok(())
192	}	160	}
...	@@ -220,7 +188,9 @@ impl State {	...	@@ -220,7 +188,9 @@ impl State {
220	let page = match change {	188	let page = match change {
221	Structure::NewSection { .. } => match self.dated_page(None) {	189	Structure::NewSection { .. } => match self.dated_page(None) {
222	Ok(page) => Some(page),	190	Ok(page) => Some(page),
223	Err(error) => return platform::alert("Couldn't add the section", &error.to_string()),	191	Err(error) => {
		192	return platform::alert("Couldn't add the section", &error.to_string());
		193	}
224	},	194	},
225	_ => None,	195	_ => None,
226	};	196	};
...	@@ -229,9 +199,9 @@ impl State {	...	@@ -229,9 +199,9 @@ impl State {
229	.as_ref()	199	.as_ref()
230	.filter(\|session\| Arc::ptr_eq(&session.library, &library))	200	.filter(\|session\| Arc::ptr_eq(&session.library, &library))
231	.map(\|session\| session.tabs[session.tab].path.clone());	201	.map(\|session\| session.tabs[session.tab].path.clone());
232	let (cache, notify) = (self.cache.clone(), notify(self.proxy.clone()));	202	let notify = notify(self.proxy.clone());
233	self.load(move \|\| {	203	self.load(move \|\| {
234	let mut notebook = Notebook::open(&library.location, &cache)?;	204	let mut notebook = library.reopen()?;
235	let names = \|notebook: &Notebook, folder: &str\| -> Vec<String> {	205	let names = \|notebook: &Notebook, folder: &str\| -> Vec<String> {
236	let mut folders = vec![notebook.catalog()];	206	let mut folders = vec![notebook.catalog()];
237	while let Some(candidate) = folders.pop() {	207	while let Some(candidate) = folders.pop() {
...	@@ -251,43 +221,56 @@ impl State {	...	@@ -251,43 +221,56 @@ impl State {
251	}	221	}
252	Vec::new()	222	Vec::new()
253	};	223	};
254	let open = match change {	224	// The open section where the change leaves it, and the section to show.
		225	let (followed, created) = match change {
255	Structure::NewSection { folder } => {	226	Structure::NewSection { folder } => {
256	let name = unused(&names(&notebook, &folder), "New Section", true);	227	let name = unused(&names(&notebook, &folder), "New Section", true);
257	let page = page.ok_or("The new section has no page")?;	228	let page = page.ok_or("The new section has no page")?;
258	Some(notebook.create_section(&folder, &name, &page)?)	229	(
		230	current,
		231	Some(notebook.create_section(&folder, &name, &page)?),
		232	)
259	}	233	}
260	Structure::NewGroup { folder } => {	234	Structure::NewGroup { folder } => {
261	let name = unused(&names(&notebook, &folder), "New Section Group", false);	235	let name = unused(&names(&notebook, &folder), "New Section Group", false);
262	notebook.create_group(&folder, &name)?;	236	notebook.create_group(&folder, &name)?;
263	current	237	(current, None)
264	}	238	}
265	Structure::Rename { path, name } => {	239	Structure::Rename { path, name } => {
266	let renamed = notebook.rename(&path, &name)?;	240	let renamed = notebook.rename(&path, &name)?;
267	current.map(\|current\| follow(&current, &path, &renamed))	241	(
		242	current.map(\|current\| follow(&current, &path, &renamed)),
		243	None,
		244	)
268	}	245	}
269	Structure::Delete { path } => {	246	Structure::Delete { path } => {
270	notebook.delete(&path)?;	247	notebook.delete(&path)?;
271	current	248	(current, None)
272	}	249	}
273	Structure::Move { path, folder } => {	250	Structure::Move { path, folder } => {
274	let moved = notebook.move_entry(&path, &folder)?;	251	let moved = notebook.move_entry(&path, &folder)?;
275	current.map(\|current\| follow(&current, &path, &moved))	252	(current.map(\|current\| follow(&current, &path, &moved)), None)
276	}	253	}
277	Structure::Reorder { folder, paths } => {	254	Structure::Reorder { folder, paths } => {
278	let paths: Vec<&str> = paths.iter().map(String::as_str).collect();	255	let paths: Vec<&str> = paths.iter().map(String::as_str).collect();
279	notebook.reorder(&folder, &paths)?;	256	notebook.reorder(&folder, &paths)?;
280	current	257	(current, None)
281	}	258	}
282	};	259	};
283	let library = Arc::new(Library::open_notebook(&library.location, notebook, &cache));	260	let open = created.or(followed.clone());
		261	let library = Arc::new(library.with(notebook));
284	let path = open	262	let path = open
285	.filter(\|path\| library.contains(path))	263	.filter(\|path\| library.contains(path))
286	.or_else(\|\| library.first_section())	264	.or_else(\|\| library.first_section())
287	.ok_or("The notebook has no sections left")?;	265	.ok_or("The notebook has no sections left")?;
		266	// The open section, perhaps renamed or moved, stays open: its replica is this
		267	// thread's to reopen only where no section holds it.
		268	if followed.as_deref() == Some(path.as_str()) {
		269	return Ok(Loaded::Library(library, path));
		270	}
288	let section = library.open(&path, notify)?;	271	let section = library.open(&path, notify)?;
289	let (session, page) = read_session(section, library, path, None)?;	272	let (session, page) = read_session(section, library, path, None)?;
290	Ok((Loaded::Section(Box::new(session)), page))	273	Ok(Loaded::Section(Box::new(session), page))
291	});	274	});
292	}	275	}
293		276
...	@@ -327,16 +310,66 @@ impl State {	...	@@ -327,16 +310,66 @@ impl State {
327	space	310	space
328	}	311	}
329	};	312	};
330	let notebook = match &session.library.notebook {	313	let notebook =
331	Ok(Some(_)) => Some((session.library.location.clone(), self.cache.clone())),	314	matches!(session.library.notebook, Ok(Some(_))).then(\|\| Arc::clone(&session.library));
332	_ => None,
333	};
334	let replica = Arc::clone(session.section.replica());	315	let replica = Arc::clone(session.section.replica());
335	let author = self.author.clone();	316	let author = self.author.clone();
336	self.load(move \|\| {	317	self.load(move \|\| {
337	if let Some((location, cache)) = notebook {	318	if let Some(library) = notebook {
338	Notebook::open(&location, &cache)?.recycle_pages(&pages, &author)?;	319	library.reopen()?.recycle_pages(&pages, &author)?;
		320	}
		321	replica.apply(
		322	&author,
		323	Edit {
		324	at: crate::filetime(),
		325	ops,
		326	},
		327	)?;
		328	Ok(Loaded::Page(next, replica.page(next)?))
		329	});
		330	Ok(())
		331	}
		332
		333	/// Moves page `space` of the open section to the end of the section at catalog `path`,
		334	/// as OneNote moves a page dropped on a section's tab: the page keeps its identity,
		335	/// title, date and content there and leaves this section.
		336	pub(crate) fn move_page(&mut self, space: ExGuid, path: String) -> Result<(), Box<dyn Error>> {
		337	self.persist()?;
		338	let session = self.session.as_ref().ok_or("No section is open")?;
		339	let import = notebook::session::moved(&session.section.page(space)?, &self.author)?;
		340	let at = session
		341	.pages
		342	.iter()
		343	.position(\|(listed, ..)\| *listed == space)
		344	.unwrap_or_default();
		345	let next = session.pages[at + 1..]
		346	.iter()
		347	.chain(session.pages[..at].iter().rev())
		348	.map(\|(listed, ..)\| *listed)
		349	.next();
		350	let mut ops = vec![Op::Section(SectionOp::Delete(vec![space]))];
		351	let next = match next {
		352	Some(next) => next,
		353	None => {
		354	let fresh = self.dated_page(None)?;
		355	let space = fresh.space();
		356	ops.push(Op::Section(SectionOp::Create(fresh)));
		357	space
339	}	358	}
		359	};
		360	let library = Arc::clone(&session.library);
		361	let replica = Arc::clone(session.section.replica());
		362	let author = self.author.clone();
		363	self.load(move \|\| {
		364	let target = library.open(&path, \|\| {})?;
		365	target.replica().apply(
		366	&author,
		367	Edit {
		368	at: crate::filetime(),
		369	ops: vec![import],
		370	},
		371	)?;
		372	target.close()?;
340	replica.apply(	373	replica.apply(
341	&author,	374	&author,
342	Edit {	375	Edit {
...	@@ -344,7 +377,7 @@ impl State {	...	@@ -344,7 +377,7 @@ impl State {
344	ops,	377	ops,
345	},	378	},
346	)?;	379	)?;
347	Ok((Loaded::Page(next), replica.page(next)?))	380	Ok(Loaded::Page(next, replica.page(next)?))
348	});	381	});
349	Ok(())	382	Ok(())
350	}	383	}
...	@@ -366,9 +399,371 @@ impl State {	...	@@ -366,9 +399,371 @@ impl State {
366	}	399	}
367	}	400	}
368		401
		402	/// The ops giving `page` `choice`'s background: its template art (OneNote's pictures'
		403	/// places, our recreations' bytes) or a page colour, in place of the background it had.
		404	pub fn template_ops(
		405	page: &Page,
		406	choice: crate::templates::Choice,
		407	) -> Result<Vec<PageOp>, Box<dyn Error>> {
		408	use crate::templates::Choice;
		409	let mut ops: Vec<PageOp> = page
		410	.objects
		411	.iter()
		412	.filter(\|object\| matches!(object, PageObject::Image(image) if image.background))
		413	.map(\|object\| PageOp::Delete {
		414	object: object.id(),
		415	})
		416	.collect();
		417	match choice {
		418	Choice::Template(name) => {
		419	let template = canvas::template::find(name).ok_or("That template is not available")?;
		420	if page.color.is_some() {
		421	ops.push(PageOp::Color(None));
		422	}
		423	// Art lies under everything else on the page, first of its children (the title
		424	// is no child).
		425	let under = page
		426	.objects
		427	.iter()
		428	.find(\|object\| match object {
		429	PageObject::Title(_) => false,
		430	PageObject::Image(image) => !image.background,
		431	_ => true,
		432	})
		433	.map(PageObject::id);
		434	for art in template.art {
		435	let bytes = canvas::gpu::page::template_picture(art.art)
		436	.ok_or("That template's art is missing")?;
		437	ops.push(PageOp::Add {
		438	object: PageObject::Image(Image {
		439	id: onestore::page::text::new_id()?,
		440	layout: onestore::document::Layout {
		441	x: Some(art.position[0]),
		442	y: Some(art.position[1]),
		443	max_width: art.size.map(\|size\| size[0]),
		444	max_height: art.size.map(\|size\| size[1]),
		445	width_set_by_user: art.size.map(\|_\| true),
		446	..Default::default()
		447	},
		448	size: art.size,
		449	bytes: Some(bytes.into()),
		450	alt: None,
		451	background: true,
		452	}),
		453	before: under,
		454	});
		455	}
		456	// The one template with content worth keeping.
		457	if name == "Informal Meeting Notes" {
		458	ops.extend(onestore::op::lower_page(
		459	page,
		460	&crate::meeting::content(page)?,
		461	)?);
		462	}
		463	}
		464	Choice::Color(index) => {
		465	ops.push(PageOp::Color(Some(canvas::template::PAGE_COLORS[index].1)))
		466	}
		467	Choice::More \| Choice::Dismiss \| Choice::Colors => return Ok(Vec::new()),
		468	}
		469	Ok(ops)
		470	}
		471
369	#[cfg(test)]	472	#[cfg(test)]
370	mod tests {	473	mod tests {
371	use super::*;	474	use super::*;
		475	use crate::templates::Choice;
		476	use std::path::Path;
		477
		478	const AUTHOR: &str = "Rust Author";
		479
		480	fn dated() -> PageCreation {
		481	let creation = PageCreation::new(None, Some(""), AUTHOR).unwrap();
		482	let [date, time] = platform::date_text(creation.created());
		483	creation.dated(&date, &time).unwrap()
		484	}
		485
		486	/// Applies `ops` to the section file at `file` as one edit, as the section thread does,
		487	/// and publishes it.
		488	fn edit(file: &Path, ops: Vec<Op>) {
		489	let arena = onestore::Arena::default();
		490	let mut section =
		491	onestore::Section::open(&arena, onestore::read_file(file).unwrap()).unwrap();
		492	section
		493	.apply(
		494	AUTHOR,
		495	&Edit {
		496	at: crate::filetime(),
		497	ops,
		498	},
		499	)
		500	.unwrap();
		501	if let Some(transaction) = section.seal().unwrap() {
		502	transaction.commit_file(file).unwrap();
		503	}
		504	}
		505
		506	fn pages(file: &Path) -> Vec<(ExGuid, String, u32)> {
		507	let arena = onestore::Arena::default();
		508	onestore::Section::open(&arena, onestore::read_file(file).unwrap())
		509	.unwrap()
		510	.pages()
		511	.unwrap()
		512	}
		513
		514	fn page(file: &Path, space: ExGuid) -> Page {
		515	let arena = onestore::Arena::default();
		516	onestore::Section::open(&arena, onestore::read_file(file).unwrap())
		517	.unwrap()
		518	.page(space)
		519	.unwrap()
		520	}
		521
		522	fn copy(from: &Path, to: &Path) {
		523	std::fs::create_dir_all(to).unwrap();
		524	for entry in std::fs::read_dir(from).unwrap().flatten() {
		525	let target = to.join(entry.file_name());
		526	if entry.file_type().unwrap().is_dir() {
		527	copy(&entry.path(), &target);
		528	} else {
		529	std::fs::copy(entry.path(), target).unwrap();
		530	}
		531	}
		532	}
		533
		534	/// A notebook made and changed the way the app makes and changes one: created with a
		535	/// dated first page; sections and groups added, renamed, moved, reordered and deleted to
		536	/// the recycle bin; pages titled, given a template's art or a colour, made subpages and
		537	/// deleted to the recycle bin. `SNOWBOUND_MANAGEMENT_EXPORT` names a new directory that
		538	/// receives it for a cold reopen in OneNote 2010.
		539	#[test]
		540	fn a_notebook_is_managed_as_onenote_manages_one() {
		541	let temporary =
		542	std::env::temp_dir().join(format!("snowbound-manage-{}", std::process::id()));
		543	let _ = std::fs::remove_dir_all(&temporary);
		544	std::fs::create_dir_all(&temporary).unwrap();
		545	let root = temporary.join("Managed");
		546	let cache = temporary.join("cache");
		547	let mut notebook = Notebook::create(&root, &cache, NOTEBOOK_COLOR, &dated()).unwrap();
		548	for (folder, name) in [("", "New Section 2"), ("", "Binned")] {
		549	notebook.create_section(folder, name, &dated()).unwrap();
		550	}
		551	for (group, section) in [("Kept", "Inner"), ("Doomed", "Gone")] {
		552	notebook.create_group("", group).unwrap();
		553	notebook.create_section(group, section, &dated()).unwrap();
		554	}
		555
		556	// Pages of the first section, each titled.
		557	let file = root.join("New Section 1.one");
		558	let first = pages(&file)[0].0;
		559	let title = \|space: ExGuid, text: &str\| {
		560	let page = page(&file, space);
		561	let title = page
		562	.objects
		563	.iter()
		564	.find_map(\|object\| match object {
		565	PageObject::Title(title) => title.outlines[0].paragraphs[0].text(),
		566	_ => None,
		567	})
		568	.unwrap()
		569	.id;
		570	Op::Page {
		571	space,
		572	op: PageOp::Text {
		573	text: title,
		574	range: 0..0,
		575	with: text.to_owned(),
		576	},
		577	}
		578	};
		579	edit(&file, vec![title(first, "Garden plan")]);
		580	let mut spaces = Vec::new();
		581	for text in [
		582	"Ivy page",
		583	"Teal page",
		584	"Subpage",
		585	"Deleted page",
		586	"Meeting page",
		587	] {
		588	let creation = dated();
		589	let space = creation.space();
		590	edit(&file, vec![Op::Section(SectionOp::Create(creation))]);
		591	edit(&file, vec![title(space, text)]);
		592	spaces.push(space);
		593	}
		594	let [ivy, teal, subpage, deleted, meeting] = spaces[..] else {
		595	unreachable!()
		596	};
		597	let background = \|space: ExGuid, choice: Choice\| {
		598	template_ops(&page(&file, space), choice)
		599	.unwrap()
		600	.into_iter()
		601	.map(\|op\| Op::Page { space, op })
		602	.collect::<Vec<_>>()
		603	};
		604	edit(&file, background(ivy, Choice::Template("Ivy")));
		605	edit(
		606	&file,
		607	background(meeting, Choice::Template("Informal Meeting Notes")),
		608	);
		609	let teal_index = canvas::template::PAGE_COLORS
		610	.iter()
		611	.position(\|(name, _)\| *name == "Teal")
		612	.unwrap();
		613	edit(&file, background(teal, Choice::Color(teal_index)));
		614	edit(
		615	&file,
		616	vec![Op::Section(SectionOp::Pages(vec![
		617	PageEdit::set_level(subpage, 2).unwrap(),
		618	]))],
		619	);
		620	let recycled = page(&file, deleted);
		621	notebook
		622	.recycle_pages(std::slice::from_ref(&recycled), AUTHOR)
		623	.unwrap();
		624	edit(&file, vec![Op::Section(SectionOp::Delete(vec![deleted]))]);
		625
		626	// A page moved to another section, as a drop on its tab moves it.
		627	let moved_space = {
		628	let creation = dated();
		629	let space = creation.space();
		630	edit(&file, vec![Op::Section(SectionOp::Create(creation))]);
		631	edit(&file, vec![title(space, "Moved page")]);
		632	space
		633	};
		634	let moving = page(&file, moved_space);
		635	let other = root.join("New Section 2.one");
		636	edit(
		637	&other,
		638	vec![notebook::session::moved(&moving, AUTHOR).unwrap()],
		639	);
		640	edit(
		641	&file,
		642	vec![Op::Section(SectionOp::Delete(vec![moved_space]))],
		643	);
		644	let arrived = pages(&other).last().unwrap().0;
		645	let arrived = page(&other, arrived);
		646	assert_eq!(
		647	(
		648	arrived.title.as_str(),
		649	arrived.identity,
		650	arrived.date_text()
		651	),
		652	("Moved page", moving.identity, moving.date_text())
		653	);
		654
		655	// Structure.
		656	assert_eq!(
		657	notebook.rename("New Section 2.one", "Kitchen").unwrap(),
		658	"Kitchen.one"
		659	);
		660	assert_eq!(
		661	notebook.move_entry("Kitchen.one", "Kept").unwrap(),
		662	"Kept/Kitchen.one"
		663	);
		664	assert_eq!(notebook.rename("Kept", "Archive").unwrap(), "Archive");
		665	notebook.delete("Doomed").unwrap();
		666	notebook.delete("Binned.one").unwrap();
		667	notebook
		668	.reorder("", &["Archive", "New Section 1.one"])
		669	.unwrap();
		670
		671	let catalog = notebook.catalog();
		672	let names = \|folder: &notebook::discover::Folder\| {
		673	folder
		674	.sections
		675	.iter()
		676	.map(\|section\| section.path.clone())
		677	.chain(folder.groups.iter().map(\|group\| group.path.clone()))
		678	.collect::<Vec<_>>()
		679	};
		680	assert_eq!(
		681	names(catalog),
		682	["New Section 1.one", "Archive", "OneNote_RecycleBin"]
		683	);
		684	assert_eq!(
		685	names(&catalog.groups[0]),
		686	["Archive/Inner.one", "Archive/Kitchen.one"]
		687	);
		688	let mut binned = names(&catalog.groups[1]);
		689	binned.sort();
		690	assert_eq!(
		691	binned,
		692	[
		693	"OneNote_RecycleBin/Binned.one",
		694	"OneNote_RecycleBin/Gone.one",
		695	"OneNote_RecycleBin/OneNote_DeletedPages.one",
		696	]
		697	);
		698	assert!(!root.join("Doomed").exists());
		699
		700	let listed = pages(&file);
		701	assert_eq!(
		702	listed
		703	.iter()
		704	.map(\|(_, title, level)\| (title.as_str(), *level))
		705	.collect::<Vec<_>>(),
		706	[
		707	("Garden plan", 1),
		708	("Ivy page", 1),
		709	("Teal page", 1),
		710	("Subpage", 2),
		711	("Meeting page", 1)
		712	]
		713	);
		714	let shown = page(&file, teal);
		715	assert_eq!(
		716	shown.color,
		717	Some(canvas::template::PAGE_COLORS[teal_index].1)
		718	);
		719	assert!(shown.date_text().is_some());
		720	assert!(
		721	page(&file, ivy)
		722	.objects
		723	.iter()
		724	.any(\|object\| matches!(object, PageObject::Image(image) if image.background))
		725	);
		726	let written = page(&file, meeting);
		727	let outlines: Vec<_> = written
		728	.objects
		729	.iter()
		730	.filter_map(\|object\| match object {
		731	PageObject::Outline(outline) => Some(outline),
		732	_ => None,
		733	})
		734	.collect();
		735	assert_eq!(outlines.len(), 4);
		736	let lines: Vec<&str> = outlines
		737	.iter()
		738	.flat_map(\|outline\| &outline.paragraphs)
		739	.filter_map(\|paragraph\| paragraph.text())
		740	.map(\|text\| text.text.text())
		741	.collect();
		742	assert!(lines.contains(&"Meeting Details") && lines.contains(&"Attendees:"));
		743	assert!(
		744	outlines
		745	.iter()
		746	.flat_map(\|outline\| &outline.paragraphs)
		747	.filter_map(\|paragraph\| paragraph.text())
		748	.any(\|text\| !text.tags.is_empty())
		749	);
		750	let bin = root.join("OneNote_RecycleBin/OneNote_DeletedPages.one");
		751	let [(space, title, 1)] = &pages(&bin)[..] else {
		752	panic!("{:?}", pages(&bin))
		753	};
		754	assert_eq!(title, "Deleted page");
		755	let kept = page(&bin, *space);
		756	assert_eq!(
		757	(kept.identity, kept.created),
		758	(recycled.identity, recycled.created)
		759	);
		760	assert_eq!(kept.date_text(), recycled.date_text());
		761
		762	if let Some(directory) = std::env::var_os("SNOWBOUND_MANAGEMENT_EXPORT") {
		763	copy(&root, Path::new(&directory));
		764	}
		765	std::fs::remove_dir_all(&temporary).unwrap();
		766	}
372		767
373	#[test]	768	#[test]
374	fn moved_sections_are_followed_and_new_names_take_the_next_number() {	769	fn moved_sections_are_followed_and_new_names_take_the_next_number() {
...	@@ -379,7 +774,11 @@ mod tests {	...	@@ -379,7 +774,11 @@ mod tests {
379	assert_eq!(unused(&taken, "New Section", true), "New Section 3");	774	assert_eq!(unused(&taken, "New Section", true), "New Section 3");
380	assert_eq!(unused(&[], "New Section Group", false), "New Section Group");	775	assert_eq!(unused(&[], "New Section Group", false), "New Section Group");
381	assert_eq!(	776	assert_eq!(
382	unused(&["New Section Group".to_owned()], "New Section Group", false),	777	unused(
		778	&["New Section Group".to_owned()],
		779	"New Section Group",
		780	false
		781	),
383	"New Section Group 2"	782	"New Section Group 2"
384	);	783	);
385	}	784	}

crates/snowbound/src/meeting.rs created+237

...	@@ -0,0 +1,237 @@
1	//! OneNote 2010's Informal Meeting Notes content (Business templates;
2	//! `corpus/notebook-management/native/meeting-template`): four outlines of bold headings over
3	//! numbered, to-do and arrow-bulleted lines, placed where the template places them.
4
5	use onestore::{
6	ExGuid,
7	document::{Format, Kind, Layout, Tag},
8	page::{
9	Definition, MediaIndex, Outline, Page, PageObject, PageParagraph, ParagraphContent,
10	TextObject, text::new_id,
11	},
12	};
13	use std::error::Error;
14
15	/// OneNote's automatic colour.
16	const AUTOMATIC: u32 = 0xff00_0000;
17
18	/// A list line's marker.
19	enum Marker {
20	Numbered,
21	Arrow,
22	ToDo,
23	None,
24	}
25
26	/// A heading and the lines under it.
27	type Heading = (&'static str, &'static [(&'static str, Marker)]);
28
29	/// An outline of the template: position, width, indents, then each heading's lines.
30	type Block = ([f32; 2], f32, [f32; 4], &'static [Heading]);
31
32	const OUTLINES: [Block; 4] = [
33	(
34	[36.0, 77.4],
35	141.75,
36	[18.0, 0.0, 21.6, 36.0],
37	&[("Agenda", &[("", Marker::Numbered)])],
38	),
39	(
40	[234.0, 77.4],
41	137.25,
42	[18.0, 0.0, 18.0, 36.0],
43	&[("Action Items", &[("", Marker::ToDo)])],
44	),
45	(
46	[423.0, 77.4],
47	136.5,
48	[18.0, 0.0, 21.6, 36.0],
49	&[("Important Dates", &[("", Marker::Arrow)])],
50	),
51	(
52	[36.0, 221.4],
53	529.5,
54	[18.0, 0.0, 36.0, 36.0],
55	&[
56	(
57	"Meeting Details",
58	&[
59	("Date and Time:", Marker::Arrow),
60	("Location:", Marker::Arrow),
61	("Attendees:", Marker::Arrow),
62	],
63	),
64	("Announcements", &[("", Marker::Arrow)]),
65	("Discussion", &[("", Marker::Arrow)]),
66	("Summary", &[("", Marker::Arrow), ("", Marker::None)]),
67	(
68	"Next Meeting",
69	&[
70	("Date and Time:", Marker::Arrow),
71	("Location:", Marker::Arrow),
72	("Agenda:", Marker::Arrow),
73	("Notes:", Marker::Arrow),
74	],
75	),
76	],
77	),
78	];
79
80	/// `page` with the template's outlines added after what it holds.
81	pub fn content(page: &Page) -> Result<Page, Box<dyn Error>> {
82	let mut page = page.clone();
83	let text = \|bold: bool\| Format {
84	bold: Some(bold),
85	italic: Some(false),
86	underline: Some(false),
87	strike: Some(false),
88	superscript: Some(false),
89	subscript: Some(false),
90	font: Some("Calibri".into()),
91	font_size: Some(11.0),
92	color: Some(AUTOMATIC),
93	highlight: Some(AUTOMATIC),
94	language: Some(0x409),
95	space_before: Some(0.0),
96	space_after: Some(0.0),
97	..Format::default()
98	};
99	let style = new_id()?;
100	page.definitions.insert(
101	style,
102	Definition {
103	kind: Kind::Style {
104	name: Some("p".into()),
105	},
106	format: Format {
107	language: None,
108	..text(false)
109	},
110	},
111	);
112	// Tag dates count seconds since 1980.
113	let created = u32::try_from(crate::filetime() / 10_000_000 - 11_644_473_600 - 315_532_800)?;
114	let to_do = new_id()?;
115	page.definitions.insert(
116	to_do,
117	Definition {
118	kind: Kind::TagDefinition {
119	label: Some("To Do".into()),
120	action_type: Some(0),
121	shape: Some(3),
122	color: None,
123	highlight: None,
124	},
125	format: Format::default(),
126	},
127	);
128	let paragraph = \|parent: Option<ExGuid>,
129	line: &str,
130	bold: bool,
131	lists: Vec<ExGuid>,
132	tags: Vec<Tag>\|
133	-> Result<PageParagraph, Box<dyn Error>> {
134	Ok(PageParagraph {
135	id: new_id()?,
136	parent,
137	level: if parent.is_some() { 2 } else { 1 },
138	style: Some(style),
139	format: Format::default(),
140	content: ParagraphContent::Text(TextObject {
141	id: new_id()?,
142	date_field: None,
143	text: onestore::page::Paragraph::new(line.to_owned(), text(bold)),
144	// OneNote tags the line's text, not its paragraph.
145	tags,
146	}),
147	lists,
148	tags: Vec::new(),
149	media: MediaIndex::default(),
150	collapsed: false,
151	})
152	};
153	for (position, width, indents, headings) in OUTLINES {
154	let mut paragraphs = Vec::new();
155	for (heading, lines) in headings {
156	let parent = paragraph(None, heading, true, Vec::new(), Vec::new())?;
157	let id = parent.id;
158	paragraphs.push(parent);
159	for (line, marker) in *lines {
160	let (lists, tags) = match marker {
161	Marker::None => (Vec::new(), Vec::new()),
162	Marker::ToDo => (
163	Vec::new(),
164	vec![Tag {
165	definition: Some(to_do),
166	action_type: None,
167	status: 0,
168	created: Some(created),
169	completed: Some(0),
170	start: None,
171	due: None,
172	task_id: None,
173	extra_set: 0,
174	}],
175	),
176	Marker::Numbered \| Marker::Arrow => {
177	let list = new_id()?;
178	page.definitions.insert(list, list_definition(marker));
179	(vec![list], Vec::new())
180	}
181	};
182	paragraphs.push(paragraph(Some(id), line, false, lists, tags)?);
183	}
184	}
185	page.objects.push(PageObject::Outline(Outline {
186	id: new_id()?,
187	title: false,
188	min_width: None,
189	layout: Layout {
190	x: Some(position[0]),
191	y: Some(position[1]),
192	max_width: Some(width),
193	width_set_by_user: Some(true),
194	..Layout::default()
195	},
196	indents: indents.to_vec(),
197	paragraphs,
198	unsupported: Vec::new(),
199	}));
200	}
201	Ok(page)
202	}
203
204	/// The template's `##.` numbering, or its Wingdings 3 arrow bullet.
205	fn list_definition(marker: &Marker) -> Definition {
206	let format = Format {
207	font_size: Some(11.0),
208	color: Some(AUTOMATIC),
209	..Format::default()
210	};
211	match marker {
212	Marker::Numbered => Definition {
213	kind: Kind::List {
214	font: None,
215	format: Some("\u{fffd}\u{0}.".into()),
216	restart: None,
217	bullet: None,
218	},
219	format: Format {
220	bold: Some(false),
221	italic: Some(false),
222	font: Some("Calibri".into()),
223	language: Some(0x409),
224	..format
225	},
226	},
227	_ => Definition {
228	kind: Kind::List {
229	font: Some("Wingdings 3".into()),
230	format: Some("}".into()),
231	restart: None,
232	bullet: Some(11),
233	},
234	format,
235	},
236	}
237	}

crates/snowbound/src/menus.rs+120-8

...	@@ -6,6 +6,15 @@ use onestore::{ExGuid, PageEdit};	...	@@ -6,6 +6,15 @@ use onestore::{ExGuid, PageEdit};
6	use std::sync::Arc;	6	use std::sync::Arc;
7	use ui::{Anchor, Id, popup::Item};	7	use ui::{Anchor, Id, popup::Item};
8		8
		9	/// What a drag holds.
		10	pub enum Drag {
		11	Page(ExGuid),
		12	/// A sidebar row.
		13	Entry(crate::sidebar::Entry),
		14	/// A section tab, by index.
		15	Tab(usize),
		16	}
		17
9	/// What a context menu was opened on.	18	/// What a context menu was opened on.
10	pub enum Target {	19	pub enum Target {
11	Page(ExGuid),	20	Page(ExGuid),
...	@@ -55,6 +64,8 @@ impl State {	...	@@ -55,6 +64,8 @@ impl State {
55	separated: true,	64	separated: true,
56	..item("New Page")	65	..item("New Page")
57	},	66	},
		67	// OneNote offers this beside New Page, which is a plain + here.
		68	item("New Subpage"),
58	Item {	69	Item {
59	separated: true,	70	separated: true,
60	disabled: level > above \|\| level >= 3,	71	disabled: level > above \|\| level >= 3,
...	@@ -93,7 +104,8 @@ impl State {	...	@@ -93,7 +104,8 @@ impl State {
93	};	104	};
94	let command = match (target, items[chosen].text) {	105	let command = match (target, items[chosen].text) {
95	(Target::Page(space), "Delete") => Some(Command::DeletePages(vec![space])),	106	(Target::Page(space), "Delete") => Some(Command::DeletePages(vec![space])),
96	(Target::Page(_), "New Page") => Some(Command::NewPage { subpage: false }),	107	(Target::Page(_), "New Page") => Some(Command::NewPage { under: None }),
		108	(Target::Page(space), "New Subpage") => Some(Command::NewPage { under: Some(space) }),
97	(Target::Page(space), text) => self.session.as_ref().and_then(\|session\| {	109	(Target::Page(space), text) => self.session.as_ref().and_then(\|session\| {
98	let level = session	110	let level = session
99	.pages	111	.pages
...	@@ -151,14 +163,33 @@ impl State {	...	@@ -151,14 +163,33 @@ impl State {
151	self.commands.extend(command);	163	self.commands.extend(command);
152	}	164	}
153		165
		166	/// The section tab, of those built as `row`, under the pointer while a page is dragged
		167	/// there, which a drop moves the page into.
		168	pub(crate) fn page_drop(&self, row: Id) -> Option<usize> {
		169	let (Some(Drag::Page(_)), Some(session), Some([x, y])) =
		170	(&self.drag, &self.session, self.ui.pointer())
		171	else {
		172	return None;
		173	};
		174	(0..session.tabs.len())
		175	.filter(\|tab\| *tab != session.tab)
		176	.find(\|tab\| {
		177	self.ui.rect(ui::shell::tab_id(row, *tab)).is_some_and(
		178	\|[left, top, right, bottom]\| x >= left && x < right && y >= top && y < bottom,
		179	)
		180	})
		181	}
		182
154	/// Moves a page by dragging its tab: while `held`, a line shows where it would go; let	183	/// Moves a page by dragging its tab: while `held`, a line shows where it would go; let
155	/// go, it moves there at its level, or under a page at most one level above it.	184	/// go, it moves there at its level, or under a page at most one level above it. Onto a
156	/// `panel` is the page list's rectangle.	185	/// section tab of those built as `row`, it moves to the end of that section, as
		186	/// OneNote moves a page dropped on a section's tab. `panel` is the page list's rectangle.
157	pub(crate) fn drag_pages(	187	pub(crate) fn drag_pages(
158	&mut self,	188	&mut self,
159	held: Option<ExGuid>,	189	held: Option<ExGuid>,
160	section: &ui::Section,	190	section: &ui::Section,
161	panel: [f32; 4],	191	panel: [f32; 4],
		192	row: Id,
162	) {	193	) {
163	let Some(session) = &self.session else {	194	let Some(session) = &self.session else {
164	return;	195	return;
...	@@ -166,17 +197,35 @@ impl State {	...	@@ -166,17 +197,35 @@ impl State {
166	if held.is_some() && !self.filter.is_empty() {	197	if held.is_some() && !self.filter.is_empty() {
167	return;	198	return;
168	}	199	}
169	let dragged = held.or(self.dragging.take());	200	let dropped = match (&self.drag, held) {
170	self.dragging = held;	201	(_, Some(space)) => Some(space),
171	let (Some(space), Some([_, y])) = (dragged, self.ui.pointer()) else {	202	(Some(Drag::Page(space)), None) => Some(*space),
		203	_ => None,
		204	};
		205	let target = self.page_drop(row);
		206	if let Some(space) = held {
		207	self.drag = Some(Drag::Page(space));
		208	} else if matches!(self.drag, Some(Drag::Page(_))) {
		209	self.drag = None;
		210	}
		211	let (Some(space), Some([_, y])) = (dropped, self.ui.pointer()) else {
172	return;	212	return;
173	};	213	};
		214	if let Some(tab) = target {
		215	if held.is_none() {
		216	let path = session.tabs[tab].path.clone();
		217	self.commands.push(Command::MovePage { space, path });
		218	}
		219	return;
		220	}
174	// Rows other than the dragged one, with where each lies.	221	// Rows other than the dragged one, with where each lies.
175	let rows: Vec<(ExGuid, u32, [f32; 4])> = session	222	let rows: Vec<(ExGuid, u32, [f32; 4])> = session
176	.pages	223	.pages
177	.iter()	224	.iter()
178	.filter(\|(listed, ..)\| *listed != space)	225	.filter(\|(listed, ..)\| *listed != space)
179	.filter_map(\|(listed, _, level)\| Some((listed, level, self.ui.rect(self.ui.id(listed))?)))	226	.filter_map(\|(listed, _, level)\| {
		227	Some((listed, level, self.ui.rect(self.ui.id(listed))?))
		228	})
180	.collect();	229	.collect();
181	let Some(level) = session	230	let Some(level) = session
182	.pages	231	.pages
...	@@ -217,11 +266,74 @@ impl State {	...	@@ -217,11 +266,74 @@ impl State {
217	section.accent,	266	section.accent,
218	1.5,	267	1.5,
219	);	268	);
220	self.dragging = held;
221	} else if let Ok(edit) = PageEdit::move_to(space, before, level) {	269	} else if let Ok(edit) = PageEdit::move_to(space, before, level) {
222	self.commands.push(Command::Pages(vec![edit]));	270	self.commands.push(Command::Pages(vec![edit]));
223	}	271	}
224	}	272	}
		273
		274	/// Reorders section tabs by dragging one: while `held`, a line shows where it would go
		275	/// among the tabs built as `row` in the tab row `bar`; let go, the folder takes that
		276	/// order.
		277	pub(crate) fn drag_tabs(
		278	&mut self,
		279	held: Option<usize>,
		280	row: Id,
		281	bar: [f32; 4],
		282	accent: [f32; 4],
		283	) {
		284	let Some(session) = &self.session else {
		285	return;
		286	};
		287	let dragged = match (&self.drag, held) {
		288	(_, Some(tab)) => Some(tab),
		289	(Some(Drag::Tab(tab)), None) => Some(*tab),
		290	_ => None,
		291	};
		292	if let Some(tab) = held {
		293	self.drag = Some(Drag::Tab(tab));
		294	} else if matches!(self.drag, Some(Drag::Tab(_))) {
		295	self.drag = None;
		296	}
		297	let (Some(tab), Some([x, _])) = (dragged, self.ui.pointer()) else {
		298	return;
		299	};
		300	let others: Vec<(usize, [f32; 4])> = (0..session.tabs.len())
		301	.filter(\|other\| *other != tab)
		302	.filter_map(\|other\| Some((other, self.ui.rect(ui::shell::tab_id(row, other))?)))
		303	.collect();
		304	let at = others
		305	.iter()
		306	.position(\|(_, rect)\| x < (rect[0] + rect[2]) / 2.0)
		307	.unwrap_or(others.len());
		308	let mut order: Vec<usize> = others.iter().map(\|(other, _)\| *other).collect();
		309	order.insert(at, tab);
		310	if order.iter().copied().eq(0..session.tabs.len()) {
		311	return;
		312	}
		313	if held.is_some() {
		314	let edge = match (
		315	at.checked_sub(1).map(\|before\| others[before].1),
		316	others.get(at),
		317	) {
		318	(_, Some((_, after))) => after[0],
		319	(Some(before), None) => before[2],
		320	(None, None) => return,
		321	} - bar[0];
		322	self.ui
		323	.mark([edge - 1.5, 4.0, edge + 1.5, bar[3] - bar[1]], accent, 1.5);
		324	} else {
		325	let path = &session.tabs[tab].path;
		326	let folder = folder(path);
		327	let paths = order
		328	.into_iter()
		329	.map(\|index\| session.tabs[index].path.clone())
		330	.collect();
		331	self.commands.push(Command::Structure(
		332	Arc::clone(&session.library),
		333	Structure::Reorder { folder, paths },
		334	));
		335	}
		336	}
225	}	337	}
226		338
227	/// The new section or group a menu's `text` asks for in `folder`.	339	/// The new section or group a menu's `text` asks for in `folder`.

crates/snowbound/src/screenshot.rs+1-4

 @@ -40,10 +40,7 @@ impl State {
             self.ui.theme = theme(appearance);
             // The page's box sizes the view whose pictures settle.
             self.layout(SIZE, SCALE)?;
-            let paper = canvas::gpu::Paper {
+            let paper = self.paper();
-                color: self.ui.theme.paper,
-                ink: self.ui.theme.paper_ink,
-            };
             if let Some((scene, _)) = &mut self.view.scene {
                 scene.settle(Some(&self.view.editor), self.view.viewport.scale, paper);
             }

crates/snowbound/src/settings.rs+17-3

 @@ -51,7 +51,8 @@ impl crate::State {
         let Some(path) = &self.settings else {
             return;
         };
-        let kept = |library: &&std::sync::Arc<crate::Library>| !matches!(library.notebook, Ok(None));
+        let kept =
+            |library: &&std::sync::Arc<crate::Library>| !matches!(library.notebook, Ok(None));
         let settings = Settings {
             notebooks: self
                 .notebooks
 @@ -74,6 +75,15 @@ impl crate::State {
     }
 }
+/// What a launch starts from besides its input.
+pub struct Launch {
+    /// Where the settings are saved; `None` leaves them as they were read.
+    pub file: Option<PathBuf>,
+    pub saved: Settings,
+    /// The directory holding the sections' replicas.
+    pub cache: PathBuf,
+}
 /// Where the settings live unless `--settings` names a file.
 pub fn default_path() -> Option<PathBuf> {
     Some(crate::platform::settings_dir()?.join("settings.json"))
 @@ -85,11 +95,15 @@ mod tests {
     #[test]
     fn settings_round_trip_and_tolerate_missing_fields() {
-        let directory = std::env::temp_dir().join(format!("snowbound-settings-{}", std::process::id()));
+        let directory =
+            std::env::temp_dir().join(format!("snowbound-settings-{}", std::process::id()));
         let path = directory.join("nested/settings.json");
         assert_eq!(Settings::load(&path), Settings::default());
         let settings = Settings {
-            notebooks: vec!["/notebooks/Personal".into(), "smb://server/share/Work".into()],
+            notebooks: vec![
+                "/notebooks/Personal".into(),
+                "smb://server/share/Work".into(),
+            ],
             current: Some("/notebooks/Personal".into()),
             sidebar: true,
             recent_fonts: vec!["Georgia".into()],

crates/snowbound/src/sidebar.rs+170-97

 @@ -22,7 +22,10 @@ pub enum Action {
     /// Shows a notebook where it was left.
     Notebook(usize),
     /// Opens a notebook's section by catalog path.
-    Open { notebook: usize, path: String },
+    Open {
+        notebook: usize,
+        path: String,
+    },
     /// Folds or unfolds a notebook's or section group's rows, by `fold_key`.
     Fold(String),
     NewNotebook,
 @@ -51,7 +54,7 @@ pub fn fold_key(library: &Library, path: &str) -> String {
 }
 /// What the tree's rows read and what they were asked.
-struct Tree<'a> {
+pub struct Tree<'a> {
     theme: &'a Theme,
     /// The open section's notebook index and catalog path.
     open: Option<(usize, &'a str)>,
 @@ -64,6 +67,25 @@ struct Tree<'a> {
     held: Option<Entry>,
 }
+impl<'a> Tree<'a> {
+    fn new(
+        theme: &'a Theme,
+        open: Option<(usize, &'a str)>,
+        folded: &'a HashSet<String>,
+        renaming: Option<&'a mut Renaming>,
+    ) -> Self {
+        Self {
+            theme,
+            open,
+            folded,
+            renaming,
+            action: None,
+            rows: Vec::new(),
+            held: None,
+        }
+    }
+}
 /// A section or group row, for dragging one onto or between the others.
 #[derive(Clone, PartialEq)]
 pub struct Entry {
 @@ -79,26 +101,10 @@ impl Entry {
     }
 }
-/// The sidebar under a header row `header` tall, listing `notebooks` with the open section
+/// The sidebar's header row, `header` tall, then with `rows` the tree of `notebooks` with
-/// marked.
+/// the open section marked.
-pub fn sidebar(
+fn sidebar(ui: &mut Ui, tree: &mut Tree, notebooks: &[Arc<Library>], header: f32, rows: bool) {
-    ui: &mut Ui,
+    let (theme, open, folded) = (tree.theme, tree.open, tree.folded);
-    theme: &Theme,
-    notebooks: &[Arc<Library>],
-    open: Option<(usize, &str)>,
-    folded: &HashSet<String>,
-    renaming: Option<&mut Renaming>,
-    header: f32,
-) -> (Option<Action>, Vec<Entry>, Option<Entry>) {
-    let mut tree = Tree {
-        theme,
-        open,
-        folded,
-        renaming,
-        action: None,
-        rows: Vec::new(),
-        held: None,
-    };
     ui.open(
         "header",
         Spec {
 @@ -121,6 +127,9 @@ pub fn sidebar(
         },
     );
     ui.close();
+    if !rows {
+        return;
+    }
     ui.open(
         "notebooks",
         Spec {
 @@ -136,7 +145,7 @@ pub fn sidebar(
         let unfolded = !folded.contains(&key);
         let (row, fold) = tree_row(
             ui,
-            &mut tree,
+            tree,
             ("notebook", index),
             Row {
                 label: &library.name,
 @@ -157,7 +166,7 @@ pub fn sidebar(
             tree.action = Some(Action::Menu(Target::Notebook(Arc::clone(library)), point));
         }
         if unfolded && let Some(catalog) = library.catalog() {
-            folder(ui, &mut tree, library, index, catalog, 1);
+            folder(ui, tree, library, index, catalog, 1);
         }
     }
     ui.close();
 @@ -176,7 +185,7 @@ pub fn sidebar(
     ] {
         let (row, _) = tree_row(
             ui,
-            &mut tree,
+            tree,
             part,
             Row {
                 label,
 @@ -193,7 +202,6 @@ pub fn sidebar(
         }
     }
     ui.close();
-    (tree.action, tree.rows, tree.held)
 }
 /// A notebook's or group's sections, then its groups, as OneNote lists them.
 @@ -210,9 +218,9 @@ fn folder(
         .filter(|(index, _)| *index == notebook)
         .map(|(_, path)| path);
     let renamed = |tree: &Tree, path: &str| {
-        tree.renaming
+        tree.renaming.as_ref().is_some_and(|renaming| {
-            .as_ref()
+            Arc::ptr_eq(&renaming.library, library) && renaming.path == path
-            .is_some_and(|renaming| Arc::ptr_eq(&renaming.library, library) && renaming.path == path)
+        })
     };
     for section in &folder.sections {
         let (name, color, readable) = match &section.state {
 @@ -299,7 +307,8 @@ fn folder(
 /// Records a section or group row for dragging.
 fn entry(ui: &Ui, tree: &mut Tree, notebook: usize, path: &str, group: bool, row: &Signal) {
-    let Some(rect) = ui.rect(ui.id(("section", notebook, path)))
+    let Some(rect) = ui
+        .rect(ui.id(("section", notebook, path)))
         .or_else(|| ui.rect(ui.id(("group", notebook, path))))
     else {
         return;
 @@ -454,9 +463,10 @@ impl crate::State {
         if self.temporary {
             return;
         }
-        let width = self
+        let width = self.ui.animate(
-            .ui
+            self.ui.id("sidebar"),
-            .animate(self.ui.id("sidebar"), if self.sidebar { WIDTH } else { RAIL });
+            if self.sidebar { WIDTH } else { RAIL },
+        );
         self.ui.open(
             "sidebar",
             Spec {
 @@ -483,15 +493,18 @@ impl crate::State {
                 .position(|library| Arc::ptr_eq(library, &session.library))?;
             Some((index, session.tabs[session.tab].path.as_str()))
         });
-        let (action, rows, held) = sidebar(
+        let mut tree = Tree::new(theme, open, &self.folded, self.renaming.as_mut());
+        // The collapsed rail shows only its button.
+        sidebar(
             &mut self.ui,
-            theme,
+            &mut tree,
             &self.notebooks,
-            open,
-            &self.folded,
-            self.renaming.as_mut(),
             crate::TAB_ROW,
+            width > RAIL + 0.5,
         );
+        let Tree {
+            action, rows, held, ..
+        } = tree;
         let corner = self.ui.rect(rows_id).unwrap_or_default();
         self.drag_entries(held, &rows, corner, theme);
         self.ui.close();
 @@ -509,12 +522,14 @@ impl crate::State {
             Some(Action::Notebook(index)) => {
                 let library = Arc::clone(&self.notebooks[index]);
                 if let Some(path) = library.first_section() {
-                    self.commands.push(crate::Command::OpenSection(library, path));
+                    self.commands
+                        .push(crate::Command::OpenSection(library, path));
                 }
             }
             Some(Action::Open { notebook, path }) => {
                 let library = Arc::clone(&self.notebooks[notebook]);
-                self.commands.push(crate::Command::OpenSection(library, path));
+                self.commands
+                    .push(crate::Command::OpenSection(library, path));
             }
             Some(Action::Menu(target, point)) => {
                 self.menu = Some((target, point));
 @@ -548,9 +563,23 @@ impl crate::State {
     /// group, as OneNote moves one dropped on a group's tab; between rows of its folder it
     /// takes that place; between rows of another folder it moves there, last. `corner` is
     /// the rows' box.
-    fn drag_entries(&mut self, held: Option<Entry>, rows: &[Entry], corner: [f32; 4], theme: &Theme) {
+    fn drag_entries(
-        let dragged = held.clone().or(self.dragging_entry.take());
+        &mut self,
-        self.dragging_entry = held.clone();
+        held: Option<Entry>,
+        rows: &[Entry],
+        corner: [f32; 4],
+        theme: &Theme,
+    ) {
+        let dragged = match (&self.drag, &held) {
+            (_, Some(entry)) => Some(entry.clone()),
+            (Some(crate::menus::Drag::Entry(entry)), None) => Some(entry.clone()),
+            _ => None,
+        };
+        if let Some(entry) = &held {
+            self.drag = Some(crate::menus::Drag::Entry(entry.clone()));
+        } else if matches!(self.drag, Some(crate::menus::Drag::Entry(_))) {
+            self.drag = None;
+        }
         let (Some(dragged), Some([_, y])) = (dragged, self.ui.pointer()) else {
             return;
         };
 @@ -620,118 +649,162 @@ impl crate::State {
             if into {
                 let [left, top, right, bottom] = under.rect;
                 self.ui.mark(
-                    [left - corner[0], top - corner[1], right - corner[0], bottom - corner[1]],
+                    [
+                        left - corner[0],
+                        top - corner[1],
+                        right - corner[0],
+                        bottom - corner[1],
+                    ],
                     [accent[0], accent[1], accent[2], 0.3],
                     4.0,
                 );
             } else {
-                let line = if before == Some(under.path.as_str()) { top } else { bottom } - corner[1];
+                let line = if before == Some(under.path.as_str()) {
+                    top
+                } else {
+                    bottom
+                } - corner[1];
                 self.ui.mark(
-                    [under.rect[0] - corner[0], line - 1.5, under.rect[2] - corner[0], line + 1.5],
+                    [
+                        under.rect[0] - corner[0],
+                        line - 1.5,
+                        under.rect[2] - corner[0],
+                        line + 1.5,
+                    ],
                     accent,
                     1.5,
                 );
             }
         } else {
             let library = std::sync::Arc::clone(&self.notebooks[dragged.notebook]);
-            self.commands.push(crate::Command::Structure(library, change));
+            self.commands
+                .push(crate::Command::Structure(library, change));
+        }
+    }
+    /// Opens what the open panel chose: a notebook folder, a notebook's table of contents,
+    /// or a section, in its notebook where it has one.
+    pub(crate) fn open_path(&mut self, path: &std::path::Path) {
+        match crate::library::locate(path) {
+            crate::library::Located::Notebook { root, section } => {
+                self.open_notebook(root.to_string_lossy().into_owned(), section)
+            }
+            crate::library::Located::Section(file) => {
+                let library = Arc::new(Library::section(&file, &self.cache));
+                let path = library.location.clone();
+                self.commands
+                    .push(crate::Command::OpenSection(library, path));
+            }
+            crate::library::Located::Nothing => crate::platform::alert(
+                "Couldn't open",
+                "Choose a notebook folder, its Open Notebook file, or a section file.",
+            ),
         }
     }
-    /// Shows the notebook at `location` at its first section, opening it unless it is open.
+    /// Shows the notebook at `location` at `section`, or its first section, opening it
-    pub(crate) fn open_notebook(&mut self, location: String) {
+    /// unless it is open.
+    pub(crate) fn open_notebook(&mut self, location: String, section: Option<String>) {
         let open = self
             .notebooks
             .iter()
             .find(|library| library.location == location)
             .cloned();
+        // The notebook shown already shows a section, which only one reader may hold.
+        if let Some(session) = &self.session
+            && session.library.location == location
+            && section
+                .as_ref()
+                .is_none_or(|section| *section == session.tabs[session.tab].path)
+        {
+            return;
+        }
         let (cache, notify) = (self.cache.clone(), crate::notify(self.proxy.clone()));
         self.load(move || {
             let library = open.unwrap_or_else(|| Arc::new(Library::notebook(&location, &cache)));
             if let Err(error) = &library.notebook {
                 return Err(error.clone().into());
             }
-            let path = library
+            let path = section
-                .first_section()
+                .filter(|path| library.contains(path))
+                .or_else(|| library.first_section())
                 .ok_or("This folder holds no notebook sections.")?;
             let section = library.open(&path, notify)?;
             let (session, page) = crate::read_session(section, library, path, None)?;
-            Ok((crate::Loaded::Section(Box::new(session)), page))
+            Ok(crate::Loaded::Section(Box::new(session), page))
         });
     }
-    /// The page's place on the first run, or once every notebook is closed.
+    /// The window below the title bar on the first run, or once every notebook is closed:
+    /// what is missing, and the two ways to start.
     pub(crate) fn welcome(&mut self, theme: &Theme) {
-        const SIZE: [f32; 2] = [420.0, 120.0];
+        const BUTTON: [f32; 2] = [200.0, 32.0];
-        let [left, top, right, bottom] = self.ui.rect(crate::page()).unwrap_or_default();
+        let [left, top, right, bottom] = self.ui.rect(self.ui.id("welcome")).unwrap_or_default();
-        self.ui.open_as(
+        self.ui.open(
-            crate::page(),
+            "welcome",
             Spec {
                 size: [fill(), fill()],
-                fill: Some(theme.paper),
+                fill: Some(theme.base),
                 ..Spec::default()
             },
         );
         self.ui.open(
-            "welcome",
+            "content",
             Spec {
                 flags: Flags::FLOAT,
                 axis: Axis::Y,
-                size: [px(SIZE[0]), px(SIZE[1])],
+                size: [px(BUTTON[0]), ui::children()],
                 position: [
-                    ((right - left - SIZE[0]) / 2.0).max(0.0),
+                    ((right - left - BUTTON[0]) / 2.0).max(0.0),
-                    ((bottom - top) * 0.4 - SIZE[1] / 2.0).max(0.0),
+                    ((bottom - top) * 0.4 - 60.0).max(0.0),
                 ],
-                gap: 4.0,
+                gap: 10.0,
                 ..Spec::default()
             },
         );
-        let ink = theme.paper_ink;
+        self.ui.leaf(
-        for (part, text, color) in [
+            "title",
-            ("title", "No notebooks open", ink),
+            Spec {
+                size: [fill(), px(28.0)],
+                text: Some("No notebooks open"),
+                center: true,
+                ..Spec::default()
+            },
+        );
+        let mut chosen = None;
+        for (part, icon, label, command) in [
+            (
+                "new",
+                art::PLUS,
+                "New Notebook",
+                crate::Command::NewNotebook,
+            ),
             (
-                "description",
+                "open",
-                "Open a notebook folder, or start a new notebook.",
+                art::NOTEBOOK,
-                ui::mix(ink, theme.paper, 0.45),
+                "Open Existing",
+                crate::Command::OpenNotebook,
             ),
         ] {
-            self.ui.leaf(
+            let button = self.ui.leaf(
                 part,
                 Spec {
-                    size: [fill(), px(26.0)],
+                    flags: Flags::CLICKABLE,
-                    text: Some(text),
+                    size: [fill(), px(BUTTON[1])],
-                    color: Some(color),
+                    icon: Some(icon),
+                    text: Some(label),
+                    fill: Some(theme.chip),
+                    hover_fill: Some(theme.hover()),
+                    hover_border: Some(theme.accent),
+                    radius: 6.0,
                     center: true,
                     ..Spec::default()
                 },
             );
-        }
+            if button.clicked {
-        let labels = ["Open Notebook…", "New Notebook…"];
-        let pad = 0.75 * theme.font_size;
-        let width: f32 = labels
-            .iter()
-            .map(|label| self.ui.measure(label)[0] + 2.0 * pad)
-            .sum::<f32>()
-            + 8.0;
-        self.ui.open(
-            "actions",
-            Spec {
-                size: [fill(), ui::children()],
-                pad: [((SIZE[0] - width) / 2.0).max(0.0), 12.0],
-                gap: 8.0,
-                ..Spec::default()
-            },
-        );
-        let mut chosen = None;
-        for (label, command) in labels
-            .into_iter()
-            .zip([crate::Command::OpenNotebook, crate::Command::NewNotebook])
-        {
-            if ui::button(&mut self.ui, label, label).clicked {
                 chosen = Some(command);
             }
         }
-        self.ui.close();
         self.commands.extend(chosen);
         self.ui.close();
         self.ui.close();

crates/snowbound/src/templates.rs+45-17

 @@ -50,9 +50,12 @@ pub enum View {
     Gallery,
 }
+/// A thumbnail's art: each raster and where it lies in the tile.
+type Art = Vec<(RasterImage, [f32; 4])>;
 /// Rasters of each template's art for its thumbnail, by template and paper.
 #[derive(Default)]
-pub struct Thumbnails(HashMap<(&'static str, bool), Vec<(RasterImage, [f32; 4])>>);
+pub struct Thumbnails(HashMap<(&'static str, bool), Art>);
 impl Thumbnails {
     /// `template`'s art and where it lies in a `TILE`, drawn at `scale` for `paper`.
 @@ -69,12 +72,8 @@ impl Thumbnails {
                 .art
                 .iter()
                 .filter_map(|art| {
-                    let (image, size) = canvas::gpu::page::template_art(
+                    let (image, size) =
-                        art.art,
+                        canvas::gpu::page::template_art(art.art, art.size, points * scale, paper)?;
-                        art.size,
-                        points * scale,
-                        paper,
-                    )?;
                     let [x, y] = [
                         (art.position[0] - REGION[0]) * points,
                         (art.position[1] - REGION[1]) * points,
 @@ -86,7 +85,10 @@ impl Thumbnails {
     }
 }
-/// The strip at `position` in the page box, with the page colours beneath while `colors`.
+/// The strip at `position` in the page box, `room` wide at most, with the page colours
+/// beneath while `colors`. Picks that do not fit give way from the end; More templates
+/// stays.
+#[allow(clippy::too_many_arguments)]
 fn strip(
     ui: &mut Ui,
     theme: &Theme,
 @@ -94,8 +96,20 @@ fn strip(
     paper: Paper,
     dark: bool,
     position: [f32; 2],
+    room: f32,
     colors: bool,
 ) -> Option<Choice> {
+    let more = (Choice::More, "More templates");
+    let mut used = 2.0 * PAD + tile_width(ui, more.1);
+    let mut shown = Vec::new();
+    for pick in STRIP {
+        used += GAP + tile_width(ui, pick.1);
+        if used > room {
+            break;
+        }
+        shown.push(pick);
+    }
+    shown.push(more);
     let mut chosen = None;
     ui.open(
         "templates",
 @@ -120,22 +134,27 @@ fn strip(
             ..Spec::default()
         },
     );
-    for (index, (choice, label)) in STRIP.into_iter().chain([(Choice::More, "More templates")]).enumerate() {
+    for (index, (choice, label)) in shown.into_iter().enumerate() {
         if tile(ui, theme, thumbnails, paper, dark, index, choice, label) {
             chosen = Some(choice);
         }
     }
     ui.close();
-    if colors {
+    let per_row = (((room - 2.0 * PAD + 6.0) / (SWATCH + 6.0)).floor() as usize).max(1);
+    for (row, swatches) in PAGE_COLORS.chunks(per_row).enumerate().filter(|_| colors) {
         ui.open(
-            "colors",
+            ("colors", row),
             Spec {
                 size: [ui::children(), px(SWATCH)],
                 gap: 6.0,
                 ..Spec::default()
             },
         );
-        for (index, (name, color)) in PAGE_COLORS.iter().enumerate() {
+        for (index, (name, color)) in swatches
+            .iter()
+            .enumerate()
+            .map(|(index, color)| (row * per_row + index, color))
+        {
             let swatch = ui.leaf(
                 (index, *name),
                 Spec {
 @@ -154,7 +173,9 @@ fn strip(
         }
         ui.close();
     }
-    let width = ui.rect(ui.id("tiles")).map_or(0.0, |rect| rect[2] - rect[0]);
+    let width = ui
+        .rect(ui.id("tiles"))
+        .map_or(0.0, |rect| rect[2] - rect[0]);
     let close = ui.leaf(
         "dismiss",
         Spec {
 @@ -279,6 +300,11 @@ fn page_color(color: u32, paper: Paper, dark: bool) -> [f32; 4] {
     [red, green, blue, 1.0]
 }
+/// How wide a tile labelled `label` stands: its thumbnail, or the label where it is wider.
+fn tile_width(ui: &mut Ui, label: &str) -> f32 {
+    TILE[0].max(ui.measure(label)[0] + 4.0)
+}
 /// One template's thumbnail over its label, as wide as the thumbnail or the label; true
 /// when clicked.
 #[allow(clippy::too_many_arguments)]
 @@ -293,7 +319,7 @@ fn tile(
     label: &str,
 ) -> bool {
     let scale = ui.scale();
-    let width = TILE[0].max(ui.measure(label)[0] + 4.0);
+    let width = tile_width(ui, label);
     let fill_color = match choice {
         Choice::Color(index) => page_color(PAGE_COLORS[index].1, paper, dark),
         Choice::More | Choice::Dismiss => theme.base,
 @@ -405,11 +431,12 @@ impl crate::State {
             (viewport.origin[0] + start[0] * viewport.scale) / scale,
             (viewport.origin[1] + (start[1] + LINES_ABOVE) * viewport.scale) / scale,
         ];
+        // Thumbnails show templates on plain paper, not the page's colour.
         let paper = Paper {
-            color: theme.paper,
+            color: self.ui.theme.paper,
-            ink: theme.paper_ink,
+            ink: self.ui.theme.paper_ink,
         };
-        let dark = theme.paper_ink[0] > theme.paper[0];
+        let dark = paper.ink[0] > paper.color[0];
         let chosen = match self.templates {
             View::Gallery => {
                 let size = [rect[2] - rect[0], rect[3] - rect[1]];
 @@ -422,6 +449,7 @@ impl crate::State {
                 paper,
                 dark,
                 position,
+                rect[2] - rect[0] - position[0] - 24.0,
                 view == View::Colors,
             ),
         };

crates/ui/src/shell.rs+35-7

 @@ -17,17 +17,17 @@ pub const TOOL: f32 = 22.0;
 /// Section tabs in a row `height` tall, as OneNote draws them: each leans over the next
 /// at 45°, and the open one lies on top in `section`'s colours, rising to meet the frame
-/// below as its outline and shadow fade in. `tabs` are names and section colours. Returns
+/// below as its outline and shadow fade in. `tabs` are names and section colours; `lit`
-/// the tab clicked, the tab whose context menu was asked for and where, and the open tab's
+/// shows as hovered, as a tab something is dragged onto.
-/// id, for `tab_base`.
 pub fn section_tabs(
     ui: &mut Ui,
     part: impl Hash,
     tabs: &[(&str, [f32; 4])],
     active: usize,
+    lit: Option<usize>,
     section: &Section,
     height: f32,
-) -> (Option<usize>, Option<(usize, [f32; 2])>, Id) {
+) -> Tabs {
     let theme = ui.theme.clone();
     ui.open(
         part,
 @@ -47,7 +47,7 @@ pub fn section_tabs(
             (left - width, width)
         })
         .collect();
-    let (mut clicked, mut context) = (None, None);
+    let (mut clicked, mut context, mut held) = (None, None, None);
     // Earlier tabs lie over later ones; the open tab over all.
     let order = (0..tabs.len())
         .rev()
 @@ -70,7 +70,11 @@ pub fn section_tabs(
                 position: [x, height - tall],
                 text: Some(name),
                 color: Some(mix(mix(theme.ink, fill, 0.2), theme.ink, open)),
-                fill: Some(mix(fill, [1.0; 4], 0.08)),
+                fill: Some(if lit == Some(index) {
+                    mix(colors.frame[0], [1.0; 4], 0.08)
+                } else {
+                    mix(fill, [1.0; 4], 0.08)
+                }),
                 gradient: Some(fill),
                 hover_fill: (index != active).then(|| mix(colors.frame[0], [1.0; 4], 0.08)),
                 border: Some(fade(section.edge, open)),
 @@ -87,10 +91,34 @@ pub fn section_tabs(
         if let Some(point) = signal.context {
             context = Some((index, point));
         }
+        if signal.dragging {
+            held = Some(index);
+        }
     }
     let open_tab = ui.id(("tab", active));
     ui.close();
-    (clicked, context, open_tab)
+    Tabs {
+        clicked,
+        context,
+        held,
+        open: open_tab,
+    }
+}
+/// The id of tab `index` of the section tabs built as `row`.
+pub fn tab_id(row: Id, index: usize) -> Id {
+    row.child(("tab", index))
+}
+/// What the section tabs were asked this frame.
+pub struct Tabs {
+    pub clicked: Option<usize>,
+    /// The tab whose context menu was asked for, and where.
+    pub context: Option<(usize, [f32; 2])>,
+    /// The tab held down, which a drag moves.
+    pub held: Option<usize>,
+    /// The open tab's id, for `tab_base`.
+    pub open: Id,
 }
 /// Where the tab laid out at `tab` in a row `height` tall meets the edge below it: from its

crates/ui/src/tests.rs+1-1

...	@@ -162,7 +162,7 @@ fn a_click_within_one_frame_starts_an_animation_read_before_it() {	...	@@ -162,7 +162,7 @@ fn a_click_within_one_frame_starts_an_animation_read_before_it() {
162	let mut ui = Ui::new(Theme::dark(), DOUBLE_CLICK);	162	let mut ui = Ui::new(Theme::dark(), DOUBLE_CLICK);
163	let mut open = false;	163	let mut open = false;
164	let mut width = 0.0;	164	let mut width = 0.0;
165	let mut build = \|ui: &mut Ui, open: &mut bool, width: &mut f32\| {	165	let build = \|ui: &mut Ui, open: &mut bool, width: &mut f32\| {
166	width = ui.animate(Id::ROOT.child("panel"), if open { 100.0 } else { 0.0 });	166	width = ui.animate(Id::ROOT.child("panel"), if open { 100.0 } else { 0.0 });
167	if button(ui, "toggle", "Toggle").clicked {	167	if button(ui, "toggle", "Toggle").clicked {
168	*open = true;	168	*open = true;

readme.md+1-1

...	@@ -12,7 +12,7 @@ pen and drawing tools, recording audio and video, revision history, multi-machin	...	@@ -12,7 +12,7 @@ pen and drawing tools, recording audio and video, revision history, multi-machin
12	live collaboration, and much more.	12	live collaboration, and much more.
13		13
14	<!-- Regenerate from the sample notebook (edit it freely in OneNote or Snowbound):	14	<!-- Regenerate from the sample notebook (edit it freely in OneNote or Snowbound):
15	python3 tools/canvas/build_macos.py --release && d=$(mktemp -d) && cp -R docs/sample-notebook/Personal "$d" && target/Snowbound.app/Contents/MacOS/Snowbound --notebook "$d/Personal" --cache "$d/cache" --screenshot docs/screenshot	15	python3 tools/canvas/build_macos.py --release && d=$(mktemp -d) && cp -R docs/sample-notebook/Personal "$d" && target/Snowbound.app/Contents/MacOS/Snowbound --notebook "$d/Personal" --cache "$d/cache" --settings "$d/settings.json" --screenshot docs/screenshot
16	-->	16	-->
17	<picture>	17	<picture>
18	<source media="(prefers-color-scheme: dark)" srcset="docs/screenshot-dark.png">	18	<source media="(prefers-color-scheme: dark)" srcset="docs/screenshot-dark.png">

author	clover caruso <git@paperclover.net> 2026-09-27 11:01:00-07:00
committer	clover caruso <git@paperclover.net> 2026-09-27 11:01:00-07:00
log	1c5ad4e548ef0556a3810f749c2cee0e5e51f289
tree	de334424b672c0b5a715ebe96eae1fd6868b860a
parent	130e7b1bd5ad7e9aac3a3b4e1dadb6ab3452cb27
signature	Signed by SSH key SHA256:52mNGHRsVFBDED9IAX5pe+LRWUefqTbxEReunq21QvU

feat: notebooks, sections and pages in the app, native Linux titlebars