Commit 4534c84f0003ef1bc0827ad8d1ab37a6ce30655f | snowbound

author	clover caruso <git@paperclover.net> 2026-10-16 02:01:55-07:00
committer	clover caruso <git@paperclover.net> 2026-10-16 02:24:41-07:00
log	4534c84f0003ef1bc0827ad8d1ab37a6ce30655f
tree	791cd40813ab1bbc8239e1b17b2d248b2045a5ae
parent	f6222caecf1c286dee2a1746307bf90d715044cf
signature	Signed by SSH key SHA256:52mNGHRsVFBDED9IAX5pe+LRWUefqTbxEReunq21QvU (~clover)

refactor: hold the page view in a Pane

Splitting the window needs everything one page view owns in one place. State.pane now holds the view, which page it shows (Showing: the space, the open version, the conflict pages and versions listed beneath it, the selected conflicting change), its loads in flight, Back and Forward, the stale and focus flags, and the locked section or sectionless notebook it shows instead of a page. Session keeps only what belongs to the section, so one section can later back two panes; its methods that depended on the open page take a Showing, and loads hand over the page they read beside the session.

The recent pages leave Trail for State, since they are one list kept in the settings while Back and Forward become each pane's own.

Nothing visible or behavioural changes: there is still one pane.

Assisted-by: claude-opus-5.5

29 files changed, 667 insertions(+), 561 deletions(-)

