diff --git a/packages/cli-rs/crates/tui/src/routes/session/messages/list.rs b/packages/cli-rs/crates/tui/src/routes/session/messages/list.rs index 51f2f2775ce..01c122fc5c8 100644 --- a/packages/cli-rs/crates/tui/src/routes/session/messages/list.rs +++ b/packages/cli-rs/crates/tui/src/routes/session/messages/list.rs @@ -100,8 +100,10 @@ struct Inner { /// Where the mounted window ends, by row index, when it stops before the newest row /// (`visibleRowsEnd`): `session.first` mounts the head only. end: Cell>, - /// Set when rows mount above the window, so the reader's rows stay in place. + /// Set when rows mount above the window or the terminal resizes, so the reader's rows stay in place. pin: RefCell>, + /// The terminal resize handler, which pins the reader's row before the layout. + resize: Cell>, loading: Cell, /// Message count at the last group-boundary page request. boundary: Cell>, @@ -120,6 +122,9 @@ impl Drop for Inner { fn drop(&mut self) { if let Some(tui) = self.tui.upgrade() { dispose(&tui, self.layer.take()); + if let Some(id) = self.resize.take() { + tui.app.remove_handler(id); + } } } } @@ -145,10 +150,22 @@ impl Paint { } } -/// The content height before rows mounted above, and the frame it is from. +/// The content height before rows mounted above, and the frame it is from. A terminal resize away from the bottom +/// pins the reader's row instead (`ScrollBox.anchor`): through the resize's layout and the rebuild's after it, a row +/// above it that rewraps scrolls the view by as much. A row taller than the view keeps its top; its own content may +/// still move as it rewraps. struct Pin { height: f32, frame: u64, + /// The mounted rows above the reader's, while a resize holds it. + above: Option>, +} + +impl Pin { + /// Whether the frames that lay out the change are still to come or running. + fn live(&self, frame: u64) -> bool { + frame <= self.frame + if self.above.is_some() { 2 } else { 1 } + } } #[derive(Clone, Debug, PartialEq, Eq)] @@ -208,7 +225,11 @@ impl Transcript { let Some(inner) = weak.upgrade() else { return }; // At the tail the transcript follows the bottom; away from it, a row above the reader's that // grows or shrinks would move the rows below it on screen (`pinAbove` for a change in place). - if *inner.start.borrow() != Start::Tail && top < inner.scroll.rect().screen_y { + // A resize's pin already holds the reader's row. + if *inner.start.borrow() != Start::Tail + && top < inner.scroll.rect().screen_y + && !inner.pinned(|pin| pin.above.is_some()) + { inner.scroll.scroll_by(0.0, f64::from(grown)); } }) @@ -228,6 +249,7 @@ impl Transcript { start: RefCell::new(Start::Tail), end: Cell::new(None), pin: RefCell::default(), + resize: Cell::new(None), loading: Cell::new(false), boundary: Cell::new(None), layer: RefCell::default(), @@ -377,31 +399,11 @@ impl Transcript { /// row below it for a reply part or a group, else the first mounted row. Footers and token usage do not /// anchor. pub fn anchor(&self) -> Option { - let (_, top) = self.0.scroll.scroll_position(); - let mut first = None; - let mut anchor: Option = None; - for key in self.0.mounted.borrow().iter() { - let inset = match key { - RowKey::Message(_) => 0.0, - RowKey::Part(..) | RowKey::Group(_) => 1.0, - _ => continue, - }; - let Some(y) = self.row_y(key) else { continue }; - let item = ScrollAnchor { row: key.clone(), screen_y: y - top }; - if item.screen_y <= inset && anchor.as_ref().is_none_or(|anchor| item.screen_y > anchor.screen_y) { - anchor = Some(item.clone()); - } - first.get_or_insert(item); - } - anchor.or(first) + self.0.anchor() } pub fn row_y(&self, key: &RowKey) -> Option { - if !self.0.mounted.borrow().contains(key) { - return None; - } - let rect = self.0.rows.borrow().get(key)?.wrapper.rect(); - (rect.height > 0.0).then(|| rect.screen_y - self.0.scroll.content_view().rect().screen_y) + self.0.row_y(key) } /// Mounts [`BACKFILL_CHUNK`] rows on each side of `key` (`restoreScrollPosition`). Returns whether @@ -448,6 +450,40 @@ impl Transcript { } impl Inner { + fn anchor(&self) -> Option { + let (_, top) = self.scroll.scroll_position(); + let mut first = None; + let mut anchor: Option = None; + for key in self.mounted.borrow().iter() { + let inset = match key { + RowKey::Message(_) => 0.0, + RowKey::Part(..) | RowKey::Group(_) => 1.0, + _ => continue, + }; + let Some(y) = self.row_y(key) else { continue }; + let item = ScrollAnchor { row: key.clone(), screen_y: y - top }; + if item.screen_y <= inset && anchor.as_ref().is_none_or(|anchor| item.screen_y > anchor.screen_y) { + anchor = Some(item.clone()); + } + first.get_or_insert(item); + } + anchor.or(first) + } + + fn row_y(&self, key: &RowKey) -> Option { + if !self.mounted.borrow().contains(key) { + return None; + } + let rect = self.rows.borrow().get(key)?.wrapper.rect(); + (rect.height > 0.0).then(|| rect.screen_y - self.scroll.content_view().rect().screen_y) + } + + /// Whether a live [`Pin`] holds the view and matches `matches`. + fn pinned(&self, matches: impl Fn(&Pin) -> bool) -> bool { + let Some(tui) = self.tui.upgrade() else { return false }; + self.pin.borrow().as_ref().is_some_and(|pin| pin.live(tui.app.frame_number()) && matches(pin)) + } + /// The session's location, once its info is known. The first call reads the location's agents and /// models, whose names and colors the footer and user rows show (`local.agent.color`, `ctx.models`). fn location(&self, tui: &Tui) -> Option { @@ -504,11 +540,33 @@ impl Inner { } })); })); + // Before the layout, while the rows have their old places: away from the bottom, the rows above the reader's + // hold it (see `Pin`). A resize while one holds extends it. + self.resize.set(Some(tui.app.on_resize(bind!(self.this, |inner, cx, _, _| { + let frame = cx.app().frame_number(); + if let Some(pin) = inner.pin.borrow_mut().as_mut().filter(|pin| pin.above.is_some() && pin.live(frame)) { + pin.frame = frame; + return; + } + let (_, top) = inner.scroll.scroll_position(); + let (content, viewport) = (inner.scroll.content_view().rect().height, inner.scroll.rect().height); + if top >= f64::from((content - viewport).max(0.0)).floor() { + return; + } + let Some(anchor) = inner.anchor() else { return }; + let above = inner.mounted.borrow().iter().take_while(|key| **key != anchor.row).cloned().collect(); + *inner.pin.borrow_mut() = Some(Pin { height: content, frame, above: Some(above) }); + })))); let weak = self.this.clone(); self.scroll.content_view().on_resize(bind!(weak, |inner, cx, rect| { let Some(pin) = inner.pin.take() else { return }; - // Only the frame that lays the new rows out moves the view. - if cx.app().frame_number() > pin.frame + 1 { + // Only the frames that lay the new rows out move the view. + if !pin.live(cx.app().frame_number()) { + return; + } + // A resize's rows move the view themselves (`Inner::hold`). + if pin.above.is_some() { + *inner.pin.borrow_mut() = Some(pin); return; } let grown = rect.height - pin.height; @@ -876,13 +934,13 @@ impl Inner { mounted.retain(|key| wanted.contains(key)); // Rows mounting above the first mounted one would push the reader's rows down; the next - // layout scrolls by what they add (`pinAbove`). + // layout scrolls by what they add (`pinAbove`), in place of a resize's pin. if let Some(first) = mounted.first() && keys.first() != Some(first) - && self.pin.borrow().is_none() + && self.pin.borrow().as_ref().is_none_or(|pin| pin.above.is_some()) { - *self.pin.borrow_mut() = - Some(Pin { height: self.scroll.content_view().rect().height, frame: cx.app.frame_number() }); + let (height, frame) = (self.scroll.content_view().rect().height, cx.app.frame_number()); + *self.pin.borrow_mut() = Some(Pin { height, frame, above: None }); } let mut refs = self.refs.borrow_mut(); @@ -900,7 +958,11 @@ impl Inner { } } let fresh = !rows.contains_key(key); - let row = rows.entry(key.clone()).or_insert_with(|| Row::new(cx, spec)); + let row = rows.entry(key.clone()).or_insert_with(|| { + let row = Row::new(cx, spec); + self.hold(&row.wrapper, key.clone()); + row + }); if fresh || messages.into_iter().any(&changed) { row.update(cx, spec); } @@ -918,6 +980,18 @@ impl Inner { } } + /// While a resize's pin holds the reader's row, a row above it that changes height scrolls the view by as much + /// (`pinAbove`). Its own geometry is current in its resize, which the content's is not. + fn hold(&self, wrapper: &View, key: RowKey) { + let laid = Cell::new(None); + wrapper.on_resize(bind!(self.this, |inner, _, rect| { + let Some(before) = laid.replace(Some(rect.height)).filter(|before| *before != rect.height) else { return }; + if inner.pinned(|pin| pin.above.as_ref().is_some_and(|above| above.contains(&key))) { + inner.scroll.scroll_by(0.0, f64::from(rect.height - before)); + } + })); + } + fn window_start(&self, specs: &[Spec]) -> usize { let weights = self.weights.borrow(); if weights.len() != specs.len() { @@ -999,8 +1073,7 @@ impl Inner { fn follow(&self, tui: &Tui, down: bool) { // Newly mounted rows contribute to content size only after layout. - let frame = tui.app.frame_number(); - if self.pin.borrow().as_ref().is_some_and(|pin| frame <= pin.frame + 1) { + if self.pinned(|pin| pin.above.is_none()) { return; } let (_, top) = self.scroll.scroll_position(); diff --git a/packages/cli-rs/crates/tui/tests/all/transcript.rs b/packages/cli-rs/crates/tui/tests/all/transcript.rs index 93206996007..34738e21e0e 100644 --- a/packages/cli-rs/crates/tui/tests/all/transcript.rs +++ b/packages/cli-rs/crates/tui/tests/all/transcript.rs @@ -474,6 +474,75 @@ fn the_tail_mounts_first_and_older_pages_load_near_the_top() { assert_eq!(h.older.load(Ordering::SeqCst), 4); } +/// Ten turns whose replies wrap at every width, all on the first page, one row per wheel step. +fn wrapping_session() -> View { + let filler = "the quick brown fox jumps over the lazy dog ".repeat(5); + let messages: Vec = (1..=10) + .flat_map(|turn| { + let created = turn * 10_000; + let text = format!("Paragraph {turn} {filler}"); + [ + user(&format!("msg_{turn:03}a"), created, &format!("Question {turn}")), + assistant( + &format!("msg_{turn:03}b"), + created + 1000, + json!([{ "type": "text", "text": text }]), + Some(created + 3000), + ), + ] + }) + .collect(); + let info = Info { scroll: Some(Scroll { speed: Some(Bounded(1.0)), ..Scroll::default() }), ..Info::default() }; + open(80, 20, "ses_z", messages, info) +} + +/// The line under the session's title, which is the transcript's top row. +fn top_line(screen: &str) -> String { + screen.lines().nth(1).unwrap_or_default().trim().to_owned() +} + +/// A resize narrower and wider rewraps every row, above the reader's too, and keeps the row at the top of the view +/// there. +#[test] +fn a_resize_keeps_the_readers_row_at_the_top() { + let h = wrapping_session(); + h.wait_for("Paragraph 10"); + for _ in 0..30 { + h.scroll_up(); + } + // Up to a reply's first line, so the row's top is the view's top. + for _ in 0..20 { + if top_line(&h.app.text()).starts_with("Paragraph") { + break; + } + h.scroll_up(); + } + let top = top_line(&h.app.text()); + assert!(top.starts_with("Paragraph"), "{}", h.app.text()); + let paragraph: String = top.split_whitespace().take(2).collect::>().join(" "); + // The resize's own frame and the rebuild's after it. + for width in [50, 120, 80] { + h.app.resize(width, 20); + for frame in [h.app.render().text(), h.app.render().text()] { + let held = top_line(&frame).starts_with(&format!("{paragraph} ")); + assert!(held, "{width} columns, {paragraph:?} left the top:\n{frame}"); + } + } +} + +/// A view at the bottom still follows it after a resize. +#[test] +fn a_resize_at_the_bottom_keeps_following() { + let h = wrapping_session(); + h.wait_for("Paragraph 10"); + for width in [50, 120] { + h.app.resize(width, 20); + h.app.render(); + let screen = h.app.render().text(); + assert!(screen.contains("Paragraph 10") && !screen.contains("Jump to latest"), "{width} columns:\n{screen}"); + } +} + /// A recorded sequence of multi-step timings spans a turn across the page boundary. #[test] fn the_footer_spans_a_turn_whose_prompt_is_on_an_older_page() {