Expose content size to ScrollHandle State for scrollbars

[Serophots]

Problem Statement

In order to implement a scrollbar UI component (as far as I can tell) it is necessary to perform a duplicate computation to find the content size of the scrollable area (the full top to bottom scrollable content size). This computation has already been done by GPUI in the case of Div scrolling and I'm sure for List and Uniform List scrolling too, so I think it would be sensible and less error-prone to reuse the content size that has already been calculated by GPUI.

A scrollbar UI component needs the content size to know how far down the page the offset is as a ratio for positioning the scrollbar thumb.

Zed's scrollbar

zed/crates/ui/src/components/scrollbar.rs

Lines 67 to 89 in 7eb226b

	impl ScrollableHandle for ScrollHandle {
	fn content_size(&self) -> Option<ContentSize> {
	let last_children_index = self.children_count().checked_sub(1)?;
	let mut last_item = self.bounds_for_item(last_children_index)?;
	let mut scroll_adjustment = None;
	if last_children_index != 0 {
	// todo: PO: this is slightly wrong for horizontal scrollbar, as the last item is not necessarily the longest one.
	let first_item = self.bounds_for_item(0)?;
	last_item.size.height += last_item.origin.y;
	last_item.size.width += last_item.origin.x;
	scroll_adjustment = Some(first_item.origin);
	last_item.size.height -= first_item.origin.y;
	last_item.size.width -= first_item.origin.x;
	}
	Some(ContentSize {
	size: last_item.size,
	scroll_adjustment,
	})
	}

I can see that in Zed's ui crate a content_size trait function is implemented over Div/List/UniformList. This calculation already differs from the one used by GPUI. I think it'd be best to keep this computation in one place (GPUI) and expose the result.

Solution proposal

I propose that some 'content_size' or 'max_scroll_size' property is exposed on ScrollHandleState.

For the div implementation of scrolling this content size is calculated as max_scroll in clamp_scroll_position function inside div.rs which is called every prepaint of Div. I propose that here we check whether there's Some(tracked_focus_handle) and if there is update the property here.

zed/crates/gpui/src/elements/div.rs

Lines 1553 to 1603 in 7eb226b

	fn clamp_scroll_position(
	&self,
	bounds: Bounds<Pixels>,
	style: &Style,
	window: &mut Window,
	_cx: &mut App,
	) -> Point<Pixels> {
	if let Some(scroll_offset) = self.scroll_offset.as_ref() {
	let mut scroll_to_bottom = false;
	if let Some(scroll_handle) = &self.tracked_scroll_handle {
	let mut state = scroll_handle.0.borrow_mut();
	state.overflow = style.overflow;
	scroll_to_bottom = mem::take(&mut state.scroll_to_bottom);
	}
	let rem_size = window.rem_size();
	let padding_size = size(
	style
	.padding
	.left
	.to_pixels(bounds.size.width.into(), rem_size)
	+ style
	.padding
	.right
	.to_pixels(bounds.size.width.into(), rem_size),
	style
	.padding
	.top
	.to_pixels(bounds.size.height.into(), rem_size)
	+ style
	.padding
	.bottom
	.to_pixels(bounds.size.height.into(), rem_size),
	);
	let scroll_max = (self.content_size + padding_size - bounds.size).max(&Size::default());
	// Clamp scroll offset in case scroll max is smaller now (e.g., if children
	// were removed or the bounds became larger).
	let mut scroll_offset = scroll_offset.borrow_mut();
	scroll_offset.x = scroll_offset.x.clamp(-scroll_max.width, px(0.));
	if scroll_to_bottom {
	scroll_offset.y = -scroll_max.height;
	} else {
	scroll_offset.y = scroll_offset.y.clamp(-scroll_max.height, px(0.));
	}
	*scroll_offset
	} else {
	Point::default()
	}
	}

I'm not sure whether its best to expose the scroll_max variable or just the content_size variable since content_size would likely cater to a larger class of problems in which scrolling content size wants to be known. On the other hand scroll_max is directly what is used to clamp the scrolling, so perfectly suits the particular use case of scrollbars. Perhaps both?

Building on an existing pattern

zed/crates/gpui/src/elements/div.rs

Lines 1271 to 1282 in 7eb226b

	} else if let Some(scroll_handle) = self.interactivity.tracked_scroll_handle.as_ref() {
	let mut state = scroll_handle.0.borrow_mut();
	state.child_bounds = Vec::with_capacity(request_layout.child_layout_ids.len());
	state.bounds = bounds;
	for child_layout_id in &request_layout.child_layout_ids {
	let child_bounds = window.layout_bounds(*child_layout_id);
	child_min = child_min.min(&child_bounds.origin);
	child_max = child_max.max(&child_bounds.bottom_right());
	state.child_bounds.push(child_bounds);
	}
	(child_max - child_min).into()
	} else {

I can see that Div's prepaint already updates some properties on ScrollHandleState so the pattern of exposing certain properties in this way already exists in the codebase.

I'm fairly sure I can see what must be done in the case of Div scrolling for my proposed solution and am happy to open a PR for this, but I have not yet looked into how List and UniformList work.