Struct UniformListScrollHandle 

pub struct UniformListScrollHandle(pub Rc<RefCell<UniformListScrollState>>);

A handle that reads and sets the scroll position of a UniformList.

Store it on your view, and pass it to UniformList::track_scroll when you build the list each frame. Clones share the same state.

Scroll requests (scroll_to_*) take effect during the next prepaint, not immediately. A request does nothing until a list tracks the handle.

Tuple Fields

0: Rc<RefCell<UniformListScrollState>>

Implementations

impl UniformListScrollHandle

pub fn new() -> Self

Creates a handle that isn’t attached to a list yet.

Pass it to UniformList::track_scroll when you build the list.

pub fn scroll_to_item(&self, ix: usize, strategy: ScrollStrategy)

Scrolls the least amount that brings row ix fully into view, placed by strategy.

This is non-strict: a row that is already fully visible doesn’t move the list, so ScrollStrategy::Top does nothing for a visible row. Use Self::scroll_to_item_strict to place the row every time. The scroll takes effect on the next prepaint.

Examples

struct Rows {
    scroll: UniformListScrollHandle,
}

impl Render for Rows {
    fn render(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
        div().h(px(320.)).child(
            uniform_list("rows", 100, |range, _window, _cx| {
                range
                    .map(|ix| div().id(ix).h(px(32.)).child(format!("Row {ix}")))
                    .collect::<Vec<_>>()
            })
            .track_scroll(&self.scroll)
            .size_full(),
        )
    }
}
window.update(|rows, _, _| rows.scroll.scroll_to_item(3, ScrollStrategy::Top));
window.draw();
// Row 3 is already in the 320px viewport, so the list didn't move.
window.read(|rows, _| assert_eq!(rows.scroll.0.borrow().base_handle.offset().y, px(0.)));

window.update(|rows, _, _| rows.scroll.scroll_to_item_strict(3, ScrollStrategy::Top));
window.draw();
// The strict form puts row 3 at the top: 3 rows of 32px scrolled past.
window.read(|rows, _| assert_eq!(rows.scroll.0.borrow().base_handle.offset().y, px(-96.)));

pub fn scroll_to_item_strict(&self, ix: usize, strategy: ScrollStrategy)

Places row ix where strategy says, even when the row is already visible.

Unlike Self::scroll_to_item, this forces the requested placement when the strategy supports one. With ScrollStrategy::Nearest, a visible row still doesn’t move. Use it when a row must land at a fixed position, such as the top after a keyboard jump. The scroll takes effect on the next prepaint; see Self::scroll_to_item for an example.

pub fn scroll_to_item_with_offset( &self, ix: usize, strategy: ScrollStrategy, offset: usize, )

Scrolls like Self::scroll_to_item, and keeps offset rows clear at the top of the viewport.

offset shrinks the viewport by that many rows from the top, and strategy places the row in what remains:

• ScrollStrategy::Top puts the row just below the cleared rows.
• ScrollStrategy::Center centers the row in the rows below the cleared rows.
• ScrollStrategy::Bottom places the row at the bottom of the viewport. offset affects only whether the row counts as already visible, not where it lands.

This is non-strict, so a row that is visible below the cleared rows doesn’t move the list.

pub fn scroll_to_item_strict_with_offset( &self, ix: usize, strategy: ScrollStrategy, offset: usize, )

Places row ix like Self::scroll_to_item_with_offset, even when the row is already visible.

The offset rules are the same as for Self::scroll_to_item_with_offset.

pub fn y_flipped(&self) -> bool

Returns whether item 0 is at the bottom of the list, as set by UniformList::y_flipped on the last frame.

pub fn logical_scroll_top_index(&self) -> usize

Returns the index of the first visible row.

If a scroll request is pending, this returns the row that request targets instead, so the value is right after a request and one frame later. It is zero before the first prepaint.

Only available with the test-support feature, or in GPUI’s own tests.

pub fn is_scrollable(&self) -> bool

Returns whether the rows are taller than the viewport, as of the last prepaint.

Returns false before the first prepaint.

pub fn is_scrolled_to_end(&self) -> Option<bool>

Returns whether the list shows its last row, or None if the list isn’t scrollable.

None is also returned before the first prepaint.

pub fn scroll_to_bottom(&self)

Scrolls to the last row, as a request for the next prepaint.

Trait Implementations

impl Clone for UniformListScrollHandle

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for UniformListScrollHandle

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for UniformListScrollHandle

fn default() -> Self

Returns the “default value” for a type.