854 lines
32 KiB
Rust
854 lines
32 KiB
Rust
//! A scrollable list of elements with uniform height, optimized for large lists.
|
|
//! Rather than use the full taffy layout system, uniform_list simply measures
|
|
//! the first element and then lays out all remaining elements in a line based on that
|
|
//! measurement. This is much faster than the full layout system, but only works for
|
|
//! elements with uniform height.
|
|
|
|
use crate::{
|
|
AnyElement, App, AvailableSpace, Bounds, ContentMask, Element, ElementId, Entity,
|
|
GlobalElementId, Hitbox, InspectorElementId, InteractiveElement, Interactivity, IntoElement,
|
|
IsZero, LayoutId, ListSizingBehavior, Overflow, Pixels, Point, ScrollHandle, Size,
|
|
StyleRefinement, Styled, Window, point, size,
|
|
};
|
|
use smallvec::SmallVec;
|
|
use std::{cell::RefCell, cmp, ops::Range, rc::Rc, usize};
|
|
|
|
use super::ListHorizontalSizingBehavior;
|
|
|
|
/// uniform_list provides lazy rendering for a set of items that are of uniform height.
|
|
/// When rendered into a container with overflow-y: hidden and a fixed (or max) height,
|
|
/// uniform_list will only render the visible subset of items.
|
|
#[track_caller]
|
|
pub fn uniform_list<R>(
|
|
id: impl Into<ElementId>,
|
|
item_count: usize,
|
|
f: impl 'static + Fn(Range<usize>, &mut Window, &mut App) -> Vec<R>,
|
|
) -> UniformList
|
|
where
|
|
R: IntoElement,
|
|
{
|
|
let id = id.into();
|
|
let mut base_style = StyleRefinement::default();
|
|
base_style.overflow.y = Some(Overflow::Scroll);
|
|
|
|
let render_range = move |range: Range<usize>, window: &mut Window, cx: &mut App| {
|
|
f(range, window, cx)
|
|
.into_iter()
|
|
.map(|component| component.into_any_element())
|
|
.collect()
|
|
};
|
|
|
|
UniformList {
|
|
item_count,
|
|
item_to_measure_index: 0,
|
|
render_items: Box::new(render_range),
|
|
decorations: Vec::new(),
|
|
interactivity: Interactivity {
|
|
element_id: Some(id),
|
|
base_style: Box::new(base_style),
|
|
..Interactivity::new()
|
|
},
|
|
scroll_handle: None,
|
|
sizing_behavior: ListSizingBehavior::default(),
|
|
horizontal_sizing_behavior: ListHorizontalSizingBehavior::default(),
|
|
}
|
|
}
|
|
|
|
/// A list element for efficiently laying out and displaying a list of uniform-height elements.
|
|
pub struct UniformList {
|
|
item_count: usize,
|
|
item_to_measure_index: usize,
|
|
render_items: Box<
|
|
dyn for<'a> Fn(Range<usize>, &'a mut Window, &'a mut App) -> SmallVec<[AnyElement; 64]>,
|
|
>,
|
|
decorations: Vec<Box<dyn UniformListDecoration>>,
|
|
interactivity: Interactivity,
|
|
scroll_handle: Option<UniformListScrollHandle>,
|
|
sizing_behavior: ListSizingBehavior,
|
|
horizontal_sizing_behavior: ListHorizontalSizingBehavior,
|
|
}
|
|
|
|
/// Frame state used by the [UniformList].
|
|
pub struct UniformListFrameState {
|
|
items: SmallVec<[AnyElement; 32]>,
|
|
decorations: SmallVec<[AnyElement; 2]>,
|
|
}
|
|
|
|
/// A handle for controlling the scroll position of a uniform list.
|
|
/// This should be stored in your view and passed to the uniform_list on each frame.
|
|
#[derive(Clone, Debug, Default)]
|
|
pub struct UniformListScrollHandle(pub Rc<RefCell<UniformListScrollState>>);
|
|
|
|
/// Where to place the element scrolled to.
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
|
pub enum ScrollStrategy {
|
|
/// Place the element at the top of the list's viewport.
|
|
Top,
|
|
/// Attempt to place the element in the middle of the list's viewport.
|
|
/// May not be possible if there's not enough list items above the item scrolled to:
|
|
/// in this case, the element will be placed at the closest possible position.
|
|
Center,
|
|
/// Attempt to place the element at the bottom of the list's viewport.
|
|
/// May not be possible if there's not enough list items above the item scrolled to:
|
|
/// in this case, the element will be placed at the closest possible position.
|
|
Bottom,
|
|
/// If the element is not visible attempt to place it at:
|
|
/// - The top of the list's viewport if the target element is above currently visible elements.
|
|
/// - The bottom of the list's viewport if the target element is above currently visible elements.
|
|
Nearest,
|
|
}
|
|
|
|
#[derive(Clone, Copy, Debug)]
|
|
#[allow(missing_docs)]
|
|
pub struct DeferredScrollToItem {
|
|
/// The item index to scroll to
|
|
pub item_index: usize,
|
|
/// The scroll strategy to use
|
|
pub strategy: ScrollStrategy,
|
|
/// The offset in number of items
|
|
pub offset: usize,
|
|
pub scroll_strict: bool,
|
|
}
|
|
|
|
#[derive(Clone, Debug, Default)]
|
|
#[allow(missing_docs)]
|
|
pub struct UniformListScrollState {
|
|
pub base_handle: ScrollHandle,
|
|
pub deferred_scroll_to_item: Option<DeferredScrollToItem>,
|
|
/// Size of the item, captured during last layout.
|
|
pub last_item_size: Option<ItemSize>,
|
|
/// Whether the list was vertically flipped during last layout.
|
|
pub y_flipped: bool,
|
|
}
|
|
|
|
#[derive(Copy, Clone, Debug, Default)]
|
|
/// The size of the item and its contents.
|
|
pub struct ItemSize {
|
|
/// The size of the item.
|
|
pub item: Size<Pixels>,
|
|
/// The size of the item's contents, which may be larger than the item itself,
|
|
/// if the item was bounded by a parent element.
|
|
pub contents: Size<Pixels>,
|
|
}
|
|
|
|
impl UniformListScrollHandle {
|
|
/// Create a new scroll handle to bind to a uniform list.
|
|
pub fn new() -> Self {
|
|
Self(Rc::new(RefCell::new(UniformListScrollState {
|
|
base_handle: ScrollHandle::new(),
|
|
deferred_scroll_to_item: None,
|
|
last_item_size: None,
|
|
y_flipped: false,
|
|
})))
|
|
}
|
|
|
|
/// Scroll the list so that the given item index is visible.
|
|
///
|
|
/// This uses non-strict scrolling: if the item is already fully visible, no scrolling occurs.
|
|
/// If the item is out of view, it scrolls the minimum amount to bring it into view according
|
|
/// to the strategy.
|
|
pub fn scroll_to_item(&self, ix: usize, strategy: ScrollStrategy) {
|
|
self.0.borrow_mut().deferred_scroll_to_item = Some(DeferredScrollToItem {
|
|
item_index: ix,
|
|
strategy,
|
|
offset: 0,
|
|
scroll_strict: false,
|
|
});
|
|
}
|
|
|
|
/// Scroll the list so that the given item index is at scroll strategy position.
|
|
///
|
|
/// This uses strict scrolling: the item will always be scrolled to match the strategy position,
|
|
/// even if it's already visible. Use this when you need precise positioning.
|
|
pub fn scroll_to_item_strict(&self, ix: usize, strategy: ScrollStrategy) {
|
|
self.0.borrow_mut().deferred_scroll_to_item = Some(DeferredScrollToItem {
|
|
item_index: ix,
|
|
strategy,
|
|
offset: 0,
|
|
scroll_strict: true,
|
|
});
|
|
}
|
|
|
|
/// Scroll the list to the given item index with an offset in number of items.
|
|
///
|
|
/// This uses non-strict scrolling: if the item is already visible within the offset region,
|
|
/// no scrolling occurs.
|
|
///
|
|
/// The offset parameter shrinks the effective viewport by the specified number of items
|
|
/// from the corresponding edge, then applies the scroll strategy within that reduced viewport:
|
|
/// - `ScrollStrategy::Top`: Shrinks from top, positions item at the new top
|
|
/// - `ScrollStrategy::Center`: Shrinks from top, centers item in the reduced viewport
|
|
/// - `ScrollStrategy::Bottom`: Shrinks from bottom, positions item at the new bottom
|
|
pub fn scroll_to_item_with_offset(&self, ix: usize, strategy: ScrollStrategy, offset: usize) {
|
|
self.0.borrow_mut().deferred_scroll_to_item = Some(DeferredScrollToItem {
|
|
item_index: ix,
|
|
strategy,
|
|
offset,
|
|
scroll_strict: false,
|
|
});
|
|
}
|
|
|
|
/// Scroll the list so that the given item index is at the exact scroll strategy position with an offset.
|
|
///
|
|
/// This uses strict scrolling: the item will always be scrolled to match the strategy position,
|
|
/// even if it's already visible.
|
|
///
|
|
/// The offset parameter shrinks the effective viewport by the specified number of items
|
|
/// from the corresponding edge, then applies the scroll strategy within that reduced viewport:
|
|
/// - `ScrollStrategy::Top`: Shrinks from top, positions item at the new top
|
|
/// - `ScrollStrategy::Center`: Shrinks from top, centers item in the reduced viewport
|
|
/// - `ScrollStrategy::Bottom`: Shrinks from bottom, positions item at the new bottom
|
|
pub fn scroll_to_item_strict_with_offset(
|
|
&self,
|
|
ix: usize,
|
|
strategy: ScrollStrategy,
|
|
offset: usize,
|
|
) {
|
|
self.0.borrow_mut().deferred_scroll_to_item = Some(DeferredScrollToItem {
|
|
item_index: ix,
|
|
strategy,
|
|
offset,
|
|
scroll_strict: true,
|
|
});
|
|
}
|
|
|
|
/// Check if the list is flipped vertically.
|
|
pub fn y_flipped(&self) -> bool {
|
|
self.0.borrow().y_flipped
|
|
}
|
|
|
|
/// Get the index of the topmost visible child.
|
|
#[cfg(any(test, feature = "test-support"))]
|
|
pub fn logical_scroll_top_index(&self) -> usize {
|
|
let this = self.0.borrow();
|
|
this.deferred_scroll_to_item
|
|
.as_ref()
|
|
.map(|deferred| deferred.item_index)
|
|
.unwrap_or_else(|| this.base_handle.logical_scroll_top().0)
|
|
}
|
|
|
|
/// Checks if the list can be scrolled vertically.
|
|
pub fn is_scrollable(&self) -> bool {
|
|
if let Some(size) = self.0.borrow().last_item_size {
|
|
size.contents.height > size.item.height
|
|
} else {
|
|
false
|
|
}
|
|
}
|
|
|
|
/// Scroll to the bottom of the list.
|
|
pub fn scroll_to_bottom(&self) {
|
|
self.scroll_to_item(usize::MAX, ScrollStrategy::Bottom);
|
|
}
|
|
}
|
|
|
|
impl Styled for UniformList {
|
|
fn style(&mut self) -> &mut StyleRefinement {
|
|
&mut self.interactivity.base_style
|
|
}
|
|
}
|
|
|
|
impl Element for UniformList {
|
|
type RequestLayoutState = UniformListFrameState;
|
|
type PrepaintState = Option<Hitbox>;
|
|
|
|
fn id(&self) -> Option<ElementId> {
|
|
self.interactivity.element_id.clone()
|
|
}
|
|
|
|
fn source_location(&self) -> Option<&'static core::panic::Location<'static>> {
|
|
None
|
|
}
|
|
|
|
fn request_layout(
|
|
&mut self,
|
|
global_id: Option<&GlobalElementId>,
|
|
inspector_id: Option<&InspectorElementId>,
|
|
window: &mut Window,
|
|
cx: &mut App,
|
|
) -> (LayoutId, Self::RequestLayoutState) {
|
|
let max_items = self.item_count;
|
|
let item_size = self.measure_item(None, window, cx);
|
|
let layout_id = self.interactivity.request_layout(
|
|
global_id,
|
|
inspector_id,
|
|
window,
|
|
cx,
|
|
|style, window, cx| match self.sizing_behavior {
|
|
ListSizingBehavior::Infer => {
|
|
window.with_text_style(style.text_style().cloned(), |window| {
|
|
window.request_measured_layout(
|
|
style,
|
|
move |known_dimensions, available_space, _window, _cx| {
|
|
let desired_height = item_size.height * max_items;
|
|
let width = known_dimensions.width.unwrap_or(match available_space
|
|
.width
|
|
{
|
|
AvailableSpace::Definite(x) => x,
|
|
AvailableSpace::MinContent | AvailableSpace::MaxContent => {
|
|
item_size.width
|
|
}
|
|
});
|
|
let height = match available_space.height {
|
|
AvailableSpace::Definite(height) => desired_height.min(height),
|
|
AvailableSpace::MinContent | AvailableSpace::MaxContent => {
|
|
desired_height
|
|
}
|
|
};
|
|
size(width, height)
|
|
},
|
|
)
|
|
})
|
|
}
|
|
ListSizingBehavior::Auto => window
|
|
.with_text_style(style.text_style().cloned(), |window| {
|
|
window.request_layout(style, None, cx)
|
|
}),
|
|
},
|
|
);
|
|
|
|
(
|
|
layout_id,
|
|
UniformListFrameState {
|
|
items: SmallVec::new(),
|
|
decorations: SmallVec::new(),
|
|
},
|
|
)
|
|
}
|
|
|
|
fn prepaint(
|
|
&mut self,
|
|
global_id: Option<&GlobalElementId>,
|
|
inspector_id: Option<&InspectorElementId>,
|
|
bounds: Bounds<Pixels>,
|
|
frame_state: &mut Self::RequestLayoutState,
|
|
window: &mut Window,
|
|
cx: &mut App,
|
|
) -> Option<Hitbox> {
|
|
let style = self
|
|
.interactivity
|
|
.compute_style(global_id, None, window, cx);
|
|
let border = style.border_widths.to_pixels(window.rem_size());
|
|
let padding = style
|
|
.padding
|
|
.to_pixels(bounds.size.into(), window.rem_size());
|
|
|
|
let padded_bounds = Bounds::from_corners(
|
|
bounds.origin + point(border.left + padding.left, border.top + padding.top),
|
|
bounds.bottom_right()
|
|
- point(border.right + padding.right, border.bottom + padding.bottom),
|
|
);
|
|
|
|
let can_scroll_horizontally = matches!(
|
|
self.horizontal_sizing_behavior,
|
|
ListHorizontalSizingBehavior::Unconstrained
|
|
);
|
|
|
|
let longest_item_size = self.measure_item(None, window, cx);
|
|
let content_width = if can_scroll_horizontally {
|
|
padded_bounds.size.width.max(longest_item_size.width)
|
|
} else {
|
|
padded_bounds.size.width
|
|
};
|
|
let content_size = Size {
|
|
width: content_width,
|
|
height: longest_item_size.height * self.item_count,
|
|
};
|
|
|
|
let shared_scroll_offset = self.interactivity.scroll_offset.clone().unwrap();
|
|
let item_height = longest_item_size.height;
|
|
let shared_scroll_to_item = self.scroll_handle.as_mut().and_then(|handle| {
|
|
let mut handle = handle.0.borrow_mut();
|
|
handle.last_item_size = Some(ItemSize {
|
|
item: padded_bounds.size,
|
|
contents: content_size,
|
|
});
|
|
handle.deferred_scroll_to_item.take()
|
|
});
|
|
|
|
self.interactivity.prepaint(
|
|
global_id,
|
|
inspector_id,
|
|
bounds,
|
|
content_size,
|
|
window,
|
|
cx,
|
|
|_style, mut scroll_offset, hitbox, window, cx| {
|
|
let y_flipped = if let Some(scroll_handle) = &self.scroll_handle {
|
|
let scroll_state = scroll_handle.0.borrow();
|
|
scroll_state.y_flipped
|
|
} else {
|
|
false
|
|
};
|
|
|
|
if self.item_count > 0 {
|
|
let content_height = item_height * self.item_count;
|
|
|
|
let is_scrolled_vertically = !scroll_offset.y.is_zero();
|
|
let max_scroll_offset = padded_bounds.size.height - content_height;
|
|
|
|
if is_scrolled_vertically && scroll_offset.y < max_scroll_offset {
|
|
shared_scroll_offset.borrow_mut().y = max_scroll_offset;
|
|
scroll_offset.y = max_scroll_offset;
|
|
}
|
|
|
|
let content_width = content_size.width + padding.left + padding.right;
|
|
let is_scrolled_horizontally =
|
|
can_scroll_horizontally && !scroll_offset.x.is_zero();
|
|
if is_scrolled_horizontally && content_width <= padded_bounds.size.width {
|
|
shared_scroll_offset.borrow_mut().x = Pixels::ZERO;
|
|
scroll_offset.x = Pixels::ZERO;
|
|
}
|
|
|
|
if let Some(DeferredScrollToItem {
|
|
mut item_index,
|
|
mut strategy,
|
|
offset,
|
|
scroll_strict,
|
|
}) = shared_scroll_to_item
|
|
{
|
|
if y_flipped {
|
|
item_index = self.item_count.saturating_sub(item_index + 1);
|
|
}
|
|
let list_height = padded_bounds.size.height;
|
|
let mut updated_scroll_offset = shared_scroll_offset.borrow_mut();
|
|
let item_top = item_height * item_index;
|
|
let item_bottom = item_top + item_height;
|
|
let scroll_top = -updated_scroll_offset.y;
|
|
let offset_pixels = item_height * offset;
|
|
|
|
// is the selected item above/below currently visible items
|
|
let is_above = item_top < scroll_top + offset_pixels;
|
|
let is_below = item_bottom > scroll_top + list_height;
|
|
|
|
if scroll_strict || is_above || is_below {
|
|
if strategy == ScrollStrategy::Nearest {
|
|
if is_above {
|
|
strategy = ScrollStrategy::Top;
|
|
} else if is_below {
|
|
strategy = ScrollStrategy::Bottom;
|
|
}
|
|
}
|
|
|
|
let max_scroll_offset =
|
|
(content_height - list_height).max(Pixels::ZERO);
|
|
match strategy {
|
|
ScrollStrategy::Top => {
|
|
updated_scroll_offset.y = -(item_top - offset_pixels)
|
|
.clamp(Pixels::ZERO, max_scroll_offset);
|
|
}
|
|
ScrollStrategy::Center => {
|
|
let item_center = item_top + item_height / 2.0;
|
|
|
|
let viewport_height = list_height - offset_pixels;
|
|
let viewport_center = offset_pixels + viewport_height / 2.0;
|
|
let target_scroll_top = item_center - viewport_center;
|
|
updated_scroll_offset.y =
|
|
-target_scroll_top.clamp(Pixels::ZERO, max_scroll_offset);
|
|
}
|
|
ScrollStrategy::Bottom => {
|
|
updated_scroll_offset.y = -(item_bottom - list_height)
|
|
.clamp(Pixels::ZERO, max_scroll_offset);
|
|
}
|
|
ScrollStrategy::Nearest => {
|
|
// Nearest, but the item is visible -> no scroll is required
|
|
}
|
|
}
|
|
}
|
|
scroll_offset = *updated_scroll_offset
|
|
}
|
|
|
|
let first_visible_element_ix =
|
|
(-(scroll_offset.y + padding.top) / item_height).floor() as usize;
|
|
let last_visible_element_ix = ((-scroll_offset.y + padded_bounds.size.height)
|
|
/ item_height)
|
|
.ceil() as usize;
|
|
|
|
let visible_range = first_visible_element_ix
|
|
..cmp::min(last_visible_element_ix, self.item_count);
|
|
|
|
let items = if y_flipped {
|
|
let flipped_range = self.item_count.saturating_sub(visible_range.end)
|
|
..self.item_count.saturating_sub(visible_range.start);
|
|
let mut items = (self.render_items)(flipped_range, window, cx);
|
|
items.reverse();
|
|
items
|
|
} else {
|
|
(self.render_items)(visible_range.clone(), window, cx)
|
|
};
|
|
|
|
let content_mask = ContentMask { bounds };
|
|
window.with_content_mask(Some(content_mask), |window| {
|
|
for (mut item, ix) in items.into_iter().zip(visible_range.clone()) {
|
|
let item_origin = padded_bounds.origin
|
|
+ scroll_offset
|
|
+ point(Pixels::ZERO, item_height * ix);
|
|
|
|
let available_width = if can_scroll_horizontally {
|
|
padded_bounds.size.width + scroll_offset.x.abs()
|
|
} else {
|
|
padded_bounds.size.width
|
|
};
|
|
let available_space = size(
|
|
AvailableSpace::Definite(available_width),
|
|
AvailableSpace::Definite(item_height),
|
|
);
|
|
item.layout_as_root(available_space, window, cx);
|
|
item.prepaint_at(item_origin, window, cx);
|
|
frame_state.items.push(item);
|
|
}
|
|
|
|
let bounds =
|
|
Bounds::new(padded_bounds.origin + scroll_offset, padded_bounds.size);
|
|
for decoration in &self.decorations {
|
|
let mut decoration = decoration.as_ref().compute(
|
|
visible_range.clone(),
|
|
bounds,
|
|
scroll_offset,
|
|
item_height,
|
|
self.item_count,
|
|
window,
|
|
cx,
|
|
);
|
|
let available_space = size(
|
|
AvailableSpace::Definite(bounds.size.width),
|
|
AvailableSpace::Definite(bounds.size.height),
|
|
);
|
|
decoration.layout_as_root(available_space, window, cx);
|
|
decoration.prepaint_at(bounds.origin, window, cx);
|
|
frame_state.decorations.push(decoration);
|
|
}
|
|
});
|
|
}
|
|
|
|
hitbox
|
|
},
|
|
)
|
|
}
|
|
|
|
fn paint(
|
|
&mut self,
|
|
global_id: Option<&GlobalElementId>,
|
|
inspector_id: Option<&InspectorElementId>,
|
|
bounds: Bounds<crate::Pixels>,
|
|
request_layout: &mut Self::RequestLayoutState,
|
|
hitbox: &mut Option<Hitbox>,
|
|
window: &mut Window,
|
|
cx: &mut App,
|
|
) {
|
|
self.interactivity.paint(
|
|
global_id,
|
|
inspector_id,
|
|
bounds,
|
|
hitbox.as_ref(),
|
|
window,
|
|
cx,
|
|
|_, window, cx| {
|
|
for item in &mut request_layout.items {
|
|
item.paint(window, cx);
|
|
}
|
|
for decoration in &mut request_layout.decorations {
|
|
decoration.paint(window, cx);
|
|
}
|
|
},
|
|
)
|
|
}
|
|
}
|
|
|
|
impl IntoElement for UniformList {
|
|
type Element = Self;
|
|
|
|
fn into_element(self) -> Self::Element {
|
|
self
|
|
}
|
|
}
|
|
|
|
/// A decoration for a [`UniformList`]. This can be used for various things,
|
|
/// such as rendering indent guides, or other visual effects.
|
|
pub trait UniformListDecoration {
|
|
/// Compute the decoration element, given the visible range of list items,
|
|
/// the bounds of the list, and the height of each item.
|
|
fn compute(
|
|
&self,
|
|
visible_range: Range<usize>,
|
|
bounds: Bounds<Pixels>,
|
|
scroll_offset: Point<Pixels>,
|
|
item_height: Pixels,
|
|
item_count: usize,
|
|
window: &mut Window,
|
|
cx: &mut App,
|
|
) -> AnyElement;
|
|
}
|
|
|
|
impl<T: UniformListDecoration + 'static> UniformListDecoration for Entity<T> {
|
|
fn compute(
|
|
&self,
|
|
visible_range: Range<usize>,
|
|
bounds: Bounds<Pixels>,
|
|
scroll_offset: Point<Pixels>,
|
|
item_height: Pixels,
|
|
item_count: usize,
|
|
window: &mut Window,
|
|
cx: &mut App,
|
|
) -> AnyElement {
|
|
self.update(cx, |inner, cx| {
|
|
inner.compute(
|
|
visible_range,
|
|
bounds,
|
|
scroll_offset,
|
|
item_height,
|
|
item_count,
|
|
window,
|
|
cx,
|
|
)
|
|
})
|
|
}
|
|
}
|
|
|
|
impl UniformList {
|
|
/// Selects a specific list item for measurement.
|
|
pub fn with_width_from_item(mut self, item_index: Option<usize>) -> Self {
|
|
self.item_to_measure_index = item_index.unwrap_or(0);
|
|
self
|
|
}
|
|
|
|
/// Sets the sizing behavior, similar to the `List` element.
|
|
pub fn with_sizing_behavior(mut self, behavior: ListSizingBehavior) -> Self {
|
|
self.sizing_behavior = behavior;
|
|
self
|
|
}
|
|
|
|
/// Sets the horizontal sizing behavior, controlling the way list items laid out horizontally.
|
|
/// With [`ListHorizontalSizingBehavior::Unconstrained`] behavior, every item and the list itself will
|
|
/// have the size of the widest item and lay out pushing the `end_slot` to the right end.
|
|
pub fn with_horizontal_sizing_behavior(
|
|
mut self,
|
|
behavior: ListHorizontalSizingBehavior,
|
|
) -> Self {
|
|
self.horizontal_sizing_behavior = behavior;
|
|
match behavior {
|
|
ListHorizontalSizingBehavior::FitList => {
|
|
self.interactivity.base_style.overflow.x = None;
|
|
}
|
|
ListHorizontalSizingBehavior::Unconstrained => {
|
|
self.interactivity.base_style.overflow.x = Some(Overflow::Scroll);
|
|
}
|
|
}
|
|
self
|
|
}
|
|
|
|
/// Adds a decoration element to the list.
|
|
pub fn with_decoration(mut self, decoration: impl UniformListDecoration + 'static) -> Self {
|
|
self.decorations.push(Box::new(decoration));
|
|
self
|
|
}
|
|
|
|
fn measure_item(
|
|
&self,
|
|
list_width: Option<Pixels>,
|
|
window: &mut Window,
|
|
cx: &mut App,
|
|
) -> Size<Pixels> {
|
|
if self.item_count == 0 {
|
|
return Size::default();
|
|
}
|
|
|
|
let item_ix = cmp::min(self.item_to_measure_index, self.item_count - 1);
|
|
let mut items = (self.render_items)(item_ix..item_ix + 1, window, cx);
|
|
let Some(mut item_to_measure) = items.pop() else {
|
|
return Size::default();
|
|
};
|
|
let available_space = size(
|
|
list_width.map_or(AvailableSpace::MinContent, |width| {
|
|
AvailableSpace::Definite(width)
|
|
}),
|
|
AvailableSpace::MinContent,
|
|
);
|
|
item_to_measure.layout_as_root(available_space, window, cx)
|
|
}
|
|
|
|
/// Track and render scroll state of this list with reference to the given scroll handle.
|
|
pub fn track_scroll(mut self, handle: &UniformListScrollHandle) -> Self {
|
|
self.interactivity.tracked_scroll_handle = Some(handle.0.borrow().base_handle.clone());
|
|
self.scroll_handle = Some(handle.clone());
|
|
self
|
|
}
|
|
|
|
/// Sets whether the list is flipped vertically, such that item 0 appears at the bottom.
|
|
pub fn y_flipped(mut self, y_flipped: bool) -> Self {
|
|
if let Some(ref scroll_handle) = self.scroll_handle {
|
|
let mut scroll_state = scroll_handle.0.borrow_mut();
|
|
let mut base_handle = &scroll_state.base_handle;
|
|
let offset = base_handle.offset();
|
|
match scroll_state.last_item_size {
|
|
Some(last_size) if scroll_state.y_flipped != y_flipped => {
|
|
let new_y_offset =
|
|
-(offset.y + last_size.contents.height - last_size.item.height);
|
|
base_handle.set_offset(point(offset.x, new_y_offset));
|
|
scroll_state.y_flipped = y_flipped;
|
|
}
|
|
// Handle case where list is initially flipped.
|
|
None if y_flipped => {
|
|
base_handle.set_offset(point(offset.x, Pixels::MIN));
|
|
scroll_state.y_flipped = y_flipped;
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
self
|
|
}
|
|
}
|
|
|
|
impl InteractiveElement for UniformList {
|
|
fn interactivity(&mut self) -> &mut crate::Interactivity {
|
|
&mut self.interactivity
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
use crate::TestAppContext;
|
|
|
|
#[gpui::test]
|
|
fn test_scroll_strategy_nearest(cx: &mut TestAppContext) {
|
|
use crate::{
|
|
Context, FocusHandle, ScrollStrategy, UniformListScrollHandle, Window, div, prelude::*,
|
|
px, uniform_list,
|
|
};
|
|
use std::ops::Range;
|
|
|
|
actions!(example, [SelectNext, SelectPrev]);
|
|
|
|
struct TestView {
|
|
index: usize,
|
|
length: usize,
|
|
scroll_handle: UniformListScrollHandle,
|
|
focus_handle: FocusHandle,
|
|
visible_range: Range<usize>,
|
|
}
|
|
|
|
impl TestView {
|
|
pub fn select_next(
|
|
&mut self,
|
|
_: &SelectNext,
|
|
window: &mut Window,
|
|
_: &mut Context<Self>,
|
|
) {
|
|
if self.index + 1 == self.length {
|
|
self.index = 0
|
|
} else {
|
|
self.index += 1;
|
|
}
|
|
self.scroll_handle
|
|
.scroll_to_item(self.index, ScrollStrategy::Nearest);
|
|
window.refresh();
|
|
}
|
|
|
|
pub fn select_previous(
|
|
&mut self,
|
|
_: &SelectPrev,
|
|
window: &mut Window,
|
|
_: &mut Context<Self>,
|
|
) {
|
|
if self.index == 0 {
|
|
self.index = self.length - 1
|
|
} else {
|
|
self.index -= 1;
|
|
}
|
|
self.scroll_handle
|
|
.scroll_to_item(self.index, ScrollStrategy::Nearest);
|
|
window.refresh();
|
|
}
|
|
}
|
|
|
|
impl Render for TestView {
|
|
fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
|
|
div()
|
|
.id("list-example")
|
|
.track_focus(&self.focus_handle)
|
|
.on_action(cx.listener(Self::select_next))
|
|
.on_action(cx.listener(Self::select_previous))
|
|
.size_full()
|
|
.child(
|
|
uniform_list(
|
|
"entries",
|
|
self.length,
|
|
cx.processor(|this, range: Range<usize>, _window, _cx| {
|
|
this.visible_range = range.clone();
|
|
range
|
|
.map(|ix| div().id(ix).h(px(20.0)).child(format!("Item {ix}")))
|
|
.collect()
|
|
}),
|
|
)
|
|
.track_scroll(&self.scroll_handle)
|
|
.h(px(200.0)),
|
|
)
|
|
}
|
|
}
|
|
|
|
let (view, cx) = cx.add_window_view(|window, cx| {
|
|
let focus_handle = cx.focus_handle();
|
|
window.focus(&focus_handle);
|
|
TestView {
|
|
scroll_handle: UniformListScrollHandle::new(),
|
|
index: 0,
|
|
focus_handle,
|
|
length: 47,
|
|
visible_range: 0..0,
|
|
}
|
|
});
|
|
|
|
// 10 out of 47 items are visible
|
|
|
|
// First 9 times selecting next item does not scroll
|
|
for ix in 1..10 {
|
|
cx.dispatch_action(SelectNext);
|
|
view.read_with(cx, |view, _| {
|
|
assert_eq!(view.index, ix);
|
|
assert_eq!(view.visible_range, 0..10);
|
|
})
|
|
}
|
|
|
|
// Now each time the list scrolls down by 1
|
|
for ix in 10..47 {
|
|
cx.dispatch_action(SelectNext);
|
|
view.read_with(cx, |view, _| {
|
|
assert_eq!(view.index, ix);
|
|
assert_eq!(view.visible_range, ix - 9..ix + 1);
|
|
})
|
|
}
|
|
|
|
// After the last item we move back to the start
|
|
cx.dispatch_action(SelectNext);
|
|
view.read_with(cx, |view, _| {
|
|
assert_eq!(view.index, 0);
|
|
assert_eq!(view.visible_range, 0..10);
|
|
});
|
|
|
|
// Return to the last element
|
|
cx.dispatch_action(SelectPrev);
|
|
view.read_with(cx, |view, _| {
|
|
assert_eq!(view.index, 46);
|
|
assert_eq!(view.visible_range, 37..47);
|
|
});
|
|
|
|
// First 9 times selecting previous does not scroll
|
|
for ix in (37..46).rev() {
|
|
cx.dispatch_action(SelectPrev);
|
|
view.read_with(cx, |view, _| {
|
|
assert_eq!(view.index, ix);
|
|
assert_eq!(view.visible_range, 37..47);
|
|
})
|
|
}
|
|
|
|
// Now each time the list scrolls up by 1
|
|
for ix in (0..37).rev() {
|
|
cx.dispatch_action(SelectPrev);
|
|
view.read_with(cx, |view, _| {
|
|
assert_eq!(view.index, ix);
|
|
assert_eq!(view.visible_range, ix..ix + 10);
|
|
})
|
|
}
|
|
}
|
|
}
|