crates/snowbound/src/attachment.rs+13-6

 @@ -10,10 +10,14 @@ use std::{
 impl State {
     /// Inserts a file at the caret or window point `at`, as a picture when requested.
     pub(crate) fn import_file(&mut self, path: &Path, at: Option<[f32; 2]>, picture: bool) {
-        if self.session.as_ref().is_some_and(crate::Session::read_only) {
+        if self
+            .session
+            .as_ref()
+            .is_some_and(|session| session.read_only(&self.pane.showing))
+        {
             return;
         }
-        let loading = self.loading;
+        let loading = self.pane.loading;
         let reply = self.reply(
             move |state, (path, read): (PathBuf, std::io::Result<Vec<u8>>)| {
                 let bytes = match read {
 @@ -27,7 +31,7 @@ impl State {
                         return Ok(());
                     }
                 };
-                if state.loading != loading {
+                if state.pane.loading != loading {
                     platform::alert(
                         "File wasn't inserted",
                         "Return to the page and insert the file again.",
 @@ -37,7 +41,7 @@ impl State {
                 if state
                     .session
                     .as_ref()
-                    .is_some_and(crate::Session::read_only)
+                    .is_some_and(|session| session.read_only(&state.pane.showing))
                 {
                     return Ok(());
                 }
 @@ -60,8 +64,11 @@ impl State {
                     tags: Vec::new(),
                 };
                 let response = match at {
-                    Some(point) => state.view.drop_attachment(state.page_point(point), file)?,
+                    Some(point) => state
-                    None => state.view.insert_attachment(file)?,
+                        .pane
+                        .view
+                        .drop_attachment(state.page_point(point), file)?,
+                    None => state.pane.view.insert_attachment(file)?,
                 };
                 state.respond(response);
                 Ok(())

crates/snowbound/src/commands.rs+44-42

 @@ -1070,7 +1070,7 @@ impl State {
     }
     pub(crate) fn format_state(&self) -> FormatState {
-        self.view.editor.format_state().unwrap_or_default()
+        self.pane.view.editor.format_state().unwrap_or_default()
     }
     /// Queues `choice` to run after this frame's input, as a key or a click on it does.
 @@ -1127,7 +1127,7 @@ impl State {
     pub(crate) fn status(&self, choice: &Choice, format: &FormatState) -> Status {
         let session = self.session.as_ref();
-        let welcome = session.is_none() && !self.temporary && self.sectionless.is_none();
+        let welcome = session.is_none() && !self.temporary && self.pane.sectionless.is_none();
         let modal = self.options.is_some()
             || self.password.is_some()
             || self.themes.is_some()
 @@ -1138,13 +1138,14 @@ impl State {
         #[cfg(any(windows, target_os = "linux"))]
         let modal = modal || self.prompt.strong_count() != 0;
         let page = (session.is_some() || self.temporary) && !modal;
-        let writable = page && !session.is_some_and(|session| session.read_only());
+        let writable =
+            page && !session.is_some_and(|session| session.read_only(&self.pane.showing));
         // Picked drawings leave the text selection behind them unseen, so it takes no edits.
-        let typing = self.view.accepts_text() && self.view.ink_selection().is_empty();
+        let typing = self.pane.view.accepts_text() && self.pane.view.ink_selection().is_empty();
         let text = writable && typing;
         let tagged = writable
             && matches!(
-                self.view.object_focus(),
+                self.pane.view.object_focus(),
                 Some(
                     canvas::interaction::ObjectFocus::Image(_)
                         | canvas::interaction::ObjectFocus::File(_)
 @@ -1152,12 +1153,12 @@ impl State {
             );
         // Palette commands act after its search field returns focus to the editor.
         let field = self.ui.focused_field(Some(crate::palette::id())).is_some();
-        let [anchor, focus] = self.view.editor.selection().positions;
+        let [anchor, focus] = self.pane.view.editor.selection().positions;
         let selected = page
             && !field
             && (typing && anchor != focus
                 || matches!(
-                    self.view.object_focus(),
+                    self.pane.view.object_focus(),
                     Some(canvas::interaction::ObjectFocus::Image(_))
                 ));
         let enabled = |enabled| Status {
 @@ -1178,7 +1179,7 @@ impl State {
             Choice::Pen(_) => Id::Pen,
             Choice::Symbol(_) => Id::Symbol,
         };
-        let tool = self.view.tool();
+        let tool = self.pane.view.tool();
         match id {
             Id::Settings
             | Id::NewNotebook
 @@ -1267,8 +1268,8 @@ impl State {
                     checked: Some(false),
                 },
                 |session| Status {
-                    enabled: !session.page_versions(session.space).is_empty(),
+                    enabled: !session.page_versions(self.pane.showing.space).is_empty(),
-                    checked: Some(session.shown_history == Some(session.space)),
+                    checked: Some(self.pane.showing.shown_history == Some(self.pane.showing.space)),
                 },
             ),
             Id::FullPageView => Status {
 @@ -1312,7 +1313,7 @@ impl State {
             },
             Id::SnapToGrid => Status {
                 enabled: !modal,
-                checked: Some(self.view.snap_to_grid),
+                checked: Some(self.pane.view.snap_to_grid),
             },
             Id::HideSpelling => Status {
                 enabled: !modal && self.spelling.is_some(),
 @@ -1320,9 +1321,9 @@ impl State {
             },
             Id::MarkdownShortcuts => Status {
                 enabled: !modal,
-                checked: Some(self.view.editor.markdown.is_some()),
+                checked: Some(self.pane.view.editor.markdown.is_some()),
             },
-            Id::Spelling => enabled(text && self.view.spelling.is_some()),
+            Id::Spelling => enabled(text && self.pane.view.spelling.is_some()),
             Id::FormatPainter => Status {
                 enabled: text,
                 checked: Some(self.painter.is_some()),
 @@ -1343,7 +1344,7 @@ impl State {
             Id::Transport(transport) => self.transport_status(transport),
             Id::InsertSpace => Status {
                 enabled: writable,
-                checked: Some(self.view.inserting_space()),
+                checked: Some(self.pane.view.inserting_space()),
             },
             Id::SelectType => Status {
                 enabled: page,
 @@ -1427,7 +1428,7 @@ impl State {
         if matches!(formatting, Formatting::Font(_)) || self.toolbar != kept {
             self.save_settings();
         }
-        let response = self.view.format(formatting)?;
+        let response = self.pane.view.format(formatting)?;
         self.respond(response);
         Ok(())
     }
 @@ -1442,7 +1443,7 @@ impl State {
         self.session
             .as_ref()
             .map(|session| &session.library)
-            .or(self.sectionless.as_ref())
+            .or(self.pane.sectionless.as_ref())
     }
     /// Runs `choice` where it applies now.
 @@ -1463,22 +1464,22 @@ impl State {
             Choice::Color(color) => return format(self, Formatting::Color(color)),
             Choice::List(style) => return format(self, Formatting::List(style)),
             Choice::Table([rows, columns]) => {
-                let response = self.view.insert_table(rows, columns)?;
+                let response = self.pane.view.insert_table(rows, columns)?;
                 self.respond(response);
                 return Ok(());
             }
             Choice::PageColor(color) => {
-                return self.paper_page(color, self.view.editor.rule_lines(), None);
+                return self.paper_page(color, self.pane.view.editor.rule_lines(), None);
             }
             Choice::Art(name) => {
                 return self.with_art(name.and_then(canvas::template::find), |state, art| {
-                    let editor = &state.view.editor;
+                    let editor = &state.pane.view.editor;
                     state.paper_page(editor.page_color(), editor.rule_lines(), Some(art))
                 });
             }
             Choice::RuleLines(lines) => {
                 let lines = lines.map(|index| canvas::template::RULE_LINES[index].1);
-                return self.paper_page(self.view.editor.page_color(), lines, None);
+                return self.paper_page(self.pane.view.editor.page_color(), lines, None);
             }
             Choice::Pen(place) => {
                 self.toolbar.pen = place;
 @@ -1495,7 +1496,7 @@ impl State {
                 recent.insert(0, symbol);
                 recent.truncate(crate::symbol::GALLERY);
                 self.save_settings();
-                let response = self.view.insert_symbol(symbol)?;
+                let response = self.pane.view.insert_symbol(symbol)?;
                 self.respond(response);
                 return Ok(());
             }
 @@ -1544,18 +1545,19 @@ impl State {
                 title: String::new(),
             },
             Id::NewSubpage => Work::NewPage {
-                under: self.session.as_ref().map(|session| session.space),
+                under: self.session.as_ref().map(|_| self.pane.showing.space),
                 title: String::new(),
             },
             Id::PageVersions => {
-                let session = self.session.as_ref().ok_or("No notebook is open")?;
+                self.session.as_ref().ok_or("No notebook is open")?;
                 Work::History {
-                    page: session.space,
+                    page: self.pane.showing.space,
-                    show: session.shown_history != Some(session.space),
+                    show: self.pane.showing.shown_history != Some(self.pane.showing.space),
                 }
             }
             Id::CopyPageLink => {
-                let space = self.session.as_ref().ok_or("No notebook is open")?.space;
+                self.session.as_ref().ok_or("No notebook is open")?;
+                let space = self.pane.showing.space;
                 let link = self.page_link(space, None)?;
                 self.clipboard.set_text(link)?;
                 return Ok(());
 @@ -1604,7 +1606,7 @@ impl State {
             }
             Id::Undo | Id::Redo => return self.step(id == Id::Redo),
             Id::Cut | Id::Copy => {
-                let response = self.view.copy(id == Id::Cut)?;
+                let response = self.pane.view.copy(id == Id::Cut)?;
                 self.respond(response);
                 return Ok(());
             }
 @@ -1624,7 +1626,7 @@ impl State {
             Id::FormatPainter => {
                 self.painter = match self.painter {
                     Some(_) => None,
-                    None => Some(self.view.editor.painted_format()?),
+                    None => Some(self.pane.view.editor.painted_format()?),
                 };
                 return Ok(());
             }
 @@ -1632,7 +1634,7 @@ impl State {
                 match field {
                     Some(field) => self.ui.focus_all(field),
                     None => {
-                        let response = self.view.widen_selection()?;
+                        let response = self.pane.view.widen_selection()?;
                         self.respond(response);
                     }
                 }
 @@ -1668,11 +1670,11 @@ impl State {
             }
             Id::ZoomIn | Id::ZoomOut | Id::ActualSize => {
                 let zoom = match id {
-                    Id::ZoomIn => self.view.zoom() * 1.1,
+                    Id::ZoomIn => self.pane.view.zoom() * 1.1,
-                    Id::ZoomOut => self.view.zoom() / 1.1,
+                    Id::ZoomOut => self.pane.view.zoom() / 1.1,
                     _ => 1.0,
                 };
-                let response = self.view.set_zoom(zoom)?;
+                let response = self.pane.view.set_zoom(zoom)?;
                 self.respond(response);
                 return Ok(());
             }
 @@ -1725,12 +1727,12 @@ impl State {
                 return Ok(());
             }
             Id::SnapToGrid => {
-                self.view.snap_to_grid = !self.view.snap_to_grid;
+                self.pane.view.snap_to_grid = !self.pane.view.snap_to_grid;
                 self.save_settings();
                 return Ok(());
             }
             Id::MarkdownShortcuts => {
-                self.view.editor.markdown = markdown(self.view.editor.markdown.is_none());
+                self.pane.view.editor.markdown = markdown(self.pane.view.editor.markdown.is_none());
                 self.save_settings();
                 return Ok(());
             }
 @@ -1743,7 +1745,7 @@ impl State {
             Id::RecordAudio | Id::RecordVideo => return self.record(id == Id::RecordVideo),
             Id::Transport(transport) => return self.run_transport(transport),
             Id::InsertSpace => {
-                let response = self.view.insert_space();
+                let response = self.pane.view.insert_space();
                 self.respond(response);
                 return Ok(());
             }
 @@ -1756,7 +1758,7 @@ impl State {
                     Id::Shape(kind) => Tool::Shape(kind, pens[0].shape()),
                     _ => Tool::Select,
                 };
-                let response = self.view.set_tool(tool);
+                let response = self.pane.view.set_tool(tool);
                 self.respond(response);
                 return Ok(());
             }
 @@ -1765,7 +1767,7 @@ impl State {
                 return Ok(());
             }
             Id::Equation => {
-                let response = self.view.insert_equation()?;
+                let response = self.pane.view.insert_equation()?;
                 self.respond(response);
                 return Ok(());
             }
 @@ -1779,7 +1781,7 @@ impl State {
                     Id::Time => time,
                     _ => format!("{date} {time}"),
                 };
-                let response = self.view.insert_text(format!("{text} "))?;
+                let response = self.pane.view.insert_text(format!("{text} "))?;
                 self.respond(response);
                 return Ok(());
             }
 @@ -1803,7 +1805,7 @@ impl State {
             // Clear Formatting at a caret makes the paragraph Normal, as OneNote 2010's
             // Ctrl+Shift+N does; over a selection it clears the characters' formatting.
             Id::ClearFormatting => {
-                let [anchor, focus] = self.view.editor.selection().positions;
+                let [anchor, focus] = self.pane.view.editor.selection().positions;
                 if anchor == focus {
                     return format(self, Formatting::Style(self.gallery_style("p")));
                 }
 @@ -2096,9 +2098,9 @@ mod tests {
         for effect in [
             "self.respond(",
             "self.changed",
-            "self.view.format(",
+            "self.pane.view.format(",
-            "self.view.set_zoom(",
+            "self.pane.view.set_zoom(",
-            "self.view.insert",
+            "self.pane.view.insert",
             "self.open_link_dialog(",
         ] {
             assert!(

crates/snowbound/src/conflict_render.rs+21-15

 @@ -10,7 +10,7 @@ const SCALE: f32 = 2.0;
 /// One view laid out: the bar and the page on the left, the page list on the right; `menu`
 /// opens the conflict page's menu.
-fn layout(ui: &mut Ui, session: &Session, menu: bool) -> Vec<Command> {
+fn layout(ui: &mut Ui, session: &Session, showing: &Showing, menu: bool) -> Vec<Command> {
     let theme = ui.theme.clone();
     let section = theme.section(section_color(None));
     ui.begin(SIZE, SCALE, Instant::now());
 @@ -36,7 +36,7 @@ fn layout(ui: &mut Ui, session: &Session, menu: bool) -> Vec<Command> {
         },
     );
     let mut commands: Vec<Command> = session
-        .bar()
+        .bar(showing)
         .and_then(|bar| conflict_bar(ui, bar, &["synthetic", "Songs"], [false, true]))
         .into_iter()
         .collect();
 @@ -64,6 +64,7 @@ fn layout(ui: &mut Ui, session: &Session, menu: bool) -> Vec<Command> {
         &theme,
         &section,
         session,
+        showing,
         [&HashSet::new(); 2],
         &HashMap::new(),
         (0.0, false),
 @@ -242,8 +243,7 @@ fn conflict_views_offer_the_versions_and_render_offscreen() {
     let library = Arc::new(crate::Library::section(&file, &directory.join("cache")));
     let section = library.open(&library.location, || {}).unwrap();
     let path = library.location.clone();
-    let (mut session, _) = read_session(section, library, path, None).unwrap();
+    let (session, page, _) = read_session(section, library, path, None).unwrap();
-    let page = session.space;
     let version = session.versions(page)[0].space;
     let output = std::env::var_os("SNOWBOUND_CONFLICT_RENDER").map(PathBuf::from);
     let mut gpu = output.as_deref().map(gpu);
 @@ -262,15 +262,18 @@ fn conflict_views_offer_the_versions_and_render_offscreen() {
             Theme::dark(),
         ),
     ] {
-        session.space = space;
+        let showing = Showing {
-        session.shown = shown;
+            space,
+            shown,
+            ..Showing::default()
+        };
         let mut ui = Ui::new(appearance, std::time::Duration::from_millis(500));
         // Later frames lay out with earlier frames' measurements, and a menu fades in.
         for _ in 0..8 {
-            layout(&mut ui, &session, menu);
+            layout(&mut ui, &session, &showing, menu);
             std::thread::sleep(std::time::Duration::from_millis(30));
         }
-        let bar = session.bar();
+        let bar = session.bar(&showing);
         match (name, bar) {
             ("page" | "page-dark", Some(Bar::Page { shown: false, .. }))
             | ("versions", Some(Bar::Page { shown: true, .. }))
 @@ -326,8 +329,7 @@ fn page_versions_list_open_read_only_and_render_offscreen() {
     let library = Arc::new(crate::Library::section(&file, &directory.join("cache")));
     let section = library.open(&library.location, || {}).unwrap();
     let path = library.location.clone();
-    let (mut session, _) = read_session(section, library, path, None).unwrap();
+    let (session, page, _) = read_session(section, library, path, None).unwrap();
-    let page = session.space;
     let versions: Vec<_> = session
         .page_versions(page)
         .iter()
 @@ -374,10 +376,14 @@ fn page_versions_list_open_read_only_and_render_offscreen() {
             Theme::dark(),
         ),
     ] {
-        session.shown_history = shown;
+        let showing = Showing {
-        session.version = version;
+            space: page,
-        assert_eq!(session.read_only(), version.is_some(), "{name}");
+            version,
-        match (session.bar(), version) {
+            shown_history: shown,
+            ..Showing::default()
+        };
+        assert_eq!(session.read_only(&showing), version.is_some(), "{name}");
+        match (session.bar(&showing), version) {
             (
                 Some(Bar::History {
                     version: open,
 @@ -393,7 +399,7 @@ fn page_versions_list_open_read_only_and_render_offscreen() {
         }
         let mut ui = Ui::new(appearance, std::time::Duration::from_millis(500));
         for _ in 0..8 {
-            layout(&mut ui, &session, menu);
+            layout(&mut ui, &session, &showing, menu);
             std::thread::sleep(std::time::Duration::from_millis(30));
         }
         for context in &versions {

crates/snowbound/src/history.rs+16-14

 @@ -25,9 +25,9 @@ impl Session {
     /// Whether the open page takes no edits: a conflict page, a version, or a page of the
     /// recycle bin.
-    pub(crate) fn read_only(&self) -> bool {
+    pub(crate) fn read_only(&self, showing: &Showing) -> bool {
-        self.version.is_some()
+        showing.version.is_some()
-            || self.conflict(self.space).is_some()
+            || self.conflict(showing.space).is_some()
             || crate::recycle::binned(&self.tabs[self.tab].path)
     }
 @@ -54,13 +54,13 @@ impl Session {
         }
     }
-    pub(crate) fn refresh_history(&mut self) -> Result<(), Box<dyn Error>> {
+    pub(crate) fn refresh_history(&mut self, showing: &mut Showing) -> Result<(), Box<dyn Error>> {
         self.history = self.section.versions()?;
-        if self
+        if showing
             .shown_history
             .is_some_and(|page| self.page_versions(page).is_empty())
         {
-            self.shown_history = None;
+            showing.shown_history = None;
         }
         Ok(())
     }
 @@ -142,9 +142,9 @@ pub fn menu(
 impl State {
     /// Shows or hides a page's versions under it; hiding leaves an open version for its page.
     pub(crate) fn show_history(&mut self, page: ExGuid, show: bool) -> Result<(), Box<dyn Error>> {
-        let session = self.session.as_mut().ok_or("No section is open")?;
+        self.session.as_ref().ok_or("No section is open")?;
-        session.shown_history = show.then_some(page);
+        self.pane.showing.shown_history = show.then_some(page);
-        if !show && session.version.is_some() {
+        if !show && self.pane.showing.version.is_some() {
             self.commands.push(Command::OpenPage(page));
         }
         Ok(())
 @@ -174,7 +174,7 @@ impl State {
             .restore_version_async(page, version, &self.author);
         self.section_edit(operation, move |state, _| {
             if let Some(session) = &mut state.session {
-                session.refresh_history()?;
+                session.refresh_history(&mut state.pane.showing)?;
             }
             state.edited(vec![page]);
             state.commands.push(Command::OpenPage(page));
 @@ -193,7 +193,7 @@ impl State {
             .delete_versions_async(&[(page, vec![version])]);
         self.section_edit(operation, move |state, _| {
             if let Some(session) = &mut state.session {
-                session.refresh_history()?;
+                session.refresh_history(&mut state.pane.showing)?;
             }
             state.commands.push(Command::OpenPage(page));
             Ok(())
 @@ -274,9 +274,11 @@ impl State {
         };
         self.section_edit(operation, move |state, ()| {
             if let Some(session) = &mut state.session {
-                session.refresh_history()?;
+                session.refresh_history(&mut state.pane.showing)?;
-                if session.version.is_some() {
+                if state.pane.showing.version.is_some() {
-                    state.commands.push(Command::OpenPage(session.space));
+                    state
+                        .commands
+                        .push(Command::OpenPage(state.pane.showing.space));
                 }
             }
             Ok(())

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

 @@ -75,7 +75,7 @@ impl State {
     /// Ctrl+K and the toolbar's Link: the dialog opens on what the selection links.
     pub(crate) fn open_link_dialog(&mut self) {
         // As OneNote 2010's, Link does nothing over a selection across paragraphs.
-        let Some((text, address)) = self.view.link_prefill() else {
+        let Some((text, address)) = self.pane.view.link_prefill() else {
             return;
         };
         self.link = Some(LinkDialog {
 @@ -239,7 +239,7 @@ impl State {
         }
         let dialog = self.link.as_ref().unwrap();
         if ok && !dialog.address.trim().is_empty() {
-            let response = self.view.set_link(&dialog.text, &dialog.address)?;
+            let response = self.pane.view.set_link(&dialog.text, &dialog.address)?;
             self.respond(response);
         } else if !cancel {
             return Ok(());
 @@ -252,7 +252,7 @@ impl State {
     /// A secondary press on text, a picture or a file opens its context menu there.
     pub(crate) fn open_text_menu(&mut self) -> Result<(), Box<dyn Error>> {
-        let Some((response, context)) = self.view.context()? else {
+        let Some((response, context)) = self.pane.view.context()? else {
             return Ok(());
         };
         self.respond(response);
 @@ -338,15 +338,15 @@ impl State {
         let correction = context.spelling.unwrap();
         let response = match chosen_text.as_str() {
             _ if chosen < correction.suggestions.len() => {
-                self.view.correct(&correction, &chosen_text)?
+                self.pane.view.correct(&correction, &chosen_text)?
             }
-            "Delete Repeated Word" => self.view.correct(&correction, "")?,
+            "Delete Repeated Word" => self.pane.view.correct(&correction, "")?,
             "Spelling" => {
                 self.open_spelling_pane();
                 return Ok(());
             }
             text => {
-                if let Some(spelling) = &self.view.spelling {
+                if let Some(spelling) = &self.pane.view.spelling {
                     if text == "Ignore" {
                         spelling.ignore(&correction.word);
                     } else {
 @@ -407,7 +407,8 @@ impl State {
                         separated: true,
                         disabled: disabled(commands::Id::Cut)
                             || image.size.is_none_or(|size| {
-                                self.view
+                                self.pane
+                                    .view
                                     .editor
                                     .image_placement(image.id)
                                     .is_none_or(|(_, shown)| shown == size)
 @@ -554,7 +555,7 @@ impl State {
                     return Ok(());
                 }
                 "Restore to Original Size" => {
-                    let response = self.view.restore_picture_size(image.id)?;
+                    let response = self.pane.view.restore_picture_size(image.id)?;
                     self.respond(response);
                     return Ok(());
                 }
 @@ -581,15 +582,15 @@ impl State {
                 return Ok(());
             }
             "Copy Link to Paragraph" => {
-                if let Some(session) = &self.session {
+                if self.session.is_some() {
-                    let link = self.page_link(session.space, context.paragraph)?;
+                    let link = self.page_link(self.pane.showing.space, context.paragraph)?;
                     self.clipboard.set_text(link)?;
                 }
                 return Ok(());
             }
-            "Select Link" => self.view.unlink(true)?,
+            "Select Link" => self.pane.view.unlink(true)?,
-            "Remove Link" => self.view.unlink(false)?,
+            "Remove Link" => self.pane.view.unlink(false)?,
-            text => self.view.switch_equation(text == "Linear")?,
+            text => self.pane.view.switch_equation(text == "Linear")?,
         };
         self.respond(response);
         Ok(())

crates/snowbound/src/live.rs+12-11

 @@ -590,8 +590,9 @@ impl State {
         let Some(session) = &self.session else {
             return live::Presence::default();
         };
-        let outline = self.view.editor.active_outline();
+        let outline = self.pane.view.editor.active_outline();
         let [anchor, focus] = self
+            .pane
             .view
             .editor
             .selection()
 @@ -599,7 +600,7 @@ impl State {
             .map(|position| spot(outline, position));
         live::Presence {
             section: section(session),
-            page: Some(session.space.into()),
+            page: Some(self.pane.showing.space.into()),
             caret: anchor
                 .zip(focus)
                 .map(|(anchor, focus)| Caret { anchor, focus }),
 @@ -815,26 +816,26 @@ impl State {
                 self.commands
                     .push(Command::OpenSection(library, tab.path.clone()));
             }
-        } else if presence.page != Some(session.space.into()) {
+        } else if presence.page != Some(self.pane.showing.space.into()) {
             if asked != Some(place) {
                 self.commands.push(Command::OpenPage(presence.page?.into()));
             }
         } else {
             self.peers.going = None;
             let caret = presence.caret?;
-            let (outline, focus) = find(&self.view.editor, caret.focus)?;
+            let (outline, focus) = find(&self.pane.view.editor, caret.focus)?;
             let rect = outline
                 .caret_at(focus, parley::Affinity::Downstream, 0.0)
                 .ok()?;
             let [x, y] = outline.origin();
-            let viewport = self.view.viewport;
+            let viewport = self.pane.view.viewport;
             let [width, height] = viewport.size.map(|side| side as f32);
             let middle = ((rect.y0 + rect.y1) as f32 / 2.0 + y) * viewport.scale;
-            let mut responses = vec![self.view.scroll_to(1, middle - height / 2.0).ok()?];
+            let mut responses = vec![self.pane.view.scroll_to(1, middle - height / 2.0).ok()?];
             let across = (rect.x0 as f32 + x) * viewport.scale + viewport.origin[0];
             if !(0.0..width).contains(&across) {
                 let left = (rect.x0 as f32 + x) * viewport.scale - width / 2.0;
-                responses.push(self.view.scroll_to(0, left).ok()?);
+                responses.push(self.pane.view.scroll_to(0, left).ok()?);
             }
             for response in responses {
                 self.respond(response);
 @@ -924,9 +925,9 @@ impl State {
         let Some([left, top, right, bottom]) = self.ui.laid_out(page()) else {
             return;
         };
-        let here = (section(session), Some(session.space.into()));
+        let here = (section(session), Some(self.pane.showing.space.into()));
         let scale = self.ui.scale();
-        let viewport = self.view.viewport;
+        let viewport = self.pane.view.viewport;
         // A point on the page in points from the page box's corner.
         let shown = |[x, y]: [f32; 2]| {
             [
 @@ -943,7 +944,7 @@ impl State {
             else {
                 continue;
             };
-            let Some((outline, focus)) = find(&self.view.editor, caret.focus) else {
+            let Some((outline, focus)) = find(&self.pane.view.editor, caret.focus) else {
                 continue;
             };
             let Ok(rect) = outline.caret_at(focus, parley::Affinity::Downstream, 0.0) else {
 @@ -971,7 +972,7 @@ impl State {
             if !(0.0..right - left).contains(&x0) {
                 continue;
             }
-            let selection = find(&self.view.editor, caret.anchor)
+            let selection = find(&self.pane.view.editor, caret.anchor)
                 .filter(|(other, _)| other.id == outline.id)
                 .and_then(|(_, anchor)| outline.range_rects([anchor, focus].into()).ok())
                 .unwrap_or_default()

crates/snowbound/src/main.rs+318-252

 @@ -539,7 +539,44 @@ fn icloud_listed(proxy: EventLoopProxy<UserEvent>) -> impl Fn() + Send + Sync +
     }
 }
-/// The open section and the page the editor shows.
+/// A page view, and which page, locked section or empty notebook it shows.
+struct Pane {
+    view: PageView,
+    showing: Showing,
+    /// The newest read requested; older ones are dropped when they finish.
+    loading: u64,
+    opening: Option<Opening>,
+    /// The section tab, if another, that the newest read opens, and when it was asked for.
+    switching: Option<(Option<usize>, Instant)>,
+    /// Pages visited, for Back and Forward.
+    trail: navigation::Trail,
+    /// The stored page changed elsewhere while marked text was pending; it is shown once
+    /// the composition ends.
+    stale: bool,
+    /// Whether the page last heard it had keyboard focus.
+    page_focused: bool,
+    /// The notebook shown while it has no section open, as one whose last section was
+    /// deleted.
+    sectionless: Option<Arc<Library>>,
+    /// A password-protected section shown locked, in place of an open one.
+    locked: Option<protection::Locked>,
+}
+/// Which page of the open section a pane shows, and what the page list shows beneath it.
+#[derive(Default)]
+struct Showing {
+    space: ExGuid,
+    /// The version of page `space` open, by its context.
+    version: Option<ExGuid>,
+    /// The page whose conflict pages the list shows beneath it.
+    shown: Option<ExGuid>,
+    /// Which of the open conflict page's conflicting changes is selected, in page order.
+    change: Option<usize>,
+    /// The page whose versions the list shows beneath it (Show Page Versions).
+    shown_history: Option<ExGuid>,
+}
+/// An open section.
 struct Session {
     section: notebook::session::Section,
     /// The notebook the section belongs to.
 @@ -549,21 +586,12 @@ struct Session {
     tab: usize,
     /// Spaces, titles and outline levels in section order.
     pages: Vec<(ExGuid, String, u32)>,
-    space: ExGuid,
     /// The section's sync status as last read.
     sync: notebook::session::SyncStatus,
     /// Each page's conflict pages, the versions a merge could not take.
     conflicts: Vec<(ExGuid, Vec<onestore::ConflictPage>)>,
-    /// The page whose conflict pages the list shows beneath it.
-    shown: Option<ExGuid>,
-    /// Which of the open conflict page's conflicting changes is selected, in page order.
-    change: Option<usize>,
     /// Each page's versions, newest first.
     history: Vec<(ExGuid, Vec<onestore::PageVersion>)>,
-    /// The page whose versions the list shows beneath it (Show Page Versions).
-    shown_history: Option<ExGuid>,
-    /// The version of page `space` open, by its context.
-    version: Option<ExGuid>,
 }
 /// The information bar above a page with conflict pages, or above one of them.
 @@ -602,13 +630,13 @@ impl Session {
         Ok(())
     }
-    fn title(&self) -> &str {
+    fn title(&self, space: ExGuid) -> &str {
-        match self.conflict(self.space) {
+        match self.conflict(space) {
             Some((_, version)) => &version.title,
             None => self
                 .pages
                 .iter()
-                .find(|(space, ..)| *space == self.space)
+                .find(|(listed, ..)| *listed == space)
                 .map_or("", |(_, title, _)| title),
         }
     }
 @@ -630,33 +658,34 @@ impl Session {
         })
     }
-    fn bar(&self) -> Option<Bar> {
+    fn bar(&self, showing: &Showing) -> Option<Bar> {
-        if let Some(version) = self.version {
+        let space = showing.space;
+        if let Some(version) = showing.version {
             return Some(Bar::History {
-                page: self.space,
+                page: space,
                 version,
                 grouped: self.grouped(),
             });
         }
-        match self.conflict(self.space) {
+        match self.conflict(space) {
             Some((page, _)) => Some(Bar::Version {
                 page,
-                version: self.space,
+                version: space,
             }),
-            None => (!self.versions(self.space).is_empty()).then_some(Bar::Page {
+            None => (!self.versions(space).is_empty()).then_some(Bar::Page {
-                page: self.space,
+                page: space,
-                shown: self.shown == Some(self.space),
+                shown: showing.shown == Some(space),
             }),
         }
     }
-    fn refresh_conflicts(&mut self) -> Result<(), Box<dyn Error>> {
+    fn refresh_conflicts(&mut self, showing: &mut Showing) -> Result<(), Box<dyn Error>> {
         self.conflicts = self.section.conflicts()?;
-        if self
+        if showing
             .shown
             .is_some_and(|page| self.versions(page).is_empty())
         {
-            self.shown = None;
+            showing.shown = None;
         }
         Ok(())
     }
 @@ -685,9 +714,9 @@ impl Session {
 /// 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),
+    Section(Box<Session>, ExGuid, Page),
     /// A section just created, whose name opens for renaming as OneNote's New Section does.
-    Created(Box<Session>, Page),
+    Created(Box<Session>, ExGuid, Page),
     Page(ExGuid, Page),
     /// A page's version, by the page's space and the version's context.
     Version(ExGuid, ExGuid, Page),
 @@ -697,8 +726,8 @@ enum Loaded {
 /// What an opening page replaces: the section, or the page of the open one.
 enum Shown {
-    Section(Box<Session>),
+    Section(Box<Session>, ExGuid),
-    Created(Box<Session>),
+    Created(Box<Session>, ExGuid),
     Page(ExGuid),
     Version(ExGuid, ExGuid),
 }
 @@ -822,19 +851,14 @@ struct State {
     loads: (mpsc::Sender<Read>, mpsc::Receiver<Read>),
     /// Lays out pages the loader threads read, off the frame.
     layouts: Arc<Mutex<TextEngine>>,
-    /// The newest read requested; older ones are dropped when they finish.
-    loading: u64,
-    opening: Option<Opening>,
-    /// The section tab, if another, that the newest read opens, and when it was asked for.
-    switching: Option<(Option<usize>, Instant)>,
     prefetch: prefetch::Prefetch,
     /// Where each page was left this run, by `Library::key` and page space, as OneNote
     /// returns to it until the notebook closes.
     places: HashMap<(String, ExGuid), Place>,
     /// The page each section showed last this run, by `Library::key`.
     last_pages: HashMap<String, ExGuid>,
-    /// Pages visited, for Back and Forward.
+    /// Each page shown lately once, latest first, kept between launches.
-    trail: navigation::Trail,
+    recent: Vec<navigation::Place>,
     /// What Undo and Redo take back across pages and sections.
     undo: undo::Timeline,
     swipe: navigation::Swipe,
 @@ -853,9 +877,11 @@ struct State {
     /// Backends that failed to start this run, and why.
     unavailable: Vec<(settings::Backend, String)>,
     ui: Ui,
-    view: PageView,
+    /// The page view the window shows.
+    pane: Pane,
     /// The open notebooks in the sidebar's order.
     notebooks: Vec<Arc<Library>>,
+    /// The open section, the one the pane shows.
     session: Option<Session>,
     /// A page not kept in any notebook, from a text file or `--page`.
     temporary: bool,
 @@ -938,11 +964,6 @@ struct State {
     titlebar: [[f32; 4]; 2],
     /// A section or group being renamed in the sidebar.
     renaming: Option<rename::Renaming>,
-    /// The notebook shown while it has no section open, as one whose last section was
-    /// deleted.
-    sectionless: Option<Arc<Library>>,
-    /// A password-protected section shown locked, in place of an open one.
-    locked: Option<protection::Locked>,
     /// The password dialog while it is open.
     password: Option<protection::Asking>,
     /// Options' Passwords.
 @@ -977,11 +998,6 @@ struct State {
     changed: bool,
     /// Only the view scrolled or zoomed during this frame, to be announced after it.
     moved: bool,
-    /// The stored page changed elsewhere while marked text was pending; it is shown once
-    /// the composition ends.
-    stale: bool,
-    /// Whether the page last heard it had keyboard focus.
-    page_focused: bool,
     /// The pointer in logical pixels, for window drags from the strip.
     pointer: [f32; 2],
     /// When the strip was last pressed, to zoom on a double click.
 @@ -1180,6 +1196,7 @@ impl State {
         icloud::look_up(icloud_listed(proxy.clone()));
         let mut notebooks = Vec::new();
         let mut session = None;
+        let mut showing = Showing::default();
         let mut sectionless = None;
         let mut locked = None;
         let (editor, scene) = match input {
 @@ -1213,9 +1230,10 @@ impl State {
                     .0;
                 notebooks.push(Arc::clone(&library));
                 let path = library.location.clone();
-                let (opened, page) = read_session(section, library, path, Some(space))?;
+                let (opened, space, page) = read_session(section, library, path, Some(space))?;
                 let (scene, editor) = PageScene::from_page(page, &mut engine)?;
                 session = Some(opened);
+                showing.space = space;
                 (editor, Some((scene, [0.0; 2])))
             }
             Input::Notebooks { locations, current } => {
 @@ -1249,10 +1267,11 @@ impl State {
                 match shown {
                     Some((library, path, left)) if !library.locked(&path) => {
                         let section = library.open_async(&path, notify(proxy.clone())).await?;
-                        let (opened, page) =
+                        let (opened, space, page) =
                             read_session(section, Arc::clone(library), path, left)?;
                         let (scene, editor) = PageScene::from_page(page, &mut engine)?;
                         session = Some(opened);
+                        showing.space = space;
                         (editor, Some((scene, [0.0; 2])))
                     }
                     shown => {
 @@ -1348,14 +1367,25 @@ impl State {
             drawing,
             unavailable,
             ui,
-            view: PageView::new(
+            pane: Pane {
-                editor,
+                view: PageView::new(
-                engine,
+                    editor,
-                scene,
+                    engine,
-                [size.width, size.height],
+                    scene,
-                dpr,
+                    [size.width, size.height],
-                platform::double_click_interval(),
+                    dpr,
-            ),
+                    platform::double_click_interval(),
+                ),
+                showing,
+                loading: 0,
+                opening: None,
+                switching: None,
+                trail: navigation::Trail::default(),
+                stale: false,
+                page_focused: true,
+                sectionless,
+                locked,
+            },
             notebooks,
             session,
             temporary,
 @@ -1398,8 +1428,6 @@ impl State {
             light_pages: stored.light_pages,
             titlebar,
             renaming: None,
-            sectionless,
-            locked,
             password: None,
             passwords: stored.passwords,
             notebook_theme: (stored.notebook_theme.0)
 @@ -1420,8 +1448,6 @@ impl State {
             commands: Vec::new(),
             changed: false,
             moved: false,
-            stale: false,
-            page_focused: true,
             pointer: [0.0; 2],
             strip_press: None,
             strip_held: false,
 @@ -1439,18 +1465,11 @@ impl State {
             loads: mpsc::channel(),
             prefetch,
             layouts,
-            loading: 0,
-            opening: None,
-            switching: None,
             places: HashMap::new(),
             last_pages: (stored.recent.iter().rev())
                 .map(|place| (library::key(&place.notebook, &place.section), place.page))
                 .collect(),
-            trail: {
+            recent: stored.recent,
-                let mut trail = navigation::Trail::default();
-                trail.recent = stored.recent;
-                trail
-            },
             undo: undo::Timeline::default(),
             swipe: navigation::Swipe::default(),
             access_adapter,
 @@ -1464,9 +1483,9 @@ impl State {
             servers: stored.servers,
             correction: None,
         };
-        state.view.snap_to_grid = !stored.ignore_grid;
+        state.pane.view.snap_to_grid = !stored.ignore_grid;
-        state.view.editor.default_font = stored.default_font;
+        state.pane.view.editor.default_font = stored.default_font;
-        state.view.editor.markdown = commands::markdown(!stored.ignore_markdown);
+        state.pane.view.editor.markdown = commands::markdown(!stored.ignore_markdown);
         // A notebook opened from its server that couldn't sign in asks to, as the Finder does.
         let unsigned = state.notebooks.iter().find(|library| {
             library.notebook.is_err() && library::server_address(&library.location).is_some()
 @@ -1557,7 +1576,7 @@ impl State {
         let scale = self.scale();
         if scale != self.ui.scale() {
             self.renderer.clear_glyph_cache();
-            let response = self.view.scale_factor_changed(scale)?;
+            let response = self.pane.view.scale_factor_changed(scale)?;
             self.respond(response);
         }
         #[cfg(feature = "live")]
 @@ -1572,10 +1591,10 @@ impl State {
             platform::resize_direction(&self.window, self.pointer)
                 .map(CursorIcon::from)
                 .or_else(|| self.ui.cursor())
-                .unwrap_or_else(|| cursor_icon(self.view.cursor())),
+                .unwrap_or_else(|| cursor_icon(self.pane.view.cursor())),
         );
         let ime = if self.ui.focused() == Some(page()) {
-            self.view.accepts_text()
+            self.pane.view.accepts_text()
         } else {
             search::takes_text(self.ui.focused())
         };
 @@ -1590,8 +1609,8 @@ impl State {
         let commands = std::mem::take(&mut self.commands);
         let follow = !commands.is_empty()
             || self.ui.wants_frame()
-            || self.opening.is_some()
+            || self.pane.opening.is_some()
-            || self.switching.is_some();
+            || self.pane.switching.is_some();
         for command in commands {
             self.apply(command)?;
         }
 @@ -1601,7 +1620,7 @@ impl State {
             self.after_move()?;
         }
         self.moved = false;
-        if self.stale {
+        if self.pane.stale {
             self.refresh()?;
         }
         // A covered window shows nothing, so animations wait for it to be uncovered.
 @@ -1669,8 +1688,8 @@ impl State {
                 ((rect[2] - rect[0]) * scale).round() as u32,
                 ((rect[3] - rect[1]) * scale).round() as u32,
             ];
-            if size != self.view.viewport.size {
+            if size != self.pane.view.viewport.size {
-                let response = self.view.resized(size)?;
+                let response = self.pane.view.resized(size)?;
                 self.respond(response);
             }
         }
 @@ -1743,8 +1762,8 @@ impl State {
         platform::update_menu(|| self.statuses());
         let welcome = self.session.is_none()
             && !self.temporary
-            && self.sectionless.is_none()
+            && self.pane.sectionless.is_none()
-            && self.locked.is_none();
+            && self.pane.locked.is_none();
         self.toolbar(&theme, !welcome)?;
         if welcome {
             self.welcome();
 @@ -1916,7 +1935,7 @@ impl State {
                 }
                 (clicked, open_tab)
             }
-            None if self.locked.is_some() => self.locked_tabs(row, &section, theme.strip),
+            None if self.pane.locked.is_some() => self.locked_tabs(row, &section, theme.strip),
             None => {
                 let tabs = [("Temporary page", section_color(None), false)];
                 let shown = if self.temporary { &tabs[..] } else { &[] };
 @@ -1994,13 +2013,16 @@ impl State {
             },
         );
         if let Some(session) = &self.session
-            && let Some(bar) = session.bar()
+            && let Some(bar) = session.bar(&self.pane.showing)
         {
             let changes = self.changes().len();
             let sections: Vec<&str> = session.tabs.iter().map(|tab| tab.name.as_str()).collect();
             let steps = [
-                session.change.is_some_and(|at| at > 0),
+                self.pane.showing.change.is_some_and(|at| at > 0),
-                session.change.map_or(changes > 0, |at| at + 1 < changes),
+                self.pane
+                    .showing
+                    .change
+                    .map_or(changes > 0, |at| at + 1 < changes),
             ];
             self.commands
                 .extend(conflict_bar(&mut self.ui, bar, &sections, steps));
 @@ -2008,7 +2030,7 @@ impl State {
         if self.in_recycle_bin() {
             recycle::bar(&mut self.ui);
         }
-        if self.session.is_none() && self.locked.is_some() {
+        if self.session.is_none() && self.pane.locked.is_some() {
             self.locked_page();
             self.ui.close();
             self.ui.close();
 @@ -2021,7 +2043,12 @@ impl State {
             self.context_menu();
             return Ok((section, open_tab, None));
         }
-        if let Some(library) = self.sectionless.clone().filter(|_| self.session.is_none()) {
+        if let Some(library) = self
+            .pane
+            .sectionless
+            .clone()
+            .filter(|_| self.session.is_none())
+        {
             self.no_sections(library);
             self.ui.close();
             self.ui.close();
 @@ -2053,7 +2080,7 @@ impl State {
             self.template_strip(&theme);
         }
         self.transport(&theme)?;
-        let scroll = self.view.scroll();
+        let scroll = self.pane.view.scroll();
         for (index, axis) in [Axis::X, Axis::Y]
             .into_iter()
             .filter(|_| !opening)
 @@ -2063,13 +2090,13 @@ impl State {
                 &mut self.ui,
                 index,
                 axis,
-                -self.view.viewport.origin[index],
+                -self.pane.view.viewport.origin[index],
                 [scroll.min[index], scroll.max[index]],
-                self.view.viewport.size[index] as f32,
+                self.pane.view.viewport.size[index] as f32,
                 scroll.max[1 - index] > scroll.min[1 - index],
                 [0.18, 0.18, 0.18, 0.45],
             ) {
-                let response = self.view.scroll_to(index, offset)?;
+                let response = self.pane.view.scroll_to(index, offset)?;
                 self.respond(response);
             }
         }
 @@ -2077,7 +2104,7 @@ impl State {
         if !opening {
             self.peer_carets();
         }
-        let task = self.view.task_under_pointer().map(|[x0, y0, x1, y1]| {
+        let task = self.pane.view.task_under_pointer().map(|[x0, y0, x1, y1]| {
             let scale = self.ui.scale();
             self.ui.leaf(
                 "task",
 @@ -2101,9 +2128,9 @@ impl State {
         }
         let signal = self.ui.signal(page());
         let focused = self.ui.window_focused && self.ui.focused() == Some(page());
-        if focused != self.page_focused {
+        if focused != self.pane.page_focused {
-            self.page_focused = focused;
+            self.pane.page_focused = focused;
-            let response = self.view.focus_changed(focused)?;
+            let response = self.pane.view.focus_changed(focused)?;
             self.respond(response);
         }
         self.page_events(signal.events)?;
 @@ -2427,7 +2454,7 @@ impl State {
         let fonts = &self.fonts;
         let recent_fonts = &self.recent_fonts;
         let pens = &self.toolbar;
-        let engine = &self.view.engine;
+        let engine = &self.pane.view.engine;
         let session = self.session.as_ref();
         let update = self.updates.status();
         let sheet = self.gallery_sheet();
 @@ -3126,8 +3153,8 @@ impl State {
                         color: ui.theme.paper,
                         ink: ui.theme.paper_ink,
                     },
-                    self.view.editor.page_color(),
+                    self.pane.view.editor.page_color(),
-                    self.view.editor.rule_lines(),
+                    self.pane.view.editor.rule_lines(),
                     false,
                     &mut self.page_color_preview,
                 )
 @@ -3187,7 +3214,7 @@ impl State {
         let format = self.format_state();
         let [out, into] =
             [Cmd::ZoomOut, Cmd::ZoomIn].map(|id| self.status(&Choice::Command(id), &format));
-        let level = format!("{:.0}%", self.view.zoom() * 100.0);
+        let level = format!("{:.0}%", self.pane.view.zoom() * 100.0);
         let field = self.ui.id("zoom field");
         if self.ui.focused() != Some(field) {
             self.zoom_typed = None;
 @@ -3303,7 +3330,7 @@ impl State {
             self.choose(choice);
         }
         if let Some(percent) = zoom {
-            let response = self.view.set_zoom(percent / 100.0)?;
+            let response = self.pane.view.set_zoom(percent / 100.0)?;
             self.respond(response);
         }
         Ok(())
 @@ -3402,7 +3429,7 @@ impl State {
             node.set_orientation(accesskit::Orientation::Vertical);
         }
         // Another section's pages are on their way.
-        if self.loading().is_some() && self.switching.is_some_and(|(tab, _)| tab.is_some()) {
+        if self.loading().is_some() && self.pane.switching.is_some_and(|(tab, _)| tab.is_some()) {
             self.ui.close();
             return None;
         }
 @@ -3419,6 +3446,7 @@ impl State {
             theme,
             section,
             session,
+            &self.pane.showing,
             [&found, &unread],
             &peers,
             (rounding, self.page_tabs_left),
 @@ -3461,7 +3489,10 @@ impl State {
         if self.loading().is_some() {
             return Ok(());
         }
-        let read_only = self.session.as_ref().is_some_and(Session::read_only);
+        let read_only = self
+            .session
+            .as_ref()
+            .is_some_and(|session| session.read_only(&self.pane.showing));
         let scale = self.ui.scale();
         let corner = self.ui.laid_out(page()).unwrap_or_default();
         let device = |point: [f32; 2]| {
 @@ -3472,30 +3503,32 @@ impl State {
         };
         for event in events {
             let response = match event {
-                ui::Event::PointerMoved(point) => self.view.pointer_moved(device(point))?,
+                ui::Event::PointerMoved(point) => self.pane.view.pointer_moved(device(point))?,
                 ui::Event::Pressure(pressure) => {
-                    self.view
+                    self.pane
+                        .view
                         .set_pressure(pressure.filter(|_| self.pen_pressure));
                     continue;
                 }
-                ui::Event::PointerLeft => self.view.pointer_left(),
+                ui::Event::PointerLeft => self.pane.view.pointer_left(),
                 ui::Event::Button {
                     button: MouseButton::Left,
                     pressed,
                     at,
                 } => {
                     if pressed {
-                        let response = self.view.pointer_pressed(at)?;
+                        let response = self.pane.view.pointer_pressed(at)?;
                         // Drawing or clicking anywhere but the title puts the templates away.
-                        if (self.view.inking() || !self.view.editor.active_outline().title)
+                        if (self.pane.view.inking()
-                            && let Some(session) = &self.session
+                            || !self.pane.view.editor.active_outline().title)
+                            && self.session.is_some()
                         {
-                            self.dismissed.insert(session.space);
+                            self.dismissed.insert(self.pane.showing.space);
                         }
                         response
                     } else {
-                        let response = self.view.pointer_released()?;
+                        let response = self.pane.view.pointer_released()?;
-                        let [anchor, focus] = self.view.editor.selection().positions;
+                        let [anchor, focus] = self.pane.view.editor.selection().positions;
                         if anchor != focus
                             && let Some(painted) = self.painter.take()
                         {
 @@ -3521,7 +3554,7 @@ impl State {
                 ui::Event::Ime(Ime::Preedit(..) | Ime::Commit(_)) if read_only => continue,
                 ui::Event::Key { ref key, .. }
                     if read_only
-                        && !self.view.modifiers().command
+                        && !self.pane.view.modifiers().command
                         && !matches!(
                             key,
                             Key::Named(
 @@ -3538,20 +3571,25 @@ impl State {
                 {
                     continue;
                 }
-                ui::Event::Wheel(delta) => self.view.wheel([delta[0] * scale, delta[1] * scale])?,
+                ui::Event::Wheel(delta) => {
+                    self.pane.view.wheel([delta[0] * scale, delta[1] * scale])?
+                }
                 ui::Event::Key { key, text } => {
-                    self.view.key(&ui::edit_key(&key), text.as_deref())?
+                    self.pane.view.key(&ui::edit_key(&key), text.as_deref())?
                 }
-                ui::Event::Ime(Ime::Preedit(text, cursor)) => self.view.compose(text, cursor)?,
+                ui::Event::Ime(Ime::Preedit(text, cursor)) => {
-                ui::Event::Ime(Ime::Commit(text)) => self.view.commit_text(text)?,
+                    self.pane.view.compose(text, cursor)?
-                ui::Event::Ime(Ime::Disabled) => self.view.cancel_composition()?,
-                ui::Event::Modifiers(modifiers) => {
-                    self.view.modifiers_changed(ui::edit_modifiers(modifiers))?
                 }
+                ui::Event::Ime(Ime::Commit(text)) => self.pane.view.commit_text(text)?,
+                ui::Event::Ime(Ime::Disabled) => self.pane.view.cancel_composition()?,
+                ui::Event::Modifiers(modifiers) => self
+                    .pane
+                    .view
+                    .modifiers_changed(ui::edit_modifiers(modifiers))?,
             };
             self.respond(response);
         }
-        if self.view.editor.marked_range().is_none() {
+        if self.pane.view.editor.marked_range().is_none() {
             platform::clear_marked_text(&self.window);
         }
         Ok(())
 @@ -3579,7 +3617,7 @@ impl State {
                 let tab = match &self.session {
                     // Back to the open section before another one opened.
                     Some(session)
-                        if self.switching.is_some()
+                        if self.pane.switching.is_some()
                             && Arc::ptr_eq(&session.library, &library)
                             && session.tabs[session.tab].path == path =>
                     {
 @@ -3591,34 +3629,37 @@ impl State {
                     }
                     _ => None,
                 };
-                self.switching = Some((tab, Instant::now()));
+                self.pane.switching = Some((tab, Instant::now()));
                 let notify = notify(self.proxy.clone());
                 let last = self.last_pages.get(&library.key(&path)).copied();
                 self.load_async(move || async move {
                     let start = Instant::now();
                     let section = library.open_async(&path, notify).await?;
                     lap("switch section open", start);
-                    let (session, page) = read_session(section, library, path, last)?;
+                    let (session, space, page) = read_session(section, library, path, last)?;
-                    Ok(Loaded::Section(Box::new(session), page))
+                    Ok(Loaded::Section(Box::new(session), space, page))
                 });
             }
             Command::OpenPage(space) => {
                 let session = self.session.as_ref().ok_or("No section is open")?;
-                if self.switching.is_some() && session.space == space && session.version.is_none() {
+                if self.pane.switching.is_some()
+                    && self.pane.showing.space == space
+                    && self.pane.showing.version.is_none()
+                {
                     self.stop_loading();
                     return Ok(());
                 }
-                self.switching = Some((None, Instant::now()));
+                self.pane.switching = Some((None, Instant::now()));
                 let read = session.reader(space);
                 self.load(move || Ok(Loaded::Page(space, read()?)));
             }
             Command::Versions { page, show } => {
                 let session = self.session.as_mut().ok_or("No section is open")?;
-                session.shown = show.then_some(page);
+                self.pane.showing.shown = show.then_some(page);
                 let open = if show {
                     session.versions(page).first().map(|version| version.space)
                 } else {
-                    (session.space != page).then_some(page)
+                    (self.pane.showing.space != page).then_some(page)
                 };
                 self.commands.extend(open.map(Command::OpenPage));
             }
 @@ -3627,7 +3668,7 @@ impl State {
                 let operation = session.section.delete_pages_async(&[version]);
                 self.section_edit(operation, move |state, _| {
                     if let Some(session) = &mut state.session {
-                        session.refresh_conflicts()?;
+                        session.refresh_conflicts(&mut state.pane.showing)?;
                     }
                     state.commands.push(Command::OpenPage(page));
                     Ok(())
 @@ -3635,9 +3676,9 @@ impl State {
             }
             Command::CopyVersion { version, tab } => {
                 let session = self.session.as_mut().ok_or("No section is open")?;
-                let page = match session.version {
+                let page = match self.pane.showing.version {
                     Some(open) if open == version => {
-                        session.section.version(session.space, open)?
+                        session.section.version(self.pane.showing.space, open)?
                     }
                     _ => session.section.page(version)?,
                 };
 @@ -3729,7 +3770,7 @@ impl State {
             Command::Choose(choice) => self.run(choice)?,
             Command::TagPicture => self.pick_tag_picture(),
             Command::Text(text) => {
-                if let Some(context) = self.view.caret_context() {
+                if let Some(context) = self.pane.view.caret_context() {
                     self.text_command(context, text)?;
                 }
             }
 @@ -3747,8 +3788,8 @@ impl State {
         &mut self,
         read: impl FnOnce() -> F + Send + 'static,
     ) {
-        self.loading += 1;
+        self.pane.loading += 1;
-        let (id, sender, redraw) = (self.loading, self.loads.0.clone(), self.redraw.clone());
+        let (id, sender, redraw) = (self.pane.loading, self.loads.0.clone(), self.redraw.clone());
         let layouts = Arc::clone(&self.layouts);
         let requested = Instant::now();
         let scenes = Arc::clone(&self.prefetch.scenes);
 @@ -3757,8 +3798,8 @@ impl State {
             let laid = read().await.and_then(|loaded| {
                 lap("switch read", requested);
                 let (shown, page) = match loaded {
-                    Loaded::Section(session, page) => (Shown::Section(session), page),
+                    Loaded::Section(session, space, page) => (Shown::Section(session, space), page),
-                    Loaded::Created(session, page) => (Shown::Created(session), page),
+                    Loaded::Created(session, space, page) => (Shown::Created(session, space), page),
                     Loaded::Page(space, page) => (Shown::Page(space), page),
                     Loaded::Version(space, version, page) => (Shown::Version(space, version), page),
                     Loaded::Library(library, path) => return Ok(Laid::Library(library, path)),
 @@ -3766,8 +3807,8 @@ impl State {
                 let mut engine = layouts.lock().map_err(|_| "Page layout failed")?;
                 let start = Instant::now();
                 let key = match &shown {
-                    Shown::Section(session) | Shown::Created(session) => {
+                    Shown::Section(session, space) | Shown::Created(session, space) => {
-                        Some((session.key(), session.space))
+                        Some((session.key(), *space))
                     }
                     Shown::Page(space) => open.map(|open| (open, *space)),
                     Shown::Version(..) => None,
 @@ -3846,12 +3887,12 @@ impl State {
         for (id, loaded) in reads {
             match loaded {
                 // A later load supersedes what this one shows, but not its failure.
-                Ok(_) if id != self.loading => {}
+                Ok(_) if id != self.pane.loading => {}
-                Ok(Laid::Page(opening)) => self.opening = Some(*opening),
+                Ok(Laid::Page(opening)) => self.pane.opening = Some(*opening),
                 Ok(Laid::Library(library, path)) => self.adopt(library, path.as_deref())?,
                 Err(error) => {
-                    if id == self.loading {
+                    if id == self.pane.loading {
-                        self.switching = None;
+                        self.pane.switching = None;
                     }
                     platform::alert("Couldn't open", &error);
                 }
 @@ -3861,17 +3902,18 @@ impl State {
             color: self.ui.theme.paper,
             ink: self.ui.theme.paper_ink,
         };
-        self.prefetch.draw(&self.view, paper, &self.redraw);
+        self.prefetch.draw(&self.pane.view, paper, &self.redraw);
-        let Some(mut opening) = self.opening.take() else {
+        let Some(mut opening) = self.pane.opening.take() else {
             return Ok(());
         };
         let paper = paper.colored(opening.editor.page_color());
         if !self
+            .pane
             .view
             .prepare(&mut opening.scene, &opening.editor, paper, &self.redraw)
             && opening.since.elapsed() < HOLD
         {
-            self.opening = Some(opening);
+            self.pane.opening = Some(opening);
             return Ok(());
         }
         lap("switch pictures", opening.since);
 @@ -3880,7 +3922,7 @@ impl State {
     fn show_page(&mut self, mut opening: Opening) -> Result<(), Box<dyn Error>> {
         let requested = opening.requested;
-        if let Shown::Section(session) | Shown::Created(session) = &mut opening.loaded
+        if let Shown::Section(session, _) | Shown::Created(session, _) = &mut opening.loaded
             && let Some(library) = self
                 .notebooks
                 .iter()
 @@ -3905,7 +3947,7 @@ impl State {
             } else if let Some(path) = library.first_section() {
                 return self.apply(Command::OpenSection(library, path));
             } else {
-                self.switching = None;
+                self.pane.switching = None;
                 return self.adopt(library, None);
             }
         }
 @@ -3916,22 +3958,24 @@ impl State {
         let mut leaving = self
             .session
             .as_ref()
-            .filter(|session| !session.read_only())
+            .filter(|session| !session.read_only(&self.pane.showing))
-            .map(|session| session.space);
+            .map(|_| self.pane.showing.space);
         if let Some(session) = &self.session {
             let key = session.key();
-            self.places
+            self.places.insert(
-                .insert((key.clone(), session.space), self.view.place());
+                (key.clone(), self.pane.showing.space),
-            self.last_pages.insert(key.clone(), session.space);
+                self.pane.view.place(),
-            if session.version.is_none()
+            );
-                && let Some(scene) = self.view.scene.take()
+            self.last_pages.insert(key.clone(), self.pane.showing.space);
+            if self.pane.showing.version.is_none()
+                && let Some(scene) = self.pane.view.scene.take()
             {
-                self.prefetch.keep(key, session.space, scene);
+                self.prefetch.keep(key, self.pane.showing.space, scene);
             }
         }
-        let created = matches!(opening.loaded, Shown::Created(_));
+        let created = matches!(opening.loaded, Shown::Created(..));
         match opening.loaded {
-            Shown::Section(session) | Shown::Created(session) => {
+            Shown::Section(session, space) | Shown::Created(session, space) => {
                 // The settings keep the notebook shown, not the section.
                 let other_notebook = self
                     .session
 @@ -3940,7 +3984,7 @@ impl State {
                 self.list(&session.library);
                 // The section left stays open a while for coming back to; the notebook's
                 // background sync takes it over once it is closed.
-                self.locked = None;
+                self.pane.locked = None;
                 if let Some(previous) = self.session.replace(*session) {
                     let path = &previous.tabs[previous.tab].path;
                     let locked = self.leave(&previous.library, path);
 @@ -3956,7 +4000,11 @@ impl State {
                         });
                     }
                 }
-                self.sectionless = None;
+                self.pane.showing = Showing {
+                    space,
+                    ..Showing::default()
+                };
+                self.pane.sectionless = None;
                 if other_notebook {
                     self.save_settings();
                 }
 @@ -3964,12 +4012,12 @@ impl State {
             Shown::Page(space) | Shown::Version(space, _) => {
                 let session = self.session.as_mut().ok_or("No section is open")?;
                 let pages = session.section.pages()?;
-                session.space = space;
+                self.pane.showing.space = space;
-                session.version = match opening.loaded {
+                self.pane.showing.version = match opening.loaded {
                     Shown::Version(_, version) => Some(version),
                     _ => None,
                 };
-                session.change = None;
+                self.pane.showing.change = None;
                 // Pages created, moved or deleted since the list was read.
                 session.pages = pages;
                 leaving = leaving.filter(|left| session.pages.iter().any(|(s, ..)| s == left));
 @@ -3977,9 +4025,12 @@ impl State {
         }
         let place = self.session.as_ref().and_then(|session| {
             let key = session.key();
-            self.places.get(&(key, session.space)).copied()
+            self.places.get(&(key, self.pane.showing.space)).copied()
         });
-        let left = self.view.open(opening.editor, Some(opening.scene), place);
+        let left = self
+            .pane
+            .view
+            .open(opening.editor, Some(opening.scene), place);
         // Each page takes up the history it was left with.
         if let Some(leaving) = leaving {
             self.undo.park(leaving, left);
 @@ -3987,19 +4038,19 @@ impl State {
         let shown = self
             .session
             .as_ref()
-            .filter(|session| !session.read_only())
+            .filter(|session| !session.read_only(&self.pane.showing))
-            .map(|session| session.space);
+            .map(|_| self.pane.showing.space);
         if let Some(parked) = shown.and_then(|space| self.undo.resume(space)) {
-            self.view.resume(parked)?;
+            self.pane.view.resume(parked)?;
         }
         lap("switch shown", requested);
-        self.switching = None;
+        self.pane.switching = None;
         self.visited();
         if let Some((space, action)) = self.after_open.take()
             && let Some(session) = self
                 .session
                 .as_ref()
-                .filter(|session| session.space == space)
+                .filter(|_| self.pane.showing.space == space)
         {
             let target = menus::Target::Page {
                 library: Arc::clone(&session.library),
 @@ -4029,7 +4080,7 @@ impl State {
         self.list(&library);
         let shown = |shown: &Library| shown.location == library.location;
         let Some(path) = path else {
-            if self.sectionless.as_deref().is_some_and(shown)
+            if self.pane.sectionless.as_deref().is_some_and(shown)
                 || self
                     .session
                     .as_ref()
 @@ -4043,7 +4094,7 @@ impl State {
                         }
                     });
                 }
-                self.sectionless = Some(Arc::clone(&library));
+                self.pane.sectionless = Some(Arc::clone(&library));
                 self.title();
             }
             self.show_arrived(&library);
 @@ -4104,7 +4155,7 @@ impl State {
     fn after_move(&mut self) -> Result<(), Box<dyn Error>> {
         let scale = self.ui.scale();
         let corner = self.ui.laid_out(page()).unwrap_or_default();
-        let [x0, y0, x1, y1] = self.view.caret_area()?;
+        let [x0, y0, x1, y1] = self.pane.view.caret_area()?;
         self.window.set_ime_cursor_area(
             LogicalPosition::new(x0 / scale + corner[0], y0 / scale + corner[1]),
             LogicalSize::new((x1 - x0) / scale, (y1 - y0) / scale),
 @@ -4132,11 +4183,11 @@ impl State {
                 } else {
                     ""
                 };
-                format!("{}{bin} · {file}", session.title())
+                format!("{}{bin} · {file}", session.title(self.pane.showing.space))
             }
             None if !self.temporary => "Snowbound".to_owned(),
             None => {
-                let editor = &self.view.editor;
+                let editor = &self.pane.view.editor;
                 if !editor.active_outline().title {
                     return;
                 }
 @@ -4169,27 +4220,27 @@ impl State {
     }
     fn edit_date(&mut self, field: DateField) {
-        let Some(date) = self.view.editor.date() else {
+        let Some(date) = self.pane.view.editor.date() else {
             return;
         };
         let timestamp = date.timestamp();
-        self.view.editor.finish_composition();
+        self.pane.view.editor.finish_composition();
         platform::clear_marked_text(&self.window);
         let title = match field {
             DateField::Date => "Change Page Date",
             DateField::Time => "Change Page Time",
         };
-        let page = self.session.as_ref().map(|session| session.space);
+        let page = self.session.as_ref().map(|_| self.pane.showing.space);
         let reply = self.reply(
             move |state, chosen: Result<(u64, [String; 2]), &'static str>| {
                 let (changed, text) = chosen?;
                 // The answer belongs to the page that asked, unless another has opened since.
-                if state.session.as_ref().map(|session| session.space) != page
+                if state.session.as_ref().map(|_| state.pane.showing.space) != page
-                    || state.view.editor.date().map(|date| date.timestamp()) != Some(timestamp)
+                    || state.pane.view.editor.date().map(|date| date.timestamp()) != Some(timestamp)
                 {
                     return Ok(());
                 }
-                let response = state.view.change_date(changed, text)?;
+                let response = state.pane.view.change_date(changed, text)?;
                 state.respond(response);
                 Ok(())
             },
 @@ -4211,13 +4262,13 @@ impl State {
         let Some((_, version)) = self
             .session
             .as_ref()
-            .and_then(|session| session.conflict(session.space))
+            .and_then(|session| session.conflict(self.pane.showing.space))
         else {
             return Vec::new();
         };
         let marked = |id: &ExGuid| version.objects.contains(id);
         let mut changes = Vec::new();
-        for outline in self.view.editor.outlines() {
+        for outline in self.pane.view.editor.outlines() {
             for (at, node) in outline.document().text_nodes().enumerate() {
                 let Some(text) = node.text() else {
                     continue;
 @@ -4234,10 +4285,10 @@ impl State {
     /// Selects the next or previous conflicting change, as OneNote's conflict menu does.
     fn select_change(&mut self, forward: bool) -> Result<(), Box<dyn Error>> {
         let changes = self.changes();
-        let Some(session) = &mut self.session else {
+        if self.session.is_none() {
             return Ok(());
-        };
+        }
-        let next = match (session.change, forward) {
+        let next = match (self.pane.showing.change, forward) {
             (None, true) => 0,
             (Some(at), true) => at + 1,
             (Some(at), false) if at > 0 => at - 1,
 @@ -4246,12 +4297,12 @@ impl State {
         let Some(&(outline, paragraph, length)) = changes.get(next) else {
             return Ok(());
         };
-        session.change = Some(next);
+        self.pane.showing.change = Some(next);
         let at = |offset| canvas::document::TextPosition { paragraph, offset };
-        self.view.editor.focus_outline(outline)?;
+        self.pane.view.editor.focus_outline(outline)?;
-        self.view.editor.select([at(0), at(length)].into())?;
+        self.pane.view.editor.select([at(0), at(length)].into())?;
         self.ui.set_focus(Some(page()));
-        let response = self.view.focus_text()?;
+        let response = self.pane.view.focus_text()?;
         self.respond(response);
         self.window.request_redraw();
         Ok(())
 @@ -4281,7 +4332,7 @@ impl State {
     /// Hands the section the ops the editor recorded since the last call, as one edit; the
     /// section thread stores it.
     fn persist(&mut self) -> Result<(), Box<dyn Error>> {
-        let ops = match self.view.editor.take_ops() {
+        let ops = match self.pane.view.editor.take_ops() {
             Ok(ops) => ops,
             Err(error) => return self.refused(&error.to_string()),
         };
 @@ -4291,12 +4342,12 @@ impl State {
         if ops.is_empty() {
             return Ok(());
         }
-        if session.read_only() {
+        if session.read_only(&self.pane.showing) {
             // A conflict page or a version is read-only: it returns to what is stored.
-            self.stale = true;
+            self.pane.stale = true;
             return Ok(());
         }
-        let space = session.space;
+        let space = self.pane.showing.space;
         session.section.apply(
             &self.author,
             onestore::op::Edit {
 @@ -4308,18 +4359,20 @@ impl State {
             },
         )?;
         // The page list shows the title as it is typed, even when the caret left it since.
-        let editor = &self.view.editor;
+        let editor = &self.pane.view.editor;
         let title = (editor.outlines().iter())
             .find(|outline| outline.title)
             .and_then(|outline| outline.document().paragraphs().last())
             .map(|paragraph| onestore::op::title_line(paragraph.text()));
         if editor.active_outline().title
-            || title.is_some_and(|title| !title.is_empty() && title != session.title())
+            || title.is_some_and(|title| {
+                !title.is_empty() && title != session.title(self.pane.showing.space)
+            })
         {
             session.pages = session.section.pages()?;
         }
         self.edited(vec![space]);
-        let editor = &self.view.editor;
+        let editor = &self.pane.view.editor;
         self.undo
             .edited(space, editor.history_depth(), editor.typing().is_some());
         Ok(())
 @@ -4328,17 +4381,17 @@ impl State {
     /// Shows the page as stored after a change made elsewhere, in place: the caret,
     /// selection, scroll and drawn pictures stay. Waits for marked text to end.
     fn refresh(&mut self) -> Result<(), Box<dyn Error>> {
-        if self.view.editor.marked_range().is_some() {
+        if self.pane.view.editor.marked_range().is_some() {
-            self.stale = true;
+            self.pane.stale = true;
             return Ok(());
         }
-        self.stale = false;
+        self.pane.stale = false;
         self.persist()?;
         let Some(session) = &self.session else {
             return Ok(());
         };
-        let page = session.reader(session.space)()?;
+        let page = session.reader(self.pane.showing.space)()?;
-        let response = self.view.refresh(page)?;
+        let response = self.pane.view.refresh(page)?;
         self.respond(response);
         self.title();
         self.window.request_redraw();
 @@ -4349,10 +4402,13 @@ impl State {
     /// text the editor showed goes on the clipboard so nothing typed is lost unannounced.
     fn refused(&mut self, error: &str) -> Result<(), Box<dyn Error>> {
         eprintln!("Saving failed: {error}");
-        self.clipboard.set_text(page_text(&self.view.editor))?;
+        self.clipboard.set_text(page_text(&self.pane.view.editor))?;
         // What the editor recorded since builds on the refused edit.
-        let _ = self.view.editor.take_ops();
+        let _ = self.pane.view.editor.take_ops();
-        self.view.editor.cancel_composition(&mut self.view.engine)?;
+        self.pane
+            .view
+            .editor
+            .cancel_composition(&mut self.pane.view.engine)?;
         platform::clear_marked_text(&self.window);
         self.refresh()?;
         platform::alert(
 @@ -4413,13 +4469,13 @@ impl State {
             match event {
                 Event::Changed(spaces) => {
                     listed = true;
-                    changed |= spaces.contains(&session.space);
+                    changed |= spaces.contains(&self.pane.showing.space);
                     elsewhere.extend_from_slice(&spaces);
                     self.search
                         .changed(session.key(), session.section.replica(), spaces);
                 }
                 Event::Rejected { spaces, error } => {
-                    if spaces.contains(&session.space) {
+                    if spaces.contains(&self.pane.showing.space) {
                         rejected = Some(error);
                     } else {
                         eprintln!("Saving failed: {error}");
 @@ -4447,23 +4503,26 @@ impl State {
             return Ok(());
         };
         if listed {
-            let back = session.shown;
+            let back = self.pane.showing.shown;
             session.pages = session.section.pages()?;
-            session.refresh_conflicts()?;
+            session.refresh_conflicts(&mut self.pane.showing)?;
-            session.refresh_history()?;
+            session.refresh_history(&mut self.pane.showing)?;
             let listed = |space: ExGuid| session.pages.iter().any(|(page, ..)| *page == space);
-            let gone = session.version.is_some_and(|version| {
+            let gone = self.pane.showing.version.is_some_and(|version| {
                 !session
-                    .page_versions(session.space)
+                    .page_versions(self.pane.showing.space)
                     .iter()
                     .any(|listed| listed.context == version)
             });
-            if gone && listed(session.space) {
+            if gone && listed(self.pane.showing.space) {
                 // A version deleted elsewhere returns to its page.
-                self.commands.push(Command::OpenPage(session.space));
+                self.commands
+                    .push(Command::OpenPage(self.pane.showing.space));
                 return Ok(());
             }
-            if !listed(session.space) && session.conflict(session.space).is_none() {
+            if !listed(self.pane.showing.space)
+                && session.conflict(self.pane.showing.space).is_none()
+            {
                 // A page removed elsewhere, or a conflict page deleted elsewhere, which
                 // returns to its page.
                 let open = back
 @@ -4511,7 +4570,7 @@ impl State {
         }
         let mut error = None;
         let mut sent = false;
-        let (view, ui, window) = (&self.view, &self.ui, &self.window);
+        let (view, ui, window) = (&self.pane.view, &self.ui, &self.window);
         self.access_adapter.update_if_active(|| {
             sent = true;
             page_tree(view, ui, window, &mut self.accessibility).unwrap_or_else(|failure| {
 @@ -4592,7 +4651,7 @@ impl State {
         let mut tree = Tree::new(chrome, true);
         if self.ui.laid_out(page()).is_some() {
             let mut fresh = accessibility::Accessibility::default();
-            let page = page_tree(&self.view, &self.ui, &self.window, &mut fresh)?;
+            let page = page_tree(&self.pane.view, &self.ui, &self.window, &mut fresh)?;
             tree.update_and_process_changes(page, &mut Unwatched);
         }
         if focus != graft || self.ui.laid_out(page()).is_some() {
 @@ -4638,7 +4697,7 @@ impl State {
             if request.action == Action::Focus {
                 self.window.focus_window();
                 self.ui.set_focus(Some(page()));
-                let response = self.view.focus_read_only(index)?;
+                let response = self.pane.view.focus_read_only(index)?;
                 self.respond(response);
                 self.window.request_redraw();
             }
 @@ -4647,7 +4706,7 @@ impl State {
         let Some(outline) = self.accessibility.outline_for_node(request.target_node) else {
             return Ok(());
         };
-        let view = &mut self.view;
+        let view = &mut self.pane.view;
         match (request.action, request.data) {
             (Action::Focus, _) => {
                 view.editor.focus_outline(outline)?;
 @@ -4671,7 +4730,7 @@ impl State {
             _ => return Ok(()),
         }
         self.ui.set_focus(Some(page()));
-        let response = self.view.focus_text()?;
+        let response = self.pane.view.focus_text()?;
         self.respond(response);
         self.window.request_redraw();
         Ok(())
 @@ -4682,8 +4741,12 @@ impl State {
         if let Some(path) = self.snapshot.take() {
             // A hidden window never paints, so nothing polls the pictures between snapshots.
             let paper = self.paper();
-            if let Some((scene, _)) = &mut self.view.scene {
+            if let Some((scene, _)) = &mut self.pane.view.scene {
-                scene.settle(Some(&self.view.editor), self.view.viewport.scale, paper);
+                scene.settle(
+                    Some(&self.pane.view.editor),
+                    self.pane.view.viewport.scale,
+                    paper,
+                );
             }
             self.snapshot(&path)?;
         }
 @@ -4724,7 +4787,7 @@ impl State {
     /// Marks misspelled words on the page unless Hide Spelling Errors is on.
     fn show_spelling(&mut self) {
-        self.view.spelling = self.spelling.clone().filter(|_| !self.hide_spelling);
+        self.pane.view.spelling = self.spelling.clone().filter(|_| !self.hide_spelling);
         self.window.request_redraw();
     }
 @@ -4736,7 +4799,7 @@ impl State {
         }
         .colored(
             self.page_color_preview
-                .unwrap_or_else(|| self.view.editor.page_color()),
+                .unwrap_or_else(|| self.pane.view.editor.page_color()),
         )
     }
 @@ -4758,9 +4821,9 @@ impl State {
     fn paint(&mut self, target: &draw::Target) -> Result<(), Box<dyn Error>> {
         let start = Instant::now();
         let paper = self.paper();
-        self.view.update_pictures(paper, &self.redraw);
+        self.pane.view.update_pictures(paper, &self.redraw);
         if let Some(session) = &self.session {
-            self.view.tag_art = session.library.tag_art();
+            self.pane.view.tag_art = session.library.tag_art();
         }
         let theme = &self.ui.theme;
         let scale = self.ui.scale();
 @@ -4772,20 +4835,20 @@ impl State {
                 canvas::gpu::Viewport {
                     scale,
                     origin: [0.0; 2],
-                    ..self.view.viewport
+                    ..self.pane.view.viewport
                 },
             ),
             None => (
-                self.view.primitives(TextColors {
+                self.pane.view.primitives(TextColors {
                     caret: theme.caret,
-                    selection: if self.page_focused {
+                    selection: if self.pane.page_focused {
                         theme.selection
                     } else {
                         theme.inactive_selection
                     },
                     paper,
                 })?,
-                self.view.viewport,
+                self.pane.view.viewport,
             ),
         };
         lap("page primitives", start);
 @@ -4853,14 +4916,17 @@ impl State {
     fn pinch(&mut self, factor: f32) -> Result<(), Box<dyn Error>> {
         if self.over_page() {
             // The pointer here, as the page's own lags by the moves queued for the next frame.
-            let response = self.view.pinch(factor, self.page_point(self.pointer))?;
+            let response = self
+                .pane
+                .view
+                .pinch(factor, self.page_point(self.pointer))?;
             self.respond(response);
         }
         Ok(())
     }
     fn swipe_scroll(&mut self, phase: winit::event::TouchPhase, delta: [f32; 2]) {
-        let scroll = self.view.scroll();
+        let scroll = self.pane.view.scroll();
         let armed = scroll.max[0] <= scroll.min[0] && self.over_page();
         if let Some(forward) = self.swipe.scroll(phase, delta, armed, Instant::now()) {
             self.travel(forward);
 @@ -5209,6 +5275,7 @@ fn page_rows(
     theme: &Theme,
     section: &ui::Section,
     session: &Session,
+    showing: &Showing,
     marked: [&HashSet<ExGuid>; 2],
     peers: &HashMap<ExGuid, Vec<[f32; 4]>>,
     shape: (f32, bool),
 @@ -5255,6 +5322,7 @@ fn page_rows(
             theme,
             section,
             session,
+            showing,
             marked,
             peers,
             shape,
 @@ -5283,6 +5351,7 @@ fn page_rows(
             theme,
             section,
             session,
+            showing,
             marked,
             peers,
             shape,
 @@ -5305,6 +5374,7 @@ fn page_row(
     theme: &Theme,
     section: &ui::Section,
     session: &Session,
+    showing: &Showing,
     [found, unread]: [&HashSet<ExGuid>; 2],
     peers: &HashMap<ExGuid, Vec<[f32; 4]>>,
     shape: (f32, bool),
 @@ -5334,7 +5404,7 @@ fn page_row(
         shift,
         lifted,
     };
-    let selected = *space == session.space && session.version.is_none();
+    let selected = *space == showing.space && showing.version.is_none();
     if selected && !lifted {
         rows.open = Some(ui.id(space));
     }
 @@ -5366,19 +5436,19 @@ fn page_row(
     };
     // Each row: its id, its label, whether it is open, and whether it is a page version.
     let history = (session.page_versions(*space).iter())
-        .filter(|_| session.shown_history == Some(*space))
+        .filter(|_| showing.shown_history == Some(*space))
         .map(|version| {
-            let open = session.version == Some(version.context);
+            let open = showing.version == Some(version.context);
             (version.context, history::label(version), open, true)
         });
     let conflicts = (versions.iter())
-        .filter(|_| session.shown == Some(*space))
+        .filter(|_| showing.shown == Some(*space))
         .map(|version| {
             let label = match version.created {
                 Some(created) => format!("{} {}", platform::short_date(created), version.user),
                 None => version.user.clone(),
             };
-            (version.space, label, version.space == session.space, false)
+            (version.space, label, version.space == showing.space, false)
         });
     for (id, label, selected, version) in history.chain(conflicts) {
         let tab = PageTab {
 @@ -6236,14 +6306,14 @@ pub fn plain(error: &(dyn Error + 'static), thing: &str) -> String {
     }
 }
-/// The session for `section`, at catalog `path` in `library`, showing `space` or its first
+/// The session for `section`, at catalog `path` in `library`, with `space` or its first
-/// page, and that page.
+/// page and that page.
 fn read_session(
     section: notebook::session::Section,
     library: Arc<Library>,
     path: String,
     space: Option<ExGuid>,
-) -> Result<(Session, Page), Box<dyn Error>> {
+) -> Result<(Session, ExGuid, Page), Box<dyn Error>> {
     let folder = path.rsplit_once('/').map_or("", |(folder, _)| folder);
     let tabs = library.tabs(folder);
     let tab = tabs
 @@ -6266,15 +6336,11 @@ fn read_session(
             tabs,
             tab,
             pages,
-            space,
             sync,
             conflicts,
-            shown: None,
-            change: None,
             history,
-            shown_history: None,
-            version: None,
         },
+        space,
         page,
     ))
 }
 @@ -6371,7 +6437,7 @@ impl State {
             }
             UserEvent::InsertText(text) => {
                 if self.ui.focused() == Some(page()) {
-                    match self.view.insert_text(text) {
+                    match self.pane.view.insert_text(text) {
                         Ok(response) => self.respond(response),
                         Err(error) => eprintln!("{error}"),
                     }
 @@ -6488,7 +6554,7 @@ impl State {
                 // Quiet still when the mark sent on finding it quiet arrives, what a thread sent
                 // as it ended has been taken, however many frames wait in the queue before it.
                 let quiet = self.settled()
-                    && self.opening.is_none()
+                    && self.pane.opening.is_none()
                     && RUNNING.load(Ordering::Acquire) == 0
                     && self.search.pending.load(Ordering::Relaxed) == 0;
                 if let Some((path, settled, sent)) = self.replay_settle.take() {
 @@ -6522,7 +6588,7 @@ impl State {
         if event.window_id != self.window.id() {
             return;
         }
-        let was_marked = self.view.editor.marked_range().is_some();
+        let was_marked = self.pane.view.editor.marked_range().is_some();
         let result = match event.window_event {
             accesskit_winit::WindowEvent::InitialTreeRequested => {
                 self.deactivate_accessibility();
 @@ -6534,7 +6600,7 @@ impl State {
                 Ok(())
             }
         };
-        if was_marked && self.view.editor.marked_range().is_none() {
+        if was_marked && self.pane.view.editor.marked_range().is_none() {
             platform::clear_marked_text(&self.window);
         }
         if let Err(error) = result {
 @@ -6547,7 +6613,7 @@ impl State {
 impl State {
     /// Quits, first asking whether to discard a temporary page holding edits.
     fn quit(&self) {
-        let editor = &self.view.editor;
+        let editor = &self.pane.view.editor;
         let unchanged = editor.caret_outline().is_none_or(TextOutline::is_empty)
             && self.initial_date == editor.date().map(|date| date.timestamp())
             && (self.initial_layouts.iter())
 @@ -6804,7 +6870,7 @@ impl ApplicationHandler<UserEvent> for App {
                 WindowEvent::PinchGesture { delta, .. } => state.pinch(1.0 + delta as f32)?,
                 // Smart zoom: to 200% about the fingers, or back to 100%.
                 WindowEvent::DoubleTapGesture { .. } => {
-                    let zoom = state.view.zoom();
+                    let zoom = state.pane.view.zoom();
                     let target = if (zoom - 1.0).abs() < 0.01 { 2.0 } else { 1.0 };
                     state.pinch(target / zoom)?
                 }
 @@ -6826,7 +6892,7 @@ impl ApplicationHandler<UserEvent> for App {
             return;
         }
         let now = Instant::now();
-        let (repaint, blink) = state.view.blink(now);
+        let (repaint, blink) = state.pane.view.blink(now);
         // A due interface change waits on the frame that shows it, which sets the next.
         let wake = state.ui.wake_at();
         if repaint || wake.is_some_and(|wake| wake <= now) {
 @@ -7562,7 +7628,7 @@ mod tests {
                 let section = library.open(&tab.path, || {}).unwrap();
                 let opened = ms(start);
                 let start = Instant::now();
-                let (session, page) =
+                let (session, _, page) =
                     read_session(section, Arc::clone(&library), tab.path.clone(), None).unwrap();
                 let read = ms(start);
                 let start = Instant::now();

crates/snowbound/src/manage.rs+50-41

 @@ -177,8 +177,8 @@ impl State {
         title: &str,
     ) -> Result<PageCreation, Box<dyn Error>> {
         let creation = PageCreation::new(before, Some(title), &self.author)?.titled_in(
-            &self.view.editor.default_font.face,
+            &self.pane.view.editor.default_font.face,
-            self.view.editor.default_font.color,
+            self.pane.view.editor.default_font.color,
         )?;
         let [date, time] = platform::date_text(creation.created());
         Ok(creation.dated(&date, &time)?)
 @@ -228,7 +228,7 @@ impl State {
         session.section.replica().apply(&self.author, edit)?;
         #[cfg(target_arch = "wasm32")]
         session.section.apply(&self.author, edit)?;
-        let shown = session.space;
+        let shown = self.pane.showing.space;
         self.made(Change::Delete {
             pages: vec![space],
             show: Some(shown),
 @@ -236,7 +236,8 @@ impl State {
         });
         let session = self.session.as_ref().ok_or("No section is open")?;
         let page = session.section.page(space)?;
-        let (scene, editor) = canvas::gpu::page::PageScene::from_page(page, &mut self.view.engine)?;
+        let (scene, editor) =
+            canvas::gpu::page::PageScene::from_page(page, &mut self.pane.view.engine)?;
         self.stop_loading();
         let now = crate::Instant::now();
         self.show_page(crate::Opening {
 @@ -248,14 +249,15 @@ impl State {
         })?;
         self.ui.set_focus(Some(crate::page()));
         if let Some(title) = self
+            .pane
             .view
             .editor
             .outlines()
             .iter()
             .find(|outline| outline.title)
         {
-            self.view.editor.focus_outline(title.id)?;
+            self.pane.view.editor.focus_outline(title.id)?;
-            let response = self.view.focus_text()?;
+            let response = self.pane.view.focus_text()?;
             self.respond(response);
         }
         Ok(())
 @@ -267,7 +269,7 @@ impl State {
         self.with_art(Some(template), move |state, art| {
             state.persist()?;
             let session = state.session.as_ref().ok_or("No section is open")?;
-            let ops = template_ops(&session.section.page(session.space)?, name, art)?;
+            let ops = template_ops(&session.section.page(state.pane.showing.space)?, name, art)?;
             state.edit_page(ops)
         })
     }
 @@ -283,16 +285,13 @@ impl State {
         let Some(template) = template else {
             return then(self, Vec::new());
         };
-        let space = self.session.as_ref().ok_or("No section is open")?.space;
+        self.session.as_ref().ok_or("No section is open")?;
+        let space = self.pane.showing.space;
         let proxy = self.proxy.clone();
         crate::spawn(move || {
             let art = template.pictures().map_err(|error| error.to_string());
             let _ = proxy.send_event(crate::UserEvent::Then(Box::new(move |state| {
-                if state
+                if state.session.is_some() && state.pane.showing.space == space {
-                    .session
-                    .as_ref()
-                    .is_some_and(|open| open.space == space)
-                {
                     then(state, art?)
                 } else {
                     Ok(())
 @@ -310,7 +309,7 @@ impl State {
         rule_lines: Option<onestore::page::RuleLines>,
         art: Option<Vec<Image>>,
     ) -> Result<(), Box<dyn Error>> {
-        let response = self.view.set_paper(color, rule_lines, art)?;
+        let response = self.pane.view.set_paper(color, rule_lines, art)?;
         self.respond(response);
         Ok(())
     }
 @@ -321,7 +320,7 @@ impl State {
             return Ok(());
         }
         let session = self.session.as_ref().ok_or("No section is open")?;
-        let space = session.space;
+        let space = self.pane.showing.space;
         session.section.apply(
             &self.author,
             Edit {
 @@ -469,6 +468,7 @@ impl State {
     pub(crate) fn show_arrived(&mut self, library: &Arc<Library>) {
         if self.session.is_some()
             || self
+                .pane
                 .sectionless
                 .as_ref()
                 .is_some_and(|shown| shown.location != library.location)
 @@ -476,7 +476,7 @@ impl State {
             return;
         }
         let first = library.first_section();
-        self.sectionless = Some(Arc::clone(library));
+        self.pane.sectionless = Some(Arc::clone(library));
         self.title();
         if let Some(path) = first {
             self.commands
 @@ -572,8 +572,8 @@ impl State {
                 .first_section()
                 .ok_or("The new notebook has no section")?;
             let section = library.open_async(&path, notify).await?;
-            let (session, page) = read_session(section, library, path, None)?;
+            let (session, space, page) = read_session(section, library, path, None)?;
-            Ok(Loaded::Section(Box::new(session), page))
+            Ok(Loaded::Section(Box::new(session), space, page))
         });
         Ok(())
     }
 @@ -623,7 +623,7 @@ impl State {
             background.discard();
         }
         let shown = |shown: &Arc<Library>| shown.location == library.location;
-        if self.sectionless.as_ref().is_some_and(shown)
+        if self.pane.sectionless.as_ref().is_some_and(shown)
             || self
                 .session
                 .as_ref()
 @@ -631,7 +631,7 @@ impl State {
         {
             self.persist().unwrap_or_else(|error| eprintln!("{error}"));
             self.session = None;
-            self.sectionless = None;
+            self.pane.sectionless = None;
             match self
                 .notebooks
                 .iter()
 @@ -639,7 +639,7 @@ impl State {
             {
                 Some((open, path)) => self.commands.push(Command::OpenSection(open, path)),
                 None => {
-                    self.sectionless = self.notebooks.first().cloned();
+                    self.pane.sectionless = self.notebooks.first().cloned();
                     self.title();
                 }
             }
 @@ -695,15 +695,16 @@ impl State {
             (self.session).take_if(|session| Arc::ptr_eq(&session.library, &library))
         {
             // Its replica goes with it, so nothing may hold it.
-            let _ = self.view.editor.take_ops();
+            let _ = self.pane.view.editor.take_ops();
             if let Err(error) = session.section.close() {
                 eprintln!("{location}: {error}");
             }
-            self.sectionless = Some(Arc::clone(&library));
+            self.pane.sectionless = Some(Arc::clone(&library));
         }
         self.trashing.insert(location.clone());
         self.close_notebook(&library);
-        self.trail.forget(&location);
+        self.pane.trail.forget(&location);
+        self.recent.retain(|place| place.notebook != location);
         self.reads.forget(&location);
         let ours = crate::library::key(&location, "");
         self.folded.retain(|key| !key.starts_with(&ours));
 @@ -754,13 +755,13 @@ impl State {
             .as_ref()
             .and_then(|_| self.session.take())
             .map(|session| session.section);
-        let showing = shown.is_some() || self.sectionless.as_ref().is_some_and(ours);
+        let showing = shown.is_some() || self.pane.sectionless.as_ref().is_some_and(ours);
         if showing {
-            self.sectionless = Some(Arc::clone(&library));
+            self.pane.sectionless = Some(Arc::clone(&library));
             self.title();
         }
         self.folder_rename = Some((library.location.clone(), to.clone()));
-        let (cache, proxy, requested) = (self.cache.clone(), self.proxy.clone(), self.loading);
+        let (cache, proxy, requested) = (self.cache.clone(), self.proxy.clone(), self.pane.loading);
         crate::spawn_async(move || async move {
             let structure = Arc::clone(&library.structure);
             let _structure = structure.lock().await;
 @@ -805,7 +806,7 @@ impl State {
                     state.folder_rename = None;
                 }
                 let restore = showing
-                    && requested == state.loading
+                    && requested == state.pane.loading
                     && state.notebook().is_some_and(|current| {
                         current.location == library.location
                             && Arc::ptr_eq(&current.structure, &library.structure)
 @@ -839,7 +840,14 @@ impl State {
             .retain(|open| open.location != to || !std::mem::replace(&mut listed, true));
         if from != to {
             self.undo.close(&from);
-            self.trail.moved(&from, &to);
+            self.pane.trail.moved(&from, &to);
+            for place in self
+                .recent
+                .iter_mut()
+                .filter(|place| place.notebook == from)
+            {
+                place.notebook.clone_from(&to);
+            }
             self.reads.moved(&from, &to);
             let (from, to) = (crate::library::key(&from, ""), crate::library::key(&to, ""));
             let rekey = |key: &String| match key.strip_prefix(&from) {
 @@ -852,7 +860,7 @@ impl State {
                 .collect();
         }
         if let Some(shown) = shown {
-            self.sectionless = Some(Arc::clone(&reopened));
+            self.pane.sectionless = Some(Arc::clone(&reopened));
             self.title();
             if let Some(path) = shown
                 .filter(|path| reopened.contains(path))
 @@ -885,8 +893,8 @@ impl State {
             .filter(|session| Arc::ptr_eq(&session.library, &library))
             .map(|session| session.tabs[session.tab].path.clone());
         let notify = notify(self.proxy.clone());
-        let (proxy, requested) = (self.proxy.clone(), self.loading);
+        let (proxy, requested) = (self.proxy.clone(), self.pane.loading);
-        let showing = self.switching.is_none() && self.opening.is_none();
+        let showing = self.pane.switching.is_none() && self.pane.opening.is_none();
         let structure = Arc::clone(&library.structure);
         let pending = match &change {
             Structure::Rename { path, name } => library.entry_identity(path).map(|identity| {
 @@ -991,8 +999,8 @@ impl State {
                         library.keep_key(&path, key);
                     }
                     let section = library.open_async(&path, notify).await?;
-                    let (session, page) = read_session(section, library, path, None)?;
+                    let (session, space, page) = read_session(section, library, path, None)?;
-                    return Ok(Loaded::Section(Box::new(session), page));
+                    return Ok(Loaded::Section(Box::new(session), space, page));
                 }
                 Structure::Properties { name, color } => {
                     if name != library.name {
 @@ -1018,11 +1026,11 @@ impl State {
                 return Ok(Loaded::Library(library, Some(path)));
             }
             let section = library.open_async(&path, notify).await?;
-            let (session, page) = read_session(section, library, path, None)?;
+            let (session, space, page) = read_session(section, library, path, None)?;
             Ok(if fresh {
-                Loaded::Created(Box::new(session), page)
+                Loaded::Created(Box::new(session), space, page)
             } else {
-                Loaded::Section(Box::new(session), page)
+                Loaded::Section(Box::new(session), space, page)
             })
         };
         crate::spawn_async(move || async move {
 @@ -1040,7 +1048,7 @@ impl State {
                 };
                 let library = match &loaded {
                     Loaded::Library(library, _) => Arc::clone(library),
-                    Loaded::Section(session, _) | Loaded::Created(session, _) => {
+                    Loaded::Section(session, ..) | Loaded::Created(session, ..) => {
                         Arc::clone(&session.library)
                     }
                     _ => unreachable!("A structure change returns its notebook"),
 @@ -1071,7 +1079,7 @@ impl State {
                     });
                     if let Some(path) = path {
                         state.adopt(library, Some(&path))?;
-                    } else if requested != state.loading || !showing {
+                    } else if requested != state.pane.loading || !showing {
                         if let Some(path) = library.first_section() {
                             state.commands.push(Command::OpenSection(library, path));
                         } else {
 @@ -1079,13 +1087,14 @@ impl State {
                         }
                     }
                 } else if state
+                    .pane
                     .sectionless
                     .as_ref()
                     .is_some_and(|shown| shown.location == library.location)
                 {
-                    state.sectionless = Some(library);
+                    state.pane.sectionless = Some(library);
                 }
-                if showing && requested == state.loading {
+                if showing && requested == state.pane.loading {
                     match loaded {
                         Loaded::Library(library, path) => state.adopt(library, path.as_deref())?,
                         loaded => state.load(move || Ok(loaded)),

crates/snowbound/src/menus.rs+2-2

...	@@ -489,7 +489,7 @@ impl State {	...	@@ -489,7 +489,7 @@ impl State {
489	let above = at	489	let above = at
490	.and_then(\|at\| at.checked_sub(1))	490	.and_then(\|at\| at.checked_sub(1))
491	.map_or(0, \|above\| pages[above].2);	491	.map_or(0, \|above\| pages[above].2);
492	let shown = session.shown_history == Some(*space);	492	let shown = self.pane.showing.shown_history == Some(*space);
493	let versions = if shown {	493	let versions = if shown {
494	"Hide Page Versions"	494	"Hide Page Versions"
495	} else {	495	} else {
...	@@ -1039,7 +1039,7 @@ impl State {	...	@@ -1039,7 +1039,7 @@ impl State {
1039	new(&action, String::new()).map(\|structure\| Command::Structure(library, structure))	1039	new(&action, String::new()).map(\|structure\| Command::Structure(library, structure))
1040	}	1040	}
1041	(Target::Closed(location), Action::Delete) => {	1041	(Target::Closed(location), Action::Delete) => {
1042	self.trail.recent.retain(\|place\| place.notebook != location);	1042	self.recent.retain(\|place\| place.notebook != location);
1043	self.save_settings();	1043	self.save_settings();
1044	None	1044	None
1045	}	1045	}

crates/snowbound/src/navigation.rs+46-50

...	@@ -39,19 +39,17 @@ impl Visit {	...	@@ -39,19 +39,17 @@ impl Visit {
39	}	39	}
40	}	40	}
41		41
42	/// Pages visited before and after the one shown, and those shown lately.	42	/// Pages visited before and after the one shown.
43	#[derive(Default)]	43	#[derive(Default)]
44	pub struct Trail {	44	pub struct Trail {
45	back: Vec<Visit>,	45	back: Vec<Visit>,
46	here: Option<Visit>,	46	here: Option<Visit>,
47	forward: Vec<Visit>,	47	forward: Vec<Visit>,
48	/// Each page shown lately once, latest first, kept between launches.
49	pub recent: Vec<Place>,
50	}	48	}
51		49
52	/// Places Back keeps, at most.	50	/// Places Back keeps, at most.
53	const KEPT: usize = 100;	51	const KEPT: usize = 100;
54	/// Pages `Trail::recent` keeps, at most.	52	/// Pages `State::recent` keeps, at most.
55	const RECENT: usize = 8;	53	const RECENT: usize = 8;
56		54
57	impl Trail {	55	impl Trail {
...	@@ -61,8 +59,7 @@ impl Trail {	...	@@ -61,8 +59,7 @@ impl Trail {
61	.chain(&mut self.here)	59	.chain(&mut self.here)
62	.chain(&mut self.forward)	60	.chain(&mut self.forward)
63	.map(\|visit\| &mut visit.notebook);	61	.map(\|visit\| &mut visit.notebook);
64	let places = self.recent.iter_mut().map(\|place\| &mut place.notebook);	62	for notebook in visits.filter(\|notebook\| *notebook == from) {
65	for notebook in visits.chain(places).filter(\|notebook\| *notebook == from) {
66	*notebook = to.to_owned();	63	*notebook = to.to_owned();
67	}	64	}
68	}	65	}
...	@@ -73,14 +70,6 @@ impl Trail {	...	@@ -73,14 +70,6 @@ impl Trail {
73	self.back.retain(elsewhere);	70	self.back.retain(elsewhere);
74	self.forward.retain(elsewhere);	71	self.forward.retain(elsewhere);
75	self.here = self.here.take().filter(elsewhere);	72	self.here = self.here.take().filter(elsewhere);
76	self.recent.retain(\|place\| place.notebook != location);
77	}
78
79	/// Notes `place` shown, as the recent pages list it.
80	pub fn remember(&mut self, place: Place) {
81	self.recent.retain(\|recent\| *recent != place);
82	self.recent.insert(0, place);
83	self.recent.truncate(RECENT);
84	}	73	}
85		74
86	/// Notes `visit` shown. Arriving anywhere but where Back or Forward went drops the pages	75	/// Notes `visit` shown. Arriving anywhere but where Back or Forward went drops the pages
...	@@ -122,23 +111,30 @@ impl Trail {	...	@@ -122,23 +111,30 @@ impl Trail {
122	pub fn open(&self, exists: impl Fn(&Visit) -> bool) -> [bool; 2] {	111	pub fn open(&self, exists: impl Fn(&Visit) -> bool) -> [bool; 2] {
123	[&self.back, &self.forward].map(\|side\| side.iter().rev().any(&exists))	112	[&self.back, &self.forward].map(\|side\| side.iter().rev().any(&exists))
124	}	113	}
		114	}
125		115
126	/// Drops the recent pages whose section `listed` refuses, and those whose section `index`	116	/// Notes `place` shown, as the recent pages list it.
127	/// has read without them. Returns whether any went.	117	pub fn remember(recent: &mut Vec<Place>, place: Place) {
128	pub fn prune(&mut self, index: &Index, listed: impl Fn(&Place) -> bool) -> bool {	118	recent.retain(\|known\| *known != place);
129	let read: HashSet<&str> = (index.entries().iter())	119	recent.insert(0, place);
130	.map(\|entry\| entry.section.as_str())	120	recent.truncate(RECENT);
131	.collect();	121	}
132	let before = self.recent.len();	122
133	self.recent.retain(\|place\| {	123	/// Drops the recent pages whose section `listed` refuses, and those whose section `index`
134	let key = crate::library::key(&place.notebook, &place.section);	124	/// has read without them. Returns whether any went.
135	listed(place)	125	pub fn prune(recent: &mut Vec<Place>, index: &Index, listed: impl Fn(&Place) -> bool) -> bool {
136	&& (!read.contains(key.as_str())	126	let read: HashSet<&str> = (index.entries().iter())
137	\|\| (index.entries().iter())	127	.map(\|entry\| entry.section.as_str())
138	.any(\|entry\| entry.space == place.page && entry.section == key))	128	.collect();
139	});	129	let before = recent.len();
140	self.recent.len() != before	130	recent.retain(\|place\| {
141	}	131	let key = crate::library::key(&place.notebook, &place.section);
		132	listed(place)
		133	&& (!read.contains(key.as_str())
		134	\|\| (index.entries().iter())
		135	.any(\|entry\| entry.space == place.page && entry.section == key))
		136	});
		137	recent.len() != before
142	}	138	}
143		139
144	/// Where `visit`'s page is in `notebooks`, as `index` has read them and `open` tells whether	140	/// Where `visit`'s page is in `notebooks`, as `index` has read them and `open` tells whether
...	@@ -189,19 +185,19 @@ impl State {	...	@@ -189,19 +185,19 @@ impl State {
189	let place = Place {	185	let place = Place {
190	notebook: session.library.location.clone(),	186	notebook: session.library.location.clone(),
191	section: path.clone(),	187	section: path.clone(),
192	page: session.space,	188	page: self.pane.showing.space,
193	};	189	};
194	if let Ok(section) = session.section.identity() {	190	if let Ok(section) = session.section.identity() {
195	self.trail.visit(Visit {	191	self.pane.trail.visit(Visit {
196	notebook: place.notebook.clone(),	192	notebook: place.notebook.clone(),
197	section,	193	section,
198	space: session.space,	194	space: self.pane.showing.space,
199	page: self.view.editor.identity(),	195	page: self.pane.view.editor.identity(),
200	binned: crate::recycle::binned(path),	196	binned: crate::recycle::binned(path),
201	});	197	});
202	}	198	}
203	let moved = self.trail.recent.first() != Some(&place);	199	let moved = self.recent.first() != Some(&place);
204	self.trail.remember(place);	200	remember(&mut self.recent, place);
205	if moved {	201	if moved {
206	self.save_settings();	202	self.save_settings();
207	}	203	}
...	@@ -222,7 +218,7 @@ impl State {	...	@@ -222,7 +218,7 @@ impl State {
222		218
223	/// Whether Back and Forward have a page to go to.	219	/// Whether Back and Forward have a page to go to.
224	pub(crate) fn can_travel(&self) -> [bool; 2] {	220	pub(crate) fn can_travel(&self) -> [bool; 2] {
225	self.trail.open(\|visit\| self.find(visit).is_some())	221	self.pane.trail.open(\|visit\| self.find(visit).is_some())
226	}	222	}
227		223
228	/// Whether `library`'s section at `path` is the one open.	224	/// Whether `library`'s section at `path` is the one open.
...	@@ -246,9 +242,9 @@ impl State {	...	@@ -246,9 +242,9 @@ impl State {
246	/// Shows the page visited before the one shown, or after it going `forward`, wherever it	242	/// Shows the page visited before the one shown, or after it going `forward`, wherever it
247	/// went since. Pages since deleted, and those of notebooks since closed, are passed over.	243	/// went since. Pages since deleted, and those of notebooks since closed, are passed over.
248	pub(crate) fn travel(&mut self, forward: bool) {	244	pub(crate) fn travel(&mut self, forward: bool) {
249	let mut trail = std::mem::take(&mut self.trail);	245	let mut trail = std::mem::take(&mut self.pane.trail);
250	let visit = trail.step(forward, \|visit\| self.find(visit).is_some());	246	let visit = trail.step(forward, \|visit\| self.find(visit).is_some());
251	self.trail = trail;	247	self.pane.trail = trail;
252	if let Some((library, path, space)) = visit.and_then(\|visit\| self.find(&visit)) {	248	if let Some((library, path, space)) = visit.and_then(\|visit\| self.find(&visit)) {
253	self.go(library, path, space);	249	self.go(library, path, space);
254	}	250	}
...	@@ -418,16 +414,16 @@ mod tests {	...	@@ -418,16 +414,16 @@ mod tests {
418		414
419	#[test]	415	#[test]
420	fn recent_pages_are_kept_once_latest_first_and_bounded() {	416	fn recent_pages_are_kept_once_latest_first_and_bounded() {
421	let mut trail = Trail::default();	417	let mut recent = Vec::new();
422	for page in [1, 2, 1] {	418	for page in [1, 2, 1] {
423	trail.remember(place("A.one", page));	419	remember(&mut recent, place("A.one", page));
424	}	420	}
425	assert_eq!(trail.recent, [place("A.one", 1), place("A.one", 2)]);	421	assert_eq!(recent, [place("A.one", 1), place("A.one", 2)]);
426	for page in 0..20 {	422	for page in 0..20 {
427	trail.remember(place("B.one", page));	423	remember(&mut recent, place("B.one", page));
428	}	424	}
429	assert_eq!(trail.recent.len(), RECENT);	425	assert_eq!(recent.len(), RECENT);
430	assert_eq!(trail.recent[0], place("B.one", 19));	426	assert_eq!(recent[0], place("B.one", 19));
431	}	427	}
432		428
433	#[test]	429	#[test]
...	@@ -452,7 +448,7 @@ mod tests {	...	@@ -452,7 +448,7 @@ mod tests {
452	&page("Kept"),	448	&page("Kept"),
453	0,	449	0,
454	));	450	));
455	let mut trail = Trail::default();	451	let mut recent = Vec::new();
456	// Visited oldest first: the index has read A without page 2, not yet B, and C is gone.	452	// Visited oldest first: the index has read A without page 2, not yet B, and C is gone.
457	for gone in [	453	for gone in [
458	place("C.one", 1),	454	place("C.one", 1),
...	@@ -460,12 +456,12 @@ mod tests {	...	@@ -460,12 +456,12 @@ mod tests {
460	place("A.one", 2),	456	place("A.one", 2),
461	kept.clone(),	457	kept.clone(),
462	] {	458	] {
463	trail.remember(gone);	459	remember(&mut recent, gone);
464	}	460	}
465	let listed = \|place: &Place\| place.section != "C.one";	461	let listed = \|place: &Place\| place.section != "C.one";
466	assert!(trail.prune(&index, listed));	462	assert!(prune(&mut recent, &index, listed));
467	assert_eq!(trail.recent, [kept, place("B.one", 1)]);	463	assert_eq!(recent, [kept, place("B.one", 1)]);
468	assert!(!trail.prune(&index, listed), "nothing more goes");	464	assert!(!prune(&mut recent, &index, listed), "nothing more goes");
469	}	465	}
470		466
471	#[test]	467	#[test]

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

crates/snowbound/src/palette.rs+5-5

...	@@ -114,7 +114,7 @@ impl State {	...	@@ -114,7 +114,7 @@ impl State {
114	}	114	}
115	}	115	}
116	// And what the page's context menu does at the caret, or to the file selected.	116	// And what the page's context menu does at the caret, or to the file selected.
117	let text = self.view.caret_context();	117	let text = self.pane.view.caret_context();
118	for (item, title) in text.iter().flat_map(\|context\| self.text_items(context)) {	118	for (item, title) in text.iter().flat_map(\|context\| self.text_items(context)) {
119	if !(commands::COMMANDS.iter()).any(\|command\| command.title == title) {	119	if !(commands::COMMANDS.iter()).any(\|command\| command.title == title) {
120	commands.push(Row {	120	commands.push(Row {
...	@@ -334,7 +334,7 @@ impl State {	...	@@ -334,7 +334,7 @@ impl State {
334	Target::Page {	334	Target::Page {
335	library: Arc::clone(library),	335	library: Arc::clone(library),
336	path: path.clone(),	336	path: path.clone(),
337	space: session.space,	337	space: self.pane.showing.space,
338	},	338	},
339	Target::Section {	339	Target::Section {
340	library: Arc::clone(library),	340	library: Arc::clone(library),
...	@@ -367,7 +367,7 @@ impl State {	...	@@ -367,7 +367,7 @@ impl State {
367	.map(Arc::clone)	367	.map(Arc::clone)
368	};	368	};
369	// A closed notebook keeps its places to open it again, an unreadable one until it reads.	369	// A closed notebook keeps its places to open it again, an unreadable one until it reads.
370	let pruned = self.trail.prune(&index, \|place\| {	370	let pruned = crate::navigation::prune(&mut self.recent, &index, \|place\| {
371	library(&place.notebook)	371	library(&place.notebook)
372	.is_none_or(\|library\| library.notebook.is_err() \|\| library.contains(&place.section))	372	.is_none_or(\|library\| library.notebook.is_err() \|\| library.contains(&place.section))
373	});	373	});
...	@@ -375,7 +375,7 @@ impl State {	...	@@ -375,7 +375,7 @@ impl State {
375	(	375	(
376	session.library.location.as_str(),	376	session.library.location.as_str(),
377	session.tabs[session.tab].path.as_str(),	377	session.tabs[session.tab].path.as_str(),
378	session.space,	378	self.pane.showing.space,
379	)	379	)
380	});	380	});
381	let theme = &self.ui.theme;	381	let theme = &self.ui.theme;
...	@@ -393,7 +393,7 @@ impl State {	...	@@ -393,7 +393,7 @@ impl State {
393	_ => false,	393	_ => false,
394	})	394	})
395	};	395	};
396	for place in &self.trail.recent {	396	for place in &self.recent {
397	let Some(library) = library(&place.notebook) else {	397	let Some(library) = library(&place.notebook) else {
398	let target = Target::Closed(place.notebook.clone());	398	let target = Target::Closed(place.notebook.clone());
399	if !listed(&closed, &target) {	399	if !listed(&closed, &target) {

crates/snowbound/src/paste.rs+7-6

...	@@ -124,7 +124,7 @@ impl State {	...	@@ -124,7 +124,7 @@ impl State {
124	}	124	}
125	}	125	}
126	Some(Pasted::Clip(clip)) => {	126	Some(Pasted::Clip(clip)) => {
127	let response = self.view.paste_clip(clip)?;	127	let response = self.pane.view.paste_clip(clip)?;
128	self.respond(response);	128	self.respond(response);
129	}	129	}
130	Some(Pasted::Page(html, text)) => {	130	Some(Pasted::Page(html, text)) => {
...	@@ -142,12 +142,12 @@ impl State {	...	@@ -142,12 +142,12 @@ impl State {
142	});	142	});
143	if pieces.is_empty() {	143	if pieces.is_empty() {
144	if let Some(text) = text {	144	if let Some(text) = text {
145	let response = self.view.paste(&text, language)?;	145	let response = self.pane.view.paste(&text, language)?;
146	self.respond(response);	146	self.respond(response);
147	}	147	}
148	return Ok(());	148	return Ok(());
149	}	149	}
150	let (places, response) = self.view.paste_pieces(pieces)?;	150	let (places, response) = self.pane.view.paste_pieces(pieces)?;
151	self.respond(response);	151	self.respond(response);
152	for (place, (source, css)) in places.into_iter().zip(fetched) {	152	for (place, (source, css)) in places.into_iter().zip(fetched) {
153	let proxy = self.proxy.clone();	153	let proxy = self.proxy.clone();
...	@@ -159,7 +159,7 @@ impl State {	...	@@ -159,7 +159,7 @@ impl State {
159	return;	159	return;
160	};	160	};
161	let _ = proxy.send_event(crate::UserEvent::Then(Box::new(move \|state\| {	161	let _ = proxy.send_event(crate::UserEvent::Then(Box::new(move \|state\| {
162	let response = state.view.insert_awaited(place, bytes, size)?;	162	let response = state.pane.view.insert_awaited(place, bytes, size)?;
163	state.respond(response);	163	state.respond(response);
164	Ok(())	164	Ok(())
165	})));	165	})));
...	@@ -168,7 +168,7 @@ impl State {	...	@@ -168,7 +168,7 @@ impl State {
168	}	168	}
169	Some(Pasted::Text(text)) => {	169	Some(Pasted::Text(text)) => {
170	let language = canvas::language::lcid(&platform::input_language());	170	let language = canvas::language::lcid(&platform::input_language());
171	let response = self.view.paste(&text, language)?;	171	let response = self.pane.view.paste(&text, language)?;
172	self.respond(response);	172	self.respond(response);
173	}	173	}
174	Some(Pasted::Picture(bytes)) => self.insert_picture(bytes, None)?,	174	Some(Pasted::Picture(bytes)) => self.insert_picture(bytes, None)?,
...	@@ -194,9 +194,10 @@ impl State {	...	@@ -194,9 +194,10 @@ impl State {
194	let size = picture_size(&bytes, pixels);	194	let size = picture_size(&bytes, pixels);
195	let response = match at {	195	let response = match at {
196	Some(point) => self	196	Some(point) => self
		197	.pane
197	.view	198	.view
198	.drop_picture(self.page_point(point), bytes, size)?,	199	.drop_picture(self.page_point(point), bytes, size)?,
199	None => self.view.insert_picture(bytes, size)?,	200	None => self.pane.view.insert_picture(bytes, size)?,
200	};	201	};
201	self.respond(response);	202	self.respond(response);
202	Ok(())	203	Ok(())

crates/snowbound/src/prefetch.rs+7-7

...	@@ -277,7 +277,7 @@ impl State {	...	@@ -277,7 +277,7 @@ impl State {
277	/// The section tab shown open: one being opened, from the moment it is asked for.	277	/// The section tab shown open: one being opened, from the moment it is asked for.
278	pub fn open_tab(&self) -> Option<usize> {	278	pub fn open_tab(&self) -> Option<usize> {
279	let session = self.session.as_ref()?;	279	let session = self.session.as_ref()?;
280	let opening = self.switching.and_then(\|(tab, _)\| tab);	280	let opening = self.pane.switching.and_then(\|(tab, _)\| tab);
281	Some(	281	Some(
282	opening	282	opening
283	.filter(\|tab\| *tab < session.tabs.len())	283	.filter(\|tab\| *tab < session.tabs.len())
...	@@ -287,15 +287,15 @@ impl State {	...	@@ -287,15 +287,15 @@ impl State {
287		287
288	/// Since when the page area shows that a page is opening, once it has taken a while.	288	/// Since when the page area shows that a page is opening, once it has taken a while.
289	pub fn loading(&self) -> Option<Instant> {	289	pub fn loading(&self) -> Option<Instant> {
290	let (_, since) = self.switching?;	290	let (_, since) = self.pane.switching?;
291	(since.elapsed() >= PATIENCE).then_some(since)	291	(since.elapsed() >= PATIENCE).then_some(since)
292	}	292	}
293		293
294	/// Leaves the page shown as it is, dropping whatever was opening in its place.	294	/// Leaves the page shown as it is, dropping whatever was opening in its place.
295	pub fn stop_loading(&mut self) {	295	pub fn stop_loading(&mut self) {
296	self.loading += 1;	296	self.pane.loading += 1;
297	self.opening = None;	297	self.pane.opening = None;
298	self.switching = None;	298	self.pane.switching = None;
299	}	299	}
300		300
301	/// Readies the pages beside the open one and the sections beside the open section.	301	/// Readies the pages beside the open one and the sections beside the open section.
...	@@ -306,7 +306,7 @@ impl State {	...	@@ -306,7 +306,7 @@ impl State {
306	let at = session	306	let at = session
307	.pages	307	.pages
308	.iter()	308	.iter()
309	.position(\|(space, ..)\| *space == session.space);	309	.position(\|(space, ..)\| *space == self.pane.showing.space);
310	let pages: Vec<ExGuid> = at	310	let pages: Vec<ExGuid> = at
311	.into_iter()	311	.into_iter()
312	.flat_map(\|at\| [at + 1, at.wrapping_sub(1)])	312	.flat_map(\|at\| [at + 1, at.wrapping_sub(1)])
...	@@ -330,7 +330,7 @@ impl State {	...	@@ -330,7 +330,7 @@ impl State {
330	return;	330	return;
331	};	331	};
332	let key = session.key();	332	let key = session.key();
333	if space == session.space \|\| !self.prefetch.ask((key.clone(), Some(space))) {	333	if space == self.pane.showing.space \|\| !self.prefetch.ask((key.clone(), Some(space))) {
334	return;	334	return;
335	}	335	}
336	let read = session.reader(space);	336	let read = session.reader(space);

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

crates/snowbound/src/protection.rs+5-5

...	@@ -89,8 +89,8 @@ impl State {	...	@@ -89,8 +89,8 @@ impl State {
89	previous.library.keep(path, previous.section);	89	previous.library.keep(path, previous.section);
90	}	90	}
91	}	91	}
92	self.sectionless = None;	92	self.pane.sectionless = None;
93	self.locked = Some(Locked { library, path });	93	self.pane.locked = Some(Locked { library, path });
94	self.ui.set_focus(Some(notice()));	94	self.ui.set_focus(Some(notice()));
95	self.title();	95	self.title();
96	Ok(())	96	Ok(())
...	@@ -113,7 +113,7 @@ impl State {	...	@@ -113,7 +113,7 @@ impl State {
113	section: &ui::Section,	113	section: &ui::Section,
114	strip: [f32; 4],	114	strip: [f32; 4],
115	) -> (Option<Command>, Id) {	115	) -> (Option<Command>, Id) {
116	let Some(locked) = &self.locked else {	116	let Some(locked) = &self.pane.locked else {
117	return (None, row);	117	return (None, row);
118	};	118	};
119	let library = Arc::clone(&locked.library);	119	let library = Arc::clone(&locked.library);
...	@@ -157,7 +157,7 @@ impl State {	...	@@ -157,7 +157,7 @@ impl State {
157		157
158	/// The locked section's page, as OneNote 2010 draws it: a click or Enter unlocks.	158	/// The locked section's page, as OneNote 2010 draws it: a click or Enter unlocks.
159	pub(crate) fn locked_page(&mut self) {	159	pub(crate) fn locked_page(&mut self) {
160	let Some(locked) = &self.locked else {	160	let Some(locked) = &self.pane.locked else {
161	return;	161	return;
162	};	162	};
163	let (library, path) = (Arc::clone(&locked.library), locked.path.clone());	163	let (library, path) = (Arc::clone(&locked.library), locked.path.clone());
...	@@ -266,7 +266,7 @@ impl State {	...	@@ -266,7 +266,7 @@ impl State {
266		266
267	/// The section shown, open or locked, with its notebook.	267	/// The section shown, open or locked, with its notebook.
268	pub(crate) fn shown_section(&self) -> Option<(Arc<Library>, String)> {	268	pub(crate) fn shown_section(&self) -> Option<(Arc<Library>, String)> {
269	match (&self.session, &self.locked) {	269	match (&self.session, &self.pane.locked) {
270	(Some(session), _) if session.library.catalog().is_some() => Some((	270	(Some(session), _) if session.library.catalog().is_some() => Some((
271	Arc::clone(&session.library),	271	Arc::clone(&session.library),
272	session.tabs[session.tab].path.clone(),	272	session.tabs[session.tab].path.clone(),

crates/snowbound/src/recording.rs+15-15

...	@@ -93,7 +93,7 @@ impl State {	...	@@ -93,7 +93,7 @@ impl State {
93	};	93	};
94	let [date, time] = platform::date_text(crate::filetime());	94	let [date, time] = platform::date_text(crate::filetime());
95	let label = canvas::recording::label(video, &date, &time);	95	let label = canvas::recording::label(video, &date, &time);
96	let (id, response) = self.view.start_recording(&label)?;	96	let (id, response) = self.pane.view.start_recording(&label)?;
97	self.respond(response);	97	self.respond(response);
98	if id.is_none() {	98	if id.is_none() {
99	recorder.stop()?()?;	99	recorder.stop()?()?;
...	@@ -117,7 +117,7 @@ impl State {	...	@@ -117,7 +117,7 @@ impl State {
117	path,	117	path,
118	} => {	118	} => {
119	// Nothing written while the file saves links to the recording.	119	// Nothing written while the file saves links to the recording.
120	self.view.editor.pause_recording(true);	120	self.pane.view.editor.pause_recording(true);
121	let finish = match recorder.stop() {	121	let finish = match recorder.stop() {
122	Ok(finish) => finish,	122	Ok(finish) => finish,
123	Err(detail) => {	123	Err(detail) => {
...	@@ -126,8 +126,8 @@ impl State {	...	@@ -126,8 +126,8 @@ impl State {
126	}	126	}
127	};	127	};
128	let recorded = path.clone();	128	let recorded = path.clone();
129	let id = self.view.editor.recording();	129	let id = self.pane.view.editor.recording();
130	let title = self.view.editor.page()?.title;	130	let title = self.pane.view.editor.page()?.title;
131	let job = std::thread::spawn(move \|\| {	131	let job = std::thread::spawn(move \|\| {
132	finish()?;	132	finish()?;
133	let recorded =	133	let recorded =
...	@@ -150,7 +150,7 @@ impl State {	...	@@ -150,7 +150,7 @@ impl State {
150	let saved = job	150	let saved = job
151	.join()	151	.join()
152	.unwrap_or_else(\|_\| Err("Try recording again.".into()));	152	.unwrap_or_else(\|_\| Err("Try recording again.".into()));
153	if self.view.editor.recording().is_none() {	153	if self.pane.view.editor.recording().is_none() {
154	return Ok(());	154	return Ok(());
155	}	155	}
156	let mut file = match saved {	156	let mut file = match saved {
...	@@ -162,7 +162,7 @@ impl State {	...	@@ -162,7 +162,7 @@ impl State {
162	};	162	};
163	file.preview = platform::file_icon(&path).map(Into::into);	163	file.preview = platform::file_icon(&path).map(Into::into);
164	notebook::fs::remove_file(&path)?;	164	notebook::fs::remove_file(&path)?;
165	let response = self.view.finish_recording(file)?;	165	let response = self.pane.view.finish_recording(file)?;
166	self.respond(response);	166	self.respond(response);
167	Ok(())	167	Ok(())
168	}	168	}
...	@@ -225,7 +225,7 @@ impl State {	...	@@ -225,7 +225,7 @@ impl State {
225	let (enabled, checked) = match transport {	225	let (enabled, checked) = match transport {
226	Transport::Pause => (	226	Transport::Pause => (
227	recording \|\| playing.is_some(),	227	recording \|\| playing.is_some(),
228	Some(self.view.editor.recording_paused() \|\| playing == Some(false)),	228	Some(self.pane.view.editor.recording_paused() \|\| playing == Some(false)),
229	),	229	),
230	Transport::Stop => (recording \|\| playing.is_some(), None),	230	Transport::Stop => (recording \|\| playing.is_some(), None),
231	Transport::Skip(_) \| Transport::SeekTo => (playing.is_some(), None),	231	Transport::Skip(_) \| Transport::SeekTo => (playing.is_some(), None),
...	@@ -241,9 +241,9 @@ impl State {	...	@@ -241,9 +241,9 @@ impl State {
241	(Transport::Stop, Media::Recording { .. }) => self.stop_recording(false)?,	241	(Transport::Stop, Media::Recording { .. }) => self.stop_recording(false)?,
242	(Transport::Stop, Media::Playing(_)) => self.media = Media::Idle,	242	(Transport::Stop, Media::Playing(_)) => self.media = Media::Idle,
243	(Transport::Pause, Media::Recording { recorder, .. }) => {	243	(Transport::Pause, Media::Recording { recorder, .. }) => {
244	let paused = !self.view.editor.recording_paused();	244	let paused = !self.pane.view.editor.recording_paused();
245	recorder.pause(paused);	245	recorder.pause(paused);
246	self.view.editor.pause_recording(paused);	246	self.pane.view.editor.pause_recording(paused);
247	}	247	}
248	(Transport::Pause, Media::Playing(playback)) => {	248	(Transport::Pause, Media::Playing(playback)) => {
249	let player = &mut playback.player;	249	let player = &mut playback.player;
...	@@ -281,13 +281,13 @@ impl State {	...	@@ -281,13 +281,13 @@ impl State {
281	let mut played = None;	281	let mut played = None;
282	let (clock_text, picture) = match &mut self.media {	282	let (clock_text, picture) = match &mut self.media {
283	Media::Idle => {	283	Media::Idle => {
284	let response = self.view.set_played(None)?;	284	let response = self.pane.view.set_played(None)?;
285	self.respond(response);	285	self.respond(response);
286	return Ok(());	286	return Ok(());
287	}	287	}
288	Media::Recording { video, .. } => {	288	Media::Recording { video, .. } => {
289	let at = self.view.editor.recording_ms().unwrap_or(0);	289	let at = self.pane.view.editor.recording_ms().unwrap_or(0);
290	let state = if self.view.editor.recording_paused() {	290	let state = if self.pane.view.editor.recording_paused() {
291	"Paused"	291	"Paused"
292	} else if *video {	292	} else if *video {
293	"Recording video"	293	"Recording video"
...	@@ -311,8 +311,8 @@ impl State {	...	@@ -311,8 +311,8 @@ impl State {
311	played = playback	311	played = playback
312	.recording	312	.recording
313	.filter(\|_\| self.see_playback)	313	.filter(\|_\| self.see_playback)
314	.and_then(\|id\| self.view.editor.played_note(id, at))	314	.and_then(\|id\| self.pane.view.editor.played_note(id, at))
315	.and_then(\|note\| canvas::search::paragraph_match(&self.view.editor, note));	315	.and_then(\|note\| canvas::search::paragraph_match(&self.pane.view.editor, note));
316	let mut picture = None;	316	let mut picture = None;
317	if let Some(video) = &mut playback.video {	317	if let Some(video) = &mut playback.video {
318	let frame = video.movie.frame(at);	318	let frame = video.movie.frame(at);
...	@@ -344,7 +344,7 @@ impl State {	...	@@ -344,7 +344,7 @@ impl State {
344	)	344	)
345	}	345	}
346	};	346	};
347	let response = self.view.set_played(played)?;	347	let response = self.pane.view.set_played(played)?;
348	self.respond(response);	348	self.respond(response);
349	let picture_height = picture	349	let picture_height = picture
350	.as_ref()	350	.as_ref()

crates/snowbound/src/recycle.rs+5-5

crates/snowbound/src/save_as.rs+6-2

 @@ -166,11 +166,15 @@ impl State {
             .filter(|session| Arc::ptr_eq(&session.library, &library))
             .map(|session| {
                 let path = session.tabs[session.tab].path.clone();
-                (path, Arc::clone(session.section.replica()), session.space)
+                (
+                    path,
+                    Arc::clone(session.section.replica()),
+                    self.pane.showing.space,
+                )
             });
         let section = dialog.section.unwrap_or_default();
         let title = match dialog.scope {
-            Scope::Page => self.view.editor.page()?.title,
+            Scope::Page => self.pane.view.editor.page()?.title,
             Scope::Section => crate::library::section_name(&section, &None),
             Scope::Notebook => library.name.clone(),
         };

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

 @@ -59,17 +59,18 @@ impl State {
         };
         self.surface.size = size.map(|side| (side * scale).max(1.0) as u32);
         self.renderer.clear_glyph_cache();
-        let response = self.view.scale_factor_changed(scale)?;
+        let response = self.pane.view.scale_factor_changed(scale)?;
         self.respond(response);
         self.ui.set_focus(None);
         if let Some(title) = self
+            .pane
             .view
             .editor
             .outlines()
             .iter()
             .find(|outline| outline.title)
         {
-            self.view.editor.focus_outline(title.id)?;
+            self.pane.view.editor.focus_outline(title.id)?;
         }
         #[cfg(target_os = "macos")]
         if snow_leopard() {
 @@ -99,8 +100,12 @@ impl State {
         // The page's box sizes the view whose pictures settle.
         self.layout(size, scale)?;
         let paper = self.paper();
-        if let Some((scene, _)) = &mut self.view.scene {
+        if let Some((scene, _)) = &mut self.pane.view.scene {
-            scene.settle(Some(&self.view.editor), self.view.viewport.scale, paper);
+            scene.settle(
+                Some(&self.pane.view.editor),
+                self.pane.view.viewport.scale,
+                paper,
+            );
         }
         // Later frames lay out with earlier frames' measurements while colours ease.
         let deadline = Instant::now() + std::time::Duration::from_secs(2);

crates/snowbound/src/search.rs+15-15

...	@@ -614,26 +614,26 @@ impl State {	...	@@ -614,26 +614,26 @@ impl State {
614	/// Marks the query's matches on the page; with `select`, selects the match Find on	614	/// Marks the query's matches on the page; with `select`, selects the match Find on
615	/// This Page is at, or the first, or the paragraph, when a result opened the page.	615	/// This Page is at, or the first, or the paragraph, when a result opened the page.
616	pub(crate) fn refind(&mut self, select: bool) -> Result<(), Box<dyn Error>> {	616	pub(crate) fn refind(&mut self, select: bool) -> Result<(), Box<dyn Error>> {
617	self.view.found = page_matches(&self.view.editor, &self.search.shown());	617	self.pane.view.found = page_matches(&self.pane.view.editor, &self.search.shown());
618	if !select {	618	if !select {
619	return Ok(());	619	return Ok(());
620	}	620	}
621	let space = self.session.as_ref().map(\|session\| session.space);	621	let space = self.session.as_ref().map(\|_\| self.pane.showing.space);
622	let target = if self.search.finding {	622	let target = if self.search.finding {
623	self.search.current = match self.search.current {	623	self.search.current = match self.search.current {
624	Some(at) if at < self.view.found.len() => Some(at),	624	Some(at) if at < self.pane.view.found.len() => Some(at),
625	_ => (!self.view.found.is_empty()).then_some(0),	625	_ => (!self.pane.view.found.is_empty()).then_some(0),
626	};	626	};
627	self.search	627	self.search
628	.current	628	.current
629	.and_then(\|at\| self.view.found.get(at).copied())	629	.and_then(\|at\| self.pane.view.found.get(at).copied())
630	} else if let Some((_, paragraph)) =	630	} else if let Some((_, paragraph)) =
631	self.search.reveal.filter(\|(page, _)\| Some(*page) == space)	631	self.search.reveal.filter(\|(page, _)\| Some(*page) == space)
632	{	632	{
633	self.search.reveal = None;	633	self.search.reveal = None;
634	match paragraph {	634	match paragraph {
635	Some(paragraph) => paragraph_match(&self.view.editor, paragraph),	635	Some(paragraph) => paragraph_match(&self.pane.view.editor, paragraph),
636	None => self.view.found.first().copied(),	636	None => self.pane.view.found.first().copied(),
637	}	637	}
638	} else {	638	} else {
639	None	639	None
...	@@ -645,9 +645,9 @@ impl State {	...	@@ -645,9 +645,9 @@ impl State {
645	let Some((outline, selection)) = target else {	645	let Some((outline, selection)) = target else {
646	return Ok(());	646	return Ok(());
647	};	647	};
648	self.view.editor.focus_outline(outline)?;	648	self.pane.view.editor.focus_outline(outline)?;
649	self.view.editor.select(selection)?;	649	self.pane.view.editor.select(selection)?;
650	let response = self.view.focus_text()?;	650	let response = self.pane.view.focus_text()?;
651	self.respond(response);	651	self.respond(response);
652	Ok(())	652	Ok(())
653	}	653	}
...	@@ -686,7 +686,7 @@ impl State {	...	@@ -686,7 +686,7 @@ impl State {
686	if !matches!(self.search.task_pane, Some(TaskPane::Search { .. })) {	686	if !matches!(self.search.task_pane, Some(TaskPane::Search { .. })) {
687	self.search.query.clear();	687	self.search.query.clear();
688	self.search.scope = self.search.default;	688	self.search.scope = self.search.default;
689	self.view.found.clear();	689	self.pane.view.found.clear();
690	}	690	}
691	}	691	}
692		692
...	@@ -711,7 +711,7 @@ impl State {	...	@@ -711,7 +711,7 @@ impl State {
711	let open = self	711	let open = self
712	.session	712	.session
713	.as_ref()	713	.as_ref()
714	.map(\|session\| (session.key(), session.space));	714	.map(\|session\| (session.key(), self.pane.showing.space));
715	match open {	715	match open {
716	Some((key, shown)) if key == section && shown == space => self.refind(true)?,	716	Some((key, shown)) if key == section && shown == space => self.refind(true)?,
717	Some((key, _)) if key == section => self.commands.push(Command::OpenPage(space)),	717	Some((key, _)) if key == section => self.commands.push(Command::OpenPage(space)),
...	@@ -1130,7 +1130,7 @@ impl State {	...	@@ -1130,7 +1130,7 @@ impl State {
1130	&[NamedKey::Enter, NamedKey::F3, NamedKey::Escape],	1130	&[NamedKey::Enter, NamedKey::F3, NamedKey::Escape],
1131	);	1131	);
1132	let before = self.search.query.clone();	1132	let before = self.search.query.clone();
1133	let count = self.view.found.len();	1133	let count = self.pane.view.found.len();
1134	let label = if self.search.query.trim().is_empty() {	1134	let label = if self.search.query.trim().is_empty() {
1135	"Find on page".to_owned()	1135	"Find on page".to_owned()
1136	} else if count == 0 {	1136	} else if count == 0 {
...	@@ -1211,7 +1211,7 @@ impl State {	...	@@ -1211,7 +1211,7 @@ impl State {
1211	self.end_search();	1211	self.end_search();
1212	return Ok(());	1212	return Ok(());
1213	}	1213	}
1214	let shift = self.view.modifiers().shift;	1214	let shift = self.pane.view.modifiers().shift;
1215	for key in keys {	1215	for key in keys {
1216	match key {	1216	match key {
1217	NamedKey::Escape => {	1217	NamedKey::Escape => {
...	@@ -1234,7 +1234,7 @@ impl State {	...	@@ -1234,7 +1234,7 @@ impl State {
1234	(at + count - 1) % count	1234	(at + count - 1) % count
1235	};	1235	};
1236	self.search.current = Some(next);	1236	self.search.current = Some(next);
1237	self.select(self.view.found.get(next).copied())?;	1237	self.select(self.pane.view.found.get(next).copied())?;
1238	}	1238	}
1239	Ok(())	1239	Ok(())
1240	}	1240	}

crates/snowbound/src/settings.rs+4-4

crates/snowbound/src/sidebar.rs+4-4

crates/snowbound/src/task_pane.rs+4-4

...	@@ -445,7 +445,7 @@ impl State {	...	@@ -445,7 +445,7 @@ impl State {
445		445
446	/// Shows the next marked word in the Spelling pane; past the last, the check is complete.	446	/// Shows the next marked word in the Spelling pane; past the last, the check is complete.
447	fn next_word(&mut self) {	447	fn next_word(&mut self) {
448	match self.view.next_correction() {	448	match self.pane.view.next_correction() {
449	Ok(Some((response, correction))) => {	449	Ok(Some((response, correction))) => {
450	self.respond(response);	450	self.respond(response);
451	self.correction = Some(correction);	451	self.correction = Some(correction);
...	@@ -552,7 +552,7 @@ impl State {	...	@@ -552,7 +552,7 @@ impl State {
552	else {	552	else {
553	return;	553	return;
554	};	554	};
555	let spelling = self.view.spelling.clone();	555	let spelling = self.pane.view.spelling.clone();
556	let text = match (correction.repeated, pressed) {	556	let text = match (correction.repeated, pressed) {
557	(_, _) if change => correction.suggestions.get(chosen).map(String::as_str),	557	(_, _) if change => correction.suggestions.get(chosen).map(String::as_str),
558	(true, [true, _]) => Some(""),	558	(true, [true, _]) => Some(""),
...	@@ -566,7 +566,7 @@ impl State {	...	@@ -566,7 +566,7 @@ impl State {
566	}	566	}
567	};	567	};
568	if let Some(text) = text {	568	if let Some(text) = text {
569	match self.view.correct(&correction, text) {	569	match self.pane.view.correct(&correction, text) {
570	Ok(response) => self.respond(response),	570	Ok(response) => self.respond(response),
571	Err(error) => eprintln!("{error}"),	571	Err(error) => eprintln!("{error}"),
572	}	572	}
...	@@ -936,7 +936,7 @@ impl State {	...	@@ -936,7 +936,7 @@ impl State {
936	let pages = &session.pages;	936	let pages = &session.pages;
937	let at = pages	937	let at = pages
938	.iter()	938	.iter()
939	.position(\|(space, ..)\| *space == session.space)?;	939	.position(\|(space, ..)\| *space == self.pane.showing.space)?;
940	let base = pages.iter().map(\|(.., level)\| *level).min()?;	940	let base = pages.iter().map(\|(.., level)\| *level).min()?;
941	let start = pages[..=at]	941	let start = pages[..=at]
942	.iter()	942	.iter()

crates/snowbound/src/templates.rs+4-4

...	@@ -387,8 +387,8 @@ impl crate::State {	...	@@ -387,8 +387,8 @@ impl crate::State {
387	let Some(session) = &self.session else {	387	let Some(session) = &self.session else {
388	return;	388	return;
389	};	389	};
390	let space = session.space;	390	let space = self.pane.showing.space;
391	let read_only = session.read_only();	391	let read_only = session.read_only(&self.pane.showing);
392	let Some(rect) = self.ui.laid_out(crate::page()) else {	392	let Some(rect) = self.ui.laid_out(crate::page()) else {
393	return;	393	return;
394	};	394	};
...	@@ -409,7 +409,7 @@ impl crate::State {	...	@@ -409,7 +409,7 @@ impl crate::State {
409	) {	409	) {
410	self.choose(crate::commands::Choice::Art(Some(name)));	410	self.choose(crate::commands::Choice::Art(Some(name)));
411	}	411	}
412	let editor = &self.view.editor;	412	let editor = &self.pane.view.editor;
413	let blank = editor	413	let blank = editor
414	.visible_outlines()	414	.visible_outlines()
415	.chain(editor.caret_outline())	415	.chain(editor.caret_outline())
...	@@ -422,7 +422,7 @@ impl crate::State {	...	@@ -422,7 +422,7 @@ impl crate::State {
422	return;	422	return;
423	};	423	};
424	let (color, rule_lines) = (editor.page_color(), editor.rule_lines());	424	let (color, rule_lines) = (editor.page_color(), editor.rule_lines());
425	let viewport = self.view.viewport;	425	let viewport = self.pane.view.viewport;
426	let scale = self.ui.scale();	426	let scale = self.ui.scale();
427	let position = [	427	let position = [
428	(viewport.origin[0] + start[0] * viewport.scale) / scale,	428	(viewport.origin[0] + start[0] * viewport.scale) / scale,

crates/snowbound/src/themes.rs+6-6

...	@@ -120,7 +120,7 @@ impl State {	...	@@ -120,7 +120,7 @@ impl State {
120	let library = &session.library;	120	let library = &session.library;
121	library.catalog()?;	121	library.catalog()?;
122	let target = match scope {	122	let target = match scope {
123	Scope::Page => stored::Scope::page(self.view.editor.identity()?),	123	Scope::Page => stored::Scope::page(self.pane.view.editor.identity()?),
124	Scope::Section => {	124	Scope::Section => {
125	stored::Scope::section(library.section_identity(&session.tabs[session.tab].path)?)	125	stored::Scope::section(library.section_identity(&session.tabs[session.tab].path)?)
126	}	126	}
...	@@ -144,7 +144,7 @@ impl State {	...	@@ -144,7 +144,7 @@ impl State {
144	session	144	session
145	.library	145	.library
146	.themes()	146	.themes()
147	.effective(section, self.view.editor.identity())	147	.effective(section, self.pane.view.editor.identity())
148	}	148	}
149		149
150	/// The styles the gallery offers: the page's theme's, else OneNote 2010's.	150	/// The styles the gallery offers: the page's theme's, else OneNote 2010's.
...	@@ -167,17 +167,17 @@ impl State {	...	@@ -167,17 +167,17 @@ impl State {
167	let sheet = (theme.as_ref())	167	let sheet = (theme.as_ref())
168	.map(\|theme\| theme.sheet(self.section_color()))	168	.map(\|theme\| theme.sheet(self.section_color()))
169	.unwrap_or_default();	169	.unwrap_or_default();
170	if !force && self.view.editor.styles == sheet {	170	if !force && self.pane.view.editor.styles == sheet {
171	return Ok(());	171	return Ok(());
172	}	172	}
173	self.view.editor.styles = sheet.clone();	173	self.pane.view.editor.styles = sheet.clone();
174	let Some(session) = &self.session else {	174	let Some(session) = &self.session else {
175	return Ok(());	175	return Ok(());
176	};	176	};
177	if theme.is_none() \|\| session.read_only() {	177	if theme.is_none() \|\| session.read_only(&self.pane.showing) {
178	return Ok(());	178	return Ok(());
179	}	179	}
180	let page = session.section.page(session.space)?;	180	let page = session.section.page(self.pane.showing.space)?;
181	let ops = onestore::op::restyle(&page, &sheet)?;	181	let ops = onestore::op::restyle(&page, &sheet)?;
182	if ops.is_empty() {	182	if ops.is_empty() {
183	return Ok(());	183	return Ok(());

crates/snowbound/src/undo.rs+10-9

 @@ -958,13 +958,13 @@ impl State {
     /// Whether no action, page or command is on its way, which Undo and Redo wait for.
     pub(crate) fn settled(&self) -> bool {
-        self.undo.busy == 0 && self.switching.is_none() && self.commands.is_empty()
+        self.undo.busy == 0 && self.pane.switching.is_none() && self.commands.is_empty()
     }
     /// Whether Undo, or `redo` Redo, has something to take, or may once what is on its way
     /// lands.
     pub(crate) fn can_step(&self, redo: bool) -> bool {
-        let editor = &self.view.editor;
+        let editor = &self.pane.view.editor;
         !self.settled()
             || (if redo {
                 editor.can_redo()
 @@ -998,9 +998,9 @@ impl State {
     /// user is, whichever came last.
     fn take(&mut self, redo: bool) -> Result<(), Box<dyn Error>> {
         self.persist()?;
-        let depth = self.view.editor.history_depth();
+        let depth = self.pane.view.editor.history_depth();
         // A page kept in no notebook has only its own history.
-        let shown = self.session.as_ref().map(|session| session.space);
+        let shown = self.session.as_ref().map(|_| self.pane.showing.space);
         let next = match (self.here(), shown) {
             (Some(here), Some(page)) => self.undo.next(redo, page, depth, &here),
             _ => Some(Next::Edit),
 @@ -1008,10 +1008,10 @@ impl State {
         match next {
             None => {}
             Some(Next::Edit) => {
-                let response = self.view.undo(redo)?;
+                let response = self.pane.view.undo(redo)?;
                 self.respond(response);
                 if let Some(page) = shown
-                    && self.view.editor.history_depth() != depth
+                    && self.pane.view.editor.history_depth() != depth
                 {
                     self.undo.stepped(page, redo);
                 }
 @@ -1117,11 +1117,11 @@ impl State {
             author: self.author.clone(),
             fresh: self.dated_page(None, "")?,
         };
-        let shown = session.space;
+        let shown = self.pane.showing.space;
         let original = Arc::clone(&site.library);
         let proxy = self.proxy.clone();
         self.undo.busy += 1;
-        self.switching = Some((None, web_time::Instant::now()));
+        self.pane.switching = Some((None, web_time::Instant::now()));
         self.load_async(move || async move {
             let applied = site.change(change, shown).await;
             let show = match &applied {
 @@ -1150,11 +1150,12 @@ impl State {
                     } else {
                         state.list(&library);
                         if state
+                            .pane
                             .sectionless
                             .as_ref()
                             .is_some_and(|listed| lineage(listed))
                         {
-                            state.sectionless = Some(library);
+                            state.pane.sectionless = Some(library);
                         }
                     }
                 }

crates/snowbound/src/unread.rs+8-3

 @@ -274,8 +274,13 @@ impl State {
         let viewing = self.session.as_ref().and_then(|session| {
             let path = &session.tabs[session.tab].path;
             let section = session.library.section_identity(path)?;
-            (session.version.is_none() && !recycle::binned(path))
+            (self.pane.showing.version.is_none() && !recycle::binned(path)).then(|| {
-                .then(|| (session.library.location.clone(), section, session.space))
+                (
+                    session.library.location.clone(),
+                    section,
+                    self.pane.showing.space,
+                )
+            })
         });
         let same = |(notebook, section, space, _): &(String, [u8; 16], ExGuid, bool)| {
             viewing.as_ref() == Some(&(notebook.clone(), *section, *space))
 @@ -418,7 +423,7 @@ impl State {
         let at = session
             .pages
             .iter()
-            .position(|(space, ..)| *space == session.space);
+            .position(|(space, ..)| *space == self.pane.showing.space);
         let after = (session.pages.iter().skip(at.map_or(0, |at| at + 1)))
             .find(|(space, ..)| unread.contains(space));
         if let Some((space, ..)) = after {

crates/snowbound/src/web.rs+10-10

...	@@ -390,10 +390,10 @@ impl State {	...	@@ -390,10 +390,10 @@ impl State {
390	color_scheme: self.color_scheme,	390	color_scheme: self.color_scheme,
391	pages_match: !self.light_pages,	391	pages_match: !self.light_pages,
392	hide_spelling: self.hide_spelling,	392	hide_spelling: self.hide_spelling,
393	markdown: self.view.editor.markdown.is_some(),	393	markdown: self.pane.view.editor.markdown.is_some(),
394	automatic_updates: self.updates.automatic(),	394	automatic_updates: self.updates.automatic(),
395	pen_pressure: self.pen_pressure,	395	pen_pressure: self.pen_pressure,
396	default_font: self.view.editor.default_font.clone(),	396	default_font: self.pane.view.editor.default_font.clone(),
397	page_tabs_left: self.page_tabs_left,	397	page_tabs_left: self.page_tabs_left,
398	navigation_bar_left: !self.navigation_bar_right,	398	navigation_bar_left: !self.navigation_bar_right,
399	lock_after: self.passwords.lock_after,	399	lock_after: self.passwords.lock_after,
...	@@ -692,9 +692,9 @@ impl State {	...	@@ -692,9 +692,9 @@ impl State {
692	self.color_scheme = options.color_scheme;	692	self.color_scheme = options.color_scheme;
693	self.light_pages = !options.pages_match;	693	self.light_pages = !options.pages_match;
694	self.hide_spelling = options.hide_spelling;	694	self.hide_spelling = options.hide_spelling;
695	self.view.editor.markdown = crate::commands::markdown(options.markdown);	695	self.pane.view.editor.markdown = crate::commands::markdown(options.markdown);
696	self.pen_pressure = options.pen_pressure;	696	self.pen_pressure = options.pen_pressure;
697	self.view.editor.default_font = options.default_font;	697	self.pane.view.editor.default_font = options.default_font;
698	self.page_tabs_left = options.page_tabs_left;	698	self.page_tabs_left = options.page_tabs_left;
699	self.navigation_bar_right = !options.navigation_bar_left;	699	self.navigation_bar_right = !options.navigation_bar_left;
700	self.passwords = crate::settings::Passwords {	700	self.passwords = crate::settings::Passwords {

...	@@ -281,11 +281,11 @@ impl State {	...	@@ -281,11 +281,11 @@ impl State {
281	let session = self.session.as_ref().ok_or("No section is open")?;	281	let session = self.session.as_ref().ok_or("No section is open")?;
282	let tab = &session.tabs[session.tab];	282	let tab = &session.tabs[session.tab];
283	// The open page as the editor holds it; the others as stored.	283	// The open page as the editor holds it; the others as stored.
284	let open = (session.space, self.view.editor.page()?);	284	let open = (self.pane.showing.space, self.pane.view.editor.page()?);
285	let at = session	285	let at = session
286	.pages	286	.pages
287	.iter()	287	.iter()
288	.position(\|(space, ..)\| *space == session.space);	288	.position(\|(space, ..)\| *space == self.pane.showing.space);
289	let spaces: Vec<ExGuid> = match (setup.scope, at) {	289	let spaces: Vec<ExGuid> = match (setup.scope, at) {
290	(Scope::PageGroup, Some(at)) => {	290	(Scope::PageGroup, Some(at)) => {
291	let levels: Vec<u32> = session.pages.iter().map(\|(.., level)\| *level).collect();	291	let levels: Vec<u32> = session.pages.iter().map(\|(.., level)\| *level).collect();
...	@@ -297,7 +297,7 @@ impl State {	...	@@ -297,7 +297,7 @@ impl State {
297	(Scope::Section \| Scope::Notebook, _) => {	297	(Scope::Section \| Scope::Notebook, _) => {
298	session.pages.iter().map(\|(space, ..)\| *space).collect()	298	session.pages.iter().map(\|(space, ..)\| *space).collect()
299	}	299	}
300	_ => vec![session.space],	300	_ => vec![self.pane.showing.space],
301	};	301	};
302	let title = match setup.scope {	302	let title = match setup.scope {
303	Scope::Page \| Scope::PageGroup => open.1.title.clone(),	303	Scope::Page \| Scope::PageGroup => open.1.title.clone(),

...	@@ -67,8 +67,8 @@ impl State {	...	@@ -67,8 +67,8 @@ impl State {
67	section.close_async().await?;	67	section.close_async().await?;
68	continue;	68	continue;
69	}	69	}
70	let (session, page) = read_session(section, library, path, None)?;	70	let (session, space, page) = read_session(section, library, path, None)?;
71	return Ok(Loaded::Section(Box::new(session), page));	71	return Ok(Loaded::Section(Box::new(session), space, page));
72	}	72	}
73	Err("The Recycle Bin is empty.".into())	73	Err("The Recycle Bin is empty.".into())
74	});	74	});
...	@@ -127,7 +127,7 @@ impl State {	...	@@ -127,7 +127,7 @@ impl State {
127	let session = self.session.as_ref().ok_or("No section is open")?;	127	let session = self.session.as_ref().ok_or("No section is open")?;
128	let replica = Arc::clone(session.section.replica());	128	let replica = Arc::clone(session.section.replica());
129	let library = Arc::clone(&session.library);	129	let library = Arc::clone(&session.library);
130	let shown = session.space;	130	let shown = self.pane.showing.space;
131	let at = (session.pages.iter()).position(\|(space, ..)\| gone.contains(space));	131	let at = (session.pages.iter()).position(\|(space, ..)\| gone.contains(space));
132	let kept = \|space: &ExGuid\| !gone.contains(space);	132	let kept = \|space: &ExGuid\| !gone.contains(space);
133	let after = at.and_then(\|at\| {	133	let after = at.and_then(\|at\| {
...	@@ -149,8 +149,8 @@ impl State {	...	@@ -149,8 +149,8 @@ impl State {
149	.first_section()	149	.first_section()
150	.ok_or("The notebook has no sections")?;	150	.ok_or("The notebook has no sections")?;
151	let section = library.open_async(&path, notify(proxy)).await?;	151	let section = library.open_async(&path, notify(proxy)).await?;
152	let (session, page) = read_session(section, library, path, None)?;	152	let (session, space, page) = read_session(section, library, path, None)?;
153	Ok(Loaded::Section(Box::new(session), page))	153	Ok(Loaded::Section(Box::new(session), space, page))
154	});	154	});
155	Ok(())	155	Ok(())
156	}	156	}

...	@@ -307,18 +307,18 @@ impl crate::State {	...	@@ -307,18 +307,18 @@ impl crate::State {
307	color_scheme: self.color_scheme,	307	color_scheme: self.color_scheme,
308	light_pages: self.light_pages,	308	light_pages: self.light_pages,
309	hide_spelling: self.hide_spelling,	309	hide_spelling: self.hide_spelling,
310	ignore_markdown: self.view.editor.markdown.is_none(),	310	ignore_markdown: self.pane.view.editor.markdown.is_none(),
311	search_scope: self.search.default,	311	search_scope: self.search.default,
312	tags: (self.tags != canvas::editor::NoteTag::defaults()).then(\|\| self.tags.clone()),	312	tags: (self.tags != canvas::editor::NoteTag::defaults()).then(\|\| self.tags.clone()),
313	manual_updates: !self.updates.automatic(),	313	manual_updates: !self.updates.automatic(),
314	ignore_pen_pressure: !self.pen_pressure,	314	ignore_pen_pressure: !self.pen_pressure,
315	ignore_grid: !self.view.snap_to_grid,	315	ignore_grid: !self.pane.view.snap_to_grid,
316	default_font: self.view.editor.default_font.clone(),	316	default_font: self.pane.view.editor.default_font.clone(),
317	page_tabs_left: self.page_tabs_left,	317	page_tabs_left: self.page_tabs_left,
318	navigation_bar_right: self.navigation_bar_right,	318	navigation_bar_right: self.navigation_bar_right,
319	servers: self.servers.clone(),	319	servers: self.servers.clone(),
320	keys: crate::commands::Keymap::current().saved(),	320	keys: crate::commands::Keymap::current().saved(),
321	recent: self.trail.recent.clone(),	321	recent: self.recent.clone(),
322	passwords: self.passwords,	322	passwords: self.passwords,
323	notebook_theme: NotebookTheme(self.notebook_theme.clone()),	323	notebook_theme: NotebookTheme(self.notebook_theme.clone()),
324	live: self.live_options.clone(),	324	live: self.live_options.clone(),

...	@@ -941,7 +941,7 @@ impl crate::State {	...	@@ -941,7 +941,7 @@ impl crate::State {
941	},	941	},
942	);	942	);
943	crate::name(&mut self.ui, rows_id, "My Notebooks");	943	crate::name(&mut self.ui, rows_id, "My Notebooks");
944	let shown = match (&self.session, &self.locked) {	944	let shown = match (&self.session, &self.pane.locked) {
945	(Some(session), _) => Some((&session.library, session.tabs[session.tab].path.as_str())),	945	(Some(session), _) => Some((&session.library, session.tabs[session.tab].path.as_str())),
946	(None, Some(locked)) => Some((&locked.library, locked.path.as_str())),	946	(None, Some(locked)) => Some((&locked.library, locked.path.as_str())),
947	(None, None) => None,	947	(None, None) => None,
...	@@ -1444,7 +1444,7 @@ impl crate::State {	...	@@ -1444,7 +1444,7 @@ impl crate::State {
1444	read: impl FnOnce(&str, &std::path::Path) -> Result<Library, String> + Send + 'static,	1444	read: impl FnOnce(&str, &std::path::Path) -> Result<Library, String> + Send + 'static,
1445	) {	1445	) {
1446	let section = section.or_else(\|\| {	1446	let section = section.or_else(\|\| {
1447	(self.trail.recent.iter())	1447	(self.recent.iter())
1448	.find(\|place\| place.notebook == location)	1448	.find(\|place\| place.notebook == location)
1449	.map(\|place\| place.section.clone())	1449	.map(\|place\| place.section.clone())
1450	});	1450	});
...	@@ -1477,8 +1477,8 @@ impl crate::State {	...	@@ -1477,8 +1477,8 @@ impl crate::State {
1477	return Err("This folder holds no notebook sections.".into());	1477	return Err("This folder holds no notebook sections.".into());
1478	};	1478	};
1479	let section = library.open_async(&path, notify).await?;	1479	let section = library.open_async(&path, notify).await?;
1480	let (session, page) = crate::read_session(section, library, path, left)?;	1480	let (session, space, page) = crate::read_session(section, library, path, left)?;
1481	Ok(crate::Loaded::Section(Box::new(session), page))	1481	Ok(crate::Loaded::Section(Box::new(session), space, page))
1482	});	1482	});
1483	}	1483	}
1484		1484

...	@@ -999,7 +999,7 @@ pub async fn start(	...	@@ -999,7 +999,7 @@ pub async fn start(
999	if let Some(resume) = resumed().and_then(\|resume\| serde_json::from_str::<Resume>(&resume).ok())	999	if let Some(resume) = resumed().and_then(\|resume\| serde_json::from_str::<Resume>(&resume).ok())
1000	{	1000	{
1001	for (axis, offset) in resume.offset.into_iter().enumerate() {	1001	for (axis, offset) in resume.offset.into_iter().enumerate() {
1002	match state.view.scroll_to(axis, offset) {	1002	match state.pane.view.scroll_to(axis, offset) {
1003	Ok(response) => state.respond(response),	1003	Ok(response) => state.respond(response),
1004	Err(error) => report(error),	1004	Err(error) => report(error),
1005	}	1005	}
...	@@ -1571,13 +1571,13 @@ fn turn(state: &mut State) -> Result<(), Box<dyn Error>> {	...	@@ -1571,13 +1571,13 @@ fn turn(state: &mut State) -> Result<(), Box<dyn Error>> {
1571	state.frame()?;	1571	state.frame()?;
1572	remember_look(state);	1572	remember_look(state);
1573	}	1573	}
1574	let space = state.session.as_ref().map(\|session\| session.space);	1574	let space = state.session.as_ref().map(\|_\| state.pane.showing.space);
1575	if TYPED.take() \|\| LOOKED.replace(space) != space {	1575	if TYPED.take() \|\| LOOKED.replace(space) != space {
1576	fetch_fallbacks(&crate::page_text(&state.view.editor));	1576	fetch_fallbacks(&crate::page_text(&state.pane.view.editor));
1577	}	1577	}
1578	park_input(state);	1578	park_input(state);
1579	let now = Instant::now();	1579	let now = Instant::now();
1580	let (repaint, blink) = state.view.blink(now);	1580	let (repaint, blink) = state.pane.view.blink(now);
1581	let wake = state.ui.wake_at();	1581	let wake = state.ui.wake_at();
1582	if repaint \|\| wake.is_some_and(\|wake\| wake <= now) {	1582	if repaint \|\| wake.is_some_and(\|wake\| wake <= now) {
1583	state.window.request_redraw();	1583	state.window.request_redraw();
...	@@ -1709,7 +1709,7 @@ pub fn update_now(state: &mut State) {	...	@@ -1709,7 +1709,7 @@ pub fn update_now(state: &mut State) {
1709	return RELOADING.set(false);	1709	return RELOADING.set(false);
1710	};	1710	};
1711	let resume = Resume {	1711	let resume = Resume {
1712	offset: state.view.viewport.origin.map(\|origin\| -origin),	1712	offset: state.pane.view.viewport.origin.map(\|origin\| -origin),
1713	build,	1713	build,
1714	};	1714	};
1715	let reloading = reload_into(&serde_json::to_string(&resume).unwrap_or_default());	1715	let reloading = reload_into(&serde_json::to_string(&resume).unwrap_or_default());
...	@@ -1737,8 +1737,8 @@ fn follow_updates(state: &mut State, now: Instant) -> Option<Instant> {	...	@@ -1737,8 +1737,8 @@ fn follow_updates(state: &mut State, now: Instant) -> Option<Instant> {
1737	}	1737	}
1738	let idle = LAST_INPUT.get().map_or(now, \|last\| last + IDLE);	1738	let idle = LAST_INPUT.get().map_or(now, \|last\| last + IDLE);
1739	let quiet = !state.ui.popups_open()	1739	let quiet = !state.ui.popups_open()
1740	&& state.opening.is_none()	1740	&& state.pane.opening.is_none()
1741	&& state.loading == 0	1741	&& state.pane.loading == 0
1742	&& matches!(state.media, crate::recording::Media::Idle);	1742	&& matches!(state.media, crate::recording::Media::Idle);
1743	if update_ready() && (returned \|\| idle <= now) && quiet {	1743	if update_ready() && (returned \|\| idle <= now) && quiet {
1744	update_now(state);	1744	update_now(state);
...	@@ -1783,7 +1783,7 @@ pub fn font_arrived(name: String, bytes: Vec<u8>) {	...	@@ -1783,7 +1783,7 @@ pub fn font_arrived(name: String, bytes: Vec<u8>) {
1783	families	1783	families
1784	};	1784	};
1785	send(UserEvent::Then(Box::new(move \|state\| {	1785	send(UserEvent::Then(Box::new(move \|state\| {
1786	let families = register(&mut state.view.engine.fonts.collection, face.clone());	1786	let families = register(&mut state.pane.view.engine.fonts.collection, face.clone());
1787	if let Ok(mut layouts) = state.layouts.lock() {	1787	if let Ok(mut layouts) = state.layouts.lock() {
1788	register(&mut layouts.fonts.collection, face.clone());	1788	register(&mut layouts.fonts.collection, face.clone());
1789	}	1789	}
...	@@ -1792,7 +1792,7 @@ pub fn font_arrived(name: String, bytes: Vec<u8>) {	...	@@ -1792,7 +1792,7 @@ pub fn font_arrived(name: String, bytes: Vec<u8>) {
1792	}	1792	}
1793	state.ui.fall_back_to(&families);	1793	state.ui.fall_back_to(&families);
1794	state.renderer.clear_glyph_cache();	1794	state.renderer.clear_glyph_cache();
1795	let response = state.view.relayout()?;	1795	let response = state.pane.view.relayout()?;
1796	state.respond(response);	1796	state.respond(response);
1797	state.window.request_redraw();	1797	state.window.request_redraw();
1798	Ok(())	1798	Ok(())
...	@@ -1816,7 +1816,7 @@ pub fn dictionary_arrived(name: String, affix: String, words: String) {	...	@@ -1816,7 +1816,7 @@ pub fn dictionary_arrived(name: String, affix: String, words: String) {
1816	/// Parks the text area while the page takes no text, keeping it writable for the	1816	/// Parks the text area while the page takes no text, keeping it writable for the
1817	/// interface's fields.	1817	/// interface's fields.
1818	fn park_input(state: &State) {	1818	fn park_input(state: &State) {
1819	if state.ui.focused() != Some(page()) \|\| !state.view.accepts_text() {	1819	if state.ui.focused() != Some(page()) \|\| !state.pane.view.accepts_text() {
1820	place_input(0.0, 0.0, 1.0, state.ui.focused().is_some());	1820	place_input(0.0, 0.0, 1.0, state.ui.focused().is_some());
1821	}	1821	}
1822	}	1822	}