feat: add scrollbar for virtualized lists

crates/core/src/lib.rs

@@ -63,6 +63,9 @@ pub mod popover;
 #[cfg(feature = "scroll_area")]
 pub mod scroll_area;
 
+#[cfg(feature = "scrollbar")]
+pub mod scrollbar;
+
 #[cfg(feature = "segmented")]
 pub mod segmented;
 

crates/core/src/scroll_area.rs

@@ -1,8 +1,12 @@
+use std::time::Duration;
+use std::time::Instant;
+
 use gpui::prelude::FluentBuilder as _;
 use gpui::{
-    App, Bounds, DispatchPhase, ElementId, InteractiveElement as _, IntoElement, MouseDownEvent,
-    MouseMoveEvent, ParentElement, Pixels, RenderOnce, ScrollHandle, SharedString,
-    StatefulInteractiveElement as _, Styled, Window, canvas, div, fill, point,
+    App, Bounds, DispatchPhase, ElementId, Entity, EntityId, InteractiveElement as _, IntoElement,
+    MouseDownEvent, MouseMoveEvent, MouseUpEvent, ParentElement, Pixels, RenderOnce, ScrollEvent,
+    ScrollHandle, SharedString, StatefulInteractiveElement as _, Styled, Task, Window, canvas, div,
+    fill, point,
 };
 use gpui_native_theme::ActiveTheme as _;
 
@@ -20,12 +24,115 @@ pub enum ScrollAxes {
     Both,
 }
 
