Skip to content

armgit / zed

Public Imported from GitHub
0

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.rs
index 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.rs
index 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, |_| {});