Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
editor: Fix cursor animation across width and scroll changes (#64184)
Cain7a01ac15c5f6
diff --git a/crates/editor/src/cursor_animation.rs b/crates/editor/src/cursor_animation.rsindex 750f2f14565..0ea173c1e7f 100644--- a/crates/editor/src/cursor_animation.rs+++ b/crates/editor/src/cursor_animation.rs@@ -73,6 +73,13 @@ impl CursorViewport {&& f32::from(self.line_height).is_finite()&& f32::from(self.em_advance).is_finite()}++ fn has_same_layout(self, other: Self) -> bool {+ self.content_origin == other.content_origin+ && self.text_bounds == other.text_bounds+ && self.line_height == other.line_height+ && self.em_advance == other.em_advance+ }}#[derive(Clone, Copy, Debug, Default, PartialEq)]@@ -400,6 +407,11 @@ impl CursorAnimationStates {self.newest_selection_id = None;self.newest_state = None;}++ #[cfg(test)]+ pub(crate) fn has_active_animation(&self) -> bool {+ self.states.values().any(|state| state.active)+ }}impl Default for CursorAnimationState {@@ -436,20 +448,40 @@ impl CursorAnimationState {return None;}- let Some(previous_geometry) = self.target_geometry else {+ let Some(mut previous_geometry) = self.target_geometry else {+ self.snap(logical_position, target_geometry, viewport, now);+ return None;+ };+ let Some(previous_viewport) = self.last_viewport else {self.snap(logical_position, target_geometry, viewport, now);return None;};let logical_position_changed = self.last_logical_position != Some(logical_position);+ let viewport_changed = previous_viewport != viewport;++ if viewport_changed {+ if !previous_viewport.has_same_layout(viewport) {+ self.snap(logical_position, target_geometry, viewport, now);+ return None;+ }++ self.translate(AnimationPoint {+ x: (previous_viewport.scroll_pixel_position.x - viewport.scroll_pixel_position.x)+ as f32,+ y: (previous_viewport.scroll_pixel_position.y - viewport.scroll_pixel_position.y)+ as f32,+ });+ if let Some(target_geometry) = self.target_geometry {+ previous_geometry = target_geometry;+ }+ }+let target_origin_changed = !previous_geometry.has_same_origin(target_geometry);- let viewport_changed = self.last_viewport != Some(viewport);let geometry_size_changed = !previous_geometry.has_same_size(target_geometry);+ let geometry_changed = target_origin_changed || geometry_size_changed;- if viewport_changed- || geometry_size_changed- || (!logical_position_changed && target_origin_changed)- {+ if !logical_position_changed && geometry_changed {self.snap(logical_position, target_geometry, viewport, now);return None;}@@ -458,7 +490,7 @@ impl CursorAnimationState {self.last_viewport = Some(viewport);self.target_geometry = Some(target_geometry);- if target_origin_changed {+ if logical_position_changed && geometry_changed {let elapsed = if self.active {self.elapsed_since_last_frame(now)} else {@@ -479,6 +511,16 @@ impl CursorAnimationState {})}+ fn translate(&mut self, delta: AnimationPoint) {+ for corner in &mut self.corners {+ corner.current_position = corner.current_position + delta;+ corner.target_position = corner.target_position + delta;+ }+ if let Some(target_geometry) = &mut self.target_geometry {+ target_geometry.origin = target_geometry.origin + delta;+ }+ }+pub(crate) fn reset(&mut self) {self.target_geometry = None;self.last_logical_position = None;@@ -562,9 +604,13 @@ mod tests {use gpui::size;fn bounds(x: f32, y: f32) -> Bounds<Pixels> {+ bounds_with_width(x, y, 2.0)+ }++ fn bounds_with_width(x: f32, y: f32, width: f32) -> Bounds<Pixels> {Bounds {origin: point(px(x), px(y)),- size: size(px(2.0), px(20.0)),+ size: size(px(width), px(20.0)),}}@@ -586,6 +632,32 @@ mod tests {LogicalCursorPosition { row, column }}+ fn assert_converges_to(+ state: &mut CursorAnimationState,+ logical_position: LogicalCursorPosition,+ target_bounds: Bounds<Pixels>,+ viewport: CursorViewport,+ now: Instant,+ ) {+ for frame in 1..30 {+ state.update(+ logical_position,+ target_bounds,+ viewport,+ now + Duration::from_millis(frame * 16),+ );+ }++ assert!(!state.active);+ let target_geometry = CursorGeometry::from_bounds(target_bounds);+ assert_eq!(+ state.corners.map(|corner| corner.current_position),+ state+ .corners+ .map(|corner| corner.destination(target_geometry))+ );+ }+#[test]fn spring_converges() {let mut spring = DampedSpringAnimation {@@ -734,6 +806,96 @@ mod tests {assert!(corners[0].x < px(4.0));}+ #[test]+ fn moving_to_a_wider_cursor_animates_and_converges() {+ let now = Instant::now();+ let mut state = CursorAnimationState::default();+ state.update(+ logical_position(0, 0),+ bounds_with_width(0.0, 0.0, 8.0),+ viewport(0.0),+ now,+ );++ assert!(+ state+ .update(+ logical_position(0, 1),+ bounds_with_width(8.0, 0.0, 16.0),+ viewport(0.0),+ now,+ )+ .is_some()+ );+ assert!(state.active);++ assert_converges_to(+ &mut state,+ logical_position(0, 1),+ bounds_with_width(8.0, 0.0, 16.0),+ viewport(0.0),+ now,+ );+ }++ #[test]+ fn moving_to_a_narrower_cursor_animates_and_converges() {+ let now = Instant::now();+ let mut state = CursorAnimationState::default();+ state.update(+ logical_position(0, 0),+ bounds_with_width(0.0, 0.0, 16.0),+ viewport(0.0),+ now,+ );++ assert!(+ state+ .update(+ logical_position(0, 1),+ bounds_with_width(16.0, 0.0, 8.0),+ viewport(0.0),+ now,+ )+ .is_some()+ );+ assert!(state.active);++ assert_converges_to(+ &mut state,+ logical_position(0, 1),+ bounds_with_width(16.0, 0.0, 8.0),+ viewport(0.0),+ now,+ );+ }++ #[test]+ fn geometry_change_without_logical_movement_snaps() {+ let now = Instant::now();+ let mut state = CursorAnimationState::default();+ state.update(+ logical_position(0, 0),+ bounds_with_width(0.0, 0.0, 8.0),+ viewport(0.0),+ now,+ );++ assert!(+ state+ .update(+ logical_position(0, 0),+ bounds_with_width(4.0, 0.0, 16.0),+ viewport(0.0),+ now + Duration::from_millis(16),+ )+ .is_none()+ );+ assert!(!state.active);+ assert_eq!(state.corners[0].current_position.x, 4.0);+ assert_eq!(state.corners[1].current_position.x, 20.0);+ }+#[test]fn long_movement_ranks_leading_corners_ahead_of_trailing_corners() {let now = Instant::now();@@ -789,7 +951,35 @@ mod tests {}#[test]- fn viewport_movement_snaps_even_during_animation() {+ fn moving_down_while_the_viewport_scrolls_starts_animation() {+ let now = Instant::now();+ let mut state = CursorAnimationState::default();+ state.update(logical_position(0, 0), bounds(0.0, 0.0), viewport(0.0), now);++ assert!(+ state+ .update(logical_position(1, 0), bounds(0.0, 0.0), viewport(1.0), now,)+ .is_some()+ );+ assert!(state.active);+ }++ #[test]+ fn moving_up_while_the_viewport_scrolls_starts_animation() {+ let now = Instant::now();+ let mut state = CursorAnimationState::default();+ state.update(logical_position(1, 0), bounds(0.0, 0.0), viewport(1.0), now);++ assert!(+ state+ .update(logical_position(0, 0), bounds(0.0, 0.0), viewport(0.0), now,)+ .is_some()+ );+ assert!(state.active);+ }++ #[test]+ fn scrolling_during_animation_preserves_motion_and_velocity() {let now = Instant::now();let mut state = CursorAnimationState::default();state.update(logical_position(0, 0), bounds(0.0, 0.0), viewport(0.0), now);@@ -799,7 +989,20 @@ mod tests {viewport(0.0),now,);+ state.update(+ logical_position(0, 10),+ bounds(100.0, 0.0),+ viewport(0.0),+ now + Duration::from_millis(16),+ );assert!(state.active);+ let positions_before_scroll = state.corners.map(|corner| corner.current_position);+ let velocities_before_scroll = state.corners.map(|corner| {+ (+ corner.horizontal_animation.velocity,+ corner.vertical_animation.velocity,+ )+ });assert!(state@@ -809,10 +1012,69 @@ mod tests {viewport(1.0),now + Duration::from_millis(16),)- .is_none()+ .is_some());- assert!(!state.active);- assert_eq!(state.corners[0].current_position.y, -20.0);+ assert!(state.active);+ assert_eq!(+ state.corners.map(|corner| corner.current_position),+ positions_before_scroll.map(|position| AnimationPoint {+ x: position.x,+ y: position.y - 20.0,+ })+ );+ assert_eq!(+ state.corners.map(|corner| (+ corner.horizontal_animation.velocity,+ corner.vertical_animation.velocity,+ )),+ velocities_before_scroll+ );+ }++ #[test]+ fn layout_changes_snap_even_during_animation() {+ let now = Instant::now();++ for changed_viewport in [+ CursorViewport {+ line_height: px(24.0),+ ..viewport(0.0)+ },+ CursorViewport {+ text_bounds: Bounds {+ origin: point(px(0.0), px(0.0)),+ size: size(px(700.0), px(500.0)),+ },+ ..viewport(0.0)+ },+ CursorViewport {+ em_advance: px(10.0),+ ..viewport(0.0)+ },+ ] {+ let mut state = CursorAnimationState::default();+ state.update(logical_position(0, 0), bounds(0.0, 0.0), viewport(0.0), now);+ state.update(+ logical_position(0, 10),+ bounds(100.0, 0.0),+ viewport(0.0),+ now,+ );+ assert!(state.active);++ assert!(+ state+ .update(+ logical_position(0, 10),+ bounds(100.0, 0.0),+ changed_viewport,+ now + Duration::from_millis(16),+ )+ .is_none()+ );+ assert!(!state.active);+ assert_eq!(state.corners[0].current_position.x, 100.0);+ }}#[test]diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rsindex e92b1b89496..7fe1e071935 100644--- a/crates/editor/src/editor_tests.rs+++ b/crates/editor/src/editor_tests.rs@@ -3756,6 +3756,69 @@ async fn test_autoscroll(cx: &mut TestAppContext) {});}+#[gpui::test]+async fn test_cursor_animation_remains_active_during_keyboard_autoscroll(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ update_test_editor_settings(cx, &|settings| {+ settings.cursor_animation.get_or_insert_default().enabled = Some(true);+ });+ let mut cx = EditorTestContext::new(cx).await;++ let line_height = cx.update_editor(|editor, window, cx| {+ editor.set_vertical_scroll_margin(3, cx);+ editor.set_cursor_shape(CursorShape::Block, cx);+ editor+ .style(cx)+ .text+ .line_height_in_pixels(window.rem_size())+ });+ let window = cx.window;+ cx.simulate_window_resize(window, size(px(1000.0), 8.0 * line_height));++ let text = (0..40)+ .map(|row| format!("line {row}"))+ .collect::<Vec<_>>()+ .join("\n");+ cx.set_state(&format!("ˇ{text}"));+ cx.update(|window, cx| {+ window.refresh();+ let _ = window.draw(cx);+ });++ let mut previous_scroll_y = 0.0;+ let mut observed_autoscroll = false;+ for _ in 0..20 {+ cx.update_editor(|editor, window, cx| {+ editor.move_down(&Default::default(), window, cx);+ });+ cx.update(|window, cx| {+ window.refresh();+ let _ = window.draw(cx);+ });++ let (scroll_y, animation_active) = cx.update_editor(|editor, window, cx| {+ (+ editor.snapshot(window, cx).scroll_position().y,+ editor.cursor_animations.has_active_animation(),+ )+ });+ if scroll_y > previous_scroll_y {+ assert!(+ animation_active,+ "cursor animation should remain active when keyboard movement autoscrolls"+ );+ observed_autoscroll = true;+ break;+ }+ previous_scroll_y = scroll_y;+ }++ assert!(+ observed_autoscroll,+ "expected cursor movement to autoscroll"+ );+}+#[gpui::test]async fn test_autoscroll_relative(cx: &mut TestAppContext) {init_test(cx, |_| {});