+/// When an overlay scrollbar shows.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub enum ScrollbarVisibility {
+    /// The running platform's behavior, from the theme.
+    #[default]
+    Platform,
+    Always,
+    Autohide,
+}
+
+/// How long an autohide thumb stays fully visible before its fade begins.
+const AUTOHIDE_DELAY: Duration = Duration::from_millis(700);
+/// How long the autohide fade runs.
+const AUTOHIDE_FADE: Duration = Duration::from_millis(250);
+/// How often the fade repaints while it runs.
+const AUTOHIDE_FADE_STEP: Duration = Duration::from_millis(50);
+
+/// The shared autohide timeline for an overlay scrollbar.
+#[derive(Clone)]
+pub(crate) struct Autohide {
+    view: EntityId,
+    state: Entity<AutohideState>,
+}
+
+struct AutohideState {
+    last_activity: Option<Instant>,
+    hide_task: Option<Task<()>>,
+}
+
+impl Autohide {
+    pub(crate) fn new(window: &mut Window, cx: &mut App) -> Self {
+        let view = window.current_view();
+        let state = window.use_keyed_state("scrollbar-autohide", cx, |_, _| AutohideState {
+            last_activity: None,
+            hide_task: None,
+        });
+        Self { view, state }
+    }
+
+    /// Marks interaction.
+    pub(crate) fn touch(&self, window: &mut Window, cx: &mut App) {
+        let view = self.view;
+        let reduce_motion = cx.theme().accessibility.reduce_motion;
+
+        let task = window.spawn(cx, async move |cx| {
+            if reduce_motion {
+                cx.background_executor()
+                    .timer(AUTOHIDE_DELAY + AUTOHIDE_FADE)
+                    .await;
+                cx.update(|_, cx| cx.notify(view)).ok();
+                return;
+            }
+
+            let steps = (AUTOHIDE_FADE.as_millis() / AUTOHIDE_FADE_STEP.as_millis()).max(1);
+            cx.background_executor().timer(AUTOHIDE_DELAY).await;
+
+            for _ in 0..steps {
+                cx.update(|_, cx| cx.notify(view)).ok();
+                cx.background_executor().timer(AUTOHIDE_FADE_STEP).await;
+            }
+
+            cx.update(|_, cx| cx.notify(view)).ok();
+        });
+
+        self.state.update(cx, |state, _| {
+            state.last_activity = Some(Instant::now());
+            state.hide_task = Some(task);
+        });
+    }
+
+    /// The thumb's opacity.
+    pub(crate) fn alpha(&self, cx: &App, dragging: bool) -> f32 {
+        if dragging {
+            return 1.0;
+        }
+
+        let Some(activity) = self.state.read(cx).last_activity else {
+            return 0.0;
+        };
+
+        let idle = activity.elapsed();
+        if idle <= AUTOHIDE_DELAY {
+            return 1.0;
+        }
+
+        let fade = idle.saturating_sub(AUTOHIDE_DELAY);
+        if fade >= AUTOHIDE_FADE {
+            return 0.0;
+        }
+
+        1.0 - fade.as_secs_f32() / AUTOHIDE_FADE.as_secs_f32()
+    }
+}
+
+/// An overlay scrollbar thumb's style for one paint: `None` hides it.
+pub(crate) fn thumb_style(color: gpui::Hsla, alpha: f32) -> Option<gpui::Hsla> {
+    (alpha > 0.0).then_some(gpui::Hsla {
+        a: color.a * alpha,
+        ..color
+    })
+}
+
 /// A scrollable container with an overlay scrollbar.
 #[derive(IntoElement)]
 pub struct ScrollArea {
     id: ElementId,
     handle: Option<ScrollHandle>,
     axes: ScrollAxes,
+    visibility: ScrollbarVisibility,
     a11y_label: Option<SharedString>,
     style: gpui::StyleRefinement,
     children: Vec<gpui::AnyElement>,
@@ -53,6 +160,7 @@ impl ScrollArea {
             id: id.into(),
             handle: None,
             axes: ScrollAxes::Vertical,
+            visibility: ScrollbarVisibility::default(),
             a11y_label: None,
             style: gpui::StyleRefinement::default(),
             children: Vec::new(),
@@ -65,6 +173,12 @@ impl ScrollArea {
         self
     }
 
+    /// Overrides when the scrollbar shows, instead of the platform default.
+    pub fn visibility(mut self, visibility: ScrollbarVisibility) -> Self {
+        self.visibility = visibility;
+        self
+    }
+
     /// Scrolls with a handle held on the owning view.
     pub fn handle(mut self, handle: ScrollHandle) -> Self {
         self.handle = Some(handle);
@@ -101,7 +215,7 @@ pub(crate) fn thumb_geometry(
 }
 
 impl RenderOnce for ScrollArea {
-    fn render(self, _window: &mut Window, _cx: &mut App) -> impl IntoElement {
+    fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {
         let mut pane = div()
             .id(self.id.clone())
             .overflow_hidden()
@@ -128,11 +242,16 @@ impl RenderOnce for ScrollArea {
         wrapper.extend(std::iter::once(pane.into_any_element()));
 
         if let Some(handle) = self.handle {
+            let autohide = match self.visibility {
+                ScrollbarVisibility::Platform => cx.theme().scrollbar.autohide,
+                ScrollbarVisibility::Always => false,
+                ScrollbarVisibility::Autohide => true,
+            };
             wrapper.extend(std::iter::once(
                 canvas(|_, _, _| {}, {
                     let handle = handle.clone();
                     move |_, _, window, cx| {
-                        paint_scrollbar(&handle, window, cx);
+                        paint_scrollbar(&handle, autohide, window, cx);
                     }
                 })
                 .absolute()
@@ -146,8 +265,10 @@ impl RenderOnce for ScrollArea {
 }
 
 /// Paints the overlay scrollbar thumb.
-fn paint_scrollbar(handle: &ScrollHandle, window: &mut Window, cx: &mut App) {
+fn paint_scrollbar(handle: &ScrollHandle, autohide: bool, window: &mut Window, cx: &mut App) {
     let theme = cx.theme();
+    let view = window.current_view();
+
     let color = theme.colors.scrollbar_thumb;
     let width = theme.scrollbar.width;
     let inset = theme.scrollbar.inset;
@@ -155,10 +276,22 @@ fn paint_scrollbar(handle: &ScrollHandle, window: &mut Window, cx: &mut App) {
 
     let max_offset = handle.max_offset().y;
     let bounds = handle.bounds();
+
     if max_offset <= Pixels::ZERO || bounds.size.height <= Pixels::ZERO {
         return;
     }
 
+    let autohide_state = autohide.then(|| Autohide::new(window, cx));
+    let drag = window.use_keyed_state("scrollbar-thumb-drag", cx, |_, _| {
+        Option::<(Pixels, Pixels)>::None
+    });
+    let dragging = drag.read(cx).is_some();
+
+    let alpha = match (&autohide_state, autohide) {
+        (Some(state), true) => state.alpha(cx, dragging),
+        _ => 1.0,
+    };
+
     let track = bounds.size.height - inset * 2.0;
     let (thumb_length, thumb_top) = thumb_geometry(
         bounds.size.height,
@@ -177,16 +310,27 @@ fn paint_scrollbar(handle: &ScrollHandle, window: &mut Window, cx: &mut App) {
         ),
     );
 
-    window.paint_quad(fill(thumb_bounds, color).corner_radii(width / 2.0));
+    if let Some(color) = thumb_style(color, alpha) {
+        window.paint_quad(fill(thumb_bounds, color).corner_radii(width / 2.0));
+    }
 
-    let drag = window.use_keyed_state("scrollbar-thumb-drag", cx, |_, _| {
-        Option::<(Pixels, Pixels)>::None
-    });
+    if let Some(state) = &autohide_state {
+        window.on_mouse_event({
+            let state = state.clone();
+            move |event: &ScrollEvent, phase, window, cx| {
+                if phase != DispatchPhase::Bubble || !bounds.contains(&event.position) {
+                    return;
+                }
+                state.touch(window, cx);
+            }
+        });
+    }
 
     window.on_mouse_event({
         let handle = handle.clone();
         let drag = drag.clone();
-        move |event: &MouseDownEvent, phase, _window, cx| {
+        let autohide_state = autohide_state.clone();
+        move |event: &MouseDownEvent, phase, window, cx| {
             if phase != DispatchPhase::Bubble
                 || event.button != gpui::MouseButton::Left
                 || !thumb_bounds.contains(&event.position)
@@ -197,17 +341,53 @@ fn paint_scrollbar(handle: &ScrollHandle, window: &mut Window, cx: &mut App) {
             drag.update(cx, |drag, _| {
                 *drag = Some((event.position.y, handle.offset().y));
             });
+
+            if let Some(state) = &autohide_state {
+                state.touch(window, cx);
+            }
+
             cx.stop_propagation();
         }
     });
 
+    window.on_mouse_event({
+        let drag = drag.clone();
+        let autohide_state = autohide_state.clone();
+        move |event: &MouseUpEvent, phase, window, cx| {
+            if phase != DispatchPhase::Bubble || event.button != gpui::MouseButton::Left {
+                return;
+            }
+
+            if drag.read(cx).is_none() {
+                return;
+            }
+
+            drag.update(cx, |drag, _| {
+                *drag = None;
+            });
+
+            if let Some(state) = &autohide_state {
+                state.touch(window, cx);
+            }
+        }
+    });
+
     window.on_mouse_event({
         let handle = handle.clone();
         let drag = drag.clone();
-        move |event: &MouseMoveEvent, phase, _window, cx| {
-            if phase != DispatchPhase::Bubble
-                || event.pressed_button != Some(gpui::MouseButton::Left)
+        let autohide_state = autohide_state.clone();
+        move |event: &MouseMoveEvent, phase, window, cx| {
+            if phase != DispatchPhase::Bubble {
+                return;
+            }
+
+            if let Some(state) = &autohide_state
+                && drag.read(cx).is_some()
             {
+                state.touch(window, cx);
+            }
+
+            if event.pressed_button != Some(gpui::MouseButton::Left) {
                 return;
             }
 
@@ -220,6 +400,7 @@ fn paint_scrollbar(handle: &ScrollHandle, window: &mut Window, cx: &mut App) {
                 let offset = (start_offset - (event.position.y - start_y) * scale)
                     .clamp(-max_offset, Pixels::ZERO);
                 handle.set_offset(point(handle.offset().x, offset));
+                cx.notify(view);
             }
         }
     });

crates/core/src/scrollbar.rs

@@ -0,0 +1,394 @@
+//! Overlay scrollbars for scroll surfaces, including gpui's virtualized
+//! `uniform_list` and `list`. Render the scrollbar as a later child of a
+//! `.relative()` container around the scrolled surface:
+//!
+//! ```
+//! div().relative()
+//!     .child(uniform_list(...).track_scroll(&handle))
+//!     .child(Scrollbar::vertical(handle))
+//! ```
+
+use std::rc::Rc;
+
+use gpui::{
+    App, Bounds, DispatchPhase, IntoElement, ListState, MouseButton, MouseDownEvent,
+    MouseMoveEvent, MouseUpEvent, Pixels, Point, RenderOnce, ScrollEvent, ScrollHandle,
+    Styled as _, UniformListScrollHandle, Window, canvas, fill, point,
+};
+use gpui_native_theme::ActiveTheme as _;
+
+use crate::scroll_area::{Autohide, thumb_geometry, thumb_style};
+
+/// Re-exported so callers only need the scrollbar module.
+pub use crate::scroll_area::ScrollbarVisibility;
+
+/// The scroll state a scrollbar drives, implemented for gpui's scroll handles.
+pub trait ScrollbarHandle: 'static {
+    /// How far the content can scroll, positive along each axis.
+    fn max_offset(&self) -> Point<Pixels>;
+    /// The current offset, non-positive along each axis.
+    fn offset(&self) -> Point<Pixels>;
+    /// Applies the offset along one axis, keeping the other.
+    fn set_offset(&self, offset: Point<Pixels>);
+    /// The bounds of the scrolled surface.
+    fn viewport(&self) -> Bounds<Pixels>;
+    /// A thumb drag began.
+    fn drag_started(&self) {}
+    /// A thumb drag ended.
+    fn drag_ended(&self) {}
+}
+
+impl ScrollbarHandle for ScrollHandle {
+    fn max_offset(&self) -> Point<Pixels> {
+        ScrollHandle::max_offset(self)
+    }
+
+    fn offset(&self) -> Point<Pixels> {
+        ScrollHandle::offset(self)
+    }
+
+    fn set_offset(&self, offset: Point<Pixels>) {
+        ScrollHandle::set_offset(self, offset);
+    }
+
+    fn viewport(&self) -> Bounds<Pixels> {
+        self.bounds()
+    }
+}
+
+impl ScrollbarHandle for UniformListScrollHandle {
+    fn max_offset(&self) -> Point<Pixels> {
+        self.0.borrow().base_handle.max_offset()
+    }
+
+    fn offset(&self) -> Point<Pixels> {
+        self.0.borrow().base_handle.offset()
+    }
+
+    fn set_offset(&self, offset: Point<Pixels>) {
+        self.0.borrow().base_handle.set_offset(offset);
+    }
+
+    fn viewport(&self) -> Bounds<Pixels> {
+        self.0.borrow().base_handle.bounds()
+    }
+}
+
+impl ScrollbarHandle for ListState {
+    fn max_offset(&self) -> Point<Pixels> {
+        ListState::max_offset_for_scrollbar(self)
+    }
+
+    fn offset(&self) -> Point<Pixels> {
+        ListState::scroll_px_offset_for_scrollbar(self)
+    }
+
+    fn set_offset(&self, offset: Point<Pixels>) {
+        ListState::set_offset_from_scrollbar(self, offset);
+    }
+
+    fn viewport(&self) -> Bounds<Pixels> {
+        self.viewport_bounds()
+    }
+
+    fn drag_started(&self) {
+        ListState::scrollbar_drag_started(self);
+    }
+
+    fn drag_ended(&self) {
+        ListState::scrollbar_drag_ended(self);
+    }
+}
+
+/// Which direction the scrollbar lies along.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum Axis {
+    Vertical,
+    Horizontal,
+}
+
+impl Axis {
+    fn along(self, position: Point<Pixels>) -> Pixels {
+        match self {
+            Axis::Vertical => position.y,
+            Axis::Horizontal => position.x,
+        }
+    }
+
+    fn with_along(self, position: Point<Pixels>, along: Pixels) -> Point<Pixels> {
+        match self {
+            Axis::Vertical => point(position.x, along),
+            Axis::Horizontal => point(along, position.y),
+        }
+    }
+
+    fn viewport_along(self, viewport: &Bounds<Pixels>) -> Pixels {
+        match self {
+            Axis::Vertical => viewport.size.height,
+            Axis::Horizontal => viewport.size.width,
+        }
+    }
+}
+
+/// An overlay scrollbar; the caller renders it over the scrolled surface.
+#[derive(IntoElement)]
+pub struct Scrollbar {
+    axis: Axis,
+    handle: Rc<dyn ScrollbarHandle>,
+    visibility: ScrollbarVisibility,
+}
+
+impl Scrollbar {
+    /// A vertical scrollbar driven by `handle`.
+    pub fn vertical<H>(handle: H) -> Self
+    where
+        H: ScrollbarHandle,
+    {
+        Self {
+            axis: Axis::Vertical,
+            handle: Rc::new(handle),
+            visibility: ScrollbarVisibility::default(),
+        }
+    }
+
+    /// A horizontal scrollbar driven by `handle`.
+    pub fn horizontal<H>(handle: H) -> Self
+    where
+        H: ScrollbarHandle,
+    {
+        Self {
+            axis: Axis::Horizontal,
+            handle: Rc::new(handle),
+            visibility: ScrollbarVisibility::default(),
+        }
+    }
+
+    /// Overrides when the scrollbar shows, instead of the platform default.
+    pub fn visibility(mut self, visibility: ScrollbarVisibility) -> Self {
+        self.visibility = visibility;
+        self
+    }
+}
+
+impl RenderOnce for Scrollbar {
+    fn render(self, _window: &mut Window, _cx: &mut App) -> impl IntoElement {
+        canvas(|_, _, _| {}, {
+            let handle = self.handle;
+            let axis = self.axis;
+            let visibility = self.visibility;
+            move |_, _, window, cx| paint_scrollbar(&handle, axis, visibility, window, cx)
+        })
+        .absolute()
+        .inset_0()
+    }
+}
+
+/// The drag state shared between the scrollbar's mouse handlers.
+type Drag = Option<(Pixels, Pixels)>;
+
+fn paint_scrollbar(
+    handle: &Rc<dyn ScrollbarHandle>,
+    axis: Axis,
+    visibility: ScrollbarVisibility,
+    window: &mut Window,
+    cx: &mut App,
+) {
+    let view = window.current_view();
+    let theme = cx.theme();
+
+    let color = theme.colors.scrollbar_thumb;
+    let width = theme.scrollbar.width;
+    let inset = theme.scrollbar.inset;
+    let min_thumb = theme.scrollbar.min_thumb;
+
+    let viewport = handle.viewport();
+    let viewport_along = axis.viewport_along(&viewport);
+    let max_offset = axis.along(handle.max_offset());
+
+    if max_offset <= Pixels::ZERO || viewport_along <= Pixels::ZERO {
+        return;
+    }
+
+    let autohide = match visibility {
+        ScrollbarVisibility::Platform => theme.scrollbar.autohide,
+        ScrollbarVisibility::Always => false,
+        ScrollbarVisibility::Autohide => true,
+    };
+    let autohide_state = autohide.then(|| Autohide::new(window, cx));
+
+    let track_length = viewport_along - inset * 2.0;
+
+    let (thumb_length, thumb_travel) = thumb_geometry(
+        viewport_along,
+        viewport_along + max_offset,
+        axis.along(handle.offset()),
+        track_length,
+        min_thumb,
+    );
+
+    // The track strip is the thumb's rail plus the padding the thumb rides inside.
+    let (thumb_bounds, track_bounds) = match axis {
+        Axis::Vertical => {
+            let thumb_x = viewport.right() - width - inset;
+            (
+                Bounds::from_corners(
+                    point(thumb_x, viewport.top() + inset + thumb_travel),
+                    point(
+                        thumb_x + width,
+                        viewport.top() + inset + thumb_travel + thumb_length,
+                    ),
+                ),
+                Bounds::from_corners(
+                    point(viewport.right() - width, viewport.top() + inset),
+                    point(viewport.right(), viewport.top() + inset + track_length),
+                ),
+            )
+        }
+        Axis::Horizontal => {
+            let thumb_y = viewport.bottom() - width - inset;
+            (
+                Bounds::from_corners(
+                    point(viewport.left() + inset + thumb_travel, thumb_y),
+                    point(
+                        viewport.left() + inset + thumb_travel + thumb_length,
+                        thumb_y + width,
+                    ),
+                ),
+                Bounds::from_corners(
+                    point(viewport.left() + inset, viewport.bottom() - width),
+                    point(viewport.left() + inset + track_length, viewport.bottom()),
+                ),
+            )
+        }
+    };
+
+    let drag = window.use_keyed_state("scrollbar-thumb-drag", cx, |_, _| Drag::None);
+    let dragging = drag.read(cx).is_some();
+
+    let alpha = match &autohide_state {
+        Some(state) => state.alpha(cx, dragging),
+        None => 1.0,
+    };
+
+    if let Some(color) = thumb_style(color, alpha) {
+        window.paint_quad(fill(thumb_bounds, color).corner_radii(width / 2.0));
+    }
+
+    if let Some(state) = &autohide_state {
+        window.on_mouse_event({
+            let state = state.clone();
+            move |event: &ScrollEvent, phase, window, cx| {
+                if phase != DispatchPhase::Bubble || !viewport.contains(&event.position) {
+                    return;
+                }
+                state.touch(window, cx);
+            }
+        });
+    }
+
+    window.on_mouse_event({
+        let handle = handle.clone();
+        let drag = drag.clone();
+        let autohide_state = autohide_state.clone();
+        move |event: &MouseDownEvent, phase, window, cx| {
+            if phase != DispatchPhase::Bubble || event.button != MouseButton::Left {
+                return;
+            }
+
+            let in_thumb = thumb_bounds.contains(&event.position);
+            let in_track = !in_thumb && track_bounds.contains(&event.position);
+
+            if !in_thumb && !in_track {
+                return;
+            }
+
+            let start_offset = if in_thumb {
+                axis.along(handle.offset())
+            } else if track_length > thumb_length {
+                let thumb_start = ((axis.along(event.position) - axis.along(track_bounds.origin))
+                    - thumb_length / 2.0)
+                    .clamp(Pixels::ZERO, track_length - thumb_length);
+                let offset = -(thumb_start / (track_length - thumb_length)) * max_offset;
+                handle.set_offset(axis.with_along(handle.offset(), offset));
+                cx.notify(view);
+                offset
+            } else {
+                return;
+            };
+
+            drag.update(cx, |drag, _| {
+                *drag = Some((axis.along(event.position), start_offset));
+            });
+            handle.drag_started();
+
+            if let Some(state) = &autohide_state {
+                state.touch(window, cx);
+            }
+
+            cx.stop_propagation();
+        }
+    });
+
+    window.on_mouse_event({
+        let handle = handle.clone();
+        let drag = drag.clone();
+        let autohide_state = autohide_state.clone();
+        move |event: &MouseMoveEvent, phase, window, cx| {
+            if phase != DispatchPhase::Bubble {
+                return;
+            }
+
+            if let Some(state) = &autohide_state
+                && track_bounds.contains(&event.position)
+                && drag.read(cx).is_none()
+            {
+                state.touch(window, cx);
+            }
+
+            if event.pressed_button != Some(MouseButton::Left) {
+                return;
+            }
+
+            let Some((start_position, start_offset)) = *drag.read(cx) else {
+                return;
+            };
+
+            if track_length <= thumb_length {
+                return;
+            }
+
+            let scale = max_offset / (track_length - thumb_length);
+            let offset = (start_offset - (axis.along(event.position) - start_position) * scale)
+                .clamp(-max_offset, Pixels::ZERO);
+            handle.set_offset(axis.with_along(handle.offset(), offset));
+            cx.notify(view);
+        }
+    });
+
+    window.on_mouse_event({
+        let handle = handle.clone();
+        let drag = drag.clone();
+        let autohide_state = autohide_state.clone();
+        move |event: &MouseUpEvent, phase, window, cx| {
+            if phase != DispatchPhase::Bubble || event.button != MouseButton::Left {
+                return;
+            }
+
+            if drag.read(cx).is_none() {
+                return;
+            }
+
+            drag.update(cx, |drag, _| {
+                *drag = None;
+            });
+            handle.drag_ended();
+
+            // Unfreezing a ListState's height can change the thumb's geometry.
+            cx.notify(view);
+
+            if let Some(state) = &autohide_state {
+                state.touch(window, cx);
+            }
+        }
+    });
+}