editor: Smooth scrolling

assets/settings/default.json

@@ -700,6 +700,10 @@
   // to both the horizontal and vertical delta values while scrolling. Fast scrolling
   // happens when a user holds the alt or option key while scrolling.
   "fast_scroll_sensitivity": 4.0,
+  "smooth_scroll": {
+    // Whether to animate scrolling with a smooth easing effect.
+    "enabled": false,
+  },
   "sticky_scroll": {
     // Whether to stick scopes to the top of the editor.
     "enabled": false,

crates/editor/src/editor.rs

@@ -9683,6 +9683,7 @@ impl Editor {
         {
             let editor_settings = EditorSettings::get_global(cx);
             self.scroll_manager.vertical_scroll_margin = editor_settings.vertical_scroll_margin;
+            self.scroll_manager.smooth_scroll = editor_settings.smooth_scroll.enabled;
             if self.breadcrumbs_visibility.settings_visibility()
                 != editor_settings.toolbar.breadcrumbs
             {

crates/editor/src/editor_settings.rs

@@ -38,6 +38,7 @@ pub struct EditorSettings {
     pub scroll_sensitivity: f32,
     pub mouse_wheel_zoom: bool,
     pub fast_scroll_sensitivity: f32,
+    pub smooth_scroll: SmoothScroll,
     pub sticky_scroll: StickyScroll,
     pub relative_line_numbers: RelativeLineNumbers,
     pub seed_search_query_from_cursor: SeedQuerySetting,
@@ -82,6 +83,11 @@ pub struct StickyScroll {
     pub enabled: bool,
 }
 
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub struct SmoothScroll {
+    pub enabled: bool,
+}
+
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct Toolbar {
     pub breadcrumbs: bool,
@@ -203,6 +209,7 @@ impl Settings for EditorSettings {
         let search = editor.search.unwrap();
         let drag_and_drop_selection = editor.drag_and_drop_selection.unwrap();
         let sticky_scroll = editor.sticky_scroll.unwrap();
+        let smooth_scroll = editor.smooth_scroll.unwrap();
         Self {
             cursor_blink: editor.cursor_blink.unwrap(),
             cursor_shape: editor.cursor_shape.map(Into::into),
@@ -264,6 +271,9 @@ impl Settings for EditorSettings {
             scroll_sensitivity: editor.scroll_sensitivity.unwrap(),
             mouse_wheel_zoom: editor.mouse_wheel_zoom.unwrap(),
             fast_scroll_sensitivity: editor.fast_scroll_sensitivity.unwrap(),
+            smooth_scroll: SmoothScroll {
+                enabled: smooth_scroll.enabled.unwrap(),
+            },
             sticky_scroll: StickyScroll {
                 enabled: sticky_scroll.enabled.unwrap(),
             },

crates/editor/src/editor_tests.rs

@@ -6,7 +6,7 @@ use crate::{
     element::{StickyHeader, header_jump_data},
     linked_editing_ranges::LinkedEditingRanges,
     runnables::RunnableTasks,
-    scroll::scroll_amount::ScrollAmount,
+    scroll::{ScrollBehavior, scroll_amount::ScrollAmount},
     test::{
         assert_text_with_selections, build_editor, editor_content_with_blocks,
         editor_lsp_test_context::{EditorLspTestContext, git_commit_lang},
@@ -19,7 +19,7 @@ use collections::HashMap;
 use futures::{StreamExt, channel::oneshot};
 use gpui::{
     BackgroundExecutor, DismissEvent, Task, TaskExt, TestAppContext, UpdateGlobal,
-    VisualTestContext, WindowBounds, WindowOptions, div,
+    VisualTestContext, WindowBounds, WindowOptions, div, point,
 };
 use indoc::indoc;
 use language::{
@@ -2864,6 +2864,142 @@ async fn test_move_start_of_paragraph_end_of_paragraph(cx: &mut TestAppContext)
     cx.assert_editor_state(&"ˇone\ntwo\n \nthree\nfour\nfive\n\nsix");
 }
 
+#[gpui::test]
+async fn test_instant_scroll_request_during_scroll_animation(cx: &mut TestAppContext) {
+    init_test(cx, |_| {});
+    update_test_editor_settings(cx, &|settings| {
+        settings.smooth_scroll = Some(settings::SmoothScrollContent {
+            enabled: Some(true),
+        });
+    });
+    let mut cx = EditorTestContext::new(cx).await;
+    let line_height = cx.update_editor(|editor, window, cx| {
+        editor.set_vertical_scroll_margin(0, cx);
+        editor
+            .style(cx)
+            .text
+            .line_height_in_pixels(window.rem_size())
+    });
+    let window = cx.window;
+    cx.simulate_window_resize(window, size(px(1000.), 4. * line_height));
+    cx.set_state(indoc! {"
+        ˇone
+        two
+        three
+        four
+        five
+        six
+        seven
+        eight
+        nine
+        ten
+        eleven
+        twelve
+    "});
+
+    cx.update_editor(|editor, window, cx| {
+        editor.scroll(
+            point(0., 8.),
+            None,
+            Some(ScrollBehavior::RequestAnimation),
+            window,
+            cx,
+        );
+        assert!(
+            editor
+                .scroll_manager
+                .scroll_animation()
+                .is_some_and(|animation| animation.is_animating())
+        );
+
+        editor.scroll(
+            point(0., 2.),
+            None,
+            Some(ScrollBehavior::Instant),
+            window,
+            cx,
+        );
+        assert!(
+            editor
+                .scroll_manager
+                .scroll_animation()
+                .is_some_and(|animation| animation.is_finished())
+        );
+
+        editor.flush_scroll_animation(window, cx);
+        assert_eq!(editor.snapshot(window, cx).scroll_position(), point(0., 2.));
+        assert!(editor.scroll_manager.scroll_animation().is_none());
+    });
+}
+
+#[gpui::test]
+async fn test_smooth_scroll_setting_update_during_animation(cx: &mut TestAppContext) {
+    init_test(cx, |_| {});
+    update_test_editor_settings(cx, &|settings| {
+        settings.smooth_scroll = Some(settings::SmoothScrollContent {
+            enabled: Some(true),
+        });
+    });
+    let mut cx = EditorTestContext::new(cx).await;
+    let line_height = cx.update_editor(|editor, window, cx| {
+        editor.set_vertical_scroll_margin(0, cx);
+        editor
+            .style(cx)
+            .text
+            .line_height_in_pixels(window.rem_size())
+    });
+    let window = cx.window;
+    cx.simulate_window_resize(window, size(px(1000.), 4. * line_height));
+    cx.set_state(indoc! {"
+        ˇone
+        two
+        three
+        four
+        five
+        six
+        seven
+        eight
+        nine
+        ten
+        eleven
+        twelve
+    "});
+
+    cx.update_editor(|editor, window, cx| {
+        assert!(editor.scroll_manager.smooth_scroll);
+        editor.scroll(point(0., 8.), None, None, window, cx);
+        assert!(
+            editor
+                .scroll_manager
+                .scroll_animation()
+                .is_some_and(|animation| animation.is_animating())
+        );
+    });
+
+    cx.update(|_, cx| {
+        SettingsStore::update_global(cx, |store, cx| {
+            store.update_user_settings(cx, |settings| {
+                settings.editor.smooth_scroll = Some(settings::SmoothScrollContent {
+                    enabled: Some(false),
+                });
+            });
+        });
+    });
+    cx.run_until_parked();
+
+    cx.update_editor(|editor, window, cx| {
+        assert!(!editor.scroll_manager.smooth_scroll);
+
+        editor.set_scroll_top_row(DisplayRow(3), window, cx);
+        assert_eq!(editor.snapshot(window, cx).scroll_position(), point(0., 3.));
+        assert!(editor.scroll_manager.scroll_animation().is_none());
+
+        editor.set_scroll_top_row(DisplayRow(6), window, cx);
+        assert_eq!(editor.snapshot(window, cx).scroll_position(), point(0., 6.));
+        assert!(editor.scroll_manager.scroll_animation().is_none());
+    });
+}
+
 #[gpui::test]
 async fn test_scroll_page_up_page_down(cx: &mut TestAppContext) {
     init_test(cx, |_| {});
@@ -2896,28 +3032,37 @@ async fn test_scroll_page_up_page_down(cx: &mut TestAppContext) {
             editor.snapshot(window, cx).scroll_position(),
             gpui::Point::new(0., 0.)
         );
+
         editor.scroll_screen(&ScrollAmount::Page(1.), window, cx);
+        editor.flush_scroll_animation(window, cx);
         assert_eq!(
             editor.snapshot(window, cx).scroll_position(),
             gpui::Point::new(0., 3.)
         );
+
         editor.scroll_screen(&ScrollAmount::Page(1.), window, cx);
+        editor.flush_scroll_animation(window, cx);
         assert_eq!(
             editor.snapshot(window, cx).scroll_position(),
             gpui::Point::new(0., 6.)
         );
+
         editor.scroll_screen(&ScrollAmount::Page(-1.), window, cx);
+        editor.flush_scroll_animation(window, cx);
         assert_eq!(
             editor.snapshot(window, cx).scroll_position(),
             gpui::Point::new(0., 3.)
         );
 
         editor.scroll_screen(&ScrollAmount::Page(-0.5), window, cx);
+        editor.flush_scroll_animation(window, cx);
         assert_eq!(
             editor.snapshot(window, cx).scroll_position(),
             gpui::Point::new(0., 1.)
         );
+
         editor.scroll_screen(&ScrollAmount::Page(0.5), window, cx);
+        editor.flush_scroll_animation(window, cx);
         assert_eq!(
             editor.snapshot(window, cx).scroll_position(),
             gpui::Point::new(0., 3.)
@@ -26065,7 +26210,13 @@ async fn test_expand_first_line_diff_hunk_keeps_deleted_lines_visible(
     cx.set_state("ˇnew\nsecond\nthird\n");
     cx.set_head_text("old\nsecond\nthird\n");
     cx.update_editor(|editor, window, cx| {
-        editor.scroll(gpui::Point { x: 0., y: 0. }, None, window, cx);
+        editor.scroll(
+            gpui::Point { x: 0., y: 0. },
+            None,
+            Some(ScrollBehavior::Instant),
+            window,
+            cx,
+        );
     });
     executor.run_until_parked();
     assert_eq!(cx.update_editor(|e, _, cx| e.scroll_position(cx)).y, 0.0);
@@ -33919,7 +34070,13 @@ async fn test_sticky_scroll(cx: &mut TestAppContext) {
 
     let mut sticky_headers = |offset: ScrollOffset| {
         cx.update_editor(|e, window, cx| {
-            e.scroll(gpui::Point { x: 0., y: offset }, None, window, cx);
+            e.scroll(
+                gpui::Point { x: 0., y: offset },
+                None,
+                Some(ScrollBehavior::Instant),
+                window,
+                cx,
+            );
         });
         cx.run_until_parked();
         cx.update_editor(|e, window, cx| {
@@ -34008,7 +34165,13 @@ async fn test_sticky_scroll_with_decoration_prefix_in_item(cx: &mut TestAppConte
 
     let mut sticky_headers = |offset: ScrollOffset| {
         cx.update_editor(|e, window, cx| {
-            e.scroll(gpui::Point { x: 0., y: offset }, None, window, cx);
+            e.scroll(
+                gpui::Point { x: 0., y: offset },
+                None,
+                Some(ScrollBehavior::Instant),
+                window,
+                cx,
+            );
         });
         cx.run_until_parked();
         cx.update_editor(|e, window, cx| {
@@ -34071,7 +34234,7 @@ async fn test_sticky_scroll_anchors_multiline_c_signature_on_name_row(cx: &mut T
 
     let mut sticky_headers = |offset: ScrollOffset| {
         cx.update_editor(|editor, window, cx| {
-            editor.scroll(gpui::Point { x: 0., y: offset }, None, window, cx);
+            editor.scroll(gpui::Point { x: 0., y: offset }, None, None, window, cx);
         });
         cx.run_until_parked();
         cx.update_editor(|editor, window, cx| {
@@ -34154,7 +34317,13 @@ async fn test_sticky_scroll_with_expanded_deleted_diff_hunks(
 
     let mut sticky_headers = |offset: ScrollOffset| {
         cx.update_editor(|e, window, cx| {
-            e.scroll(gpui::Point { x: 0., y: offset }, None, window, cx);
+            e.scroll(
+                gpui::Point { x: 0., y: offset },
+                None,
+                Some(ScrollBehavior::Instant),
+                window,
+                cx,
+            );
         });
         cx.run_until_parked();
         cx.update_editor(|e, window, cx| {
@@ -34210,7 +34379,13 @@ async fn test_no_duplicated_sticky_headers(cx: &mut TestAppContext) {
 
     let mut sticky_headers = |offset: ScrollOffset| {
         cx.update_editor(|e, window, cx| {
-            e.scroll(gpui::Point { x: 0., y: offset }, None, window, cx);
+            e.scroll(
+                gpui::Point { x: 0., y: offset },
+                None,
+                Some(ScrollBehavior::Instant),
+                window,
+                cx,
+            );
         });
         cx.run_until_parked();
         cx.update_editor(|e, window, cx| {
@@ -34507,9 +34682,11 @@ async fn test_scroll_by_clicking_sticky_header(cx: &mut TestAppContext) {
                     y: scroll_offset,
                 },
                 None,
+                Some(ScrollBehavior::Instant),
                 window,
                 cx,
             );
+            e.flush_scroll_animation(window, cx);
         });
         cx.run_until_parked();
         cx.simulate_click(
@@ -34598,7 +34775,13 @@ async fn test_scroll_by_clicking_sticky_header(cx: &mut TestAppContext) {
     // The text "impl Bar {" starts at column 0, so column 5 = 'B'.
     let click_x = text_origin_x + em_width * 5.5;
     cx.update_editor(|e, window, cx| {
-        e.scroll(gpui::Point { x: 0., y: 4.5 }, None, window, cx);
+        e.scroll(
+            gpui::Point { x: 0., y: 4.5 },
+            None,
+            Some(ScrollBehavior::Instant),
+            window,
+            cx,
+        );
     });
     cx.run_until_parked();
     cx.simulate_click(
@@ -34672,7 +34855,13 @@ async fn test_clicking_sticky_header_sets_character_select_mode(cx: &mut TestApp
         editor.end_selection(window, cx);
 
         // Scroll down one row to make `fn foo() {` a sticky header
-        editor.scroll(gpui::Point { x: 0., y: 1. }, None, window, cx);
+        editor.scroll(
+            gpui::Point { x: 0., y: 1. },
+            None,
+            Some(ScrollBehavior::Instant),
+            window,
+            cx,
+        );
     });
     cx.run_until_parked();
 

crates/editor/src/element.rs

@@ -7975,6 +7975,14 @@ impl Element for EditorElement {
                         );
                         editor.set_visible_column_count(f64::from(editor_width / em_advance));
 
+                        if let Some(animation) = editor.scroll_manager.update_animation() {
+                            editor.set_scroll_position(animation.position(), window, cx);
+
+                            if animation.is_animating() {
+                                window.request_animation_frame();
+                            }
+                        }
+
                         if matches!(
                             editor.mode,
                             EditorMode::AutoHeight { .. } | EditorMode::Minimap { .. }