use crate::binding::Binding;
use crate::draw::inset_rect;
use std::{
cell::{Cell, RefCell},
collections::HashMap,
fmt,
ops::Range,
rc::Rc,
time::Duration,
};
use sui_reactive::Observable;
use web_time::Instant;
use sui_core::{
Color, Event, KeyState, Path, PathBuilder, Point, PointerButton, PointerEventKind, Rect,
SemanticsAction, SemanticsNode, SemanticsRole, SemanticsValue, Size, ToggleState, Transform,
Vector, WidgetId,
};
use sui_layout::{Constraints, Padding as Insets};
use sui_reactive::Signal;
use sui_runtime::{
ArrangeCtx, EventCtx, EventPhase, FrameClock, MeasureCtx, PaintCtx, SemanticsCtx, SingleChild,
Widget, WidgetPodMutVisitor, WidgetPodVisitor,
};
use sui_text::{
FontFeature, FontWeight, TextAlign, TextDocument, TextLayoutRequest, TextMeasurement,
TextStyle, TextWrap,
};
use crate::frame::{draw_control_shape, physical_pixels, snap_to_pixels, stroke_border};
use crate::{
DefaultTheme, ThemeTextToken,
collection::{
CollectionAnchor, CollectionAnchorGravity, CollectionExtentIndex, CollectionWindow,
ScrollAlignment, VirtualViewportSnapshot,
},
containers::{ScrollAxes, ScrollState},
controls::{IconGlyph, draw_icon_glyph},
text_align::{paint_text, vertically_centered_text_rect_y},
};
pub struct ListItem {
label: String,
detail: Option<String>,
semantic_name: Option<String>,
semantic_description: Option<String>,
trailing: Option<String>,
leading_icon: Option<IconGlyph>,
leading_text: Option<String>,
leading_color: Option<Color>,
accent: Option<Color>,
disabled: bool,
activate_with_child: bool,
content: Option<SingleChild>,
}
impl ListItem {
pub fn new(label: impl Into<String>) -> Self {
Self {
label: label.into(),
detail: None,
semantic_name: None,
semantic_description: None,
trailing: None,
leading_icon: None,
leading_text: None,
leading_color: None,
accent: None,
disabled: false,
activate_with_child: false,
content: None,
}
}
pub fn detail(mut self, detail: impl Into<String>) -> Self {
self.detail = Some(detail.into());
self
}
#[deprecated(note = "use `detail`")]
pub fn subtitle(self, subtitle: impl Into<String>) -> Self {
self.detail(subtitle)
}
pub fn semantic_name(mut self, name: impl Into<String>) -> Self {
self.semantic_name = Some(name.into());
self
}
pub fn description(mut self, description: impl Into<String>) -> Self {
self.semantic_description = Some(description.into());
self
}
pub fn trailing(mut self, trailing: impl Into<String>) -> Self {
self.trailing = Some(trailing.into());
self
}
pub fn leading_icon(mut self, icon: IconGlyph) -> Self {
self.leading_icon = Some(icon);
self.leading_text = None;
self
}
pub fn leading_text(mut self, text: impl Into<String>) -> Self {
self.leading_text = Some(text.into());
self.leading_icon = None;
self
}
pub fn leading_color(mut self, color: Color) -> Self {
self.leading_color = Some(color);
self
}
pub fn accent(mut self, accent: Color) -> Self {
self.accent = Some(accent);
self
}
pub fn enabled(mut self, enabled: bool) -> Self {
self.disabled = !enabled;
self
}
#[deprecated(note = "use `enabled(false)`")]
pub fn disabled(self) -> Self {
self.enabled(false)
}
pub fn activate_with_child(mut self, activate_with_child: bool) -> Self {
self.activate_with_child = activate_with_child;
self
}
#[deprecated(note = "use `activate_with_child`")]
pub fn activate_with_content(self) -> Self {
self.activate_with_child(true)
}
pub fn child<W>(mut self, child: W) -> Self
where
W: Widget + 'static,
{
self.content = Some(SingleChild::new(child));
self
}
#[deprecated(note = "use `child`")]
pub fn with_child<W>(self, child: W) -> Self
where
W: Widget + 'static,
{
self.child(child)
}
#[deprecated(note = "use `child`")]
pub fn with_content<W>(self, content: W) -> Self
where
W: Widget + 'static,
{
self.child(content)
}
pub fn label(&self) -> &str {
&self.label
}
pub fn has_child(&self) -> bool {
self.content.is_some()
}
fn can_activate_from_row(&self) -> bool {
!self.disabled && (self.content.is_none() || self.activate_with_child)
}
}
pub struct ListView {
theme: Box<DefaultTheme>,
theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
enabled: Binding<bool>,
name: String,
items: Vec<ListItem>,
selected: Option<usize>,
selected_reader: Option<Box<dyn Fn() -> Option<usize>>>,
hovered: Option<usize>,
pressed: Option<usize>,
hover_motion: IndexedInteractionMotion<usize>,
press_motion: IndexedInteractionMotion<usize>,
focus_animation: AnimatedScalar,
row_height: Option<f32>,
padding: Option<Insets>,
scroll_y: f32,
row_heights: Vec<f32>,
row_offsets: Vec<f32>,
content_height: f32,
on_change: Option<ListViewChange>,
on_change_with_ctx: Option<ListViewContextChange>,
}
impl ListView {
pub fn new(name: impl Into<String>) -> Self {
Self {
theme: Box::new(DefaultTheme::default()),
theme_reader: None,
enabled: Binding::new(true),
name: name.into(),
items: Vec::new(),
selected: None,
selected_reader: None,
hovered: None,
pressed: None,
hover_motion: IndexedInteractionMotion::new(),
press_motion: IndexedInteractionMotion::new(),
focus_animation: AnimatedScalar::new(0.0),
row_height: None,
padding: None,
scroll_y: 0.0,
row_heights: Vec::new(),
row_offsets: Vec::new(),
content_height: 0.0,
on_change: None,
on_change_with_ctx: None,
}
}
pub fn theme(mut self, theme: DefaultTheme) -> Self {
self.theme = Box::new(theme);
self.theme_reader = None;
self
}
pub fn theme_when<F>(mut self, theme: F) -> Self
where
F: Fn() -> DefaultTheme + 'static,
{
self.theme_reader = Some(Box::new(theme));
self
}
pub fn enabled(mut self, enabled: bool) -> Self {
self.enabled.set(enabled);
self
}
pub fn enabled_when<F>(mut self, enabled: F) -> Self
where
F: Fn() -> bool + 'static,
{
self.enabled.set_when(enabled);
self
}
pub fn enabled_from<O>(mut self, enabled: O) -> Self
where
O: Observable<bool> + 'static,
{
self.enabled.set_from(enabled);
self
}
pub fn is_enabled(&self) -> bool {
self.enabled.get()
}
fn paint_theme(&self) -> DefaultTheme {
let theme = self.resolved_theme();
if self.enabled.get() {
theme
} else {
theme.for_disabled_control()
}
}
pub fn item(mut self, item: ListItem) -> Self {
self.items.push(item);
self
}
pub fn items<I>(mut self, items: I) -> Self
where
I: IntoIterator<Item = ListItem>,
{
self.items.extend(items);
self
}
pub fn selected(mut self, selected: impl Into<Option<usize>>) -> Self {
let selected = selected.into();
self.selected = selected;
self.selected_reader = None;
self
}
pub fn selected_when<F>(mut self, selected: F) -> Self
where
F: Fn() -> Option<usize> + 'static,
{
self.selected_reader = Some(Box::new(selected));
self
}
pub fn row_height(mut self, row_height: f32) -> Self {
self.row_height = Some(row_height.max(0.0));
self
}
pub fn padding(mut self, padding: Insets) -> Self {
self.padding = Some(padding);
self
}
pub fn on_change<F>(mut self, on_change: F) -> Self
where
F: FnMut(usize, String) + 'static,
{
self.on_change = Some(Box::new(on_change));
self
}
pub fn on_change_with_ctx<F>(mut self, on_change: F) -> Self
where
F: FnMut(&mut EventCtx, usize, String) + 'static,
{
self.on_change_with_ctx = Some(Box::new(on_change));
self
}
pub fn selected_index(&self) -> Option<usize> {
self.current_selected()
}
fn sync_selected(&mut self) {
if self.selected_reader.is_some() {
self.selected = self.current_selected();
} else if self
.selected
.is_some_and(|selected| selected >= self.items.len())
{
self.selected = None;
}
}
fn current_selected(&self) -> Option<usize> {
self.selected_reader
.as_ref()
.map(|selected| selected())
.unwrap_or(self.selected)
.filter(|index| *index < self.items.len())
}
fn resolved_theme(&self) -> DefaultTheme {
self.theme_reader
.as_ref()
.map(|theme| theme())
.unwrap_or(*self.theme)
}
fn resolved_row_height(&self) -> f32 {
self.row_height
.unwrap_or(self.resolved_theme().metrics.list_row_height)
}
fn viewport_rect(&self, bounds: Rect) -> Rect {
inset_rect(bounds, self.resolved_padding())
}
fn resolved_padding(&self) -> Insets {
self.padding
.unwrap_or(self.resolved_theme().metrics.data_viewport_padding)
}
fn measured_content_height(&self) -> f32 {
if self.row_heights.len() == self.items.len() {
self.content_height
} else {
self.items.len() as f32 * self.resolved_row_height()
}
}
fn clamp_scroll(&self, viewport_height: f32, scroll_y: f32) -> f32 {
let max_scroll = (self.measured_content_height() - viewport_height).max(0.0);
scroll_y.clamp(0.0, max_scroll)
}
fn row_metrics(&self, index: usize) -> Option<(f32, f32)> {
self.row_offsets
.get(index)
.zip(self.row_heights.get(index))
.map(|(offset, height)| (*offset, *height))
.or_else(|| {
(index < self.items.len()).then(|| {
let row_height = self.resolved_row_height();
(index as f32 * row_height, row_height)
})
})
}
fn visible_row_rect(&self, bounds: Rect, index: usize) -> Option<Rect> {
let viewport = self.viewport_rect(bounds);
let (top, row_height) = self.row_metrics(index)?;
let y = viewport.y() + top - self.scroll_y;
Rect::new(viewport.x(), y, viewport.width(), row_height)
.intersection(viewport)
.filter(|rect| !rect.is_empty())
}
fn row_at_position(&self, bounds: Rect, position: Point) -> Option<usize> {
let viewport = self.viewport_rect(bounds);
if !viewport.contains(position) {
return None;
}
let y = position.y - viewport.y() + self.scroll_y;
(0..self.items.len()).find(|index| {
self.row_metrics(*index)
.is_some_and(|(top, height)| y >= top && y < top + height)
})
}
fn ensure_visible(&mut self, viewport_height: f32, index: usize) {
let Some((top, row_height)) = self.row_metrics(index) else {
return;
};
let bottom = top + row_height;
if top < self.scroll_y {
self.scroll_y = top;
} else if bottom > self.scroll_y + viewport_height {
self.scroll_y = bottom - viewport_height;
}
self.scroll_y = self.clamp_scroll(viewport_height, self.scroll_y);
}
fn row_blocks_parent_activation(&self, index: usize) -> bool {
self.items
.get(index)
.is_some_and(|item| item.has_child() && !item.activate_with_child)
}
fn row_activation_waits_for_child_target(&self, index: usize) -> bool {
self.items
.get(index)
.is_some_and(|item| item.has_child() && item.activate_with_child)
}
fn activate(&mut self, index: usize, ctx: &mut EventCtx) {
let Some(item) = self.items.get(index) else {
return;
};
if item.disabled {
return;
}
let label = item.label.clone();
self.selected = Some(index);
if let Some(on_change) = &mut self.on_change {
on_change(index, label.clone());
}
if let Some(on_change) = &mut self.on_change_with_ctx {
on_change(ctx, index, label);
}
}
fn move_selection(&mut self, delta: isize, viewport_height: f32, ctx: &mut EventCtx) {
if self.items.is_empty() {
return;
}
let current = self.selected.unwrap_or(0) as isize;
let next = (current + delta).clamp(0, self.items.len() as isize - 1) as usize;
self.activate(next, ctx);
self.ensure_visible(viewport_height, next);
}
fn set_hovered(&mut self, hovered: Option<usize>, ctx: &mut EventCtx) {
if self.hovered == hovered {
return;
}
self.hovered = hovered;
let theme = self.resolved_theme();
self.hover_motion.set_hover_target(hovered, &theme, ctx);
ctx.request_paint();
ctx.request_semantics();
}
fn set_pressed(&mut self, pressed: Option<usize>, ctx: &mut EventCtx) {
if self.pressed == pressed {
return;
}
self.pressed = pressed;
let theme = self.resolved_theme();
self.press_motion.set_press_target(pressed, &theme, ctx);
ctx.request_paint();
ctx.request_semantics();
}
}
impl Widget for ListView {
fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
if !self.enabled.get() {
if let Event::Pointer(pointer) = event
&& pointer.kind == PointerEventKind::Up
{
ctx.release_pointer_capture(pointer.pointer_id);
}
return;
}
self.sync_selected();
let viewport = self.viewport_rect(ctx.bounds());
match event {
Event::Pointer(pointer) if pointer.kind == PointerEventKind::Move => {
let hovered = self.row_at_position(ctx.bounds(), pointer.position);
self.set_hovered(hovered, ctx);
}
Event::Pointer(pointer)
if pointer.kind == PointerEventKind::Scroll
&& viewport.contains(pointer.position) =>
{
let delta = pointer
.scroll_delta
.map(scroll_delta_to_offset)
.unwrap_or(pointer.delta);
let next = self.clamp_scroll(viewport.height(), self.scroll_y - delta.y);
if (next - self.scroll_y).abs() > f32::EPSILON {
self.scroll_y = next;
ctx.request_arrange();
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
}
Event::Pointer(pointer)
if pointer.kind == PointerEventKind::Down
&& pointer.button == Some(PointerButton::Primary)
&& viewport.contains(pointer.position) =>
{
let row = self.row_at_position(ctx.bounds(), pointer.position);
if row.is_some_and(|index| self.row_blocks_parent_activation(index)) {
return;
}
if ctx.phase() == EventPhase::Capture
&& row.is_some_and(|index| self.row_activation_waits_for_child_target(index))
{
return;
}
self.set_hovered(row, ctx);
self.set_pressed(row, ctx);
ctx.request_focus();
ctx.request_pointer_capture(pointer.pointer_id);
ctx.set_handled();
}
Event::Pointer(pointer)
if pointer.kind == PointerEventKind::Up
&& pointer.button == Some(PointerButton::Primary) =>
{
if self.pressed.is_none() {
return;
}
let hovered = self.row_at_position(ctx.bounds(), pointer.position);
if let Some(index) = self
.pressed
.zip(hovered)
.filter(|(pressed, hovered)| pressed == hovered)
.map(|(index, _)| index)
&& !self.row_blocks_parent_activation(index)
{
self.activate(index, ctx);
}
self.set_hovered(hovered, ctx);
self.set_pressed(None, ctx);
ctx.release_pointer_capture(pointer.pointer_id);
ctx.set_handled();
}
Event::Pointer(pointer) if pointer.kind == PointerEventKind::Leave => {
self.set_hovered(None, ctx);
}
Event::Pointer(pointer) if pointer.kind == PointerEventKind::Cancel => {
if self.pressed.is_some() {
self.set_pressed(None, ctx);
self.set_hovered(None, ctx);
ctx.release_pointer_capture(pointer.pointer_id);
ctx.set_handled();
}
}
Event::Keyboard(key) if ctx.is_focused() && key.state == KeyState::Pressed => {
match key.key.as_str() {
"ArrowUp" => self.move_selection(-1, viewport.height(), ctx),
"ArrowDown" => self.move_selection(1, viewport.height(), ctx),
"Home" => {
if !self.items.is_empty() {
self.activate(0, ctx);
self.ensure_visible(viewport.height(), 0);
}
}
"End" => {
if !self.items.is_empty() {
let last = self.items.len() - 1;
self.activate(last, ctx);
self.ensure_visible(viewport.height(), last);
}
}
"PageUp" => {
let next = self.clamp_scroll(
viewport.height(),
self.scroll_y - viewport.height() * 0.85,
);
if (next - self.scroll_y).abs() > f32::EPSILON {
self.scroll_y = next;
}
}
"PageDown" => {
let next = self.clamp_scroll(
viewport.height(),
self.scroll_y + viewport.height() * 0.85,
);
if (next - self.scroll_y).abs() > f32::EPSILON {
self.scroll_y = next;
}
}
_ => return,
}
ctx.request_arrange();
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
_ => {}
}
}
fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
self.sync_selected();
let theme = self.resolved_theme();
let metrics = theme.metrics;
let text_style = theme.body_text_style();
let detail_style = caption_style(&theme);
let base_row_height = self.resolved_row_height();
let padding = self.resolved_padding();
let child_max_width = if constraints.max.width.is_finite() {
(constraints.max.width
- padding.left
- padding.right
- metrics.data_row_padding.left
- metrics.data_row_padding.right)
.max(0.0)
} else {
260.0
};
let child_constraints =
Constraints::new(Size::ZERO, Size::new(child_max_width, f32::INFINITY));
let explicit_row_height = self.row_height.is_some();
let mut content_width: f32 = 220.0;
let mut content_height = 0.0;
self.row_offsets.clear();
self.row_heights.clear();
for item in &mut self.items {
self.row_offsets.push(content_height);
let (row_width, row_height) = if let Some(content) = &mut item.content {
let content_constraints = if explicit_row_height {
let child_height = (base_row_height
- metrics.data_row_padding.top
- metrics.data_row_padding.bottom)
.max(0.0);
Constraints::new(
Size::new(0.0, child_height),
Size::new(child_max_width, child_height),
)
} else {
child_constraints
};
let child_size = content.measure(ctx, content_constraints);
(
(child_size.width
+ metrics.data_row_padding.left
+ metrics.data_row_padding.right)
.max(220.0),
if explicit_row_height {
base_row_height
} else {
(child_size.height
+ metrics.data_row_padding.top
+ metrics.data_row_padding.bottom)
.max(base_row_height)
},
)
} else {
let label = measure_text_or_estimate(ctx, &item.label, &text_style).width;
let detail = item
.detail
.as_deref()
.map(|detail| measure_text_or_estimate(ctx, detail, &detail_style).width)
.unwrap_or(0.0);
let leading = measure_list_item_leading_width(ctx, item, &text_style, &theme);
let trailing = item
.trailing
.as_deref()
.map(|trailing| measure_text_or_estimate(ctx, trailing, &detail_style).width)
.unwrap_or(0.0);
let trailing_gap = if trailing > 0.0 {
metrics.data_row_trailing_gap
} else {
0.0
};
(
metrics.data_row_padding.left
+ leading
+ label.max(detail)
+ trailing_gap
+ trailing
+ metrics.data_row_padding.right,
if item.detail.is_some() {
detail_row_height(&theme, base_row_height)
} else {
base_row_height
},
)
};
content_width = content_width.max(row_width);
content_height += row_height;
self.row_heights.push(row_height);
}
self.content_height = content_height;
let desired = Size::new(
content_width + padding.left + padding.right,
self.measured_content_height() + padding.top + padding.bottom,
);
let size = constraints.clamp(Size::new(
if constraints.max.width.is_finite() {
constraints.max.width
} else {
desired.width
},
desired.height,
));
self.scroll_y = self.clamp_scroll(
self.viewport_rect(Rect::from_origin_size(Point::ZERO, size))
.height(),
self.scroll_y,
);
size
}
fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
self.sync_selected();
let theme = self.resolved_theme();
let viewport = self.viewport_rect(bounds);
for index in 0..self.items.len() {
let Some((top, row_height)) = self.row_metrics(index) else {
continue;
};
let Some(content) = self.items[index].content.as_mut() else {
continue;
};
let row_y = viewport.y() + top - self.scroll_y;
if row_y + row_height < viewport.y() || row_y > viewport.max_y() {
content.arrange(ctx, Rect::from_origin_size(Point::ZERO, Size::ZERO));
continue;
}
let child_size = content.child().measured_size();
content.arrange(
ctx,
Rect::from_origin_size(
Point::new(
viewport.x() + theme.metrics.data_row_padding.left,
row_y + theme.metrics.data_row_padding.top,
),
Size::new(
(viewport.width()
- theme.metrics.data_row_padding.left
- theme.metrics.data_row_padding.right)
.max(0.0),
child_size.height,
),
),
);
}
}
fn paint(&self, ctx: &mut PaintCtx) {
self.enabled.observe(|source| {
ctx.observe(source);
});
let theme = self.paint_theme();
let palette = theme.palette;
let metrics = theme.metrics;
let viewport = self.viewport_rect(ctx.bounds());
let label_style = theme.body_text_style();
let detail_style = caption_style(&theme);
draw_surface(ctx, ctx.bounds(), &theme, self.focus_animation.get(ctx));
ctx.push_clip_rect(viewport);
for index in 0..self.items.len() {
let Some((top, row_height)) = self.row_metrics(index) else {
continue;
};
let y = viewport.y() + top - self.scroll_y;
if y + row_height < viewport.y() || y > viewport.max_y() {
continue;
}
let row = Rect::new(viewport.x(), y, viewport.width(), row_height);
let selected = self.current_selected() == Some(index);
let hover_amount = self.hover_motion.amount_for(&index, ctx);
let press_amount = self.press_motion.amount_for(&index, ctx);
paint_data_row_state(
ctx,
row,
viewport,
&theme,
selected,
hover_amount,
press_amount,
);
let Some(item) = self.items.get(index) else {
continue;
};
if let Some(accent) = item.accent {
ctx.fill_rect(
Rect::new(row.x() + 4.0, row.y() + 5.0, 3.0, row.height() - 10.0),
accent,
);
}
if let Some(content) = &item.content {
content.paint(ctx);
continue;
}
let mut text_x = row.x() + metrics.data_row_padding.left;
let leading_color = item.leading_color.unwrap_or({
if item.disabled {
palette.placeholder
} else {
palette.text_muted
}
});
if let Some(icon) = item.leading_icon {
let side = metrics
.data_row_icon_size
.min((row.height() - 8.0).max(0.0))
.max(0.0);
let icon_rect = Rect::new(
text_x,
row.y() + ((row.height() - side) * 0.5).max(0.0),
side,
side,
);
draw_icon_glyph(ctx, icon, icon_rect, leading_color);
text_x += side + metrics.data_row_icon_gap;
} else if let Some(leading) = &item.leading_text {
let leading_style = TextStyle {
color: leading_color,
..label_style.clone()
};
let leading_measurement = paint_text_measurement(ctx, leading, &leading_style);
let leading_slot =
Rect::new(text_x, row.y(), leading_measurement.width, row.height());
paint_text(ctx, leading_slot, leading, &leading_style, TextAlign::Start);
text_x += leading_measurement.width + metrics.data_row_icon_gap;
}
let trailing_measurement = item
.trailing
.as_deref()
.map(|trailing| paint_text_measurement(ctx, trailing, &detail_style));
let trailing_width = trailing_measurement
.map(|measurement| (measurement.width + 8.0).min(row.width() * 0.42))
.unwrap_or(0.0);
let trailing_rect = item.trailing.as_ref().map(|_| {
Rect::new(
row.max_x() - metrics.data_row_padding.right - trailing_width,
row.y(),
trailing_width,
row.height(),
)
});
let text_right = trailing_rect
.map(|rect| rect.x() - metrics.data_row_trailing_gap)
.unwrap_or(row.max_x() - metrics.data_row_padding.right);
let text_bounds = Rect::new(
text_x,
row.y(),
(text_right - text_x).max(0.0),
row.height(),
);
let label_measurement = paint_text_measurement(ctx, &item.label, &label_style);
let detail_measurement = item
.detail
.as_deref()
.map(|detail| paint_text_measurement(ctx, detail, &detail_style));
let (label_rect, detail_rect) = row_text_rects(
ctx,
text_bounds,
label_measurement,
label_style.line_height,
detail_measurement,
item.detail.as_ref().map(|_| detail_style.line_height),
);
ctx.push_clip_rect(label_rect);
ctx.draw_text(
label_rect,
item.label.clone(),
if item.disabled {
theme.text_style(palette.placeholder)
} else {
label_style.clone()
},
);
ctx.pop_clip();
if let Some(detail) = &item.detail {
let detail_rect = detail_rect.unwrap_or(text_bounds);
ctx.push_clip_rect(detail_rect);
ctx.draw_text(detail_rect, detail.clone(), detail_style.clone());
ctx.pop_clip();
}
if let (Some(trailing), Some(rect)) = (&item.trailing, trailing_rect) {
let style = detail_style.clone();
ctx.push_clip_rect(rect);
paint_text(ctx, rect, trailing, &style, TextAlign::End);
ctx.pop_clip();
}
}
ctx.pop_clip();
}
fn semantics(&self, ctx: &mut SemanticsCtx) {
self.enabled.observe(|source| {
ctx.observe(source);
});
let enabled = self.enabled.get();
let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::List, ctx.bounds());
node.name = Some(self.name.clone());
node.state.focused = ctx.is_focused();
node.value = self
.current_selected()
.and_then(|index| self.items.get(index))
.map(|item| SemanticsValue::Text(item.label.clone()));
node.actions = vec![SemanticsAction::Focus, SemanticsAction::SetValue];
if !enabled {
node.state.disabled = true;
node.actions.clear();
}
ctx.push(node);
for (index, item) in self.items.iter().enumerate() {
if let Some(bounds) = self.visible_row_rect(ctx.bounds(), index) {
let mut row = SemanticsNode::new(
list_view_row_id(ctx.widget_id(), index),
SemanticsRole::ListItem,
bounds,
);
row.parent = Some(ctx.widget_id());
row.name = Some(
item.semantic_name
.clone()
.unwrap_or_else(|| item.label.clone()),
);
row.description = item
.semantic_description
.clone()
.or_else(|| item.detail.clone());
row.value = Some(SemanticsValue::Text(
item.detail.clone().unwrap_or_else(|| item.label.clone()),
));
row.state.disabled = item.disabled;
row.state.hovered = self.hovered == Some(index);
row.state.selected = self.current_selected() == Some(index);
if item.can_activate_from_row() {
row.actions = vec![SemanticsAction::Activate];
}
if !enabled {
row.state.disabled = true;
row.actions.clear();
}
ctx.push(row);
}
if let Some(content) = &item.content {
content.semantics(ctx);
}
}
}
fn accepts_focus(&self) -> bool {
self.enabled.get()
}
fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
let theme = self.resolved_theme();
set_focus_animation_target(&mut self.focus_animation, focused as u8 as f32, &theme, ctx);
ctx.request_paint();
ctx.request_semantics();
}
fn visit_children(&self, visitor: &mut dyn WidgetPodVisitor) {
for item in &self.items {
if let Some(content) = &item.content {
content.visit_children(visitor);
}
}
}
fn visit_children_mut(&mut self, visitor: &mut dyn WidgetPodMutVisitor) {
for item in &mut self.items {
if let Some(content) = &mut item.content {
content.visit_children_mut(visitor);
}
}
}
}
#[derive(Clone)]
pub struct LayerListItem {
label: String,
detail: Option<String>,
detail_reader: Option<Rc<dyn Fn() -> String>>,
thumbnail: Option<Color>,
visible: bool,
visible_reader: Option<Rc<dyn Fn() -> bool>>,
locked: bool,
locked_reader: Option<Rc<dyn Fn() -> bool>>,
disabled: bool,
}
impl fmt::Debug for LayerListItem {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("LayerListItem")
.field("label", &self.label)
.field("detail", &self.detail)
.field("thumbnail", &self.thumbnail)
.field("visible", &self.visible)
.field("locked", &self.locked)
.field("disabled", &self.disabled)
.finish_non_exhaustive()
}
}
impl PartialEq for LayerListItem {
fn eq(&self, other: &Self) -> bool {
self.label == other.label
&& self.detail == other.detail
&& self.thumbnail == other.thumbnail
&& self.visible == other.visible
&& self.locked == other.locked
&& self.disabled == other.disabled
}
}
impl LayerListItem {
pub fn new(label: impl Into<String>) -> Self {
Self {
label: label.into(),
detail: None,
detail_reader: None,
thumbnail: None,
visible: true,
visible_reader: None,
locked: false,
locked_reader: None,
disabled: false,
}
}
pub fn detail(mut self, detail: impl Into<String>) -> Self {
self.detail = Some(detail.into());
self.detail_reader = None;
self
}
pub fn detail_when<F>(mut self, detail: F) -> Self
where
F: Fn() -> String + 'static,
{
self.detail_reader = Some(Rc::new(detail));
self
}
pub fn thumbnail(mut self, color: Color) -> Self {
self.thumbnail = Some(color);
self
}
pub fn visible(mut self, visible: bool) -> Self {
self.visible = visible;
self.visible_reader = None;
self
}
pub fn visible_when<F>(mut self, visible: F) -> Self
where
F: Fn() -> bool + 'static,
{
self.visible_reader = Some(Rc::new(visible));
self
}
pub fn locked(mut self, locked: bool) -> Self {
self.locked = locked;
self.locked_reader = None;
self
}
pub fn locked_when<F>(mut self, locked: F) -> Self
where
F: Fn() -> bool + 'static,
{
self.locked_reader = Some(Rc::new(locked));
self
}
pub fn enabled(mut self, enabled: bool) -> Self {
self.disabled = !enabled;
self
}
#[deprecated(note = "use `enabled(false)`")]
pub fn disabled(self) -> Self {
self.enabled(false)
}
pub fn label(&self) -> &str {
&self.label
}
fn current_detail(&self) -> Option<String> {
self.detail_reader
.as_ref()
.map(|reader| reader())
.or_else(|| self.detail.clone())
}
fn current_visible(&self) -> bool {
self.visible_reader
.as_ref()
.map(|reader| reader())
.unwrap_or(self.visible)
}
fn current_locked(&self) -> bool {
self.locked_reader
.as_ref()
.map(|reader| reader())
.unwrap_or(self.locked)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum LayerListHit {
Row(usize),
Visibility(usize),
Lock(usize),
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct LayerListReorderChange {
pub item: usize,
pub from: usize,
pub to: usize,
}
#[derive(Debug, Clone, Copy)]
struct LayerListReorderPress {
pointer_id: u64,
start_position: Point,
row: usize,
drag_offset_y: f32,
}
#[derive(Debug, Clone, Copy)]
struct LayerListReorderDrag {
pointer_id: u64,
row: usize,
target: usize,
position: Point,
drag_offset_y: f32,
}
type LayerListReorderCallback = Box<dyn FnMut(&mut EventCtx, LayerListReorderChange)>;
pub struct LayerList {
theme: Box<DefaultTheme>,
theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
enabled: Binding<bool>,
name: String,
layers: Vec<LayerListItem>,
selected: Option<usize>,
selected_reader: Option<Box<dyn Fn() -> Option<usize>>>,
hovered: Option<LayerListHit>,
pressed: Option<LayerListHit>,
reorder_press: Option<LayerListReorderPress>,
reorder_drag: Option<LayerListReorderDrag>,
hover_motion: IndexedInteractionMotion<LayerListHit>,
press_motion: IndexedInteractionMotion<LayerListHit>,
focus_animation: AnimatedScalar,
row_height: Option<f32>,
drag_threshold: f32,
on_select: Option<Box<dyn FnMut(usize, String)>>,
on_select_with_ctx: Option<Box<dyn FnMut(&mut EventCtx, usize, String)>>,
on_visibility_change: Option<Box<dyn FnMut(usize, bool)>>,
on_visibility_change_with_ctx: Option<Box<dyn FnMut(&mut EventCtx, usize, bool)>>,
on_lock_change: Option<Box<dyn FnMut(usize, bool)>>,
on_lock_change_with_ctx: Option<Box<dyn FnMut(&mut EventCtx, usize, bool)>>,
on_reorder: Option<LayerListReorderCallback>,
}
impl LayerList {
pub fn new(name: impl Into<String>) -> Self {
Self {
theme: Box::new(DefaultTheme::default()),
theme_reader: None,
enabled: Binding::new(true),
name: name.into(),
layers: Vec::new(),
selected: None,
selected_reader: None,
hovered: None,
pressed: None,
reorder_press: None,
reorder_drag: None,
hover_motion: IndexedInteractionMotion::new(),
press_motion: IndexedInteractionMotion::new(),
focus_animation: AnimatedScalar::new(0.0),
row_height: None,
drag_threshold: 4.0,
on_select: None,
on_select_with_ctx: None,
on_visibility_change: None,
on_visibility_change_with_ctx: None,
on_lock_change: None,
on_lock_change_with_ctx: None,
on_reorder: None,
}
}
pub fn theme(mut self, theme: DefaultTheme) -> Self {
self.theme = Box::new(theme);
self.theme_reader = None;
self
}
pub fn theme_when<F>(mut self, theme: F) -> Self
where
F: Fn() -> DefaultTheme + 'static,
{
self.theme_reader = Some(Box::new(theme));
self
}
pub fn enabled(mut self, enabled: bool) -> Self {
self.enabled.set(enabled);
self
}
pub fn enabled_when<F>(mut self, enabled: F) -> Self
where
F: Fn() -> bool + 'static,
{
self.enabled.set_when(enabled);
self
}
pub fn enabled_from<O>(mut self, enabled: O) -> Self
where
O: Observable<bool> + 'static,
{
self.enabled.set_from(enabled);
self
}
pub fn is_enabled(&self) -> bool {
self.enabled.get()
}
fn paint_theme(&self) -> DefaultTheme {
let theme = self.resolved_theme();
if self.enabled.get() {
theme
} else {
theme.for_disabled_control()
}
}
pub fn layer(mut self, layer: LayerListItem) -> Self {
self.layers.push(layer);
self
}
pub fn layers<I>(mut self, layers: I) -> Self
where
I: IntoIterator<Item = LayerListItem>,
{
self.layers.extend(layers);
self
}
pub fn selected(mut self, selected: impl Into<Option<usize>>) -> Self {
let selected = selected.into();
self.selected = selected;
self.selected_reader = None;
self
}
pub fn selected_when<F>(mut self, selected: F) -> Self
where
F: Fn() -> Option<usize> + 'static,
{
self.selected_reader = Some(Box::new(selected));
self
}
pub fn row_height(mut self, row_height: f32) -> Self {
self.row_height = Some(row_height.max(0.0));
self
}
pub fn drag_threshold(mut self, threshold: f32) -> Self {
self.drag_threshold = threshold.max(0.0);
self
}
pub fn on_change<F>(mut self, on_change: F) -> Self
where
F: FnMut(usize, String) + 'static,
{
self.on_select = Some(Box::new(on_change));
self
}
pub fn on_change_with_ctx<F>(mut self, on_change: F) -> Self
where
F: FnMut(&mut EventCtx, usize, String) + 'static,
{
self.on_select_with_ctx = Some(Box::new(on_change));
self
}
#[deprecated(note = "use `on_change`")]
pub fn on_select<F>(self, on_select: F) -> Self
where
F: FnMut(usize, String) + 'static,
{
self.on_change(on_select)
}
#[deprecated(note = "use `on_change_with_ctx`")]
pub fn on_select_with_ctx<F>(self, on_select: F) -> Self
where
F: FnMut(&mut EventCtx, usize, String) + 'static,
{
self.on_change_with_ctx(on_select)
}
pub fn on_visibility_change<F>(mut self, on_visibility_change: F) -> Self
where
F: FnMut(usize, bool) + 'static,
{
self.on_visibility_change = Some(Box::new(on_visibility_change));
self
}
pub fn on_visibility_change_with_ctx<F>(mut self, on_visibility_change: F) -> Self
where
F: FnMut(&mut EventCtx, usize, bool) + 'static,
{
self.on_visibility_change_with_ctx = Some(Box::new(on_visibility_change));
self
}
pub fn on_lock_change<F>(mut self, on_lock_change: F) -> Self
where
F: FnMut(usize, bool) + 'static,
{
self.on_lock_change = Some(Box::new(on_lock_change));
self
}
pub fn on_lock_change_with_ctx<F>(mut self, on_lock_change: F) -> Self
where
F: FnMut(&mut EventCtx, usize, bool) + 'static,
{
self.on_lock_change_with_ctx = Some(Box::new(on_lock_change));
self
}
pub fn on_reorder<F>(mut self, on_reorder: F) -> Self
where
F: FnMut(LayerListReorderChange) + 'static,
{
let mut on_reorder = on_reorder;
self.on_reorder = Some(Box::new(move |_, change| on_reorder(change)));
self
}
pub fn on_reorder_with_ctx<F>(mut self, on_reorder: F) -> Self
where
F: FnMut(&mut EventCtx, LayerListReorderChange) + 'static,
{
self.on_reorder = Some(Box::new(on_reorder));
self
}
pub fn selected_index(&self) -> Option<usize> {
self.current_selected()
}
fn sync_selected(&mut self) {
if self.selected_reader.is_some() {
self.selected = self.current_selected();
} else if self
.selected
.is_some_and(|selected| selected >= self.layers.len())
{
self.selected = None;
}
}
fn current_selected(&self) -> Option<usize> {
self.selected_reader
.as_ref()
.map(|selected| selected())
.unwrap_or(self.selected)
.filter(|index| *index < self.layers.len())
}
fn resolved_theme(&self) -> DefaultTheme {
self.theme_reader
.as_ref()
.map(|theme| theme())
.unwrap_or(*self.theme)
}
fn viewport_rect(&self, bounds: Rect) -> Rect {
inset_rect(bounds, self.resolved_theme().metrics.data_viewport_padding)
}
fn resolved_row_height(&self) -> f32 {
let theme = self.resolved_theme();
let base = self.row_height.unwrap_or(theme.metrics.layer_row_height);
if self
.layers
.iter()
.any(|layer| layer.current_detail().is_some())
{
detail_row_height(&theme, base)
} else {
base
}
}
fn row_rect(&self, bounds: Rect, index: usize) -> Option<Rect> {
if index >= self.layers.len() {
return None;
}
let viewport = self.viewport_rect(bounds);
let row_height = self.resolved_row_height();
let y = viewport.y() + index as f32 * row_height;
Rect::new(viewport.x(), y, viewport.width(), row_height)
.intersection(viewport)
.filter(|rect| !rect.is_empty())
}
fn visibility_rect(&self, row: Rect) -> Rect {
let size = self
.resolved_theme()
.metrics
.layer_action_size
.min(row.height())
.max(18.0);
Rect::new(
row.x() + self.resolved_theme().metrics.data_row_padding.left.min(8.0),
row.y() + ((row.height() - size) * 0.5),
size,
size,
)
}
fn thumbnail_rect(&self, row: Rect) -> Rect {
let theme = self.resolved_theme();
let action = self.visibility_rect(row);
let size = theme
.metrics
.layer_thumbnail_size
.min((row.height() - 8.0).max(0.0))
.max(18.0);
Rect::new(
action.max_x() + theme.metrics.data_row_icon_gap,
row.y() + ((row.height() - size) * 0.5),
size,
size,
)
}
fn lock_rect(&self, row: Rect) -> Rect {
let theme = self.resolved_theme();
let size = theme.metrics.layer_action_size.min(row.height()).max(18.0);
Rect::new(
row.max_x() - size - theme.metrics.data_row_padding.right.min(8.0),
row.y() + ((row.height() - size) * 0.5),
size,
size,
)
}
fn text_rect(&self, row: Rect) -> Rect {
let thumb = self.thumbnail_rect(row);
let lock = self.lock_rect(row);
let theme = self.resolved_theme();
Rect::new(
thumb.max_x() + theme.metrics.data_row_icon_gap,
row.y(),
(lock.x() - thumb.max_x() - theme.metrics.data_row_trailing_gap).max(0.0),
row.height(),
)
}
fn hit_at(&self, bounds: Rect, position: Point) -> Option<LayerListHit> {
let viewport = self.viewport_rect(bounds);
if !viewport.contains(position) {
return None;
}
(0..self.layers.len()).find_map(|index| {
let row = self.row_rect(bounds, index)?;
if self.visibility_rect(row).contains(position) {
return Some(LayerListHit::Visibility(index));
}
if self.lock_rect(row).contains(position) {
return Some(LayerListHit::Lock(index));
}
row.contains(position).then_some(LayerListHit::Row(index))
})
}
fn reorder_enabled(&self) -> bool {
self.on_reorder.is_some() && self.layers.len() > 1
}
fn reorder_press_at(
&self,
bounds: Rect,
pointer_id: u64,
position: Point,
) -> Option<LayerListReorderPress> {
if !self.reorder_enabled() {
return None;
}
let LayerListHit::Row(row) = self.hit_at(bounds, position)? else {
return None;
};
let layer = self.layers.get(row)?;
if layer.disabled {
return None;
}
let rect = self.row_rect(bounds, row)?;
Some(LayerListReorderPress {
pointer_id,
start_position: position,
row,
drag_offset_y: position.y - rect.y(),
})
}
fn insertion_index_at(&self, bounds: Rect, position: Point) -> usize {
let viewport = self.viewport_rect(bounds);
let row_height = self.resolved_row_height();
if row_height <= 0.0 {
return 0;
}
let local_y = position.y - viewport.y();
for index in 0..self.layers.len() {
let midpoint = index as f32 * row_height + row_height * 0.5;
if local_y < midpoint {
return index;
}
}
self.layers.len()
}
fn reorder_target_at(&self, bounds: Rect, row: usize, position: Point) -> usize {
if self.layers.is_empty() {
return 0;
}
let insertion = self.insertion_index_at(bounds, position);
let target = if insertion > row {
insertion.saturating_sub(1)
} else {
insertion
};
target.min(self.layers.len().saturating_sub(1))
}
fn start_reorder_drag(
&mut self,
ctx: &mut EventCtx,
press: LayerListReorderPress,
position: Point,
) {
let target = self.reorder_target_at(ctx.bounds(), press.row, position);
self.reorder_drag = Some(LayerListReorderDrag {
pointer_id: press.pointer_id,
row: press.row,
target,
position,
drag_offset_y: press.drag_offset_y,
});
self.pressed = None;
ctx.request_paint();
ctx.request_semantics();
}
fn update_reorder_drag(&mut self, ctx: &mut EventCtx, position: Point) {
let Some(drag) = self.reorder_drag else {
return;
};
let target = self.reorder_target_at(ctx.bounds(), drag.row, position);
self.reorder_drag = Some(LayerListReorderDrag {
target,
position,
..drag
});
ctx.request_paint();
ctx.request_semantics();
}
fn remap_index_after_reorder(index: usize, from: usize, to: usize) -> usize {
if index == from {
to
} else if from < to && index > from && index <= to {
index - 1
} else if to < from && index >= to && index < from {
index + 1
} else {
index
}
}
fn finish_reorder_drag(&mut self, ctx: &mut EventCtx) {
let Some(drag) = self.reorder_drag.take() else {
return;
};
self.reorder_press = None;
self.pressed = None;
let from = drag.row;
let to = drag.target.min(self.layers.len().saturating_sub(1));
if from >= self.layers.len() || from == to {
ctx.request_paint();
ctx.request_semantics();
return;
}
let item = self.layers.remove(from);
self.layers.insert(to, item);
if self.selected_reader.is_none() {
self.selected = self
.selected
.map(|selected| Self::remap_index_after_reorder(selected, from, to));
}
if let Some(callback) = &mut self.on_reorder {
callback(
ctx,
LayerListReorderChange {
item: from,
from,
to,
},
);
}
ctx.request_paint();
ctx.request_semantics();
}
fn cancel_reorder_drag(&mut self, ctx: &mut EventCtx) {
if self.reorder_press.is_some() || self.reorder_drag.is_some() {
self.reorder_press = None;
self.reorder_drag = None;
ctx.request_paint();
ctx.request_semantics();
}
}
fn reorder_marker_y(&self, bounds: Rect) -> Option<f32> {
let drag = self.reorder_drag?;
let target = drag.target.min(self.layers.len().saturating_sub(1));
let row = self.row_rect(bounds, target)?;
if target > drag.row {
Some(row.max_y())
} else {
Some(row.y())
}
}
fn select(&mut self, ctx: &mut EventCtx, index: usize) {
let Some(layer) = self.layers.get(index) else {
return;
};
if layer.disabled {
return;
}
let label = layer.label.clone();
self.selected = Some(index);
if let Some(on_select) = &mut self.on_select {
on_select(index, label.clone());
}
if let Some(on_select) = &mut self.on_select_with_ctx {
on_select(ctx, index, label);
}
}
fn toggle_visibility(&mut self, ctx: &mut EventCtx, index: usize) {
let Some(layer) = self.layers.get_mut(index) else {
return;
};
if layer.disabled {
return;
}
layer.visible = !layer.current_visible();
if let Some(on_visibility_change) = &mut self.on_visibility_change {
on_visibility_change(index, layer.visible);
}
if let Some(on_visibility_change) = &mut self.on_visibility_change_with_ctx {
on_visibility_change(ctx, index, layer.visible);
}
}
fn toggle_lock(&mut self, ctx: &mut EventCtx, index: usize) {
let Some(layer) = self.layers.get_mut(index) else {
return;
};
if layer.disabled {
return;
}
layer.locked = !layer.current_locked();
if let Some(on_lock_change) = &mut self.on_lock_change {
on_lock_change(index, layer.locked);
}
if let Some(on_lock_change) = &mut self.on_lock_change_with_ctx {
on_lock_change(ctx, index, layer.locked);
}
}
fn move_selection(&mut self, ctx: &mut EventCtx, delta: isize) {
if self.layers.is_empty() {
return;
}
let current = self.current_selected().unwrap_or(0) as isize;
let last = self.layers.len() as isize - 1;
self.select(ctx, (current + delta).clamp(0, last) as usize);
}
fn set_hovered(&mut self, hovered: Option<LayerListHit>, ctx: &mut EventCtx) {
if self.hovered == hovered {
return;
}
self.hovered = hovered;
let theme = self.resolved_theme();
self.hover_motion.set_hover_target(hovered, &theme, ctx);
ctx.request_paint();
ctx.request_semantics();
}
fn set_pressed(&mut self, pressed: Option<LayerListHit>, ctx: &mut EventCtx) {
if self.pressed == pressed {
return;
}
self.pressed = pressed;
let theme = self.resolved_theme();
self.press_motion.set_press_target(pressed, &theme, ctx);
ctx.request_paint();
ctx.request_semantics();
}
fn paint_row(
&self,
ctx: &mut PaintCtx,
viewport: Rect,
index: usize,
row: Rect,
theme: &DefaultTheme,
label_style: &TextStyle,
detail_style: &TextStyle,
) {
let Some(layer) = self.layers.get(index) else {
return;
};
let palette = theme.palette;
let visible = layer.current_visible();
let locked = layer.current_locked();
let detail = layer.current_detail();
let selected = self.current_selected() == Some(index);
let row_hit = LayerListHit::Row(index);
let row_hover_amount = self.hover_motion.amount_for(&row_hit, ctx);
let row_press_amount = self.press_motion.amount_for(&row_hit, ctx);
paint_data_row_state(
ctx,
row,
viewport,
theme,
selected,
row_hover_amount,
row_press_amount,
);
let visibility_hit = LayerListHit::Visibility(index);
paint_layer_visibility_button(
ctx,
self.visibility_rect(row),
theme,
visible,
self.hover_motion.amount_for(&visibility_hit, ctx),
self.press_motion.amount_for(&visibility_hit, ctx),
);
let lock_hit = LayerListHit::Lock(index);
paint_layer_lock_button(
ctx,
self.lock_rect(row),
theme,
locked,
self.hover_motion.amount_for(&lock_hit, ctx),
self.press_motion.amount_for(&lock_hit, ctx),
);
paint_layer_thumbnail(
ctx,
self.thumbnail_rect(row),
theme,
layer.thumbnail.unwrap_or(palette.control_hover),
visible,
);
let text_rect = self.text_rect(row);
let label_measurement = paint_text_measurement(ctx, &layer.label, label_style);
let detail_text = detail
.as_deref()
.unwrap_or(if visible { "Visible" } else { "Hidden" });
let detail_measurement = paint_text_measurement(ctx, detail_text, detail_style);
let (label_rect, detail_rect) = row_text_rects(
ctx,
text_rect,
label_measurement,
label_style.line_height,
Some(detail_measurement),
Some(detail_style.line_height),
);
let text_alpha = if visible { 1.0 } else { 0.58 };
ctx.draw_text(
label_rect,
layer.label.clone(),
TextStyle {
color: label_style.color.with_alpha(text_alpha),
..label_style.clone()
},
);
if let Some(detail_rect) = detail_rect {
ctx.draw_text(
detail_rect,
detail_text.to_string(),
TextStyle {
color: detail_style.color.with_alpha(text_alpha),
..detail_style.clone()
},
);
}
}
}
impl Widget for LayerList {
fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
if !self.enabled.get() {
if let Event::Pointer(pointer) = event
&& pointer.kind == PointerEventKind::Up
{
ctx.release_pointer_capture(pointer.pointer_id);
}
return;
}
self.sync_selected();
match event {
Event::Pointer(pointer) if pointer.kind == PointerEventKind::Move => {
if self
.reorder_drag
.is_some_and(|drag| drag.pointer_id == pointer.pointer_id)
{
self.update_reorder_drag(ctx, pointer.position);
ctx.set_handled();
return;
}
if self
.reorder_press
.is_some_and(|press| press.pointer_id == pointer.pointer_id)
{
let press = self.reorder_press.unwrap();
let delta = pointer.position - press.start_position;
let distance_sq = delta.x * delta.x + delta.y * delta.y;
if distance_sq >= self.drag_threshold * self.drag_threshold {
self.start_reorder_drag(ctx, press, pointer.position);
ctx.set_handled();
return;
}
}
let hovered = self.hit_at(ctx.bounds(), pointer.position);
self.set_hovered(hovered, ctx);
}
Event::Pointer(pointer)
if pointer.kind == PointerEventKind::Down
&& pointer.button == Some(PointerButton::Primary) =>
{
let hovered = self.hit_at(ctx.bounds(), pointer.position);
self.set_hovered(hovered, ctx);
self.set_pressed(hovered, ctx);
self.reorder_press =
self.reorder_press_at(ctx.bounds(), pointer.pointer_id, pointer.position);
if self.pressed.is_some() {
ctx.request_focus();
ctx.request_pointer_capture(pointer.pointer_id);
ctx.set_handled();
}
}
Event::Pointer(pointer)
if pointer.kind == PointerEventKind::Up
&& pointer.button == Some(PointerButton::Primary) =>
{
if self
.reorder_drag
.is_some_and(|drag| drag.pointer_id == pointer.pointer_id)
{
self.finish_reorder_drag(ctx);
ctx.release_pointer_capture(pointer.pointer_id);
ctx.set_handled();
return;
}
if self
.reorder_press
.is_some_and(|press| press.pointer_id == pointer.pointer_id)
{
self.reorder_press = None;
}
let hovered = self.hit_at(ctx.bounds(), pointer.position);
if let Some(hit) = self
.pressed
.zip(hovered)
.filter(|(left, right)| left == right)
.map(|(hit, _)| hit)
{
match hit {
LayerListHit::Row(index) => self.select(ctx, index),
LayerListHit::Visibility(index) => self.toggle_visibility(ctx, index),
LayerListHit::Lock(index) => self.toggle_lock(ctx, index),
}
}
self.set_hovered(hovered, ctx);
self.set_pressed(None, ctx);
ctx.release_pointer_capture(pointer.pointer_id);
ctx.set_handled();
}
Event::Pointer(pointer) if pointer.kind == PointerEventKind::Leave => {
self.set_hovered(None, ctx);
}
Event::Pointer(pointer) if pointer.kind == PointerEventKind::Cancel => {
if self
.reorder_drag
.is_some_and(|drag| drag.pointer_id == pointer.pointer_id)
|| self
.reorder_press
.is_some_and(|press| press.pointer_id == pointer.pointer_id)
{
self.cancel_reorder_drag(ctx);
ctx.release_pointer_capture(pointer.pointer_id);
ctx.set_handled();
return;
}
if self.pressed.is_some() {
self.set_pressed(None, ctx);
self.set_hovered(None, ctx);
ctx.release_pointer_capture(pointer.pointer_id);
ctx.set_handled();
}
}
Event::Keyboard(key) if ctx.is_focused() && key.state == KeyState::Pressed => {
match key.key.as_str() {
"ArrowUp" => self.move_selection(ctx, -1),
"ArrowDown" => self.move_selection(ctx, 1),
"Home" => {
if !self.layers.is_empty() {
self.select(ctx, 0);
}
}
"End" => {
if !self.layers.is_empty() {
self.select(ctx, self.layers.len() - 1);
}
}
" " => {
if let Some(index) = self.current_selected() {
self.toggle_visibility(ctx, index);
}
}
"l" | "L" => {
if let Some(index) = self.current_selected() {
self.toggle_lock(ctx, index);
}
}
_ => return,
}
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
_ => {}
}
}
fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
self.sync_selected();
let theme = self.resolved_theme();
let text_style = theme.body_text_style();
let detail_style = caption_style(&theme);
let mut width: f32 = 260.0;
for layer in &self.layers {
let detail_width = layer
.detail
.as_deref()
.map(|detail| measure_text_or_estimate(ctx, detail, &detail_style).width)
.unwrap_or(0.0)
.min(80.0);
width = width.max(
124.0
+ measure_text_or_estimate(ctx, &layer.label, &text_style).width
+ detail_width,
);
}
constraints.clamp(Size::new(
if constraints.max.width.is_finite() {
constraints.max.width
} else {
width + 16.0
},
self.layers.len().max(1) as f32 * self.resolved_row_height()
+ theme.metrics.data_viewport_padding.top
+ theme.metrics.data_viewport_padding.bottom,
))
}
fn paint(&self, ctx: &mut PaintCtx) {
self.enabled.observe(|source| {
ctx.observe(source);
});
let theme = self.paint_theme();
let viewport = self.viewport_rect(ctx.bounds());
let label_style = theme.body_text_style();
let detail_style = caption_style(&theme);
let active_row = self.reorder_drag.map(|drag| drag.row);
draw_surface(ctx, ctx.bounds(), &theme, self.focus_animation.get(ctx));
ctx.push_clip_rect(viewport);
for index in 0..self.layers.len() {
if active_row == Some(index) {
continue;
}
let Some(row) = self.row_rect(ctx.bounds(), index) else {
continue;
};
self.paint_row(
ctx,
viewport,
index,
row,
&theme,
&label_style,
&detail_style,
);
}
if let Some(marker_y) = self.reorder_marker_y(ctx.bounds()) {
let marker = Rect::new(
viewport.x() + 6.0,
(marker_y - 1.0).clamp(viewport.y(), viewport.max_y() - 2.0),
(viewport.width() - 12.0).max(0.0),
2.0,
);
ctx.fill(Path::rounded_rect(marker, 1.0), theme.palette.border_focus);
}
if let Some(drag) = self.reorder_drag
&& let Some(row) = self.row_rect(ctx.bounds(), drag.row)
{
let y = drag.position.y - drag.drag_offset_y;
ctx.push_transform(Transform::translation(0.0, y - row.y()));
self.paint_row(
ctx,
viewport,
drag.row,
row,
&theme,
&label_style,
&detail_style,
);
ctx.pop_transform();
}
ctx.pop_clip();
}
fn semantics(&self, ctx: &mut SemanticsCtx) {
self.enabled.observe(|source| {
ctx.observe(source);
});
let enabled = self.enabled.get();
let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::List, ctx.bounds());
node.name = Some(self.name.clone());
node.state.focused = ctx.is_focused();
node.value = self
.current_selected()
.and_then(|index| self.layers.get(index))
.map(|layer| SemanticsValue::Text(layer.label.clone()));
node.actions = vec![SemanticsAction::Focus, SemanticsAction::SetValue];
if !enabled {
node.state.disabled = true;
node.actions.clear();
}
ctx.push(node);
for (index, layer) in self.layers.iter().enumerate() {
let Some(row) = self.row_rect(ctx.bounds(), index) else {
continue;
};
let visible = layer.current_visible();
let locked = layer.current_locked();
let detail = layer.current_detail();
let row_id = layer_list_row_id(ctx.widget_id(), index);
let mut row_node = SemanticsNode::new(row_id, SemanticsRole::ListItem, row);
row_node.parent = Some(ctx.widget_id());
row_node.name = Some(layer.label.clone());
row_node.description = detail.clone();
row_node.value = Some(SemanticsValue::Text(format!(
"{}; {}; {}",
detail.as_deref().unwrap_or("Layer"),
if visible { "Visible" } else { "Hidden" },
if locked { "Locked" } else { "Unlocked" }
)));
row_node.state.disabled = layer.disabled;
row_node.state.hovered = self.hovered == Some(LayerListHit::Row(index));
row_node.state.selected = self.current_selected() == Some(index);
if !layer.disabled {
row_node.actions = vec![SemanticsAction::Activate];
}
if !enabled {
row_node.state.disabled = true;
row_node.actions.clear();
}
ctx.push(row_node);
let mut visibility = SemanticsNode::new(
layer_list_visibility_id(ctx.widget_id(), index),
SemanticsRole::Button,
self.visibility_rect(row),
);
visibility.parent = Some(row_id);
visibility.name = Some(if visible {
format!("Hide {} layer", layer.label)
} else {
format!("Show {} layer", layer.label)
});
visibility.value = Some(SemanticsValue::Text(if visible {
"Visible".to_string()
} else {
"Hidden".to_string()
}));
visibility.state.disabled = layer.disabled;
visibility.state.hovered = self.hovered == Some(LayerListHit::Visibility(index));
visibility.state.checked = Some(if visible {
ToggleState::Checked
} else {
ToggleState::Unchecked
});
if !layer.disabled {
visibility.actions = vec![SemanticsAction::Activate];
}
if !enabled {
visibility.state.disabled = true;
visibility.actions.clear();
}
ctx.push(visibility);
let mut lock = SemanticsNode::new(
layer_list_lock_id(ctx.widget_id(), index),
SemanticsRole::Button,
self.lock_rect(row),
);
lock.parent = Some(row_id);
lock.name = Some(if locked {
format!("Unlock {} layer", layer.label)
} else {
format!("Lock {} layer", layer.label)
});
lock.value = Some(SemanticsValue::Text(if locked {
"Locked".to_string()
} else {
"Unlocked".to_string()
}));
lock.state.disabled = layer.disabled;
lock.state.hovered = self.hovered == Some(LayerListHit::Lock(index));
lock.state.checked = Some(if locked {
ToggleState::Checked
} else {
ToggleState::Unchecked
});
if !layer.disabled {
lock.actions = vec![SemanticsAction::Activate];
}
if !enabled {
lock.state.disabled = true;
lock.actions.clear();
}
ctx.push(lock);
}
}
fn accepts_focus(&self) -> bool {
self.enabled.get() && (!self.layers.is_empty())
}
fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
let theme = self.resolved_theme();
set_focus_animation_target(&mut self.focus_animation, focused as u8 as f32, &theme, ctx);
ctx.request_paint();
ctx.request_semantics();
}
}
pub struct TreeItem {
key: Option<u64>,
label: String,
detail: Option<String>,
children: Vec<TreeItem>,
expanded: bool,
disabled: bool,
activate_with_content: bool,
content: Option<SingleChild>,
}
impl fmt::Debug for TreeItem {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("TreeItem")
.field("key", &self.key)
.field("label", &self.label)
.field("detail", &self.detail)
.field("children", &self.children)
.field("expanded", &self.expanded)
.field("disabled", &self.disabled)
.field("activate_with_content", &self.activate_with_content)
.field("has_content", &self.content.is_some())
.finish()
}
}
impl TreeItem {
pub fn new(label: impl Into<String>) -> Self {
Self {
key: None,
label: label.into(),
detail: None,
children: Vec::new(),
expanded: false,
disabled: false,
activate_with_content: false,
content: None,
}
}
pub fn key(mut self, key: u64) -> Self {
self.key = Some(key);
self
}
pub fn detail(mut self, detail: impl Into<String>) -> Self {
self.detail = Some(detail.into());
self
}
pub fn expanded(mut self, expanded: bool) -> Self {
self.expanded = expanded;
self
}
pub fn enabled(mut self, enabled: bool) -> Self {
self.disabled = !enabled;
self
}
#[deprecated(note = "use `enabled(false)`")]
pub fn disabled(self) -> Self {
self.enabled(false)
}
pub fn activate_with_child(mut self, activate_with_child: bool) -> Self {
self.activate_with_content = activate_with_child;
self
}
#[deprecated(note = "use `activate_with_child`")]
pub fn activate_with_content(self) -> Self {
self.activate_with_child(true)
}
pub fn child<W>(mut self, content: W) -> Self
where
W: Widget + 'static,
{
self.content = Some(SingleChild::new(content));
self
}
#[deprecated(note = "use `child`")]
pub fn with_content<W>(self, content: W) -> Self
where
W: Widget + 'static,
{
self.child(content)
}
pub fn item(mut self, child: TreeItem) -> Self {
self.children.push(child);
self
}
#[deprecated(note = "use `item`")]
pub fn with_child(self, child: TreeItem) -> Self {
self.item(child)
}
pub fn items<I>(mut self, children: I) -> Self
where
I: IntoIterator<Item = TreeItem>,
{
self.children.extend(children);
self
}
#[deprecated(note = "use `items`")]
pub fn children<I>(self, children: I) -> Self
where
I: IntoIterator<Item = TreeItem>,
{
self.items(children)
}
pub fn label(&self) -> &str {
&self.label
}
pub fn has_content(&self) -> bool {
self.content.is_some()
}
fn can_activate_from_row(&self) -> bool {
!self.disabled && (self.content.is_none() || self.activate_with_content)
}
}
pub struct TreeView {
theme: Box<DefaultTheme>,
theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
enabled: Binding<bool>,
name: String,
items: Vec<TreeItem>,
selected: Option<Vec<usize>>,
hovered: Option<Vec<usize>>,
pressed: Option<Vec<usize>>,
hover_motion: IndexedInteractionMotion<Vec<usize>>,
press_motion: IndexedInteractionMotion<Vec<usize>>,
focus_animation: AnimatedScalar,
row_height: Option<f32>,
padding: Option<Insets>,
scroll_y: f32,
visible_rows: Vec<TreeRow>,
visible_rows_dirty: Cell<bool>,
row_heights: Vec<f32>,
row_offsets: Vec<f32>,
content_height: f32,
on_change: Option<Box<dyn FnMut(Vec<usize>, String)>>,
on_change_with_ctx: Option<Box<dyn FnMut(&mut EventCtx, Vec<usize>, String)>>,
}
impl TreeView {
pub fn new(name: impl Into<String>) -> Self {
Self {
theme: Box::new(DefaultTheme::default()),
theme_reader: None,
enabled: Binding::new(true),
name: name.into(),
items: Vec::new(),
selected: None,
hovered: None,
pressed: None,
hover_motion: IndexedInteractionMotion::new(),
press_motion: IndexedInteractionMotion::new(),
focus_animation: AnimatedScalar::new(0.0),
row_height: None,
padding: None,
scroll_y: 0.0,
visible_rows: Vec::new(),
visible_rows_dirty: Cell::new(true),
row_heights: Vec::new(),
row_offsets: Vec::new(),
content_height: 0.0,
on_change: None,
on_change_with_ctx: None,
}
}
pub fn theme(mut self, theme: DefaultTheme) -> Self {
self.theme = Box::new(theme);
self.theme_reader = None;
self
}
pub fn theme_when<F>(mut self, theme: F) -> Self
where
F: Fn() -> DefaultTheme + 'static,
{
self.theme_reader = Some(Box::new(theme));
self
}
pub fn enabled(mut self, enabled: bool) -> Self {
self.enabled.set(enabled);
self
}
pub fn enabled_when<F>(mut self, enabled: F) -> Self
where
F: Fn() -> bool + 'static,
{
self.enabled.set_when(enabled);
self
}
pub fn enabled_from<O>(mut self, enabled: O) -> Self
where
O: Observable<bool> + 'static,
{
self.enabled.set_from(enabled);
self
}
pub fn is_enabled(&self) -> bool {
self.enabled.get()
}
fn paint_theme(&self) -> DefaultTheme {
let theme = self.resolved_theme();
if self.enabled.get() {
theme
} else {
theme.for_disabled_control()
}
}
pub fn item(mut self, item: TreeItem) -> Self {
self.items.push(item);
self.visible_rows_dirty.set(true);
self
}
pub fn items<I>(mut self, items: I) -> Self
where
I: IntoIterator<Item = TreeItem>,
{
self.items.extend(items);
self.visible_rows_dirty.set(true);
self
}
pub fn row_height(mut self, row_height: f32) -> Self {
self.row_height = Some(row_height.max(0.0));
self
}
pub fn padding(mut self, padding: Insets) -> Self {
self.padding = Some(padding);
self
}
pub fn selected(mut self, index: impl Into<Option<usize>>) -> Self {
self.selected = index.into().map(|index| vec![index]);
self
}
pub fn selected_path(mut self, path: impl IntoIterator<Item = usize>) -> Self {
let path = path.into_iter().collect::<Vec<_>>();
self.selected = (!path.is_empty()).then_some(path);
self
}
pub fn on_change<F>(mut self, on_change: F) -> Self
where
F: FnMut(Vec<usize>, String) + 'static,
{
self.on_change = Some(Box::new(on_change));
self
}
pub fn on_change_with_ctx<F>(mut self, on_change: F) -> Self
where
F: FnMut(&mut EventCtx, Vec<usize>, String) + 'static,
{
self.on_change_with_ctx = Some(Box::new(on_change));
self
}
fn resolved_theme(&self) -> DefaultTheme {
self.theme_reader
.as_ref()
.map(|theme| theme())
.unwrap_or(*self.theme)
}
fn resolved_row_height(&self) -> f32 {
self.row_height
.unwrap_or(self.resolved_theme().metrics.tree_row_height)
}
fn viewport_rect(&self, bounds: Rect) -> Rect {
inset_rect(bounds, self.resolved_padding())
}
fn resolved_padding(&self) -> Insets {
self.padding
.unwrap_or(self.resolved_theme().metrics.data_viewport_padding)
}
fn sync_visible_rows(&mut self) {
if !self.visible_rows_dirty.replace(false) {
return;
}
self.visible_rows.clear();
flatten_tree(&self.items, 0, &mut Vec::new(), &mut self.visible_rows);
self.row_heights.clear();
self.row_offsets.clear();
self.content_height = 0.0;
}
fn measured_content_height(&self) -> f32 {
if self.row_heights.len() == self.visible_rows.len() {
self.content_height
} else {
self.visible_rows.len() as f32 * self.resolved_row_height()
}
}
fn clamp_scroll(&self, viewport_height: f32, scroll_y: f32) -> f32 {
let max_scroll = (self.measured_content_height() - viewport_height).max(0.0);
scroll_y.clamp(0.0, max_scroll)
}
fn row_metrics(&self, index: usize) -> Option<(f32, f32)> {
self.row_offsets
.get(index)
.zip(self.row_heights.get(index))
.map(|(offset, height)| (*offset, *height))
.or_else(|| {
(index < self.visible_rows.len()).then(|| {
let row_height = self.resolved_row_height();
(index as f32 * row_height, row_height)
})
})
}
fn row_at_position(&self, bounds: Rect, position: Point) -> Option<TreeRow> {
let viewport = self.viewport_rect(bounds);
if !viewport.contains(position) {
return None;
}
let y = position.y - viewport.y() + self.scroll_y;
(0..self.visible_rows.len())
.find(|index| {
self.row_metrics(*index)
.is_some_and(|(top, height)| y >= top && y < top + height)
})
.and_then(|index| self.visible_rows.get(index).cloned())
}
fn row_rect(&self, bounds: Rect, index: usize) -> Option<Rect> {
let viewport = self.viewport_rect(bounds);
let (top, height) = self.row_metrics(index)?;
Some(Rect::new(
viewport.x(),
viewport.y() + top - self.scroll_y,
viewport.width(),
height,
))
}
fn position_targets_disclosure(&self, bounds: Rect, position: Point, row: &TreeRow) -> bool {
if !row.has_children {
return false;
}
let Some(index) = self
.visible_rows
.iter()
.position(|candidate| candidate.path == row.path)
else {
return false;
};
self.row_rect(bounds, index).is_some_and(|row_rect| {
disclosure_rect(&self.resolved_theme(), row_rect, row.depth).contains(position)
})
}
fn row_blocks_parent_activation(&self, path: &[usize]) -> bool {
tree_item(&self.items, path)
.is_some_and(|item| item.content.is_some() && !item.activate_with_content)
}
fn row_activation_waits_for_content_target(&self, path: &[usize]) -> bool {
tree_item(&self.items, path)
.is_some_and(|item| item.content.is_some() && item.activate_with_content)
}
fn select_path(&mut self, ctx: &mut EventCtx, path: &[usize]) {
let Some(item) = tree_item(&self.items, path) else {
return;
};
if item.disabled {
return;
}
self.selected = Some(path.to_vec());
if let Some(on_change) = &mut self.on_change {
on_change(path.to_vec(), item.label.clone());
}
if let Some(on_change) = &mut self.on_change_with_ctx {
on_change(ctx, path.to_vec(), item.label.clone());
}
}
fn toggle_path(&mut self, path: &[usize]) -> bool {
let Some(item) = tree_item_mut(&mut self.items, path) else {
return false;
};
if item.children.is_empty() {
return false;
}
item.expanded = !item.expanded;
self.visible_rows_dirty.set(true);
true
}
fn ensure_visible(&mut self, viewport_height: f32, path: &[usize]) {
let Some(index) = self.visible_rows.iter().position(|row| row.path == path) else {
return;
};
let Some((top, row_height)) = self.row_metrics(index) else {
return;
};
let bottom = top + row_height;
if top < self.scroll_y {
self.scroll_y = top;
} else if bottom > self.scroll_y + viewport_height {
self.scroll_y = bottom - viewport_height;
}
self.scroll_y = self.clamp_scroll(viewport_height, self.scroll_y);
}
fn set_hovered(&mut self, hovered: Option<Vec<usize>>, ctx: &mut EventCtx) {
if self.hovered == hovered {
return;
}
self.hovered = hovered.clone();
let theme = self.resolved_theme();
self.hover_motion.set_hover_target(hovered, &theme, ctx);
ctx.request_paint();
ctx.request_semantics();
}
fn set_pressed(&mut self, pressed: Option<Vec<usize>>, ctx: &mut EventCtx) {
if self.pressed == pressed {
return;
}
self.pressed = pressed.clone();
let theme = self.resolved_theme();
self.press_motion.set_press_target(pressed, &theme, ctx);
ctx.request_paint();
ctx.request_semantics();
}
}
impl Widget for TreeView {
fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
if !self.enabled.get() {
if let Event::Pointer(pointer) = event
&& pointer.kind == PointerEventKind::Up
{
ctx.release_pointer_capture(pointer.pointer_id);
}
return;
}
self.sync_visible_rows();
let viewport = self.viewport_rect(ctx.bounds());
match event {
Event::Pointer(pointer) if pointer.kind == PointerEventKind::Move => {
let hovered = self
.row_at_position(ctx.bounds(), pointer.position)
.map(|row| row.path);
self.set_hovered(hovered, ctx);
}
Event::Pointer(pointer)
if pointer.kind == PointerEventKind::Scroll
&& viewport.contains(pointer.position) =>
{
let delta = pointer
.scroll_delta
.map(scroll_delta_to_offset)
.unwrap_or(pointer.delta);
let next = self.clamp_scroll(viewport.height(), self.scroll_y - delta.y);
if (next - self.scroll_y).abs() > f32::EPSILON {
self.scroll_y = next;
ctx.request_arrange();
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
}
Event::Pointer(pointer)
if pointer.kind == PointerEventKind::Down
&& pointer.button == Some(PointerButton::Primary)
&& viewport.contains(pointer.position) =>
{
let pressed_row = self.row_at_position(ctx.bounds(), pointer.position);
let targets_disclosure = pressed_row.as_ref().is_some_and(|row| {
self.position_targets_disclosure(ctx.bounds(), pointer.position, row)
});
if !targets_disclosure
&& pressed_row
.as_ref()
.is_some_and(|row| self.row_blocks_parent_activation(&row.path))
{
return;
}
if ctx.phase() == EventPhase::Capture
&& !targets_disclosure
&& pressed_row
.as_ref()
.is_some_and(|row| self.row_activation_waits_for_content_target(&row.path))
{
return;
}
let pressed = pressed_row.map(|row| row.path);
self.set_hovered(pressed.clone(), ctx);
self.set_pressed(pressed, ctx);
ctx.request_focus();
ctx.request_pointer_capture(pointer.pointer_id);
ctx.set_handled();
}
Event::Pointer(pointer)
if pointer.kind == PointerEventKind::Up
&& pointer.button == Some(PointerButton::Primary) =>
{
if self.pressed.is_none() {
return;
}
let hovered_row = self.row_at_position(ctx.bounds(), pointer.position);
if let Some(row) = hovered_row
.as_ref()
.filter(|row| self.pressed.as_deref() == Some(row.path.as_slice()))
{
if self.position_targets_disclosure(ctx.bounds(), pointer.position, row) {
if self.toggle_path(&row.path) {
ctx.request_measure();
}
} else {
self.select_path(ctx, &row.path);
}
}
self.set_hovered(hovered_row.map(|row| row.path), ctx);
self.set_pressed(None, ctx);
ctx.release_pointer_capture(pointer.pointer_id);
ctx.set_handled();
}
Event::Pointer(pointer) if pointer.kind == PointerEventKind::Leave => {
self.set_hovered(None, ctx);
}
Event::Pointer(pointer) if pointer.kind == PointerEventKind::Cancel => {
if self.pressed.is_some() {
self.set_pressed(None, ctx);
self.set_hovered(None, ctx);
ctx.release_pointer_capture(pointer.pointer_id);
ctx.set_handled();
}
}
Event::Keyboard(key) if ctx.is_focused() && key.state == KeyState::Pressed => {
let rows = self.visible_rows.clone();
if rows.is_empty() {
return;
}
let current = self
.selected
.as_ref()
.and_then(|selected| rows.iter().position(|row| &row.path == selected))
.unwrap_or(0);
match key.key.as_str() {
"ArrowUp" => {
let next = current.saturating_sub(1);
self.select_path(ctx, &rows[next].path);
self.ensure_visible(viewport.height(), &rows[next].path);
}
"ArrowDown" => {
let next = (current + 1).min(rows.len() - 1);
self.select_path(ctx, &rows[next].path);
self.ensure_visible(viewport.height(), &rows[next].path);
}
"ArrowRight" => {
let row = &rows[current];
if row.has_children && !row.expanded {
if self.toggle_path(&row.path) {
ctx.request_measure();
}
} else if row.has_children {
let mut child = row.path.clone();
child.push(0);
self.select_path(ctx, &child);
self.ensure_visible(viewport.height(), &child);
}
}
"ArrowLeft" => {
let row = &rows[current];
if row.has_children && row.expanded {
if self.toggle_path(&row.path) {
ctx.request_measure();
}
} else if !row.path.is_empty() {
let mut parent = row.path.clone();
parent.pop();
self.select_path(ctx, &parent);
self.ensure_visible(viewport.height(), &parent);
}
}
"Home" => {
self.select_path(ctx, &rows[0].path);
self.ensure_visible(viewport.height(), &rows[0].path);
}
"End" => {
let last = rows.len() - 1;
self.select_path(ctx, &rows[last].path);
self.ensure_visible(viewport.height(), &rows[last].path);
}
_ => return,
}
ctx.request_arrange();
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
Event::Semantics(semantics) => {
if semantics.target == ctx.widget_id() {
let delta = match semantics.action {
sui_core::SemanticsActionRequest::Increment => {
Some(viewport.height() * 0.85)
}
sui_core::SemanticsActionRequest::Decrement => {
Some(-viewport.height() * 0.85)
}
_ => None,
};
if let Some(delta) = delta {
let next = self.clamp_scroll(viewport.height(), self.scroll_y + delta);
if (next - self.scroll_y).abs() > f32::EPSILON {
self.scroll_y = next;
ctx.request_arrange();
ctx.request_paint();
ctx.request_semantics();
}
ctx.set_handled();
}
return;
}
let Some(row) = self
.visible_rows
.iter()
.find(|row| tree_view_row_id(ctx.widget_id(), row.key) == semantics.target)
.cloned()
else {
return;
};
match semantics.action {
sui_core::SemanticsActionRequest::Activate
| sui_core::SemanticsActionRequest::Focus => {
self.select_path(ctx, &row.path);
self.ensure_visible(viewport.height(), &row.path);
ctx.request_focus();
ctx.request_arrange();
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
sui_core::SemanticsActionRequest::Expand if !row.expanded => {
if self.toggle_path(&row.path) {
ctx.request_measure();
ctx.request_semantics();
}
ctx.set_handled();
}
sui_core::SemanticsActionRequest::Collapse if row.expanded => {
if self.toggle_path(&row.path) {
ctx.request_measure();
ctx.request_semantics();
}
ctx.set_handled();
}
_ => {}
}
}
_ => {}
}
}
fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
self.sync_visible_rows();
let theme = self.resolved_theme();
let metrics = theme.metrics;
let label_style = theme.body_text_style();
let detail_style = caption_style(&theme);
let base_row_height = self.resolved_row_height();
let padding = self.resolved_padding();
let explicit_row_height = self.row_height.is_some();
let mut content_width: f32 = 220.0;
let mut content_height = 0.0;
self.row_offsets.clear();
self.row_heights.clear();
for index in 0..self.visible_rows.len() {
self.row_offsets.push(content_height);
let row = &self.visible_rows[index];
let path = row.path.clone();
let depth = row.depth;
let detail = row.detail.clone();
let label_start = tree_label_offset(&theme, depth);
let child_max_width = if constraints.max.width.is_finite() {
(constraints.max.width
- padding.left
- padding.right
- label_start
- metrics.data_row_padding.right)
.max(0.0)
} else {
260.0
};
let (row_width, row_height) = if let Some(content) =
tree_item_mut(&mut self.items, &path).and_then(|item| item.content.as_mut())
{
let content_constraints = if explicit_row_height {
let child_height = (base_row_height
- metrics.data_row_padding.top
- metrics.data_row_padding.bottom)
.max(0.0);
Constraints::new(
Size::new(0.0, child_height),
Size::new(child_max_width, child_height),
)
} else {
Constraints::new(Size::ZERO, Size::new(child_max_width, f32::INFINITY))
};
let child_size = content.measure(ctx, content_constraints);
(
label_start + child_size.width + metrics.data_row_padding.right,
if explicit_row_height {
base_row_height
} else {
(child_size.height
+ metrics.data_row_padding.top
+ metrics.data_row_padding.bottom)
.max(base_row_height)
},
)
} else {
let label = measure_text_or_estimate(ctx, &row.label, &label_style).width;
let height = if detail.is_some() {
detail_row_height(&theme, base_row_height)
} else {
base_row_height
};
let detail = detail
.as_deref()
.map(|detail| measure_text_or_estimate(ctx, detail, &detail_style).width)
.unwrap_or(0.0);
(
label_start + label.max(detail) + metrics.data_row_padding.right,
height,
)
};
content_width = content_width.max(row_width);
content_height += row_height;
self.row_heights.push(row_height);
}
self.content_height = content_height;
let desired = Size::new(
content_width + padding.left + padding.right,
self.measured_content_height() + padding.top + padding.bottom,
);
let size = constraints.clamp(Size::new(
if constraints.max.width.is_finite() {
constraints.max.width
} else {
desired.width
},
desired.height,
));
self.scroll_y = self.clamp_scroll(
self.viewport_rect(Rect::from_origin_size(Point::ZERO, size))
.height(),
self.scroll_y,
);
size
}
fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
self.sync_visible_rows();
let theme = self.resolved_theme();
let viewport = self.viewport_rect(bounds);
for index in 0..self.visible_rows.len() {
let Some((top, row_height)) = self.row_metrics(index) else {
continue;
};
let path = self.visible_rows[index].path.clone();
let depth = self.visible_rows[index].depth;
let Some(content) =
tree_item_mut(&mut self.items, &path).and_then(|item| item.content.as_mut())
else {
continue;
};
let row_y = viewport.y() + top - self.scroll_y;
if row_y + row_height < viewport.y() || row_y > viewport.max_y() {
content.arrange(ctx, Rect::from_origin_size(Point::ZERO, Size::ZERO));
continue;
}
let child_size = content.child().measured_size();
let content_x = viewport.x() + tree_label_offset(&theme, depth);
content.arrange(
ctx,
Rect::from_origin_size(
Point::new(content_x, row_y + theme.metrics.data_row_padding.top),
Size::new(
(viewport.max_x() - content_x - theme.metrics.data_row_padding.right)
.max(0.0),
child_size.height,
),
),
);
}
}
fn paint(&self, ctx: &mut PaintCtx) {
self.enabled.observe(|source| {
ctx.observe(source);
});
let theme = self.paint_theme();
let palette = theme.palette;
let viewport = self.viewport_rect(ctx.bounds());
let rows = &self.visible_rows;
draw_surface(ctx, ctx.bounds(), &theme, self.focus_animation.get(ctx));
ctx.push_clip_rect(viewport);
for (index, row) in rows.iter().enumerate() {
let Some((top, row_height)) = self.row_metrics(index) else {
continue;
};
let y = viewport.y() + top - self.scroll_y;
if y + row_height < viewport.y() || y > viewport.max_y() {
continue;
}
let row_rect = Rect::new(viewport.x(), y, viewport.width(), row_height);
let selected = self.selected.as_deref() == Some(row.path.as_slice());
let hover_amount = self
.hover_motion
.amount_for_by(|path| path.as_slice() == row.path.as_slice(), ctx);
let press_amount = self
.press_motion
.amount_for_by(|path| path.as_slice() == row.path.as_slice(), ctx);
paint_data_row_state(
ctx,
row_rect,
viewport,
&theme,
selected,
hover_amount,
press_amount,
);
if row.has_children {
ctx.fill(
disclosure_path(disclosure_rect(&theme, row_rect, row.depth), row.expanded),
if selected {
palette.text_muted
} else {
palette.placeholder
},
);
}
if let Some(content) =
tree_item(&self.items, &row.path).and_then(|item| item.content.as_ref())
{
content.paint(ctx);
continue;
}
let label_x = row_rect.x() + tree_label_offset(&theme, row.depth);
let text_bounds = Rect::new(
label_x,
row_rect.y(),
(row_rect.max_x() - label_x - 8.0).max(0.0),
row_rect.height(),
);
let detail_style = caption_style(&theme);
let label_style = theme.body_text_style();
let label_measurement = paint_text_measurement(ctx, &row.label, &label_style);
let detail_measurement = row
.detail
.as_deref()
.map(|detail| paint_text_measurement(ctx, detail, &detail_style));
let (label_rect, detail_rect) = row_text_rects(
ctx,
text_bounds,
label_measurement,
label_style.line_height,
detail_measurement,
row.detail.as_ref().map(|_| detail_style.line_height),
);
ctx.draw_text(
label_rect,
row.label.clone(),
if row.disabled {
theme.text_style(palette.placeholder)
} else {
label_style
},
);
if let Some(detail) = &row.detail {
ctx.draw_text(
detail_rect.unwrap_or(text_bounds),
detail.clone(),
detail_style,
);
}
}
ctx.pop_clip();
}
fn semantics(&self, ctx: &mut SemanticsCtx) {
self.enabled.observe(|source| {
ctx.observe(source);
});
let enabled = self.enabled.get();
let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::Tree, ctx.bounds());
node.name = Some(self.name.clone());
node.state.focused = ctx.is_focused();
let viewport = self.viewport_rect(ctx.bounds());
let visible_indices = (0..self.visible_rows.len())
.filter(|index| {
self.row_rect(ctx.bounds(), *index)
.is_some_and(|rect| rect.intersection(viewport).is_some())
})
.collect::<Vec<_>>();
let start = visible_indices.first().copied().unwrap_or(0);
let end = visible_indices
.last()
.map(|index| index + 1)
.unwrap_or(start);
node.value = self
.selected
.as_ref()
.and_then(|path| tree_item(&self.items, path))
.map(|item| SemanticsValue::Text(item.label.clone()));
node.description = Some(format!(
"{} visible tree items; showing {} through {}",
self.visible_rows.len(),
start.saturating_add(1).min(self.visible_rows.len()),
end,
));
node.actions = vec![
SemanticsAction::Focus,
SemanticsAction::SetValue,
SemanticsAction::Expand,
SemanticsAction::Collapse,
SemanticsAction::Increment,
SemanticsAction::Decrement,
];
if !enabled {
node.state.disabled = true;
node.actions.clear();
}
ctx.push(node);
for index in visible_indices {
let row = &self.visible_rows[index];
let Some(row_rect) = self
.row_rect(ctx.bounds(), index)
.and_then(|rect| rect.intersection(viewport))
else {
continue;
};
let mut item = SemanticsNode::new(
tree_view_row_id(ctx.widget_id(), row.key),
SemanticsRole::ListItem,
row_rect,
);
item.parent = Some(ctx.widget_id());
item.name = Some(row.label.clone());
item.description = Some(format!(
"Tree item {} of {}, level {}{}",
index + 1,
self.visible_rows.len(),
row.depth + 1,
row.detail
.as_deref()
.map(|detail| format!("; {detail}"))
.unwrap_or_default(),
));
item.state.disabled = row.disabled;
item.state.selected = self.selected.as_deref() == Some(row.path.as_slice());
item.state.expanded = row.has_children.then_some(row.expanded);
let tree_item = tree_item(&self.items, &row.path);
if tree_item.is_some_and(TreeItem::can_activate_from_row) {
item.actions = vec![SemanticsAction::Focus, SemanticsAction::Activate];
}
if !row.disabled && row.has_children {
item.actions.push(if row.expanded {
SemanticsAction::Collapse
} else {
SemanticsAction::Expand
});
}
if !enabled {
item.state.disabled = true;
item.actions.clear();
}
ctx.push(item);
if let Some(content) = tree_item.and_then(|item| item.content.as_ref()) {
content.semantics(ctx);
}
}
}
fn accepts_focus(&self) -> bool {
self.enabled.get()
}
fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
let theme = self.resolved_theme();
set_focus_animation_target(&mut self.focus_animation, focused as u8 as f32, &theme, ctx);
ctx.request_paint();
ctx.request_semantics();
}
fn visit_children(&self, visitor: &mut dyn WidgetPodVisitor) {
for row in &self.visible_rows {
if let Some(content) =
tree_item(&self.items, &row.path).and_then(|item| item.content.as_ref())
{
content.visit_children(visitor);
}
}
}
fn visit_children_mut(&mut self, visitor: &mut dyn WidgetPodMutVisitor) {
let paths = self
.visible_rows
.iter()
.map(|row| row.path.clone())
.collect::<Vec<_>>();
for path in paths {
if let Some(content) =
tree_item_mut(&mut self.items, &path).and_then(|item| item.content.as_mut())
{
content.visit_children_mut(visitor);
}
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TableColumnAlignment {
Start,
Center,
End,
}
impl TableColumnAlignment {
pub const fn text_align(self) -> TextAlign {
match self {
Self::Start => TextAlign::Start,
Self::Center => TextAlign::Center,
Self::End => TextAlign::End,
}
}
}
#[derive(Debug, Clone, PartialEq)]
pub struct TableColumn {
title: String,
width: Option<f32>,
min_width: f32,
alignment: TableColumnAlignment,
numeric: bool,
}
impl TableColumn {
pub fn new(title: impl Into<String>) -> Self {
Self {
title: title.into(),
width: None,
min_width: 96.0,
alignment: TableColumnAlignment::Start,
numeric: false,
}
}
pub fn width(mut self, width: f32) -> Self {
self.width = Some(width.max(40.0));
self
}
pub fn min_width(mut self, min_width: f32) -> Self {
self.min_width = min_width.max(40.0);
self
}
pub fn alignment(mut self, alignment: TableColumnAlignment) -> Self {
self.alignment = alignment;
self
}
pub fn numeric(mut self) -> Self {
self.alignment = TableColumnAlignment::End;
self.numeric = true;
self
}
}
#[derive(Debug, Clone, PartialEq)]
pub struct TableRow {
cells: Vec<String>,
}
impl TableRow {
pub fn new<I, S>(cells: I) -> Self
where
I: IntoIterator<Item = S>,
S: Into<String>,
{
Self {
cells: cells.into_iter().map(Into::into).collect(),
}
}
}
#[deprecated(note = "use `Table`")]
pub type DataGrid = Table;
#[doc(alias = "DataGrid")]
pub struct Table {
theme: Box<DefaultTheme>,
theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
enabled: Binding<bool>,
name: String,
name_reader: Option<Box<dyn Fn() -> String>>,
columns: Vec<TableColumn>,
rows: Vec<TableRow>,
selected: Option<usize>,
selected_reader: Option<Box<dyn Fn() -> Option<usize>>>,
hovered: Option<usize>,
pressed: Option<usize>,
hover_motion: IndexedInteractionMotion<usize>,
press_motion: IndexedInteractionMotion<usize>,
focus_animation: AnimatedScalar,
row_height: Option<f32>,
header_height: Option<f32>,
scroll_y: f32,
column_widths: Vec<f32>,
on_change: Option<Box<dyn FnMut(usize)>>,
on_change_with_ctx: Option<Box<dyn FnMut(&mut EventCtx, usize)>>,
}
impl Table {
pub fn new(name: impl Into<String>) -> Self {
Self {
theme: Box::new(DefaultTheme::default()),
theme_reader: None,
enabled: Binding::new(true),
name: name.into(),
name_reader: None,
columns: Vec::new(),
rows: Vec::new(),
selected: None,
selected_reader: None,
hovered: None,
pressed: None,
hover_motion: IndexedInteractionMotion::new(),
press_motion: IndexedInteractionMotion::new(),
focus_animation: AnimatedScalar::new(0.0),
row_height: None,
header_height: None,
scroll_y: 0.0,
column_widths: Vec::new(),
on_change: None,
on_change_with_ctx: None,
}
}
pub fn theme(mut self, theme: DefaultTheme) -> Self {
self.theme = Box::new(theme);
self.theme_reader = None;
self
}
pub fn theme_when<F>(mut self, theme: F) -> Self
where
F: Fn() -> DefaultTheme + 'static,
{
self.theme_reader = Some(Box::new(theme));
self
}
pub fn enabled(mut self, enabled: bool) -> Self {
self.enabled.set(enabled);
self
}
pub fn enabled_when<F>(mut self, enabled: F) -> Self
where
F: Fn() -> bool + 'static,
{
self.enabled.set_when(enabled);
self
}
pub fn enabled_from<O>(mut self, enabled: O) -> Self
where
O: Observable<bool> + 'static,
{
self.enabled.set_from(enabled);
self
}
pub fn is_enabled(&self) -> bool {
self.enabled.get()
}
fn paint_theme(&self) -> DefaultTheme {
let theme = self.resolved_theme();
if self.enabled.get() {
theme
} else {
theme.for_disabled_control()
}
}
pub fn name_when<F>(mut self, name: F) -> Self
where
F: Fn() -> String + 'static,
{
self.name_reader = Some(Box::new(name));
self
}
pub fn column(mut self, column: TableColumn) -> Self {
self.columns.push(column);
self
}
pub fn columns<I>(mut self, columns: I) -> Self
where
I: IntoIterator<Item = TableColumn>,
{
self.columns.extend(columns);
self
}
pub fn row(mut self, row: TableRow) -> Self {
self.rows.push(row);
self
}
pub fn rows<I>(mut self, rows: I) -> Self
where
I: IntoIterator<Item = TableRow>,
{
self.rows.extend(rows);
self
}
pub fn selected(mut self, selected: impl Into<Option<usize>>) -> Self {
let selected = selected.into();
self.selected = selected;
self.selected_reader = None;
self
}
pub fn selected_when<F>(mut self, selected: F) -> Self
where
F: Fn() -> Option<usize> + 'static,
{
self.selected_reader = Some(Box::new(selected));
self
}
pub fn on_change<F>(mut self, on_change: F) -> Self
where
F: FnMut(usize) + 'static,
{
self.on_change = Some(Box::new(on_change));
self
}
pub fn on_change_with_ctx<F>(mut self, on_change: F) -> Self
where
F: FnMut(&mut EventCtx, usize) + 'static,
{
self.on_change_with_ctx = Some(Box::new(on_change));
self
}
fn resolved_theme(&self) -> DefaultTheme {
self.theme_reader
.as_ref()
.map(|theme| theme())
.unwrap_or(*self.theme)
}
fn name(&self) -> String {
self.name_reader
.as_ref()
.map(|reader| reader())
.unwrap_or_else(|| self.name.clone())
}
fn resolved_row_height(&self) -> f32 {
self.row_height
.unwrap_or(self.resolved_theme().metrics.table_row_height)
}
fn resolved_header_height(&self) -> f32 {
self.header_height
.unwrap_or(self.resolved_theme().metrics.table_header_height)
}
fn body_rect(&self, bounds: Rect) -> Rect {
let theme = self.resolved_theme();
let padding = theme.metrics.data_viewport_padding;
let gap = theme.metrics.select_menu_gap;
let body = Rect::new(
bounds.x() + padding.left,
bounds.y() + padding.top + self.resolved_header_height() + gap,
(bounds.width() - padding.left - padding.right).max(0.0),
(bounds.height() - padding.top - padding.bottom - self.resolved_header_height() - gap)
.max(0.0),
);
let gutter = crate::containers::scroll_bar_gutter(
true,
crate::ScrollAxes::Vertical,
body.size,
Size::new(0.0, self.content_height()),
theme.metrics.scroll_bar_thickness,
);
Rect::from_origin_size(
body.origin,
crate::containers::scroll_viewport_size(body.size, gutter),
)
}
fn content_height(&self) -> f32 {
self.rows.len() as f32 * self.resolved_row_height()
}
fn current_selected(&self) -> Option<usize> {
self.selected_reader
.as_ref()
.map(|selected| selected())
.unwrap_or(self.selected)
.filter(|index| *index < self.rows.len())
}
fn clamp_scroll(&self, viewport_height: f32, scroll_y: f32) -> f32 {
let max_scroll = (self.content_height() - viewport_height).max(0.0);
scroll_y.clamp(0.0, max_scroll)
}
fn row_at_position(&self, bounds: Rect, position: Point) -> Option<usize> {
let body = self.body_rect(bounds);
if !body.contains(position) {
return None;
}
let y = position.y - body.y() + self.scroll_y;
let index = (y / self.resolved_row_height()).floor() as usize;
(index < self.rows.len()).then_some(index)
}
fn resolve_column_widths(&mut self, ctx: &mut MeasureCtx, available_width: f32) {
let theme = self.resolved_theme();
let header_style = theme.text_style(theme.palette.placeholder);
let body_style = theme.body_text_style();
let numeric_style = numeric_text_style(body_style.clone());
self.column_widths = self
.columns
.iter()
.enumerate()
.map(|(index, column)| {
let measured_title =
measure_text_or_estimate(ctx, &column.title, &header_style).width;
let cell_style = if column.numeric {
&numeric_style
} else {
&body_style
};
let measured_cells = self
.rows
.iter()
.filter_map(|row| row.cells.get(index))
.map(|cell| measure_text_or_estimate(ctx, cell, cell_style).width)
.fold(0.0, f32::max);
column.width.unwrap_or(
(measured_title.max(measured_cells) + (theme.metrics.table_cell_padding * 2.0))
.max(column.min_width),
)
})
.collect();
if available_width <= 0.0 || self.column_widths.is_empty() {
return;
}
let total = self.column_widths.iter().sum::<f32>();
if total < available_width {
let extra = (available_width - total) / self.column_widths.len() as f32;
for width in &mut self.column_widths {
*width += extra;
}
}
}
fn activate(&mut self, ctx: &mut EventCtx, index: usize) {
if index >= self.rows.len() {
return;
}
self.selected = Some(index);
if let Some(on_change) = &mut self.on_change {
on_change(index);
}
if let Some(on_change) = &mut self.on_change_with_ctx {
on_change(ctx, index);
}
}
fn set_hovered(&mut self, hovered: Option<usize>, ctx: &mut EventCtx) {
if self.hovered == hovered {
return;
}
self.hovered = hovered;
let theme = self.resolved_theme();
self.hover_motion.set_hover_target(hovered, &theme, ctx);
ctx.request_paint();
ctx.request_semantics();
}
fn set_pressed(&mut self, pressed: Option<usize>, ctx: &mut EventCtx) {
if self.pressed == pressed {
return;
}
self.pressed = pressed;
let theme = self.resolved_theme();
self.press_motion.set_press_target(pressed, &theme, ctx);
ctx.request_paint();
ctx.request_semantics();
}
}
impl Widget for Table {
fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
if !self.enabled.get() {
if let Event::Pointer(pointer) = event
&& pointer.kind == PointerEventKind::Up
{
ctx.release_pointer_capture(pointer.pointer_id);
}
return;
}
let body = self.body_rect(ctx.bounds());
match event {
Event::Pointer(pointer) if pointer.kind == PointerEventKind::Move => {
let hovered = self.row_at_position(ctx.bounds(), pointer.position);
self.set_hovered(hovered, ctx);
}
Event::Pointer(pointer)
if pointer.kind == PointerEventKind::Scroll && body.contains(pointer.position) =>
{
let delta = pointer
.scroll_delta
.map(scroll_delta_to_offset)
.unwrap_or(pointer.delta);
let next = self.clamp_scroll(body.height(), self.scroll_y - delta.y);
if (next - self.scroll_y).abs() > f32::EPSILON {
self.scroll_y = next;
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
}
Event::Pointer(pointer)
if pointer.kind == PointerEventKind::Down
&& pointer.button == Some(PointerButton::Primary)
&& body.contains(pointer.position) =>
{
let pressed = self.row_at_position(ctx.bounds(), pointer.position);
self.set_hovered(pressed, ctx);
self.set_pressed(pressed, ctx);
ctx.request_focus();
ctx.request_pointer_capture(pointer.pointer_id);
ctx.set_handled();
}
Event::Pointer(pointer)
if pointer.kind == PointerEventKind::Up
&& pointer.button == Some(PointerButton::Primary) =>
{
let hovered = self.row_at_position(ctx.bounds(), pointer.position);
if let Some(index) = self
.pressed
.zip(hovered)
.filter(|(pressed, hovered)| pressed == hovered)
.map(|(index, _)| index)
{
self.activate(ctx, index);
}
self.set_hovered(hovered, ctx);
self.set_pressed(None, ctx);
ctx.release_pointer_capture(pointer.pointer_id);
ctx.set_handled();
}
Event::Pointer(pointer) if pointer.kind == PointerEventKind::Leave => {
self.set_hovered(None, ctx);
}
Event::Pointer(pointer) if pointer.kind == PointerEventKind::Cancel => {
if self.pressed.is_some() {
self.set_pressed(None, ctx);
self.set_hovered(None, ctx);
ctx.release_pointer_capture(pointer.pointer_id);
ctx.set_handled();
}
}
Event::Keyboard(key) if ctx.is_focused() && key.state == KeyState::Pressed => {
if self.rows.is_empty() {
return;
}
let current = self.current_selected().unwrap_or(0);
match key.key.as_str() {
"ArrowUp" => self.activate(ctx, current.saturating_sub(1)),
"ArrowDown" => self.activate(ctx, (current + 1).min(self.rows.len() - 1)),
"Home" => self.activate(ctx, 0),
"End" => self.activate(ctx, self.rows.len() - 1),
_ => return,
}
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
_ => {}
}
}
fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
let desired_width = if constraints.max.width.is_finite() {
constraints.max.width
} else {
540.0
};
let theme = self.resolved_theme();
let padding = theme.metrics.data_viewport_padding;
let desired_height = padding.top
+ self.resolved_header_height()
+ theme.metrics.select_menu_gap
+ self.content_height()
+ padding.bottom;
let size = constraints.clamp(Size::new(desired_width, desired_height));
self.resolve_column_widths(
ctx,
self.body_rect(Rect::from_origin_size(Point::ZERO, size))
.width(),
);
self.scroll_y = self.clamp_scroll(
self.body_rect(Rect::from_origin_size(Point::ZERO, size))
.height(),
self.scroll_y,
);
size
}
fn paint(&self, ctx: &mut PaintCtx) {
self.enabled.observe(|source| {
ctx.observe(source);
});
let theme = self.paint_theme();
let palette = theme.palette;
let metrics = theme.metrics;
let header_style = theme.text_style(palette.placeholder);
let body_style = theme.body_text_style();
let numeric_body_style = numeric_text_style(body_style.clone());
let body = self.body_rect(ctx.bounds());
let padding = metrics.data_viewport_padding;
let header = Rect::new(
ctx.bounds().x() + padding.left,
ctx.bounds().y() + padding.top,
body.width(),
self.resolved_header_height(),
);
let row_height = self.resolved_row_height();
draw_surface(ctx, ctx.bounds(), &theme, self.focus_animation.get(ctx));
ctx.fill(
Path::rounded_rect(header, metrics.corner_radius),
palette.control,
);
ctx.push_clip_rect(header);
let mut x = header.x();
for (index, column) in self.columns.iter().enumerate() {
let width = *self.column_widths.get(index).unwrap_or(&column.min_width);
let cell = Rect::new(x, header.y(), width, header.height());
if index > 0 {
let separator_inset = metrics
.table_header_separator_inset
.min(cell.height() * 0.5);
ctx.stroke_rect(
Rect::new(
cell.x(),
cell.y() + separator_inset,
metrics.table_separator_width,
(cell.height() - (separator_inset * 2.0)).max(0.0),
),
palette.border,
sui_scene::StrokeStyle::new(metrics.table_separator_width.max(1.0)),
);
}
draw_aligned_text(
ctx,
horizontal_inset_rect(cell, metrics.table_cell_padding),
&column.title,
&header_style,
column.alignment,
);
x += width;
}
ctx.pop_clip();
ctx.push_clip_rect(body);
let start = (self.scroll_y / row_height).floor().max(0.0) as usize;
let end = (((self.scroll_y + body.height()) / row_height).ceil() as usize + 1)
.min(self.rows.len());
for row_index in start..end {
let row_y = body.y() + (row_index as f32 * row_height) - self.scroll_y;
let row_rect = Rect::new(body.x(), row_y, body.width(), row_height);
let selected = self.current_selected() == Some(row_index);
let hover_amount = self.hover_motion.amount_for(&row_index, ctx);
let press_amount = self.press_motion.amount_for(&row_index, ctx);
let background = if row_index % 2 == 0 {
palette.surface.with_alpha(0.88)
} else {
palette.surface_raised
};
ctx.fill_rect(row_rect, background);
paint_data_row_state(
ctx,
row_rect,
body,
&theme,
selected,
hover_amount,
press_amount,
);
stroke_border(
ctx,
row_rect,
0.0,
metrics.table_separator_width.max(1.0),
palette.border.with_alpha(metrics.table_row_border_opacity),
);
let mut cell_x = row_rect.x();
for (column_index, column) in self.columns.iter().enumerate() {
let width = *self
.column_widths
.get(column_index)
.unwrap_or(&column.min_width);
let cell_rect = Rect::new(cell_x, row_rect.y(), width, row_rect.height());
if let Some(value) = self.rows[row_index].cells.get(column_index) {
let style = if column.numeric {
numeric_body_style.clone()
} else {
body_style.clone()
};
draw_aligned_text(
ctx,
horizontal_inset_rect(cell_rect, metrics.table_cell_padding),
value,
&style,
column.alignment,
);
}
cell_x += width;
}
}
ctx.pop_clip();
draw_vertical_scroll_thumb(
ctx,
&theme,
body,
self.content_height(),
self.scroll_y,
palette.border_hover,
);
}
fn semantics(&self, ctx: &mut SemanticsCtx) {
self.enabled.observe(|source| {
ctx.observe(source);
});
let enabled = self.enabled.get();
let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::Table, ctx.bounds());
node.name = Some(self.name());
node.state.focused = ctx.is_focused();
node.value = self
.current_selected()
.and_then(|row| self.rows.get(row))
.and_then(|row| row.cells.first())
.cloned()
.map(SemanticsValue::Text);
node.actions = vec![SemanticsAction::Focus, SemanticsAction::SetValue];
if !enabled {
node.state.disabled = true;
node.actions.clear();
}
ctx.push(node);
}
fn accepts_focus(&self) -> bool {
self.enabled.get()
}
fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
let theme = self.resolved_theme();
set_focus_animation_target(&mut self.focus_animation, focused as u8 as f32, &theme, ctx);
ctx.request_paint();
ctx.request_semantics();
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum VirtualTableSortDirection {
Ascending,
Descending,
}
#[derive(Clone)]
pub struct VirtualTableState {
inner: Rc<RefCell<VirtualTableStateInner>>,
revision: Signal<u64>,
viewport: Signal<VirtualViewportSnapshot<u64>>,
scroll: ScrollState,
}
#[derive(Default)]
struct VirtualTableStateInner {
selected_key: Option<u64>,
pending_scroll: Option<(u64, ScrollAlignment)>,
column_widths: HashMap<u64, f32>,
}
impl VirtualTableState {
pub fn new() -> Self {
let scroll = ScrollState::new();
scroll.sync_unmeasured_axes(ScrollAxes::Both);
Self {
inner: Rc::new(RefCell::new(VirtualTableStateInner::default())),
revision: Signal::named("VirtualTableState", 0),
viewport: Signal::named("VirtualTableViewport", VirtualViewportSnapshot::default()),
scroll,
}
}
pub fn selected_key(&self) -> Option<u64> {
self.inner.borrow().selected_key
}
pub fn select_key(&self, key: Option<u64>) -> bool {
let changed = {
let mut inner = self.inner.borrow_mut();
if inner.selected_key == key {
false
} else {
inner.selected_key = key;
true
}
};
if changed {
self.bump();
}
changed
}
pub fn scroll_to(&self, key: u64, alignment: ScrollAlignment) {
self.inner.borrow_mut().pending_scroll = Some((key, alignment));
self.bump();
}
pub fn column_width(&self, key: u64) -> Option<f32> {
self.inner.borrow().column_widths.get(&key).copied()
}
pub fn set_column_width(&self, key: u64, width: f32) -> bool {
let width = width.max(32.0);
let changed = {
let mut inner = self.inner.borrow_mut();
if inner
.column_widths
.get(&key)
.is_some_and(|current| (*current - width).abs() <= f32::EPSILON)
{
false
} else {
inner.column_widths.insert(key, width);
true
}
};
if changed {
self.bump();
}
changed
}
pub fn scroll_state(&self) -> ScrollState {
self.scroll.clone()
}
pub fn viewport(&self) -> VirtualViewportSnapshot<u64> {
self.viewport.get()
}
pub fn viewport_signal(&self) -> Signal<VirtualViewportSnapshot<u64>> {
self.viewport.clone()
}
fn bump(&self) {
let _ = self.revision.update(|revision| {
*revision = revision.wrapping_add(1);
});
}
fn take_pending_scroll(&self) -> Option<(u64, ScrollAlignment)> {
self.inner.borrow_mut().pending_scroll.take()
}
fn publish_viewport(&self, viewport: VirtualViewportSnapshot<u64>) {
let _ = self.viewport.set(viewport);
}
}
impl Default for VirtualTableState {
fn default() -> Self {
Self::new()
}
}
#[derive(Debug, Clone, PartialEq)]
pub struct VirtualTableColumn {
key: Option<u64>,
title: String,
width: Option<f32>,
min_width: f32,
max_width: Option<f32>,
resizable: bool,
pinned: bool,
alignment: TableColumnAlignment,
sort_direction: Option<VirtualTableSortDirection>,
}
impl VirtualTableColumn {
pub fn new(title: impl Into<String>) -> Self {
Self {
key: None,
title: title.into(),
width: None,
min_width: 96.0,
max_width: None,
resizable: true,
pinned: false,
alignment: TableColumnAlignment::Start,
sort_direction: None,
}
}
pub fn key(mut self, key: u64) -> Self {
self.key = Some(key);
self
}
pub fn width(mut self, width: f32) -> Self {
self.width = Some(width.max(32.0));
self
}
pub fn min_width(mut self, min_width: f32) -> Self {
self.min_width = min_width.max(32.0);
self
}
pub fn max_width(mut self, max_width: f32) -> Self {
self.max_width = Some(max_width.max(self.min_width));
self
}
pub fn resizable(mut self, resizable: bool) -> Self {
self.resizable = resizable;
self
}
pub fn pinned(mut self, pinned: bool) -> Self {
self.pinned = pinned;
self
}
pub fn alignment(mut self, alignment: TableColumnAlignment) -> Self {
self.alignment = alignment;
self
}
pub fn sort_direction(mut self, direction: Option<VirtualTableSortDirection>) -> Self {
self.sort_direction = direction;
self
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum VirtualTableRowActivationKind {
Single,
Double,
}
pub struct VirtualTableRowContext<'a> {
pub row_index: usize,
pub row_key: u64,
pub row_rect: Rect,
pub column_rects: &'a [Rect],
pub selected: bool,
pub hovered: bool,
pub pressed: bool,
}
type ListViewChange = Box<dyn FnMut(usize, String)>;
type ListViewContextChange = Box<dyn FnMut(&mut EventCtx, usize, String)>;
type VirtualTableRowPainter = Box<dyn for<'a> Fn(&mut PaintCtx, &VirtualTableRowContext<'a>)>;
type VirtualTableRowName = Box<dyn Fn(usize) -> String>;
type VirtualTableRowDescription = Box<dyn Fn(usize) -> String>;
type VirtualTableCellActivation =
Box<dyn FnMut(usize, usize, VirtualTableRowActivationKind) -> bool>;
type VirtualTableCellActivationWithCtx =
Box<dyn FnMut(&mut EventCtx, usize, usize, VirtualTableRowActivationKind) -> bool>;
#[derive(Clone, Copy)]
struct VirtualTableColumnResize {
column_index: usize,
pointer_id: u64,
start_x: f32,
start_width: f32,
}
pub struct VirtualTable {
theme: Box<DefaultTheme>,
theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
name: String,
columns: Vec<VirtualTableColumn>,
state: Option<VirtualTableState>,
window: CollectionWindow,
window_explicit: bool,
row_count: usize,
selected: Option<usize>,
selected_reader: Option<Box<dyn Fn() -> Option<usize>>>,
hovered_row: Option<usize>,
pressed_row: Option<usize>,
pressed_header: Option<usize>,
row_height: Option<f32>,
row_heights: Option<Vec<f32>>,
row_extents: CollectionExtentIndex,
row_extents_default_height: f32,
row_key: Option<Box<dyn Fn(usize) -> u64>>,
header_height: Option<f32>,
scroll_y: f32,
scroll_x: f32,
column_widths: Vec<f32>,
focus_animation: AnimatedScalar,
row_painter: Option<VirtualTableRowPainter>,
row_name: Option<VirtualTableRowName>,
row_description: Option<VirtualTableRowDescription>,
on_change: Option<Box<dyn FnMut(usize)>>,
on_change_with_ctx: Option<Box<dyn FnMut(&mut EventCtx, usize)>>,
on_row_activate: Option<Box<dyn FnMut(usize, VirtualTableRowActivationKind)>>,
on_row_activate_with_ctx:
Option<Box<dyn FnMut(&mut EventCtx, usize, VirtualTableRowActivationKind)>>,
on_cell_activate: Option<VirtualTableCellActivation>,
on_cell_activate_with_ctx: Option<VirtualTableCellActivationWithCtx>,
on_header_activate: Option<Box<dyn FnMut(usize)>>,
on_header_activate_with_ctx: Option<Box<dyn FnMut(&mut EventCtx, usize)>>,
on_column_resize: Option<Box<dyn FnMut(usize, f32)>>,
on_column_resize_with_ctx: Option<Box<dyn FnMut(&mut EventCtx, usize, f32)>>,
on_near_end: Option<Box<dyn FnMut()>>,
on_near_end_with_ctx: Option<Box<dyn FnMut(&mut EventCtx)>>,
last_click: Option<(usize, Instant)>,
column_resize: Option<VirtualTableColumnResize>,
}
impl VirtualTable {
const DOUBLE_CLICK_WINDOW: Duration = Duration::from_millis(450);
pub fn new(name: impl Into<String>) -> Self {
Self {
theme: Box::new(DefaultTheme::default()),
theme_reader: None,
name: name.into(),
columns: Vec::new(),
state: None,
window: CollectionWindow::complete(0),
window_explicit: false,
row_count: 0,
selected: None,
selected_reader: None,
hovered_row: None,
pressed_row: None,
pressed_header: None,
row_height: None,
row_heights: None,
row_extents: CollectionExtentIndex::new(),
row_extents_default_height: 0.0,
row_key: None,
header_height: None,
scroll_y: 0.0,
scroll_x: 0.0,
column_widths: Vec::new(),
focus_animation: AnimatedScalar::new(0.0),
row_painter: None,
row_name: None,
row_description: None,
on_change: None,
on_change_with_ctx: None,
on_row_activate: None,
on_row_activate_with_ctx: None,
on_cell_activate: None,
on_cell_activate_with_ctx: None,
on_header_activate: None,
on_header_activate_with_ctx: None,
on_column_resize: None,
on_column_resize_with_ctx: None,
on_near_end: None,
on_near_end_with_ctx: None,
last_click: None,
column_resize: None,
}
}
pub fn theme(mut self, theme: DefaultTheme) -> Self {
self.theme = Box::new(theme);
self.theme_reader = None;
self
}
pub fn theme_when<F>(mut self, theme: F) -> Self
where
F: Fn() -> DefaultTheme + 'static,
{
self.theme_reader = Some(Box::new(theme));
self
}
pub fn columns<I>(mut self, columns: I) -> Self
where
I: IntoIterator<Item = VirtualTableColumn>,
{
self.columns.extend(columns);
self
}
pub fn state(mut self, state: VirtualTableState) -> Self {
self.state = Some(state);
self
}
pub fn collection_window(mut self, window: CollectionWindow) -> Self {
self.window = window;
self.window_explicit = true;
self
}
pub fn row_count(mut self, row_count: usize) -> Self {
self.row_count = row_count;
if !self.window_explicit {
self.window = CollectionWindow::complete(row_count);
}
self.row_extents.clear();
self
}
pub fn row_height(mut self, row_height: f32) -> Self {
self.row_height = Some(row_height.max(1.0));
self.row_heights = None;
self.row_extents.clear();
self
}
pub fn row_heights<I>(mut self, row_heights: I) -> Self
where
I: IntoIterator<Item = f32>,
{
self.row_heights = Some(
row_heights
.into_iter()
.map(|height| height.max(1.0))
.collect(),
);
self.row_extents.clear();
self
}
pub fn row_key<F>(mut self, row_key: F) -> Self
where
F: Fn(usize) -> u64 + 'static,
{
self.row_key = Some(Box::new(row_key));
self
}
pub fn header_height(mut self, header_height: f32) -> Self {
self.header_height = Some(header_height.max(1.0));
self
}
pub fn selected(mut self, selected: impl Into<Option<usize>>) -> Self {
let selected = selected.into();
self.selected = selected;
self
}
pub fn selected_when<F>(mut self, selected: F) -> Self
where
F: Fn() -> Option<usize> + 'static,
{
self.selected_reader = Some(Box::new(selected));
self
}
pub fn row_painter<F>(mut self, painter: F) -> Self
where
F: for<'a> Fn(&mut PaintCtx, &VirtualTableRowContext<'a>) + 'static,
{
self.row_painter = Some(Box::new(painter));
self
}
pub fn row_name<F>(mut self, name: F) -> Self
where
F: Fn(usize) -> String + 'static,
{
self.row_name = Some(Box::new(name));
self
}
pub fn row_description<F>(mut self, description: F) -> Self
where
F: Fn(usize) -> String + 'static,
{
self.row_description = Some(Box::new(description));
self
}
pub fn on_change<F>(mut self, on_change: F) -> Self
where
F: FnMut(usize) + 'static,
{
self.on_change = Some(Box::new(on_change));
self
}
pub fn on_change_with_ctx<F>(mut self, on_change: F) -> Self
where
F: FnMut(&mut EventCtx, usize) + 'static,
{
self.on_change_with_ctx = Some(Box::new(on_change));
self
}
pub fn on_row_activate<F>(mut self, on_activate: F) -> Self
where
F: FnMut(usize, VirtualTableRowActivationKind) + 'static,
{
self.on_row_activate = Some(Box::new(on_activate));
self
}
pub fn on_row_activate_with_ctx<F>(mut self, on_activate: F) -> Self
where
F: FnMut(&mut EventCtx, usize, VirtualTableRowActivationKind) + 'static,
{
self.on_row_activate_with_ctx = Some(Box::new(on_activate));
self
}
pub fn on_cell_activate<F>(mut self, on_activate: F) -> Self
where
F: FnMut(usize, usize, VirtualTableRowActivationKind) -> bool + 'static,
{
self.on_cell_activate = Some(Box::new(on_activate));
self
}
pub fn on_cell_activate_with_ctx<F>(mut self, on_activate: F) -> Self
where
F: FnMut(&mut EventCtx, usize, usize, VirtualTableRowActivationKind) -> bool + 'static,
{
self.on_cell_activate_with_ctx = Some(Box::new(on_activate));
self
}
pub fn on_header_activate<F>(mut self, on_activate: F) -> Self
where
F: FnMut(usize) + 'static,
{
self.on_header_activate = Some(Box::new(on_activate));
self
}
pub fn on_header_activate_with_ctx<F>(mut self, on_activate: F) -> Self
where
F: FnMut(&mut EventCtx, usize) + 'static,
{
self.on_header_activate_with_ctx = Some(Box::new(on_activate));
self
}
pub fn on_column_resize<F>(mut self, on_resize: F) -> Self
where
F: FnMut(usize, f32) + 'static,
{
self.on_column_resize = Some(Box::new(on_resize));
self
}
pub fn on_column_resize_with_ctx<F>(mut self, on_resize: F) -> Self
where
F: FnMut(&mut EventCtx, usize, f32) + 'static,
{
self.on_column_resize_with_ctx = Some(Box::new(on_resize));
self
}
pub fn on_near_end<F>(mut self, on_near_end: F) -> Self
where
F: FnMut() + 'static,
{
self.on_near_end = Some(Box::new(on_near_end));
self
}
pub fn on_near_end_with_ctx<F>(mut self, on_near_end: F) -> Self
where
F: FnMut(&mut EventCtx) + 'static,
{
self.on_near_end_with_ctx = Some(Box::new(on_near_end));
self
}
fn resolved_theme(&self) -> DefaultTheme {
self.theme_reader
.as_ref()
.map(|theme| theme())
.unwrap_or(*self.theme)
}
fn resolved_selected(&self) -> Option<usize> {
let selected = if let Some(selected_reader) = &self.selected_reader {
selected_reader()
} else if let Some(state) = &self.state {
state.selected_key().and_then(|selected_key| {
(0..self.row_count).find(|index| self.resolved_row_key(*index) == selected_key)
})
} else {
self.selected
};
selected.filter(|index| *index < self.row_count)
}
fn normalized_window(&self) -> CollectionWindow {
self.window
.clone()
.normalized_for_loaded_count(self.row_count)
}
fn resolved_row_height(&self) -> f32 {
self.row_height
.unwrap_or(self.resolved_theme().metrics.table_row_height)
}
fn row_height_at(&self, index: usize) -> f32 {
self.row_heights
.as_ref()
.and_then(|heights| heights.get(index).copied())
.unwrap_or_else(|| self.resolved_row_height())
.max(1.0)
}
fn sync_row_extents(&mut self) {
let default_height = self.resolved_row_height();
let needs_rebuild = self.row_extents.len() != self.row_count
|| (self.row_heights.is_none()
&& (self.row_extents_default_height - default_height).abs() > f32::EPSILON);
if needs_rebuild {
let heights = (0..self.row_count)
.map(|index| self.row_height_at(index))
.collect::<Vec<_>>();
self.row_extents.rebuild(heights);
self.row_extents_default_height = default_height;
}
}
fn resolved_row_key(&self, index: usize) -> u64 {
self.row_key
.as_ref()
.map(|row_key| row_key(index))
.unwrap_or(index as u64)
}
fn resolved_column_key(&self, index: usize) -> u64 {
self.columns
.get(index)
.and_then(|column| column.key)
.unwrap_or(index as u64)
}
fn resolved_header_height(&self) -> f32 {
self.header_height
.unwrap_or(self.resolved_theme().metrics.table_header_height)
}
fn body_rect(&self, bounds: Rect) -> Rect {
let theme = self.resolved_theme();
let padding = theme.metrics.data_viewport_padding;
let gap = theme.metrics.select_menu_gap;
let body = Rect::new(
bounds.x() + padding.left,
bounds.y() + padding.top + self.resolved_header_height() + gap,
(bounds.width() - padding.left - padding.right).max(0.0),
(bounds.height() - padding.top - padding.bottom - self.resolved_header_height() - gap)
.max(0.0),
);
let gutter = crate::containers::scroll_bar_gutter(
true,
crate::ScrollAxes::Vertical,
body.size,
Size::new(0.0, self.content_height()),
theme.metrics.scroll_bar_thickness,
);
Rect::from_origin_size(
body.origin,
crate::containers::scroll_viewport_size(body.size, gutter),
)
}
fn header_rect(&self, bounds: Rect) -> Rect {
let theme = self.resolved_theme();
let padding = theme.metrics.data_viewport_padding;
Rect::new(
bounds.x() + padding.left,
bounds.y() + padding.top,
self.body_rect(bounds).width(),
self.resolved_header_height(),
)
}
fn content_height(&self) -> f32 {
if self.row_extents.len() == self.row_count {
self.row_extents.total()
} else {
self.row_count as f32 * self.resolved_row_height()
}
}
fn clamp_scroll(&self, viewport_height: f32, scroll_y: f32) -> f32 {
let max_scroll = (self.content_height() - viewport_height).max(0.0);
scroll_y.clamp(0.0, max_scroll)
}
fn pinned_width(&self) -> f32 {
self.columns
.iter()
.enumerate()
.filter(|(_, column)| column.pinned)
.map(|(index, column)| *self.column_widths.get(index).unwrap_or(&column.min_width))
.sum()
}
fn unpinned_content_width(&self) -> f32 {
self.columns
.iter()
.enumerate()
.filter(|(_, column)| !column.pinned)
.map(|(index, column)| *self.column_widths.get(index).unwrap_or(&column.min_width))
.sum()
}
fn clamp_horizontal_scroll(&self, viewport_width: f32, scroll_x: f32) -> f32 {
let unpinned_viewport = (viewport_width - self.pinned_width()).max(0.0);
let max_scroll = (self.unpinned_content_width() - unpinned_viewport).max(0.0);
scroll_x.clamp(0.0, max_scroll)
}
fn row_at_position(&self, bounds: Rect, position: Point) -> Option<usize> {
let body = self.body_rect(bounds);
if !body.contains(position) {
return None;
}
let y = position.y - body.y() + self.scroll_y;
self.row_extents
.index_at_offset(y)
.filter(|index| *index < self.row_count)
}
fn body_column_at_position(&self, bounds: Rect, position: Point) -> Option<usize> {
let body = self.body_rect(bounds);
if !body.contains(position) {
return None;
}
self.column_rects(body)
.iter()
.position(|rect| rect.contains(position))
}
fn header_at_position(&self, bounds: Rect, position: Point) -> Option<usize> {
let header = self.header_rect(bounds);
if !header.contains(position) {
return None;
}
self.column_rects(header)
.iter()
.position(|rect| rect.contains(position))
}
fn resolve_column_widths(&mut self, ctx: &mut MeasureCtx, available_width: f32) {
let theme = self.resolved_theme();
let header_style = theme.text_style(theme.palette.placeholder);
self.column_widths = self
.columns
.iter()
.enumerate()
.map(|(index, column)| {
let retained_width = self
.state
.as_ref()
.and_then(|state| state.column_width(self.resolved_column_key(index)));
let width = retained_width.or(column.width).unwrap_or_else(|| {
(measure_text_or_estimate(ctx, &column.title, &header_style).width
+ (theme.metrics.table_cell_padding * 2.0))
.max(column.min_width)
});
width
.max(32.0)
.min(column.max_width.unwrap_or(f32::INFINITY))
})
.collect();
if available_width <= 0.0 || self.column_widths.is_empty() {
return;
}
let total = self.column_widths.iter().sum::<f32>();
let flexible = self
.columns
.iter()
.enumerate()
.filter_map(|(index, column)| {
let retained = self
.state
.as_ref()
.and_then(|state| state.column_width(self.resolved_column_key(index)));
(column.width.is_none() && retained.is_none()).then_some(index)
})
.collect::<Vec<_>>();
if total < available_width && !flexible.is_empty() {
let extra = (available_width - total) / flexible.len() as f32;
for index in flexible {
self.column_widths[index] += extra;
}
}
}
fn column_rects(&self, row_rect: Rect) -> Vec<Rect> {
let pinned_width = self.pinned_width().min(row_rect.width());
let unpinned_clip = Rect::new(
row_rect.x() + pinned_width,
row_rect.y(),
(row_rect.width() - pinned_width).max(0.0),
row_rect.height(),
);
let mut pinned_x = row_rect.x();
let mut unpinned_x = row_rect.x() + pinned_width - self.scroll_x;
self.columns
.iter()
.enumerate()
.map(|(index, column)| {
let width = *self.column_widths.get(index).unwrap_or(&column.min_width);
if column.pinned {
let rect = Rect::new(pinned_x, row_rect.y(), width, row_rect.height());
pinned_x += width;
rect.intersection(row_rect).unwrap_or(Rect::ZERO)
} else {
let rect = Rect::new(unpinned_x, row_rect.y(), width, row_rect.height());
unpinned_x += width;
rect.intersection(unpinned_clip).unwrap_or(Rect::ZERO)
}
})
.collect()
}
fn row_activation_kind(&mut self, row_index: usize) -> VirtualTableRowActivationKind {
let now = Instant::now();
let double_click = self.last_click.take().is_some_and(|(index, instant)| {
index == row_index && now.duration_since(instant) <= Self::DOUBLE_CLICK_WINDOW
});
if double_click {
VirtualTableRowActivationKind::Double
} else {
self.last_click = Some((row_index, now));
VirtualTableRowActivationKind::Single
}
}
fn row_rect(&self, body: Rect, row_index: usize) -> Rect {
let row_y = body.y() + self.row_extents.offset_of(row_index) - self.scroll_y;
Rect::new(
body.x(),
row_y,
body.width(),
self.row_extents
.extent(row_index)
.unwrap_or_else(|| self.row_height_at(row_index)),
)
}
fn visible_row_range(&self, body: Rect) -> Range<usize> {
if self.row_count == 0 {
return 0..0;
}
let start = self.row_extents.index_at_offset(self.scroll_y).unwrap_or(0);
let end = self
.row_extents
.index_at_offset(self.scroll_y + body.height())
.map_or(self.row_count, |index| index + 2)
.min(self.row_count);
start..end
}
fn viewport_row_range(&self, body: Rect) -> Range<usize> {
if self.row_count == 0 || body.height() <= 0.0 {
return 0..0;
}
let start = self.row_extents.index_at_offset(self.scroll_y).unwrap_or(0);
let end = self
.row_extents
.index_at_offset(self.scroll_y + body.height())
.map_or(self.row_count, |index| index + 1)
.min(self.row_count);
start..end
}
fn offset_for_row_alignment(
&self,
row_index: usize,
viewport_height: f32,
alignment: ScrollAlignment,
) -> f32 {
let top = self.row_extents.offset_of(row_index);
let height = self
.row_extents
.extent(row_index)
.unwrap_or_else(|| self.row_height_at(row_index));
let bottom = top + height;
let offset = match alignment {
ScrollAlignment::Nearest if top < self.scroll_y => top,
ScrollAlignment::Nearest if bottom > self.scroll_y + viewport_height => {
bottom - viewport_height
}
ScrollAlignment::Nearest => self.scroll_y,
ScrollAlignment::Start => top,
ScrollAlignment::Center => top - (viewport_height - height) * 0.5,
ScrollAlignment::End => bottom - viewport_height,
};
self.clamp_scroll(viewport_height, offset)
}
fn apply_pending_keyed_scroll(&mut self, body_height: f32) {
let Some((key, alignment)) = self
.state
.as_ref()
.and_then(VirtualTableState::take_pending_scroll)
else {
return;
};
let Some(index) = (0..self.row_count).find(|index| self.resolved_row_key(*index) == key)
else {
return;
};
self.scroll_y = self.offset_for_row_alignment(index, body_height, alignment);
}
fn sync_retained_scroll_state<C>(&mut self, ctx: &mut C, body: Rect)
where
C: crate::containers::ScrollInvalidationCtx + crate::containers::ScrollWidgetCtx,
{
let Some(state) = self.state.as_ref() else {
return;
};
state
.scroll
.bind_scroll_view(ctx.widget_id(), ctx.widget_id());
let content_width = self.column_widths.iter().sum::<f32>();
let changed = state.scroll.sync_metrics(
ScrollAxes::Both,
body.size,
Size::new(content_width, self.content_height()),
);
if changed {
for scroll_bar_id in state.scroll.subscribers().scroll_bar_ids {
crate::containers::request_scroll_bar_refresh(ctx, scroll_bar_id);
}
}
}
fn sync_retained_offset(&self) {
if let Some(state) = &self.state {
let _ = state
.scroll
.set_offset(Vector::new(self.scroll_x, self.scroll_y));
}
}
fn publish_retained_viewport(&self, body: Rect) {
let Some(state) = &self.state else {
return;
};
let window = self.normalized_window();
let local_visible = self.viewport_row_range(body);
let visible_range = window
.loaded_range
.start
.saturating_add(local_visible.start)
..window.loaded_range.start.saturating_add(local_visible.end);
let visible_keys = local_visible
.clone()
.map(|index| self.resolved_row_key(index))
.collect::<Vec<_>>();
let anchor = (local_visible.start < self.row_count).then(|| {
let index = local_visible.start;
CollectionAnchor {
key: self.resolved_row_key(index),
offset_within_item: self.scroll_y - self.row_extents.offset_of(index),
gravity: CollectionAnchorGravity::Start,
}
});
let max_offset = (self.content_height() - body.height()).max(0.0);
state.publish_viewport(VirtualViewportSnapshot {
loaded_range: window.loaded_range,
visible_range,
visible_keys,
total_count: window.total_count,
has_before: window.has_before,
has_after: window.has_after,
anchor,
offset: self.scroll_y,
max_offset,
at_loaded_start: self.scroll_y <= f32::EPSILON,
at_loaded_end: max_offset - self.scroll_y <= f32::EPSILON,
following_end: false,
});
}
fn ensure_row_visible(&mut self, body_height: f32, row_index: usize) {
if row_index >= self.row_count {
return;
}
let top = self.row_extents.offset_of(row_index);
let bottom = top
+ self
.row_extents
.extent(row_index)
.unwrap_or_else(|| self.row_height_at(row_index));
if top < self.scroll_y {
self.scroll_y = top;
} else if bottom > self.scroll_y + body_height {
self.scroll_y = bottom - body_height;
}
self.scroll_y = self.clamp_scroll(body_height, self.scroll_y);
}
fn column_separator_at_position(&self, bounds: Rect, position: Point) -> Option<usize> {
let header = self.header_rect(bounds);
if !header.contains(position) {
return None;
}
for (index, (column, rect)) in self
.columns
.iter()
.zip(self.column_rects(header))
.enumerate()
{
if !rect.is_empty() && column.resizable && (position.x - rect.max_x()).abs() <= 5.0 {
return Some(index);
}
}
None
}
fn resize_column(
&mut self,
ctx: &mut EventCtx,
resize: VirtualTableColumnResize,
position_x: f32,
) -> bool {
let Some(column) = self.columns.get_mut(resize.column_index) else {
return false;
};
let maximum = column.max_width.unwrap_or(f32::INFINITY);
let width =
(resize.start_width + position_x - resize.start_x).clamp(column.min_width, maximum);
if (column.width.unwrap_or(resize.start_width) - width).abs() <= f32::EPSILON {
return false;
}
column.width = Some(width);
if let Some(current) = self.column_widths.get_mut(resize.column_index) {
*current = width;
}
if let Some(state) = &self.state {
let _ = state.set_column_width(self.resolved_column_key(resize.column_index), width);
}
if let Some(on_resize) = &mut self.on_column_resize {
on_resize(resize.column_index, width);
}
if let Some(on_resize) = &mut self.on_column_resize_with_ctx {
on_resize(ctx, resize.column_index, width);
}
true
}
fn activate_row(&mut self, ctx: &mut EventCtx, row_index: usize, column_index: Option<usize>) {
if row_index >= self.row_count {
return;
}
let changed = self.selected != Some(row_index);
self.selected = Some(row_index);
if let Some(state) = &self.state {
let _ = state.select_key(Some(self.resolved_row_key(row_index)));
}
if changed {
if let Some(on_change) = &mut self.on_change {
on_change(row_index);
}
if let Some(on_change) = &mut self.on_change_with_ctx {
on_change(ctx, row_index);
}
}
let kind = self.row_activation_kind(row_index);
if let Some(column_index) = column_index {
if let Some(on_activate) = &mut self.on_cell_activate
&& on_activate(row_index, column_index, kind)
{
return;
}
if let Some(on_activate) = &mut self.on_cell_activate_with_ctx
&& on_activate(ctx, row_index, column_index, kind)
{
return;
}
}
if let Some(on_activate) = &mut self.on_row_activate {
on_activate(row_index, kind);
}
if let Some(on_activate) = &mut self.on_row_activate_with_ctx {
on_activate(ctx, row_index, kind);
}
}
fn maybe_notify_near_end(&mut self, ctx: &mut EventCtx, viewport_height: f32) {
let remaining = (self.content_height() - viewport_height - self.scroll_y).max(0.0);
if remaining > self.resolved_row_height() * 12.0 {
return;
}
if let Some(on_near_end) = &mut self.on_near_end {
on_near_end();
}
if let Some(on_near_end) = &mut self.on_near_end_with_ctx {
on_near_end(ctx);
}
}
}
impl Widget for VirtualTable {
fn layer_options(&self) -> sui_runtime::LayerOptions {
sui_runtime::LayerOptions {
paint_boundary: sui_runtime::PaintBoundaryMode::Explicit,
..sui_runtime::LayerOptions::default()
}
}
fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
let bounds = ctx.bounds();
let body = self.body_rect(bounds);
match event {
Event::Pointer(pointer)
if pointer.kind == PointerEventKind::Move
&& self
.column_resize
.is_some_and(|resize| resize.pointer_id == pointer.pointer_id) =>
{
let resize = self.column_resize.expect("checked resize gesture");
if self.resize_column(ctx, resize, pointer.position.x) {
ctx.request_measure();
ctx.request_paint();
ctx.request_semantics();
}
ctx.set_handled();
}
Event::Pointer(pointer) if pointer.kind == PointerEventKind::Move => {
let hovered = self.row_at_position(bounds, pointer.position);
if self.hovered_row != hovered {
self.hovered_row = hovered;
ctx.request_paint();
ctx.request_semantics();
}
}
Event::Pointer(pointer)
if pointer.kind == PointerEventKind::Scroll && body.contains(pointer.position) =>
{
let delta = pointer
.scroll_delta
.map(scroll_delta_to_offset)
.unwrap_or(pointer.delta);
let next_y = self.clamp_scroll(body.height(), self.scroll_y - delta.y);
let next_x = self.clamp_horizontal_scroll(body.width(), self.scroll_x - delta.x);
if (next_y - self.scroll_y).abs() > f32::EPSILON
|| (next_x - self.scroll_x).abs() > f32::EPSILON
{
self.scroll_y = next_y;
self.scroll_x = next_x;
self.sync_retained_offset();
self.publish_retained_viewport(body);
self.maybe_notify_near_end(ctx, body.height());
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
}
Event::Pointer(pointer)
if pointer.kind == PointerEventKind::Down
&& pointer.button == Some(PointerButton::Primary) =>
{
if let Some(column_index) =
self.column_separator_at_position(bounds, pointer.position)
{
let start_width = self.column_widths[column_index];
self.column_resize = Some(VirtualTableColumnResize {
column_index,
pointer_id: pointer.pointer_id,
start_x: pointer.position.x,
start_width,
});
ctx.request_focus();
ctx.request_pointer_capture(pointer.pointer_id);
ctx.request_paint();
ctx.set_handled();
} else if let Some(header) = self.header_at_position(bounds, pointer.position) {
self.pressed_header = Some(header);
ctx.request_focus();
ctx.request_pointer_capture(pointer.pointer_id);
ctx.request_paint();
ctx.set_handled();
} else if let Some(row) = self.row_at_position(bounds, pointer.position) {
self.pressed_row = Some(row);
self.hovered_row = Some(row);
ctx.request_focus();
ctx.request_pointer_capture(pointer.pointer_id);
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
}
Event::Pointer(pointer)
if pointer.kind == PointerEventKind::Up
&& pointer.button == Some(PointerButton::Primary) =>
{
if self
.column_resize
.take()
.is_some_and(|resize| resize.pointer_id == pointer.pointer_id)
{
ctx.release_pointer_capture(pointer.pointer_id);
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
return;
}
let header = self.header_at_position(bounds, pointer.position);
if let Some(index) = self
.pressed_header
.zip(header)
.filter(|(pressed, hovered)| pressed == hovered)
.map(|(index, _)| index)
{
if let Some(on_activate) = &mut self.on_header_activate {
on_activate(index);
}
if let Some(on_activate) = &mut self.on_header_activate_with_ctx {
on_activate(ctx, index);
}
} else {
let hovered = self.row_at_position(bounds, pointer.position);
if let Some(index) = self
.pressed_row
.zip(hovered)
.filter(|(pressed, hovered)| pressed == hovered)
.map(|(index, _)| index)
{
let column = self.body_column_at_position(bounds, pointer.position);
self.activate_row(ctx, index, column);
}
self.hovered_row = hovered;
}
self.pressed_row = None;
self.pressed_header = None;
ctx.release_pointer_capture(pointer.pointer_id);
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
Event::Pointer(pointer) if pointer.kind == PointerEventKind::Leave => {
if self.hovered_row.take().is_some() {
ctx.request_paint();
ctx.request_semantics();
}
}
Event::Pointer(pointer) if pointer.kind == PointerEventKind::Cancel => {
if self.column_resize.take().is_some()
|| self.pressed_row.take().is_some()
|| self.pressed_header.take().is_some()
{
ctx.release_pointer_capture(pointer.pointer_id);
ctx.request_paint();
ctx.set_handled();
}
if self.hovered_row.take().is_some() {
ctx.request_paint();
ctx.request_semantics();
}
}
Event::Keyboard(key) if ctx.is_focused() && key.state == KeyState::Pressed => {
if self.row_count == 0 {
return;
}
let current = self.resolved_selected().unwrap_or(0);
match key.key.as_str() {
"ArrowUp" => {
let next = current.saturating_sub(1);
self.activate_row(ctx, next, None);
self.ensure_row_visible(body.height(), next);
}
"ArrowDown" => {
let next = (current + 1).min(self.row_count - 1);
self.activate_row(ctx, next, None);
self.ensure_row_visible(body.height(), next);
}
"Home" => {
self.activate_row(ctx, 0, None);
self.ensure_row_visible(body.height(), 0);
}
"End" => {
let last = self.row_count - 1;
self.activate_row(ctx, last, None);
self.ensure_row_visible(body.height(), last);
}
"PageUp" => {
self.scroll_y =
self.clamp_scroll(body.height(), self.scroll_y - body.height() * 0.85);
}
"PageDown" => {
self.scroll_y =
self.clamp_scroll(body.height(), self.scroll_y + body.height() * 0.85);
}
_ => return,
}
self.sync_retained_offset();
self.publish_retained_viewport(body);
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
Event::Semantics(semantics) if semantics.target == ctx.widget_id() => {
let delta = match semantics.action {
sui_core::SemanticsActionRequest::Increment => Some(body.height() * 0.85),
sui_core::SemanticsActionRequest::Decrement => Some(-body.height() * 0.85),
_ => None,
};
if let Some(delta) = delta {
let next = self.clamp_scroll(body.height(), self.scroll_y + delta);
if (next - self.scroll_y).abs() > f32::EPSILON {
self.scroll_y = next;
self.sync_retained_offset();
self.publish_retained_viewport(body);
ctx.request_paint();
ctx.request_semantics();
}
ctx.set_handled();
}
}
_ => {}
}
}
fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
if let Some(state) = &self.state {
let _ = ctx.observe(&state.revision);
}
self.sync_row_extents();
let desired_width = if constraints.max.width.is_finite() {
constraints.max.width
} else {
540.0
};
let desired_height = if constraints.max.height.is_finite() {
constraints.max.height
} else {
let theme = self.resolved_theme();
let padding = theme.metrics.data_viewport_padding;
(padding.top
+ self.resolved_header_height()
+ theme.metrics.select_menu_gap
+ self.content_height()
+ padding.bottom)
.min(420.0)
};
let size = constraints.clamp(Size::new(desired_width, desired_height));
let body = self.body_rect(Rect::from_origin_size(Point::ZERO, size));
self.resolve_column_widths(ctx, body.width());
self.sync_retained_scroll_state(ctx, body);
if let Some(state) = &self.state {
let offset = state.scroll.current_offset();
self.scroll_y = offset.y;
self.scroll_x = offset.x;
}
self.apply_pending_keyed_scroll(body.height());
self.scroll_y = self.clamp_scroll(body.height(), self.scroll_y);
self.scroll_x = self.clamp_horizontal_scroll(body.width(), self.scroll_x);
self.sync_retained_offset();
self.publish_retained_viewport(body);
size
}
fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
let body = self.body_rect(bounds);
let previous = Vector::new(self.scroll_x, self.scroll_y);
self.sync_retained_scroll_state(ctx, body);
if let Some(state) = &self.state {
let offset = state.scroll.current_offset();
self.scroll_y = self.clamp_scroll(body.height(), offset.y);
self.scroll_x = self.clamp_horizontal_scroll(body.width(), offset.x);
}
self.apply_pending_keyed_scroll(body.height());
self.sync_retained_offset();
self.publish_retained_viewport(body);
if previous != Vector::new(self.scroll_x, self.scroll_y) {
ctx.request_paint();
ctx.request_semantics();
}
}
fn paint(&self, ctx: &mut PaintCtx) {
let theme = self.resolved_theme();
let palette = theme.palette;
let metrics = theme.metrics;
let header_style = theme.text_style(palette.placeholder);
let bounds = ctx.bounds();
let body = self.body_rect(bounds);
let header = self.header_rect(bounds);
let selected = self.resolved_selected();
draw_surface(ctx, bounds, &theme, self.focus_animation.get(ctx));
ctx.fill(
Path::rounded_rect(header, metrics.corner_radius),
palette.control,
);
let header_cells = self.column_rects(header);
let paint_order = self
.columns
.iter()
.enumerate()
.filter_map(|(index, column)| (!column.pinned).then_some(index))
.chain(
self.columns
.iter()
.enumerate()
.filter_map(|(index, column)| column.pinned.then_some(index)),
)
.collect::<Vec<_>>();
ctx.push_clip_rect(header);
for index in paint_order {
let column = &self.columns[index];
let cell = header_cells[index];
if cell.is_empty() {
continue;
}
if index > 0 {
let separator_inset = metrics
.table_header_separator_inset
.min(cell.height() * 0.5);
ctx.stroke_rect(
Rect::new(
cell.x(),
cell.y() + separator_inset,
metrics.table_separator_width,
(cell.height() - (separator_inset * 2.0)).max(0.0),
),
palette.border,
sui_scene::StrokeStyle::new(metrics.table_separator_width.max(1.0)),
);
}
let title = match column.sort_direction {
Some(VirtualTableSortDirection::Ascending) => format!("{} ^", column.title),
Some(VirtualTableSortDirection::Descending) => format!("{} v", column.title),
None => column.title.clone(),
};
draw_aligned_text(
ctx,
horizontal_inset_rect(cell, metrics.table_cell_padding),
&title,
&header_style,
column.alignment,
);
}
ctx.pop_clip();
ctx.push_clip_rect(body);
for row_index in self.visible_row_range(body) {
let row_rect = self.row_rect(body, row_index);
let row_selected = selected == Some(row_index);
let row_hovered = self.hovered_row == Some(row_index);
let row_pressed = self.pressed_row == Some(row_index);
paint_data_row_state(
ctx,
row_rect,
body,
&theme,
row_selected,
row_hovered as u8 as f32,
row_pressed as u8 as f32,
);
let columns = self.column_rects(row_rect);
if let Some(painter) = &self.row_painter {
let row = VirtualTableRowContext {
row_index,
row_key: self.resolved_row_key(row_index),
row_rect,
column_rects: &columns,
selected: row_selected,
hovered: row_hovered,
pressed: row_pressed,
};
painter(ctx, &row);
}
}
ctx.pop_clip();
draw_vertical_scroll_thumb(
ctx,
&theme,
body,
self.content_height(),
self.scroll_y,
palette.placeholder,
);
}
fn semantics(&self, ctx: &mut SemanticsCtx) {
let window = self.normalized_window();
let total_count = window.total_count;
let described_count = total_count.unwrap_or(window.loaded_range.end);
let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::Table, ctx.bounds());
node.name = Some(self.name.clone());
node.state.focused = ctx.is_focused();
node.value = Some(SemanticsValue::Text(match total_count {
Some(total_count) => format!("{total_count} rows"),
None => format!("{} loaded rows", self.row_count),
}));
let columns = self
.columns
.iter()
.filter_map(|column| {
let title = column.title.trim();
(!title.is_empty()).then(|| title.to_string())
})
.collect::<Vec<_>>();
if !columns.is_empty() {
let visible = self.viewport_row_range(self.body_rect(ctx.bounds()));
let visible_start = window
.loaded_range
.start
.saturating_add(visible.start)
.saturating_add(1)
.min(described_count);
let visible_end = window
.loaded_range
.start
.saturating_add(visible.end)
.min(described_count);
node.description = Some(match total_count {
Some(total_count) => format!(
"Columns: {}; showing rows {} through {} of {}",
columns.join(", "),
visible_start,
visible_end,
total_count,
),
None => format!(
"Columns: {}; showing loaded rows {} through {}",
columns.join(", "),
visible_start,
visible_end,
),
});
}
node.actions = vec![
SemanticsAction::Focus,
SemanticsAction::Increment,
SemanticsAction::Decrement,
SemanticsAction::SetValue,
];
ctx.push(node);
let body = self.body_rect(ctx.bounds());
let selected = self.resolved_selected();
for row_index in self.visible_row_range(body) {
let row_rect = self.row_rect(body, row_index);
let row_key = self.resolved_row_key(row_index);
let dataset_index = window.loaded_range.start.saturating_add(row_index);
let mut row = SemanticsNode::new(
virtual_table_row_id(ctx.widget_id(), row_key),
SemanticsRole::ListItem,
row_rect,
);
row.parent = Some(ctx.widget_id());
row.name = self.row_name.as_ref().map(|name| name(row_index));
row.description = self
.row_description
.as_ref()
.map(|description| {
let position = match total_count {
Some(total_count) => {
format!("row {} of {}", dataset_index + 1, total_count)
}
None => format!("loaded row {}", dataset_index + 1),
};
format!("{}; {}", description(row_index), position)
})
.or_else(|| {
Some(match total_count {
Some(total_count) => {
format!("Row {} of {}", dataset_index + 1, total_count)
}
None => format!("Loaded row {}", dataset_index + 1),
})
});
row.state.selected = selected == Some(row_index);
row.state.hovered = self.hovered_row == Some(row_index);
row.actions = vec![SemanticsAction::Activate];
ctx.push(row);
}
}
fn accepts_focus(&self) -> bool {
true
}
fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
let theme = self.resolved_theme();
set_focus_animation_target(&mut self.focus_animation, focused as u8 as f32, &theme, ctx);
ctx.request_paint();
ctx.request_semantics();
}
}
#[derive(Debug, Clone, PartialEq)]
pub struct BreadcrumbItem {
label: String,
}
impl BreadcrumbItem {
pub fn new(label: impl Into<String>) -> Self {
Self {
label: label.into(),
}
}
}
#[deprecated(note = "use `Breadcrumb`")]
pub type PathBar = Breadcrumb;
#[doc(alias = "PathBar")]
pub struct Breadcrumb {
theme: Box<DefaultTheme>,
theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
name: String,
name_reader: Option<Box<dyn Fn() -> String>>,
items: Vec<BreadcrumbItem>,
current: usize,
current_reader: Option<Box<dyn Fn() -> Option<usize>>>,
focused_index: usize,
hovered: Option<usize>,
pressed: Option<usize>,
hover_motion: IndexedInteractionMotion<usize>,
press_motion: IndexedInteractionMotion<usize>,
focus_animation: AnimatedScalar,
measured_widths: Vec<f32>,
content_width: f32,
scroll_x: f32,
auto_scroll_to_end: bool,
drag_anchor: Option<(Point, f32)>,
drag_moved: bool,
on_activate: Option<Box<dyn FnMut(usize, String)>>,
on_activate_with_ctx: Option<Box<dyn FnMut(&mut EventCtx, usize, String)>>,
}
impl Breadcrumb {
pub fn new(name: impl Into<String>) -> Self {
Self {
theme: Box::new(DefaultTheme::default()),
theme_reader: None,
name: name.into(),
name_reader: None,
items: Vec::new(),
current: 0,
current_reader: None,
focused_index: 0,
hovered: None,
pressed: None,
hover_motion: IndexedInteractionMotion::new(),
press_motion: IndexedInteractionMotion::new(),
focus_animation: AnimatedScalar::new(0.0),
measured_widths: Vec::new(),
content_width: 0.0,
scroll_x: 0.0,
auto_scroll_to_end: true,
drag_anchor: None,
drag_moved: false,
on_activate: None,
on_activate_with_ctx: None,
}
}
pub fn theme(mut self, theme: DefaultTheme) -> Self {
self.theme = Box::new(theme);
self.theme_reader = None;
self
}
pub fn theme_when<F>(mut self, theme: F) -> Self
where
F: Fn() -> DefaultTheme + 'static,
{
self.theme_reader = Some(Box::new(theme));
self
}
pub fn item(mut self, item: BreadcrumbItem) -> Self {
self.items.push(item);
self
}
pub fn items<I>(mut self, items: I) -> Self
where
I: IntoIterator<Item = BreadcrumbItem>,
{
self.items.extend(items);
self
}
pub fn current(mut self, current: usize) -> Self {
self.current = current;
self.current_reader = None;
self.focused_index = current;
self
}
pub fn name_when<F>(mut self, name: F) -> Self
where
F: Fn() -> String + 'static,
{
self.name_reader = Some(Box::new(name));
self
}
pub fn current_when<F>(mut self, current: F) -> Self
where
F: Fn() -> Option<usize> + 'static,
{
self.current_reader = Some(Box::new(current));
self
}
pub fn on_activate<F>(mut self, on_activate: F) -> Self
where
F: FnMut(usize, String) + 'static,
{
self.on_activate = Some(Box::new(on_activate));
self
}
pub fn on_activate_with_ctx<F>(mut self, on_activate: F) -> Self
where
F: FnMut(&mut EventCtx, usize, String) + 'static,
{
self.on_activate_with_ctx = Some(Box::new(on_activate));
self
}
fn normalized_current(&self) -> usize {
let current = self
.current_reader
.as_ref()
.and_then(|reader| reader())
.unwrap_or(self.current);
if self.items.is_empty() {
0
} else {
current.min(self.items.len() - 1)
}
}
fn name(&self) -> String {
self.name_reader
.as_ref()
.map(|reader| reader())
.unwrap_or_else(|| self.name.clone())
}
fn resolved_theme(&self) -> DefaultTheme {
self.theme_reader
.as_ref()
.map(|theme| theme())
.unwrap_or(*self.theme)
}
fn activate(&mut self, ctx: &mut EventCtx, index: usize) {
if index >= self.items.len() {
return;
}
self.current = index;
self.focused_index = index;
if let Some(on_activate) = &mut self.on_activate {
on_activate(index, self.items[index].label.clone());
}
if let Some(on_activate) = &mut self.on_activate_with_ctx {
on_activate(ctx, index, self.items[index].label.clone());
}
}
fn max_scroll_x(&self, bounds: Rect) -> f32 {
(self.content_width - bounds.width()).max(0.0)
}
fn content_overflows(&self, bounds: Rect) -> bool {
self.max_scroll_x(bounds) > 0.5
}
fn sync_scroll_to_bounds(&mut self, bounds: Rect) {
let max_scroll = self.max_scroll_x(bounds);
self.scroll_x = if self.auto_scroll_to_end {
max_scroll
} else {
self.scroll_x.clamp(0.0, max_scroll)
};
}
fn set_scroll_x(&mut self, bounds: Rect, next_scroll_x: f32) -> bool {
let max_scroll = self.max_scroll_x(bounds);
let next_scroll_x = next_scroll_x.clamp(0.0, max_scroll);
if (self.scroll_x - next_scroll_x).abs() <= 0.5 {
return false;
}
self.scroll_x = next_scroll_x;
self.auto_scroll_to_end = false;
true
}
fn wheel_scroll_delta(delta: Vector) -> f32 {
if delta.x.abs() > 0.0 {
-delta.x
} else {
-delta.y
}
}
fn item_rect(&self, bounds: Rect, index: usize) -> Option<Rect> {
let widths = &self.measured_widths;
if index >= widths.len() {
return None;
}
let theme = self.resolved_theme();
let padding = theme.metrics.breadcrumb_item_padding;
let gap = theme.metrics.breadcrumb_gap;
let mut x = bounds.x() + padding.left - self.scroll_x;
for (current, width) in widths.iter().enumerate() {
let rect = Rect::new(
x,
bounds.y() + padding.top,
*width,
(bounds.height() - padding.top - padding.bottom).max(0.0),
);
if current == index {
return Some(rect);
}
x += *width + gap;
}
None
}
fn item_at(&self, bounds: Rect, position: Point) -> Option<usize> {
if !bounds.contains(position) {
return None;
}
(0..self.items.len()).find(|index| {
self.item_rect(bounds, *index)
.is_some_and(|rect| rect.contains(position))
})
}
fn set_hovered(&mut self, hovered: Option<usize>, ctx: &mut EventCtx) {
if self.hovered == hovered {
return;
}
self.hovered = hovered;
let theme = self.resolved_theme();
self.hover_motion.set_hover_target(hovered, &theme, ctx);
ctx.request_paint();
ctx.request_semantics();
}
fn set_pressed(&mut self, pressed: Option<usize>, ctx: &mut EventCtx) {
if self.pressed == pressed {
return;
}
self.pressed = pressed;
let theme = self.resolved_theme();
self.press_motion.set_press_target(pressed, &theme, ctx);
ctx.request_paint();
ctx.request_semantics();
}
}
impl Widget for Breadcrumb {
fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
match event {
Event::Pointer(pointer) if pointer.kind == PointerEventKind::Move => {
if pointer.buttons.contains(PointerButton::Primary)
&& let Some((anchor_position, anchor_scroll_x)) = self.drag_anchor
{
let bounds = ctx.bounds();
if self.content_overflows(bounds) {
let next_scroll_x =
anchor_scroll_x - (pointer.position.x - anchor_position.x);
if self.set_scroll_x(bounds, next_scroll_x) {
self.drag_moved = true;
self.set_pressed(None, ctx);
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
if (pointer.position.x - anchor_position.x).abs() > 3.0 {
self.drag_moved = true;
}
}
}
let hovered = self.item_at(ctx.bounds(), pointer.position);
self.set_hovered(hovered, ctx);
}
Event::Pointer(pointer) if pointer.kind == PointerEventKind::Scroll => {
let bounds = ctx.bounds();
if bounds.contains(pointer.position) && self.content_overflows(bounds) {
let delta = pointer
.scroll_delta
.map(scroll_delta_to_offset)
.unwrap_or(pointer.delta);
if self.set_scroll_x(bounds, self.scroll_x + Self::wheel_scroll_delta(delta)) {
let hovered = self.item_at(bounds, pointer.position);
self.set_hovered(hovered, ctx);
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
}
}
Event::Pointer(pointer)
if pointer.kind == PointerEventKind::Down
&& pointer.button == Some(PointerButton::Primary) =>
{
let pressed = self.item_at(ctx.bounds(), pointer.position);
self.drag_anchor = Some((pointer.position, self.scroll_x));
self.drag_moved = false;
self.set_hovered(pressed, ctx);
self.set_pressed(pressed, ctx);
ctx.request_focus();
ctx.request_pointer_capture(pointer.pointer_id);
ctx.set_handled();
}
Event::Pointer(pointer)
if pointer.kind == PointerEventKind::Up
&& pointer.button == Some(PointerButton::Primary) =>
{
let hovered = self.item_at(ctx.bounds(), pointer.position);
if !self.drag_moved
&& let Some(index) = self
.pressed
.zip(hovered)
.filter(|(pressed, hovered)| pressed == hovered)
.map(|(index, _)| index)
{
self.activate(ctx, index);
}
self.set_hovered(hovered, ctx);
self.set_pressed(None, ctx);
self.drag_anchor = None;
self.drag_moved = false;
ctx.release_pointer_capture(pointer.pointer_id);
ctx.set_handled();
}
Event::Pointer(pointer) if pointer.kind == PointerEventKind::Leave => {
if self.drag_anchor.is_none() {
self.set_hovered(None, ctx);
}
}
Event::Pointer(pointer) if pointer.kind == PointerEventKind::Cancel => {
if self.pressed.is_some() || self.drag_anchor.is_some() {
self.set_pressed(None, ctx);
self.set_hovered(None, ctx);
self.drag_anchor = None;
self.drag_moved = false;
ctx.release_pointer_capture(pointer.pointer_id);
ctx.set_handled();
}
}
Event::Keyboard(key) if ctx.is_focused() && key.state == KeyState::Pressed => {
if self.items.is_empty() {
return;
}
match key.key.as_str() {
"ArrowLeft" => {
self.focused_index = self.focused_index.saturating_sub(1);
}
"ArrowRight" => {
self.focused_index = (self.focused_index + 1).min(self.items.len() - 1);
}
"Enter" | " " => self.activate(ctx, self.focused_index),
"Home" => self.focused_index = 0,
"End" => self.focused_index = self.items.len() - 1,
_ => return,
}
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
_ => {}
}
}
fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
let theme = self.resolved_theme();
let text_style = theme.body_text_style();
self.measured_widths = self
.items
.iter()
.map(|item| {
measure_text_or_estimate(ctx, &item.label, &text_style).width
+ theme.metrics.breadcrumb_item_padding.left
+ theme.metrics.breadcrumb_item_padding.right
})
.collect();
let desired_width = self.measured_widths.iter().sum::<f32>()
+ (self.items.len().saturating_sub(1) as f32 * theme.metrics.breadcrumb_gap)
+ theme.metrics.breadcrumb_item_padding.left
+ theme.metrics.breadcrumb_item_padding.right;
if (self.content_width - desired_width).abs() > 0.5 {
self.content_width = desired_width;
self.auto_scroll_to_end = true;
}
constraints.clamp(Size::new(
desired_width.max(180.0),
theme.metrics.breadcrumb_height,
))
}
fn arrange(&mut self, _ctx: &mut ArrangeCtx, bounds: Rect) {
self.sync_scroll_to_bounds(bounds);
}
fn paint(&self, ctx: &mut PaintCtx) {
let theme = self.resolved_theme();
let palette = theme.palette;
let bounds = ctx.bounds();
draw_surface(ctx, bounds, &theme, self.focus_animation.get(ctx));
ctx.push_clip_rect(bounds);
for (index, item) in self.items.iter().enumerate() {
let Some(rect) = self.item_rect(bounds, index) else {
continue;
};
if rect.max_x() < bounds.x() || rect.x() > bounds.max_x() {
continue;
}
let current = self.normalized_current() == index;
let focused = ctx.is_focused() && self.focused_index == index;
let hover_amount = self.hover_motion.amount_for(&index, ctx);
let press_amount = self.press_motion.amount_for(&index, ctx);
if current
|| focused
|| hover_amount > AnimatedScalar::EPSILON
|| press_amount > AnimatedScalar::EPSILON
{
ctx.fill(
Path::rounded_rect(rect, theme.metrics.corner_radius),
data_row_state_fill(&theme, current || focused, hover_amount, press_amount),
);
}
let style = theme.body_text_style();
draw_aligned_text(
ctx,
horizontal_inset_rect(rect, 8.0),
&item.label,
&style,
TableColumnAlignment::Start,
);
if index + 1 < self.items.len() {
let separator = chevron_path(Rect::new(
rect.max_x()
+ ((theme.metrics.breadcrumb_gap
- theme.metrics.breadcrumb_separator_size)
* 0.5)
.max(0.0),
rect.y() + ((rect.height() - theme.metrics.breadcrumb_separator_size) * 0.5),
theme.metrics.breadcrumb_separator_size,
theme.metrics.breadcrumb_separator_size,
));
ctx.stroke(
separator,
palette.placeholder.with_alpha(0.9),
sui_scene::StrokeStyle::new(1.5),
);
}
}
ctx.pop_clip();
}
fn semantics(&self, ctx: &mut SemanticsCtx) {
let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::Breadcrumb, ctx.bounds());
node.name = Some(self.name());
node.state.focused = ctx.is_focused();
node.value = self
.items
.get(self.normalized_current())
.map(|item| SemanticsValue::Text(item.label.clone()));
node.actions = vec![SemanticsAction::Focus, SemanticsAction::SetValue];
ctx.push(node);
}
fn accepts_focus(&self) -> bool {
true
}
fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
let theme = self.resolved_theme();
set_focus_animation_target(&mut self.focus_animation, focused as u8 as f32, &theme, ctx);
ctx.request_paint();
ctx.request_semantics();
}
}
#[derive(Debug, Clone, PartialEq)]
struct TreeRow {
key: u64,
path: Vec<usize>,
depth: usize,
label: String,
detail: Option<String>,
has_children: bool,
expanded: bool,
disabled: bool,
}
fn flatten_tree(items: &[TreeItem], depth: usize, path: &mut Vec<usize>, rows: &mut Vec<TreeRow>) {
for (index, item) in items.iter().enumerate() {
path.push(index);
rows.push(TreeRow {
key: item.key.unwrap_or_else(|| tree_path_key(path.as_slice())),
path: path.clone(),
depth,
label: item.label.clone(),
detail: item.detail.clone(),
has_children: !item.children.is_empty(),
expanded: item.expanded,
disabled: item.disabled,
});
if item.expanded {
flatten_tree(&item.children, depth + 1, path, rows);
}
path.pop();
}
}
fn tree_path_key(path: &[usize]) -> u64 {
path.iter().fold(0xcbf2_9ce4_8422_2325, |hash, index| {
(hash ^ (*index as u64).wrapping_add(1)).wrapping_mul(0x1000_0000_01b3)
})
}
fn tree_view_row_id(parent: WidgetId, key: u64) -> WidgetId {
const TAG: u64 = 8_u64 << 50;
const LOW_MASK: u64 = (1_u64 << 50) - 1;
let mixed = key
.wrapping_add(parent.get().rotate_left(23))
.wrapping_mul(0x9e37_79b9_7f4a_7c15);
WidgetId::new(TAG | ((mixed ^ (mixed >> 29)) & LOW_MASK))
}
fn tree_item<'a>(items: &'a [TreeItem], path: &[usize]) -> Option<&'a TreeItem> {
let (first, rest) = path.split_first()?;
let item = items.get(*first)?;
if rest.is_empty() {
Some(item)
} else {
tree_item(&item.children, rest)
}
}
fn tree_item_mut<'a>(items: &'a mut [TreeItem], path: &[usize]) -> Option<&'a mut TreeItem> {
let (first, rest) = path.split_first()?;
let item = items.get_mut(*first)?;
if rest.is_empty() {
Some(item)
} else {
tree_item_mut(&mut item.children, rest)
}
}
fn disclosure_rect(theme: &DefaultTheme, row: Rect, depth: usize) -> Rect {
let metrics = theme.metrics;
Rect::new(
row.x() + metrics.data_row_padding.left + depth as f32 * metrics.tree_indent,
row.y() + ((row.height() - metrics.tree_disclosure_size) * 0.5),
metrics.tree_disclosure_size,
metrics.tree_disclosure_size,
)
}
fn tree_label_offset(theme: &DefaultTheme, depth: usize) -> f32 {
theme.metrics.data_row_padding.left
+ depth as f32 * theme.metrics.tree_indent
+ theme.metrics.tree_disclosure_size
+ theme.metrics.tree_disclosure_gap
}
fn disclosure_path(rect: Rect, expanded: bool) -> Path {
let mut builder = PathBuilder::new();
if expanded {
builder
.move_to(Point::new(rect.x(), rect.y() + 2.0))
.line_to(Point::new(rect.max_x(), rect.y() + 2.0))
.line_to(Point::new(
rect.x() + (rect.width() * 0.5),
rect.max_y() - 2.0,
))
.close();
} else {
builder
.move_to(Point::new(rect.x() + 2.0, rect.y()))
.line_to(Point::new(
rect.max_x() - 2.0,
rect.y() + (rect.height() * 0.5),
))
.line_to(Point::new(rect.x() + 2.0, rect.max_y()))
.close();
}
builder.build()
}
fn chevron_path(rect: Rect) -> Path {
let mut builder = PathBuilder::new();
builder
.move_to(Point::new(rect.x(), rect.y()))
.line_to(Point::new(rect.max_x(), rect.y() + (rect.height() * 0.5)))
.line_to(Point::new(rect.x(), rect.max_y()));
builder.build()
}
pub(crate) fn draw_surface(
ctx: &mut PaintCtx,
rect: Rect,
theme: &DefaultTheme,
_focus_progress: f32,
) {
let palette = theme.palette;
let metrics = theme.metrics;
draw_control_shape(
ctx,
rect,
metrics.corner_radius,
physical_pixels(ctx, metrics.border_width.max(1.0)),
palette.surface,
palette.border,
);
}
fn draw_vertical_scroll_thumb(
ctx: &mut PaintCtx,
theme: &DefaultTheme,
viewport: Rect,
content_height: f32,
scroll_y: f32,
color: Color,
) {
if content_height <= viewport.height() || viewport.height() <= 0.0 {
return;
}
let ratio = (viewport.height() / content_height).clamp(0.08, 1.0);
let metrics = theme.metrics;
let thumb_height = (viewport.height() * ratio)
.max(metrics.data_scroll_thumb_min_length)
.min(viewport.height());
let gutter_width =
(ctx.bounds().max_x() - metrics.data_viewport_padding.right - viewport.max_x())
.max(0.0)
.min(metrics.scroll_bar_thickness);
if gutter_width <= 0.0 {
return;
}
let max_scroll = (content_height - viewport.height()).max(1.0);
let thumb_y = viewport.y() + ((viewport.height() - thumb_height) * (scroll_y / max_scroll));
let thumb_width = metrics.data_scroll_thumb_width.min(gutter_width).max(0.0);
let thumb_inset = metrics
.data_scroll_thumb_inset
.min((gutter_width - thumb_width).max(0.0));
ctx.fill(
Path::rounded_rect(
Rect::new(
viewport.max_x() + gutter_width - thumb_inset - thumb_width,
thumb_y,
thumb_width,
thumb_height,
),
metrics.data_scroll_thumb_radius,
),
color.with_alpha(metrics.data_scroll_thumb_opacity),
);
}
fn draw_aligned_text(
ctx: &mut PaintCtx,
rect: Rect,
text: &str,
style: &TextStyle,
alignment: TableColumnAlignment,
) {
ctx.push_clip_rect(rect);
paint_text(ctx, rect, text, style, alignment.text_align());
ctx.pop_clip();
}
const TWO_LINE_ROW_TEXT_GAP: f32 = 2.0;
fn row_text_rects(
ctx: &PaintCtx,
rect: Rect,
primary_measurement: TextMeasurement,
primary_line_height: f32,
secondary_measurement: Option<TextMeasurement>,
secondary_line_height: Option<f32>,
) -> (Rect, Option<Rect>) {
match secondary_line_height {
Some(secondary_line_height) => {
let secondary_measurement = secondary_measurement.unwrap_or(primary_measurement);
let primary_height = primary_line_height.max(primary_measurement.height);
let secondary_height = secondary_line_height.max(secondary_measurement.height);
let total_height = primary_height + secondary_height + TWO_LINE_ROW_TEXT_GAP;
let top = rect.y() + ((rect.height() - total_height) * 0.5).max(0.0);
let primary_rect = Rect::new(rect.x(), top, rect.width(), primary_height);
let secondary_rect = Rect::new(
rect.x(),
top + primary_height + TWO_LINE_ROW_TEXT_GAP,
rect.width(),
secondary_height,
);
(
Rect::new(
primary_rect.x(),
vertically_centered_text_rect_y(
ctx,
primary_rect,
primary_measurement,
primary_height,
),
primary_rect.width(),
primary_rect.height(),
),
Some(Rect::new(
secondary_rect.x(),
vertically_centered_text_rect_y(
ctx,
secondary_rect,
secondary_measurement,
secondary_height,
),
secondary_rect.width(),
secondary_rect.height(),
)),
)
}
None => {
let height = primary_line_height
.max(primary_measurement.height)
.min(rect.height());
let y = vertically_centered_text_rect_y(ctx, rect, primary_measurement, height);
(Rect::new(rect.x(), y, rect.width(), height), None)
}
}
}
fn two_line_row_height(primary_line_height: f32, secondary_line_height: f32) -> f32 {
primary_line_height + secondary_line_height + TWO_LINE_ROW_TEXT_GAP
}
fn detail_row_height(theme: &DefaultTheme, base: f32) -> f32 {
base.max(two_line_row_height(
theme.body_text_style().line_height,
caption_style(theme).line_height,
))
}
fn horizontal_inset_rect(rect: Rect, inset: f32) -> Rect {
Rect::new(
rect.x() + inset,
rect.y(),
(rect.width() - (inset * 2.0)).max(0.0),
rect.height(),
)
}
fn estimate_text_width(text: &str, style: &TextStyle) -> f32 {
text.chars().count() as f32 * style.font_size * 0.56
}
fn numeric_text_style(mut style: TextStyle) -> TextStyle {
style.features.enable(FontFeature::TABULAR_FIGURES);
style
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct LeadingLabelCellPaint {
pub icon: Option<IconGlyph>,
pub icon_color: Option<Color>,
pub label_color: Option<Color>,
pub label_weight: FontWeight,
pub padding_left: f32,
pub padding_right: f32,
pub icon_slot_side: Option<f32>,
pub icon_inset: f32,
pub gap: Option<f32>,
}
impl LeadingLabelCellPaint {
pub const fn new() -> Self {
Self {
icon: None,
icon_color: None,
label_color: None,
label_weight: FontWeight::NORMAL,
padding_left: 6.0,
padding_right: 8.0,
icon_slot_side: None,
icon_inset: 2.0,
gap: None,
}
}
pub const fn icon(mut self, icon: IconGlyph) -> Self {
self.icon = Some(icon);
self
}
pub const fn icon_color(mut self, color: Color) -> Self {
self.icon_color = Some(color);
self
}
pub const fn label_color(mut self, color: Color) -> Self {
self.label_color = Some(color);
self
}
pub const fn label_weight(mut self, weight: FontWeight) -> Self {
self.label_weight = weight;
self
}
pub const fn padding(mut self, left: f32, right: f32) -> Self {
self.padding_left = left;
self.padding_right = right;
self
}
pub const fn icon_slot_side(mut self, side: f32) -> Self {
self.icon_slot_side = Some(side);
self
}
pub const fn icon_inset(mut self, inset: f32) -> Self {
self.icon_inset = inset;
self
}
pub const fn gap(mut self, gap: f32) -> Self {
self.gap = Some(gap);
self
}
}
impl Default for LeadingLabelCellPaint {
fn default() -> Self {
Self::new()
}
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct TextCellPaint {
pub color: Option<Color>,
pub weight: FontWeight,
pub padding_left: f32,
pub padding_right: f32,
pub alignment: TableColumnAlignment,
pub numeric: bool,
pub text_token: Option<ThemeTextToken>,
}
impl TextCellPaint {
pub const fn new() -> Self {
Self {
color: None,
weight: FontWeight::NORMAL,
padding_left: 8.0,
padding_right: 8.0,
alignment: TableColumnAlignment::Start,
numeric: false,
text_token: None,
}
}
pub const fn color(mut self, color: Color) -> Self {
self.color = Some(color);
self
}
pub const fn weight(mut self, weight: FontWeight) -> Self {
self.weight = weight;
self
}
pub const fn padding(mut self, left: f32, right: f32) -> Self {
self.padding_left = left;
self.padding_right = right;
self
}
pub const fn alignment(mut self, alignment: TableColumnAlignment) -> Self {
self.alignment = alignment;
self
}
pub const fn numeric(mut self, numeric: bool) -> Self {
self.numeric = numeric;
self
}
pub const fn text_token(mut self, token: ThemeTextToken) -> Self {
self.text_token = Some(token);
self
}
}
impl Default for TextCellPaint {
fn default() -> Self {
Self::new()
}
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct TextBlockPaint {
pub color: Option<Color>,
pub weight: FontWeight,
pub padding: Insets,
pub text_token: Option<ThemeTextToken>,
pub wrap: TextWrap,
pub alignment: TextAlign,
}
impl TextBlockPaint {
pub const fn new() -> Self {
Self {
color: None,
weight: FontWeight::NORMAL,
padding: Insets::ZERO,
text_token: None,
wrap: TextWrap::Word,
alignment: TextAlign::Start,
}
}
pub const fn color(mut self, color: Color) -> Self {
self.color = Some(color);
self
}
pub const fn weight(mut self, weight: FontWeight) -> Self {
self.weight = weight;
self
}
pub const fn padding(mut self, padding: Insets) -> Self {
self.padding = padding;
self
}
pub const fn text_token(mut self, token: ThemeTextToken) -> Self {
self.text_token = Some(token);
self
}
pub const fn wrap(mut self, wrap: TextWrap) -> Self {
self.wrap = wrap;
self
}
pub const fn alignment(mut self, alignment: TextAlign) -> Self {
self.alignment = alignment;
self
}
}
impl Default for TextBlockPaint {
fn default() -> Self {
Self::new()
}
}
pub fn paint_leading_label_cell(
ctx: &mut PaintCtx,
theme: &DefaultTheme,
rect: Rect,
label: &str,
style: LeadingLabelCellPaint,
) {
if rect.width() <= 0.0 || rect.height() <= 0.0 {
return;
}
let mut text_x = rect.x() + style.padding_left.max(0.0);
if let Some(icon) = style.icon {
let slot_side = style
.icon_slot_side
.unwrap_or(theme.metrics.data_row_icon_size)
.min((rect.height() - 6.0).max(0.0))
.max(0.0);
let icon_rect = Rect::new(
text_x,
rect.y() + ((rect.height() - slot_side) * 0.5).max(0.0),
slot_side,
slot_side,
);
let icon_inset = style.icon_inset.max(0.0).min(slot_side * 0.45);
draw_icon_glyph(
ctx,
icon,
icon_rect.inflate(-icon_inset, -icon_inset),
style.icon_color.unwrap_or(theme.palette.text_muted),
);
text_x = icon_rect.max_x()
+ style
.gap
.unwrap_or(theme.metrics.data_row_icon_gap)
.max(0.0);
}
let label_rect = Rect::new(
text_x,
rect.y(),
(rect.max_x() - text_x - style.padding_right.max(0.0)).max(0.0),
rect.height(),
);
if label_rect.width() <= 0.0 {
return;
}
let mut label_style = TextStyle {
font_size: theme.text.sm.size.max(1.0),
line_height: theme.text.sm.line_height.max(1.0),
color: style.label_color.unwrap_or(theme.palette.text),
..theme.body_text_style()
};
label_style.weight = style.label_weight;
ctx.push_clip_rect(label_rect);
paint_text(ctx, label_rect, label, &label_style, TextAlign::Start);
ctx.pop_clip();
}
pub fn paint_text_block(
ctx: &mut PaintCtx,
theme: &DefaultTheme,
rect: Rect,
text: &str,
style: TextBlockPaint,
) {
if rect.width() <= 0.0 || rect.height() <= 0.0 {
return;
}
let content = Rect::new(
rect.x() + style.padding.left.max(0.0),
rect.y() + style.padding.top.max(0.0),
(rect.width() - style.padding.left.max(0.0) - style.padding.right.max(0.0)).max(0.0),
(rect.height() - style.padding.top.max(0.0) - style.padding.bottom.max(0.0)).max(0.0),
);
if content.width() <= 0.0 || content.height() <= 0.0 {
return;
}
let token = style.text_token.unwrap_or(theme.text.sm);
let mut text_style = TextStyle {
font_size: token.size.max(1.0),
line_height: token.line_height.max(1.0),
color: style.color.unwrap_or(theme.palette.text),
..theme.body_text_style()
};
text_style.weight = style.weight;
let color = text_style.color;
let mut layout_style = text_style.clone();
layout_style.color = Color::WHITE;
let mut document = TextDocument::from_plain_text(text.to_string(), layout_style);
for paragraph in &mut document.paragraphs {
paragraph.style.align = style.alignment;
paragraph.style.wrap = style.wrap;
}
ctx.push_clip_rect(content);
if let Ok(layout) = ctx.layout_text_document(TextLayoutRequest::new(document).with_box_size(
Size::new(content.width().max(1.0), content.height().max(1.0)),
)) {
ctx.draw_text_layout_with_color(content.origin, &layout, color);
} else {
ctx.draw_text(content, text.to_string(), text_style);
}
ctx.pop_clip();
}
pub fn paint_text_cell(
ctx: &mut PaintCtx,
theme: &DefaultTheme,
rect: Rect,
text: &str,
style: TextCellPaint,
) {
if rect.width() <= 0.0 || rect.height() <= 0.0 {
return;
}
let left = style.padding_left.max(0.0);
let right = style.padding_right.max(0.0);
let content = Rect::new(
rect.x() + left,
rect.y(),
(rect.width() - left - right).max(0.0),
rect.height(),
);
if content.width() <= 0.0 {
return;
}
let token = style.text_token.unwrap_or(theme.text.sm);
let mut text_style = TextStyle {
font_size: token.size.max(1.0),
line_height: token.line_height.max(1.0),
color: style.color.unwrap_or(theme.palette.text),
..theme.body_text_style()
};
text_style.weight = style.weight;
if style.numeric {
text_style = numeric_text_style(text_style);
}
ctx.push_clip_rect(content);
paint_text(
ctx,
content,
text,
&text_style,
style.alignment.text_align(),
);
ctx.pop_clip();
}
fn measure_list_item_leading_width(
ctx: &mut MeasureCtx,
item: &ListItem,
style: &TextStyle,
theme: &DefaultTheme,
) -> f32 {
if item.leading_icon.is_some() {
return theme.metrics.data_row_icon_size + theme.metrics.data_row_icon_gap;
}
item.leading_text
.as_deref()
.map(|text| {
measure_text_or_estimate(ctx, text, style).width + theme.metrics.data_row_icon_gap
})
.unwrap_or(0.0)
}
fn measure_text_or_estimate(
ctx: &mut MeasureCtx,
text: &str,
style: &TextStyle,
) -> TextMeasurement {
ctx.layout()
.measure_text(text.to_string(), style.clone())
.unwrap_or(TextMeasurement {
width: estimate_text_width(text, style),
height: style.line_height,
bounds: Rect::ZERO,
ascent: style.font_size,
descent: 0.0,
cap_height: Some(style.font_size),
})
}
fn paint_text_measurement(ctx: &PaintCtx, text: &str, style: &TextStyle) -> TextMeasurement {
ctx.measure_text(text.to_string(), style.clone())
.unwrap_or(TextMeasurement {
width: estimate_text_width(text, style),
height: style.line_height,
bounds: Rect::ZERO,
ascent: style.font_size,
descent: 0.0,
cap_height: Some(style.font_size),
})
}
fn caption_style(theme: &DefaultTheme) -> TextStyle {
TextStyle {
font_size: theme.text.xs.size.max(1.0),
line_height: theme.text.xs.line_height.max(1.0),
color: theme.palette.placeholder,
..theme.body_text_style()
}
}
fn row_highlight_rect(row: Rect, viewport: Rect) -> Option<Rect> {
row.intersection(viewport)
.map(|visible| inset_rect(visible, Insets::all(1.0)))
.filter(|rect| !rect.is_empty())
}
type AnimatedScalar = crate::Progress;
fn set_animation_target(
animation: &mut AnimatedScalar,
target: f32,
duration: f64,
easing: crate::Easing,
ctx: &mut EventCtx,
) -> bool {
animation.animate(target, crate::AnimationSpec::tween(duration, easing), ctx)
}
fn set_hover_animation_target(
animation: &mut AnimatedScalar,
target: f32,
theme: &DefaultTheme,
ctx: &mut EventCtx,
) -> bool {
set_animation_target(
animation,
target,
theme.motion.hover_duration(),
theme.motion.hover_easing(),
ctx,
)
}
fn set_press_animation_target(
animation: &mut AnimatedScalar,
target: f32,
theme: &DefaultTheme,
ctx: &mut EventCtx,
) -> bool {
set_animation_target(
animation,
target,
theme.motion.press_duration(),
theme.motion.press_easing(),
ctx,
)
}
fn set_focus_animation_target(
animation: &mut AnimatedScalar,
target: f32,
theme: &DefaultTheme,
ctx: &mut EventCtx,
) -> bool {
set_animation_target(
animation,
target,
theme.motion.focus_duration(),
theme.motion.focus_easing(),
ctx,
)
}
#[derive(Debug, Clone, PartialEq)]
struct IndexedInteractionMotion<T>
where
T: Clone + PartialEq,
{
visual: Option<T>,
animation: AnimatedScalar,
}
impl<T> IndexedInteractionMotion<T>
where
T: Clone + PartialEq,
{
const fn new() -> Self {
Self {
visual: None,
animation: AnimatedScalar::new(0.0),
}
}
fn set_hover_target(
&mut self,
target: Option<T>,
theme: &DefaultTheme,
ctx: &mut EventCtx,
) -> bool {
self.set_target(target, theme, ctx, |animation, target, theme, ctx| {
set_hover_animation_target(animation, target, theme, ctx)
})
}
fn set_press_target(
&mut self,
target: Option<T>,
theme: &DefaultTheme,
ctx: &mut EventCtx,
) -> bool {
self.set_target(target, theme, ctx, |animation, target, theme, ctx| {
set_press_animation_target(animation, target, theme, ctx)
})
}
fn set_target(
&mut self,
target: Option<T>,
theme: &DefaultTheme,
ctx: &mut EventCtx,
set_animation: impl FnOnce(&mut AnimatedScalar, f32, &DefaultTheme, &mut EventCtx) -> bool,
) -> bool {
match target {
Some(target) => {
if self.visual.as_ref() != Some(&target) {
self.visual = Some(target);
self.animation = AnimatedScalar::new(0.0);
}
set_animation(&mut self.animation, 1.0, theme, ctx)
}
None => {
let changed = set_animation(&mut self.animation, 0.0, theme, ctx);
if !changed && !self.animation.is_presented(ctx) {
self.visual = None;
}
changed
}
}
}
fn amount_for(&self, key: &T, clock: &impl FrameClock) -> f32 {
self.amount_for_by(|visual| visual == key, clock)
}
fn amount_for_by(&self, matches: impl FnOnce(&T) -> bool, clock: &impl FrameClock) -> f32 {
self.visual
.as_ref()
.filter(|visual| matches(visual))
.map(|_| self.animation.get(clock))
.unwrap_or(0.0)
}
}
fn data_row_state_fill(
theme: &DefaultTheme,
selected: bool,
hover_amount: f32,
press_amount: f32,
) -> Color {
let palette = theme.palette;
let interaction = theme.interaction;
if selected {
palette.selection
} else {
let overlay = theme.surfaces.hover;
let hover_alpha = overlay.alpha * interaction.hover_blend * hover_amount.clamp(0.0, 1.0);
let press_alpha =
overlay.alpha * 1.75 * interaction.pressed_blend * press_amount.clamp(0.0, 1.0);
let alpha = hover_alpha.max(press_alpha).min(0.18);
if alpha > AnimatedScalar::EPSILON {
overlay.with_alpha(alpha)
} else {
Color::TRANSPARENT
}
}
}
pub(crate) fn paint_data_row_state(
ctx: &mut PaintCtx,
row: Rect,
viewport: Rect,
theme: &DefaultTheme,
selected: bool,
hover_amount: f32,
press_amount: f32,
) {
if !selected
&& hover_amount <= AnimatedScalar::EPSILON
&& press_amount <= AnimatedScalar::EPSILON
{
return;
}
let Some(highlight) = row_highlight_rect(row, viewport) else {
return;
};
ctx.fill_rect(
highlight,
data_row_state_fill(theme, selected, hover_amount, press_amount),
);
if selected {
let indicator_width = 2.0_f32.min(highlight.width());
let indicator_inset = (highlight.height() * 0.18).min(5.0);
let indicator = Rect::new(
highlight.x(),
highlight.y() + indicator_inset,
indicator_width,
(highlight.height() - indicator_inset * 2.0).max(0.0),
);
if !indicator.is_empty() {
ctx.fill(
Path::rounded_rect(indicator, indicator_width * 0.5),
theme.palette.accent,
);
}
}
}
fn list_view_row_id(parent: WidgetId, index: usize) -> WidgetId {
const TAG: u64 = 5_u64 << 50;
const LOW_MASK: u64 = (1_u64 << 50) - 1;
WidgetId::new(
TAG | (parent
.get()
.wrapping_mul(359)
.wrapping_add(index as u64 + 1)
& LOW_MASK),
)
}
fn virtual_table_row_id(parent: WidgetId, row_key: u64) -> WidgetId {
const TAG: u64 = 7_u64 << 50;
const LOW_MASK: u64 = (1_u64 << 50) - 1;
let mixed = row_key
.wrapping_add(0x9e37_79b9_7f4a_7c15)
.wrapping_add(parent.get().rotate_left(17));
let mixed = (mixed ^ (mixed >> 30)).wrapping_mul(0xbf58_476d_1ce4_e5b9);
let mixed = (mixed ^ (mixed >> 27)).wrapping_mul(0x94d0_49bb_1331_11eb);
WidgetId::new(TAG | ((mixed ^ (mixed >> 31)) & LOW_MASK))
}
fn layer_list_row_id(parent: WidgetId, index: usize) -> WidgetId {
const TAG: u64 = 6_u64 << 50;
const LOW_MASK: u64 = (1_u64 << 50) - 1;
WidgetId::new(
TAG | (parent
.get()
.wrapping_mul(383)
.wrapping_add(index as u64 + 1)
& LOW_MASK),
)
}
fn layer_list_visibility_id(parent: WidgetId, index: usize) -> WidgetId {
const TAG: u64 = 7_u64 << 50;
const LOW_MASK: u64 = (1_u64 << 50) - 1;
WidgetId::new(
TAG | (parent
.get()
.wrapping_mul(389)
.wrapping_add(index as u64 + 1)
& LOW_MASK),
)
}
fn layer_list_lock_id(parent: WidgetId, index: usize) -> WidgetId {
const TAG: u64 = 4_u64 << 50;
const LOW_MASK: u64 = (1_u64 << 50) - 1;
WidgetId::new(
TAG | (parent
.get()
.wrapping_mul(397)
.wrapping_add(index as u64 + 1)
& LOW_MASK),
)
}
fn paint_layer_visibility_button(
ctx: &mut PaintCtx,
rect: Rect,
theme: &DefaultTheme,
visible: bool,
hover_amount: f32,
press_amount: f32,
) {
let palette = theme.palette;
if hover_amount > AnimatedScalar::EPSILON || press_amount > AnimatedScalar::EPSILON {
ctx.fill(
Path::rounded_rect(rect, theme.metrics.corner_radius.min(rect.height() * 0.35)),
data_row_state_fill(theme, false, hover_amount, press_amount),
);
}
let metrics = theme.metrics;
let icon = inset_rect(rect, Insets::all(metrics.layer_action_icon_inset));
let color = if visible {
palette.accent
} else {
palette.placeholder
};
ctx.stroke(
layer_visibility_eye_path(icon),
color,
sui_scene::StrokeStyle::new(metrics.layer_visibility_stroke_width),
);
if visible {
ctx.fill(
Path::circle(
Point::new(
icon.x() + icon.width() * 0.5,
icon.y() + icon.height() * 0.5,
),
icon.width().min(icon.height()) * 0.17,
),
color,
);
} else {
ctx.stroke(
line_path(
Point::new(
icon.x() + icon.width() * 0.1,
icon.max_y() - icon.height() * 0.05,
),
Point::new(
icon.max_x() - icon.width() * 0.1,
icon.y() + icon.height() * 0.05,
),
),
color,
sui_scene::StrokeStyle::new(metrics.layer_visibility_slash_stroke_width),
);
}
}
fn paint_layer_lock_button(
ctx: &mut PaintCtx,
rect: Rect,
theme: &DefaultTheme,
locked: bool,
hover_amount: f32,
press_amount: f32,
) {
let palette = theme.palette;
if hover_amount > AnimatedScalar::EPSILON || press_amount > AnimatedScalar::EPSILON {
ctx.fill(
Path::rounded_rect(rect, theme.metrics.corner_radius.min(rect.height() * 0.35)),
data_row_state_fill(theme, false, hover_amount, press_amount),
);
}
let metrics = theme.metrics;
draw_icon_glyph(
ctx,
if locked {
IconGlyph::Lock
} else {
IconGlyph::Unlock
},
inset_rect(rect, Insets::all(metrics.layer_lock_icon_inset)),
if locked {
palette.accent
} else {
palette.placeholder
},
);
}
fn paint_layer_thumbnail(
ctx: &mut PaintCtx,
rect: Rect,
theme: &DefaultTheme,
color: Color,
visible: bool,
) {
let palette = theme.palette;
let metrics = theme.metrics;
let radius = metrics.layer_thumbnail_radius;
let rect = snap_to_pixels(ctx, rect);
ctx.fill(Path::rounded_rect(rect, radius), palette.control_hover);
let fill = inset_rect(rect, Insets::all(metrics.layer_thumbnail_inset));
ctx.fill(
Path::rounded_rect(
fill,
(radius - metrics.layer_thumbnail_inset * 0.5).max(0.0),
),
if visible {
color
} else {
color.with_alpha(color.alpha * metrics.layer_thumbnail_disabled_opacity)
},
);
stroke_border(
ctx,
rect,
radius,
physical_pixels(ctx, metrics.border_width.max(1.0)),
palette.border.with_alpha(if visible {
1.0
} else {
metrics.layer_thumbnail_disabled_border_opacity
}),
);
}
fn layer_visibility_eye_path(rect: Rect) -> Path {
let mut builder = PathBuilder::new();
let cx = rect.x() + rect.width() * 0.5;
let cy = rect.y() + rect.height() * 0.5;
builder
.move_to(Point::new(rect.x(), cy))
.cubic_to(
Point::new(rect.x() + rect.width() * 0.22, rect.y()),
Point::new(rect.x() + rect.width() * 0.78, rect.y()),
Point::new(rect.max_x(), cy),
)
.cubic_to(
Point::new(rect.x() + rect.width() * 0.78, rect.max_y()),
Point::new(rect.x() + rect.width() * 0.22, rect.max_y()),
Point::new(rect.x(), cy),
)
.close();
let _ = (cx, cy);
builder.build()
}
fn line_path(from: Point, to: Point) -> Path {
let mut builder = PathBuilder::new();
builder.move_to(from).line_to(to);
builder.build()
}
fn scroll_delta_to_offset(delta: sui_core::ScrollDelta) -> Vector {
match delta {
sui_core::ScrollDelta::Lines(delta) => Vector::new(delta.x * 40.0, delta.y * 40.0),
sui_core::ScrollDelta::Pixels(delta) => delta,
}
}
#[cfg(test)]
mod tests {
use std::{cell::RefCell, rc::Rc};
use crate::draw::rect_center;
use super::{
Breadcrumb, BreadcrumbItem, DefaultTheme, LayerList, LayerListItem, LayerListReorderChange,
LeadingLabelCellPaint, ListItem, ListView, Table, TableColumn, TableColumnAlignment,
TableRow, TextBlockPaint, TextCellPaint, TreeItem, TreeView, VirtualTable,
VirtualTableColumn, VirtualTableState,
};
use crate::{
Button, CollectionWindow, Label, ScrollAlignment, ScrollView, SizedBox, Stack,
ThemeTextToken,
};
use sui_core::{
Color, Event, KeyState, KeyboardEvent, Modifiers, Point, PointerButton, PointerButtons,
PointerEvent, PointerEventKind, PointerKind, Rect, Result, ScrollDelta, SemanticsAction,
SemanticsActionRequest, SemanticsRole, SemanticsValue, Size, ToggleState, Vector, WidgetId,
WindowEvent,
};
use sui_layout::{Constraints, Padding as Insets};
use sui_runtime::{Application, PaintCtx, RenderOutput, Runtime, Widget, WindowBuilder};
use sui_scene::{Brush, SceneCommand};
use sui_text::{FontFeature, FontRegistry, FontWeight, TextSystem};
fn build_runtime<W>(root: W) -> (Runtime, sui_core::WindowId)
where
W: Widget + 'static,
{
let runtime = Application::new()
.window(WindowBuilder::new().title("Data widgets").root(root))
.build()
.unwrap();
let window_id = runtime.window_ids()[0];
(runtime, window_id)
}
fn render<W>(root: W) -> RenderOutput
where
W: Widget + 'static,
{
let (mut runtime, window_id) = build_runtime(root);
runtime.render(window_id).expect("render should succeed")
}
#[test]
fn density_modes_resize_data_widgets() {
let compact = DefaultTheme::compact();
let touch = DefaultTheme::touch();
assert!(
render(
ListView::new("Layers")
.theme(compact)
.items([ListItem::new("Paint"), ListItem::new("Ink")])
)
.frame
.viewport
.height
< render(
ListView::new("Layers")
.theme(touch)
.items([ListItem::new("Paint"), ListItem::new("Ink")])
)
.frame
.viewport
.height
);
assert!(
render(
LayerList::new("Layers")
.theme(compact)
.layers([LayerListItem::new("Paint"), LayerListItem::new("Ink")])
)
.frame
.viewport
.height
< render(
LayerList::new("Layers")
.theme(touch)
.layers([LayerListItem::new("Paint"), LayerListItem::new("Ink")])
)
.frame
.viewport
.height
);
assert!(
render(
TreeView::new("Scene")
.theme(compact)
.items([TreeItem::new("Canvas"), TreeItem::new("Lighting")])
)
.frame
.viewport
.height
< render(
TreeView::new("Scene")
.theme(touch)
.items([TreeItem::new("Canvas"), TreeItem::new("Lighting")])
)
.frame
.viewport
.height
);
assert!(
render(
Table::new("Objects")
.theme(compact)
.columns([TableColumn::new("Name")])
.rows([TableRow::new(["Canvas"]), TableRow::new(["Lighting"])])
)
.frame
.viewport
.height
< render(
Table::new("Objects")
.theme(touch)
.columns([TableColumn::new("Name")])
.rows([TableRow::new(["Canvas"]), TableRow::new(["Lighting"])])
)
.frame
.viewport
.height
);
assert!(
render(
Breadcrumb::new("Path")
.theme(compact)
.items([BreadcrumbItem::new("Scene"), BreadcrumbItem::new("Layers")])
)
.frame
.viewport
.height
< render(
Breadcrumb::new("Path")
.theme(touch)
.items([BreadcrumbItem::new("Scene"), BreadcrumbItem::new("Layers")])
)
.frame
.viewport
.height
);
}
fn text_rects_for(output: &RenderOutput, text: &str) -> Vec<Rect> {
let mut rects = Vec::new();
output
.frame
.scene
.visit_commands(&mut |command| match command {
SceneCommand::DrawText(run) if run.text == text => rects.push(run.rect),
SceneCommand::DrawShapedText(run) => {
if let Some(layout) = run
.resolve(output.frame.text_layout_registry.as_ref())
.filter(|layout| layout.text() == text)
{
rects.push(shaped_text_run_rect(run.origin, layout));
}
}
_ => {}
});
rects
}
fn shaped_text_run_rect(origin: Point, layout: &sui_text::TextLayout) -> Rect {
let measurement = layout.measurement();
let bounds = measurement.bounds;
let width = if bounds.width().is_finite() && bounds.width() > 0.0 {
bounds.width()
} else {
measurement.width
};
Rect::new(
origin.x + bounds.x(),
origin.y + ((layout.box_size().height - measurement.height).max(0.0) * 0.5),
width,
layout.style().line_height.max(measurement.height),
)
}
fn text_runs_for(output: &RenderOutput, text: &str) -> Vec<sui_text::TextRun> {
let mut runs = Vec::new();
output
.frame
.scene
.visit_commands(&mut |command| match command {
SceneCommand::DrawText(run) if run.text == text => runs.push(run.clone()),
SceneCommand::DrawShapedText(run) => {
if let Some(layout) = run
.resolve(output.frame.text_layout_registry.as_ref())
.filter(|layout| layout.text() == text)
{
let mut style = layout.style().clone();
if let Some(color) = run.color_override {
style.color = color;
}
runs.push(sui_text::TextRun {
rect: shaped_text_run_rect(run.origin, layout),
text: layout.text().to_string(),
style,
});
}
}
_ => {}
});
runs
}
fn draw_clip_rects_for(output: &RenderOutput, text: &str) -> Vec<Rect> {
let mut clips = Vec::new();
let mut stack = Vec::new();
output
.frame
.scene
.visit_commands(&mut |command| match command {
SceneCommand::PushClip { rect } => stack.push(*rect),
SceneCommand::PopClip => {
stack.pop();
}
SceneCommand::DrawText(run) if run.text == text => {
if let Some(rect) = stack.last() {
clips.push(*rect);
}
}
SceneCommand::DrawShapedText(run)
if run
.resolve(output.frame.text_layout_registry.as_ref())
.filter(|layout| layout.text() == text)
.is_some_and(|layout| !layout.text().is_empty()) =>
{
if let Some(rect) = stack.last() {
clips.push(*rect);
}
}
_ => {}
});
clips
}
fn selected_highlight_rects(output: &RenderOutput) -> Vec<Rect> {
let theme = DefaultTheme::default();
let selected_brush = Brush::Solid(super::data_row_state_fill(&theme, true, 0.0, 0.0));
let mut rects = Vec::new();
output
.frame
.scene
.visit_commands(&mut |command| match command {
SceneCommand::FillPath { path, brush } if *brush == selected_brush => {
rects.push(path.bounds());
}
SceneCommand::FillRect { rect, brush } if *brush == selected_brush => {
rects.push(*rect);
}
_ => {}
});
rects
}
fn solid_fill_colors(output: &RenderOutput) -> Vec<Color> {
let mut colors = Vec::new();
output
.frame
.scene
.visit_commands(&mut |command| match command {
SceneCommand::FillRect {
brush: Brush::Solid(color),
..
}
| SceneCommand::FillPath {
brush: Brush::Solid(color),
..
} => colors.push(*color),
_ => {}
});
colors
}
fn solid_fill_bounds_for_color(output: &RenderOutput, expected: Color) -> Vec<Rect> {
let mut rects = Vec::new();
output
.frame
.scene
.visit_commands(&mut |command| match command {
SceneCommand::FillRect {
rect,
brush: Brush::Solid(color),
} if *color == expected => rects.push(*rect),
SceneCommand::FillPath {
path,
brush: Brush::Solid(color),
} if *color == expected => rects.push(path.bounds()),
_ => {}
});
rects
}
fn solid_stroke_widths(output: &RenderOutput) -> Vec<f32> {
let mut widths = Vec::new();
output
.frame
.scene
.visit_commands(&mut |command| match command {
SceneCommand::StrokeRect { stroke, .. }
| SceneCommand::StrokePath { stroke, .. } => {
widths.push(stroke.width);
}
_ => {}
});
widths
}
fn solid_stroke_colors(output: &RenderOutput) -> Vec<Color> {
let mut colors = Vec::new();
output
.frame
.scene
.visit_commands(&mut |command| match command {
SceneCommand::StrokeRect {
brush: Brush::Solid(color),
..
}
| SceneCommand::StrokePath {
brush: Brush::Solid(color),
..
} => colors.push(*color),
_ => {}
});
colors
}
fn solid_stroke_rects(output: &RenderOutput) -> Vec<Rect> {
let mut rects = Vec::new();
output.frame.scene.visit_commands(&mut |command| {
if let SceneCommand::StrokeRect { rect, .. } = command {
rects.push(*rect);
}
});
rects
}
fn optical_visual_center(measurement: sui_text::TextMeasurement) -> f32 {
let top = -measurement.cap_height.unwrap_or(measurement.ascent);
let bottom = measurement.descent * 0.5;
(top + bottom) * 0.5
}
fn text_run_visual_center(run: &sui_text::TextRun) -> f32 {
let layout = TextSystem::new()
.shape_text(
run.text.clone(),
Size::new(f32::INFINITY, run.rect.height().max(1.0)),
run.style.clone(),
&FontRegistry::new(),
)
.expect("text run should shape");
let line = layout.lines().first().expect("text run should have a line");
run.rect.y() + line.baseline + optical_visual_center(layout.measurement())
}
fn text_visual_center_for(output: &RenderOutput, text: &str) -> f32 {
output
.frame
.scene
.commands()
.iter()
.find_map(|command| match command {
SceneCommand::DrawText(run) if run.text == text => {
Some(text_run_visual_center(run))
}
SceneCommand::DrawShapedText(run) => {
let layout = run.resolve(output.frame.text_layout_registry.as_ref())?;
if layout.text() != text {
return None;
}
let line = layout.lines().first().expect("text run should have a line");
Some(run.origin.y + line.baseline + optical_visual_center(layout.measurement()))
}
_ => None,
})
.expect("text draw command present")
}
fn assert_two_line_row_text_matches_slots(
output: &RenderOutput,
label: &str,
detail: &str,
row: Rect,
) {
let label = text_runs_for(output, label)
.into_iter()
.next()
.expect("row label draw command present");
let detail = text_runs_for(output, detail)
.into_iter()
.next()
.expect("row detail draw command present");
let total_height =
label.style.line_height + detail.style.line_height + super::TWO_LINE_ROW_TEXT_GAP;
let top = row.y() + ((row.height() - total_height) * 0.5).max(0.0);
let label_slot_center = top + (label.style.line_height * 0.5);
let detail_slot_center = top
+ label.style.line_height
+ super::TWO_LINE_ROW_TEXT_GAP
+ (detail.style.line_height * 0.5);
assert!((text_run_visual_center(&label) - label_slot_center).abs() < 0.75);
assert!((text_run_visual_center(&detail) - detail_slot_center).abs() < 0.75);
}
fn assert_text_run_uses_token(run: &sui_text::TextRun, token: ThemeTextToken) {
assert!(
(run.style.font_size - token.size).abs() < 0.001,
"text '{}' used font size {}, expected token size {}",
run.text,
run.style.font_size,
token.size
);
assert!(
(run.style.line_height - token.line_height).abs() < 0.001,
"text '{}' used line height {}, expected token line height {}",
run.text,
run.style.line_height,
token.line_height
);
}
fn vertical_scroll_thumb_rects(output: &RenderOutput) -> Vec<Rect> {
let mut rects = Vec::new();
output.frame.scene.visit_commands(&mut |command| {
if let SceneCommand::FillPath { path, .. } = command {
let bounds = path.bounds();
if (bounds.width() - 4.0).abs() <= f32::EPSILON && bounds.height() >= 28.0 {
rects.push(bounds);
}
}
});
rects
}
fn primary_pointer(kind: PointerEventKind, position: Point, pressed: bool) -> Event {
let mut buttons = PointerButtons::NONE;
if pressed {
buttons.insert(PointerButton::Primary);
}
Event::Pointer(PointerEvent {
pointer_id: 1,
kind,
position,
delta: Vector::ZERO,
scroll_delta: None,
button: Some(PointerButton::Primary),
buttons,
modifiers: Modifiers::NONE,
pointer_kind: PointerKind::Mouse,
is_primary: true,
})
}
fn wheel_scroll(position: Point, delta: Vector) -> Event {
let mut scroll = PointerEvent::new(PointerEventKind::Scroll, position);
scroll.scroll_delta = Some(ScrollDelta::Pixels(delta));
Event::Pointer(scroll)
}
fn semantic_bounds(output: &RenderOutput, role: SemanticsRole, name: &str) -> Rect {
output
.semantics
.iter()
.find(|node| node.role == role && node.name.as_deref() == Some(name))
.map(|node| node.bounds)
.unwrap_or_else(|| panic!("{role:?} semantics named {name:?} should be present"))
}
fn handle_ready_events(runtime: &mut Runtime) -> Result<usize> {
let ready = runtime.drain_ready_events();
let count = ready.len();
for (ready_window, event) in ready {
runtime.handle_event(ready_window, event)?;
}
Ok(count)
}
fn assert_focus_surface_keeps_chrome_neutral<W>(root: W, position: Point) -> Result<()>
where
W: Widget + 'static,
{
let theme = DefaultTheme::default();
let (mut runtime, window_id) = build_runtime(root);
let unfocused = runtime.render(window_id)?;
let ring_strokes = |output: &RenderOutput| {
solid_stroke_colors(output)
.into_iter()
.filter(|color| *color == theme.palette.focus_ring)
.count()
};
let unfocused_ring_strokes = ring_strokes(&unfocused);
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Down, position, true),
)?;
let focused = runtime.render(window_id)?;
let focused_strokes = solid_stroke_colors(&focused);
assert!(
ring_strokes(&focused) <= unfocused_ring_strokes,
"focused data containers should not paint a focus ring; strokes={focused_strokes:?}"
);
assert_eq!(
focused_strokes.first().copied(),
Some(theme.palette.border),
"focused data containers should keep their surface border neutral; strokes={focused_strokes:?}"
);
Ok(())
}
fn assert_pointer_hover_and_press_use_theme_motion(
runtime: &mut Runtime,
window_id: sui_core::WindowId,
position: Point,
theme: &DefaultTheme,
) -> Result<()> {
let hover_duration = theme.motion.hover_duration();
let press_duration = theme.motion.press_duration();
let expected_hover = super::data_row_state_fill(theme, false, 1.0, 0.0);
let expected_press = super::data_row_state_fill(theme, false, 0.0, 1.0);
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Move, position, false),
)?;
runtime.tick(hover_duration * 0.5);
assert_eq!(handle_ready_events(runtime)?, 0);
let mid_hover = runtime.render(window_id)?;
assert!(
!solid_fill_colors(&mid_hover).contains(&expected_hover),
"hover fill should not snap to the settled hover color"
);
runtime.tick(hover_duration);
assert_eq!(handle_ready_events(runtime)?, 0);
let settled_hover = runtime.render(window_id)?;
assert!(
solid_fill_colors(&settled_hover).contains(&expected_hover),
"hover fill should settle to the theme interaction color"
);
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Down, position, true),
)?;
runtime.tick(hover_duration + press_duration * 0.5);
assert_eq!(handle_ready_events(runtime)?, 0);
let mid_press = runtime.render(window_id)?;
assert!(
!solid_fill_colors(&mid_press).contains(&expected_press),
"press fill should not snap to the settled pressed color"
);
runtime.tick(hover_duration + press_duration);
assert_eq!(handle_ready_events(runtime)?, 0);
let settled_press = runtime.render(window_id)?;
assert!(
solid_fill_colors(&settled_press).contains(&expected_press),
"press fill should settle to the theme interaction color"
);
Ok(())
}
#[test]
fn data_row_hover_and_press_fills_are_translucent_overlays() {
let theme = DefaultTheme::default();
let hover = super::data_row_state_fill(&theme, false, 1.0, 0.0);
let press = super::data_row_state_fill(&theme, false, 0.0, 1.0);
assert_eq!(
super::data_row_state_fill(&theme, false, 0.0, 0.0),
Color::TRANSPARENT
);
assert!(hover.alpha > 0.0 && hover.alpha < 1.0);
assert!(press.alpha > hover.alpha && press.alpha < 1.0);
assert_ne!(hover, theme.palette.control);
assert_ne!(hover, theme.palette.control_hover);
let dark_hover = super::data_row_state_fill(&DefaultTheme::dark(), false, 1.0, 0.0);
assert!(dark_hover.alpha > 0.0 && dark_hover.alpha < 1.0);
}
#[test]
fn data_focus_surfaces_keep_chrome_neutral() -> Result<()> {
assert_focus_surface_keeps_chrome_neutral(
SizedBox::new().width(260.0).height(120.0).child(
ListView::new("Assets").items([ListItem::new("First"), ListItem::new("Second")]),
),
Point::new(24.0, 24.0),
)?;
assert_focus_surface_keeps_chrome_neutral(
SizedBox::new().width(280.0).height(120.0).child(
LayerList::new("Layers")
.layers([LayerListItem::new("Paint"), LayerListItem::new("Ink")]),
),
Point::new(24.0, 24.0),
)?;
assert_focus_surface_keeps_chrome_neutral(
SizedBox::new().width(260.0).height(120.0).child(
TreeView::new("Scene").items([TreeItem::new("Canvas"), TreeItem::new("Lighting")]),
),
Point::new(24.0, 24.0),
)?;
assert_focus_surface_keeps_chrome_neutral(
SizedBox::new().width(280.0).height(140.0).child(
Table::new("Objects")
.columns([TableColumn::new("Name")])
.rows([TableRow::new(["Canvas"]), TableRow::new(["Lighting"])]),
),
Point::new(24.0, 58.0),
)?;
assert_focus_surface_keeps_chrome_neutral(
Breadcrumb::new("Path").items([
BreadcrumbItem::new("Scene"),
BreadcrumbItem::new("Layers"),
BreadcrumbItem::new("Ink"),
]),
Point::new(24.0, 18.0),
)
}
#[test]
fn list_view_row_hover_and_press_use_theme_motion() -> Result<()> {
let theme = DefaultTheme::default();
let (mut runtime, window_id) =
build_runtime(SizedBox::new().width(260.0).height(140.0).child(
ListView::new("Assets").theme(theme).items([
ListItem::new("First"),
ListItem::new("Second"),
ListItem::new("Third"),
]),
));
let output = runtime.render(window_id)?;
let row = output
.semantics
.iter()
.find(|node| {
node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Second")
})
.expect("second row semantics present");
assert_pointer_hover_and_press_use_theme_motion(
&mut runtime,
window_id,
rect_center(row.bounds),
&theme,
)
}
#[test]
fn layer_list_action_hover_and_press_use_theme_motion() -> Result<()> {
let theme = DefaultTheme::default();
let (mut runtime, window_id) = build_runtime(
SizedBox::new().width(280.0).height(120.0).child(
LayerList::new("Layers")
.theme(theme)
.layers([LayerListItem::new("Paint"), LayerListItem::new("Ink")]),
),
);
let output = runtime.render(window_id)?;
let visibility = output
.semantics
.iter()
.find(|node| {
node.role == SemanticsRole::Button
&& node.name.as_deref() == Some("Hide Paint layer")
})
.expect("visibility button semantics present");
assert_pointer_hover_and_press_use_theme_motion(
&mut runtime,
window_id,
rect_center(visibility.bounds),
&theme,
)
}
#[test]
fn layer_list_drag_reorders_rows_without_activating_buttons() -> Result<()> {
let changes = Rc::new(RefCell::new(Vec::new()));
let captured = Rc::clone(&changes);
let (mut runtime, window_id) = build_runtime(
SizedBox::new().width(280.0).height(168.0).child(
LayerList::new("Layers")
.layers([
LayerListItem::new("Paint"),
LayerListItem::new("Paper"),
LayerListItem::new("Ink"),
])
.on_reorder(move |change| captured.borrow_mut().push(change)),
),
);
let output = runtime.render(window_id)?;
let paint = output
.semantics
.iter()
.find(|node| {
node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Paint")
})
.expect("paint layer semantics present");
let paper = output
.semantics
.iter()
.find(|node| {
node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Paper")
})
.expect("paper layer semantics present");
let start = rect_center(paint.bounds);
let end = Point::new(start.x, paper.bounds.max_y() + 4.0);
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Down, start, true),
)?;
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Move, end, true),
)?;
runtime.handle_event(window_id, primary_pointer(PointerEventKind::Up, end, false))?;
assert_eq!(
changes.borrow().as_slice(),
&[LayerListReorderChange {
item: 0,
from: 0,
to: 1
}]
);
let output = runtime.render(window_id)?;
let paint = output
.semantics
.iter()
.find(|node| {
node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Paint")
})
.expect("paint layer semantics present after reorder");
let paper = output
.semantics
.iter()
.find(|node| {
node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Paper")
})
.expect("paper layer semantics present after reorder");
assert!(paper.bounds.y() < paint.bounds.y());
assert!(
output.semantics.iter().any(|node| {
node.role == SemanticsRole::Button
&& node.name.as_deref() == Some("Hide Paint layer")
&& node.value == Some(SemanticsValue::Text("Visible".to_string()))
}),
"visibility button should remain a normal button after enabling row reorder"
);
Ok(())
}
#[test]
fn table_row_hover_and_press_use_theme_motion() -> Result<()> {
let theme = DefaultTheme::default();
let position = Point::new(
theme.metrics.data_viewport_padding.left + 24.0,
theme.metrics.data_viewport_padding.top
+ theme.metrics.table_header_height
+ theme.metrics.select_menu_gap
+ theme.metrics.table_row_height * 0.5,
);
let (mut runtime, window_id) = build_runtime(
SizedBox::new().width(360.0).height(180.0).child(
Table::new("Objects")
.theme(theme)
.columns([TableColumn::new("Name"), TableColumn::new("State")])
.rows([
TableRow::new(["Canvas", "Visible"]),
TableRow::new(["Lighting", "Locked"]),
]),
),
);
let _ = runtime.render(window_id)?;
assert_pointer_hover_and_press_use_theme_motion(&mut runtime, window_id, position, &theme)
}
#[test]
fn table_row_hover_keeps_row_base_under_overlay() -> Result<()> {
let theme = DefaultTheme::default();
let position = Point::new(
theme.metrics.data_viewport_padding.left + 24.0,
theme.metrics.data_viewport_padding.top
+ theme.metrics.table_header_height
+ theme.metrics.select_menu_gap
+ theme.metrics.table_row_height * 0.5,
);
let (mut runtime, window_id) = build_runtime(
SizedBox::new().width(360.0).height(180.0).child(
Table::new("Objects")
.theme(theme)
.columns([TableColumn::new("Name"), TableColumn::new("State")])
.rows([
TableRow::new(["Canvas", "Visible"]),
TableRow::new(["Lighting", "Locked"]),
]),
),
);
let _ = runtime.render(window_id)?;
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Move, position, false),
)?;
runtime.tick(theme.motion.hover_duration());
assert_eq!(handle_ready_events(&mut runtime)?, 0);
let hovered = runtime.render(window_id)?;
let fills = solid_fill_colors(&hovered);
assert!(fills.contains(&theme.palette.surface.with_alpha(0.88)));
assert!(fills.contains(&super::data_row_state_fill(&theme, false, 1.0, 0.0)));
assert!(
!fills.contains(&theme.palette.control_hover),
"hovered table rows should paint a translucent overlay, not an opaque control fill"
);
Ok(())
}
#[test]
fn selected_data_rows_share_soft_fill_and_leading_indicator() {
let theme = DefaultTheme::default();
let outputs = [
(
"list view",
render(
SizedBox::new().width(300.0).height(96.0).child(
ListView::new("Assets")
.theme(theme)
.items([ListItem::new("Canvas"), ListItem::new("Lighting")])
.selected(0),
),
),
),
(
"layer list",
render(
SizedBox::new().width(300.0).height(96.0).child(
LayerList::new("Layers")
.theme(theme)
.layers([LayerListItem::new("Canvas"), LayerListItem::new("Lighting")])
.selected(0),
),
),
),
(
"tree view",
render(
SizedBox::new().width(300.0).height(96.0).child(
TreeView::new("Scene")
.theme(theme)
.items([TreeItem::new("Canvas"), TreeItem::new("Lighting")])
.selected(0),
),
),
),
(
"table",
render(
SizedBox::new().width(300.0).height(128.0).child(
Table::new("Objects")
.theme(theme)
.columns([TableColumn::new("Name")])
.rows([TableRow::new(["Canvas"]), TableRow::new(["Lighting"])])
.selected(0),
),
),
),
(
"virtual table",
render(
SizedBox::new().width(300.0).height(128.0).child(
VirtualTable::new("Virtual objects")
.theme(theme)
.columns([VirtualTableColumn::new("Name")])
.row_count(2)
.selected(0),
),
),
),
];
for (name, output) in outputs {
assert!(
solid_fill_colors(&output).contains(&theme.palette.selection),
"{name} should use the semantic soft selection fill"
);
let indicators = solid_fill_bounds_for_color(&output, theme.palette.accent)
.into_iter()
.filter(|rect| (rect.width() - 2.0).abs() < 0.01 && rect.height() > rect.width())
.collect::<Vec<_>>();
assert_eq!(
indicators.len(),
1,
"{name} should paint one slim leading selection indicator; indicators={indicators:?}"
);
}
}
#[test]
fn breadcrumb_item_hover_and_press_use_theme_motion() -> Result<()> {
let theme = DefaultTheme::default();
let (mut runtime, window_id) = build_runtime(Breadcrumb::new("Path").theme(theme).items([
BreadcrumbItem::new("Workspace"),
BreadcrumbItem::new("Project"),
BreadcrumbItem::new("Scene"),
]));
let output = runtime.render(window_id)?;
let project_label = text_rects_for(&output, "Project")
.into_iter()
.next()
.expect("project label should render");
assert_pointer_hover_and_press_use_theme_motion(
&mut runtime,
window_id,
rect_center(project_label),
&theme,
)
}
#[test]
fn breadcrumb_overflow_clips_and_defaults_to_trailing_items() {
let output = render(
SizedBox::new()
.width(180.0)
.child(Breadcrumb::new("Path").items([
BreadcrumbItem::new("SIFS"),
BreadcrumbItem::new("sinomo"),
BreadcrumbItem::new("nodes"),
BreadcrumbItem::new("node 01kvbbd...3fsrx"),
BreadcrumbItem::new("attachments"),
])),
);
assert!(
output.frame.scene.commands().iter().any(|command| matches!(
command,
SceneCommand::PushClip { rect }
if (rect.width() - 180.0).abs() < 0.01
&& (rect.height() - output.frame.viewport.height).abs() < 0.01
)),
"overflowing breadcrumb content should be clipped to the widget bounds"
);
let trailing_label = text_rects_for(&output, "attachments")
.into_iter()
.next()
.expect("trailing breadcrumb item should render");
assert!(
trailing_label.x() >= -0.01 && trailing_label.max_x() <= 180.01,
"default overflow position should keep the last item visible: {trailing_label:?}"
);
}
#[test]
fn breadcrumb_wheel_scrolls_overflowing_content_leftward() -> Result<()> {
let (mut runtime, window_id) = build_runtime(SizedBox::new().width(180.0).child(
Breadcrumb::new("Path").items([
BreadcrumbItem::new("SIFS"),
BreadcrumbItem::new("sinomo"),
BreadcrumbItem::new("nodes"),
BreadcrumbItem::new("node 01kvbbd...3fsrx"),
BreadcrumbItem::new("attachments"),
]),
));
let before = runtime.render(window_id)?;
let before_x = text_rects_for(&before, "attachments")[0].x();
runtime.handle_event(
window_id,
wheel_scroll(Point::new(90.0, 18.0), Vector::new(0.0, 24.0)),
)?;
let after = runtime.render(window_id)?;
let after_x = text_rects_for(&after, "attachments")[0].x();
assert!(
after_x > before_x,
"wheel scrolling upward should reveal earlier breadcrumb items by moving content right"
);
Ok(())
}
#[test]
fn breadcrumb_drag_scrolls_overflowing_content_leftward() -> Result<()> {
let (mut runtime, window_id) = build_runtime(SizedBox::new().width(180.0).child(
Breadcrumb::new("Path").items([
BreadcrumbItem::new("SIFS"),
BreadcrumbItem::new("sinomo"),
BreadcrumbItem::new("nodes"),
BreadcrumbItem::new("node 01kvbbd...3fsrx"),
BreadcrumbItem::new("attachments"),
]),
));
let before = runtime.render(window_id)?;
let before_x = text_rects_for(&before, "attachments")[0].x();
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Down, Point::new(90.0, 18.0), true),
)?;
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Move, Point::new(126.0, 18.0), true),
)?;
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Up, Point::new(126.0, 18.0), false),
)?;
let after = runtime.render(window_id)?;
let after_x = text_rects_for(&after, "attachments")[0].x();
assert!(
after_x > before_x,
"dragging right should reveal earlier breadcrumb items by moving content right"
);
Ok(())
}
#[test]
fn list_view_click_selects_row_and_updates_semantics() -> Result<()> {
let changes = Rc::new(RefCell::new(Vec::new()));
let on_change = Rc::clone(&changes);
let (mut runtime, window_id) = build_runtime(
ListView::new("Assets")
.items([
ListItem::new("First"),
ListItem::new("Second"),
ListItem::new("Third"),
])
.on_change(move |index, label| on_change.borrow_mut().push((index, label))),
);
let _ = runtime.render(window_id)?;
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Down, Point::new(44.0, 44.0), true),
)?;
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Up, Point::new(44.0, 44.0), false),
)?;
assert_eq!(changes.borrow().as_slice(), &[(1, "Second".to_string())]);
let output = runtime.render(window_id)?;
let list = output
.semantics
.iter()
.find(|node| node.role == SemanticsRole::List)
.expect("list semantics present");
assert_eq!(list.value, Some(SemanticsValue::Text("Second".to_string())));
let row = output
.semantics
.iter()
.find(|node| {
node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Second")
})
.expect("selected row semantics present");
assert_eq!(row.parent, Some(list.id));
assert!(row.state.selected);
assert!(row.actions.contains(&SemanticsAction::Activate));
Ok(())
}
#[test]
fn list_view_change_callback_can_request_relayout() -> Result<()> {
let changes = Rc::new(RefCell::new(Vec::new()));
let requests = Rc::new(RefCell::new(0_usize));
let on_change = Rc::clone(&changes);
let requested = Rc::clone(&requests);
let (mut runtime, window_id) = build_runtime(
ListView::new("Assets")
.items([ListItem::new("First"), ListItem::new("Second")])
.on_change_with_ctx(move |ctx, index, label| {
on_change.borrow_mut().push((index, label));
*requested.borrow_mut() += 1;
ctx.request_measure();
ctx.request_arrange();
ctx.request_paint();
ctx.request_semantics();
}),
);
let _ = runtime.render(window_id)?;
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Down, Point::new(44.0, 44.0), true),
)?;
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Up, Point::new(44.0, 44.0), false),
)?;
assert_eq!(changes.borrow().as_slice(), &[(1, "Second".to_string())]);
assert_eq!(*requests.borrow(), 1);
Ok(())
}
#[test]
fn list_view_exposes_visible_row_semantics() -> Result<()> {
let (mut runtime, window_id) = build_runtime(
SizedBox::new().width(260.0).height(132.0).child(
ListView::new("Layers")
.items([
ListItem::new("Paint").detail("Normal / 100%"),
ListItem::new("Paper").detail("Background"),
ListItem::new("Locked").detail("Read only").enabled(false),
])
.selected(0),
),
);
let output = runtime.render(window_id)?;
let list = output
.semantics
.iter()
.find(|node| node.role == SemanticsRole::List)
.expect("list semantics present");
let rows = output
.semantics
.iter()
.filter(|node| node.role == SemanticsRole::ListItem)
.collect::<Vec<_>>();
assert_eq!(rows.len(), 3);
let paint = rows
.iter()
.find(|node| node.name.as_deref() == Some("Paint"))
.expect("paint row semantics present");
assert_eq!(paint.parent, Some(list.id));
assert_eq!(paint.description.as_deref(), Some("Normal / 100%"));
assert_eq!(
paint.value,
Some(SemanticsValue::Text("Normal / 100%".to_string()))
);
assert!(paint.state.selected);
assert!(!paint.state.disabled);
assert!(paint.actions.contains(&SemanticsAction::Activate));
let paper = rows
.iter()
.find(|node| node.name.as_deref() == Some("Paper"))
.expect("paper row semantics present");
assert_eq!(paper.parent, Some(list.id));
assert_eq!(paper.description.as_deref(), Some("Background"));
assert_eq!(
paper.value,
Some(SemanticsValue::Text("Background".to_string()))
);
assert!(!paper.state.selected);
let locked = rows
.iter()
.find(|node| node.name.as_deref() == Some("Locked"))
.expect("locked row semantics present");
assert!(locked.state.disabled);
assert!(locked.actions.is_empty());
Ok(())
}
#[test]
fn list_view_selected_when_reads_external_selection() -> Result<()> {
let selected = Rc::new(RefCell::new(0_usize));
let selected_reader = Rc::clone(&selected);
let (mut runtime, window_id) = build_runtime(
SizedBox::new().width(260.0).height(132.0).child(
ListView::new("Layers")
.items([
ListItem::new("Paint").detail("Normal / 100%"),
ListItem::new("Paper").detail("Background"),
])
.selected_when(move || Some(*selected_reader.borrow())),
),
);
let output = runtime.render(window_id)?;
let paint = output
.semantics
.iter()
.find(|node| {
node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Paint")
})
.expect("paint row semantics present");
assert!(paint.state.selected);
*selected.borrow_mut() = 1;
runtime.handle_event(
window_id,
Event::Window(WindowEvent::Resized(Size::new(260.0, 132.0))),
)?;
let output = runtime.render(window_id)?;
let list = output
.semantics
.iter()
.find(|node| node.role == SemanticsRole::List)
.expect("list semantics present");
assert_eq!(list.value, Some(SemanticsValue::Text("Paper".to_string())));
let paper = output
.semantics
.iter()
.find(|node| {
node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Paper")
})
.expect("paper row semantics present");
assert!(paper.state.selected);
Ok(())
}
#[test]
fn list_view_row_ids_are_javascript_safe_and_distinct() {
let parent = WidgetId::new(402);
let mut ids = (0..8)
.map(|index| super::list_view_row_id(parent, index).get())
.collect::<Vec<_>>();
assert!(ids.iter().all(|id| *id <= ((1_u64 << 53) - 1)));
assert!(ids.iter().all(|id| *id != parent.get()));
ids.sort_unstable();
ids.dedup();
assert_eq!(ids.len(), 8);
}
#[test]
fn layer_list_exposes_visibility_semantics() {
let output = render(
SizedBox::new().width(280.0).height(112.0).child(
LayerList::new("Layers")
.layers([
LayerListItem::new("Paint")
.detail("Normal / 100%")
.thumbnail(Color::rgba(0.16, 0.31, 0.88, 1.0)),
LayerListItem::new("Paper")
.detail("Background")
.thumbnail(Color::rgba(0.89, 0.91, 0.94, 1.0)),
])
.selected(0),
),
);
let list = output
.semantics
.iter()
.find(|node| node.role == SemanticsRole::List)
.expect("layer list semantics present");
assert_eq!(list.name.as_deref(), Some("Layers"));
assert_eq!(list.value, Some(SemanticsValue::Text("Paint".to_string())));
let paint = output
.semantics
.iter()
.find(|node| {
node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Paint")
})
.expect("paint layer row semantics present");
assert_eq!(paint.parent, Some(list.id));
assert_eq!(paint.description.as_deref(), Some("Normal / 100%"));
assert_eq!(
paint.value,
Some(SemanticsValue::Text(
"Normal / 100%; Visible; Unlocked".to_string()
))
);
assert!(paint.state.selected);
let visibility = output
.semantics
.iter()
.find(|node| {
node.role == SemanticsRole::Button
&& node.name.as_deref() == Some("Hide Paint layer")
})
.expect("paint layer visibility control semantics present");
assert_eq!(visibility.parent, Some(paint.id));
assert_eq!(
visibility.value,
Some(SemanticsValue::Text("Visible".to_string()))
);
assert_eq!(visibility.state.checked, Some(ToggleState::Checked));
assert!(visibility.actions.contains(&SemanticsAction::Activate));
let lock = output
.semantics
.iter()
.find(|node| {
node.role == SemanticsRole::Button
&& node.name.as_deref() == Some("Lock Paint layer")
})
.expect("paint layer lock control semantics present");
assert_eq!(lock.parent, Some(paint.id));
assert_eq!(
lock.value,
Some(SemanticsValue::Text("Unlocked".to_string()))
);
assert_eq!(lock.state.checked, Some(ToggleState::Unchecked));
assert!(lock.actions.contains(&SemanticsAction::Activate));
}
#[test]
fn layer_list_chrome_uses_theme_metrics() {
let mut theme = DefaultTheme::default();
theme.metrics.layer_visibility_stroke_width = 2.75;
theme.metrics.layer_visibility_slash_stroke_width = 3.25;
theme.metrics.layer_thumbnail_disabled_opacity = 0.21;
theme.metrics.layer_thumbnail_disabled_border_opacity = 0.33;
let thumbnail = Color::rgba(0.30, 0.50, 0.70, 1.0);
let output = render(
SizedBox::new().width(280.0).height(64.0).child(
LayerList::new("Layers")
.theme(theme)
.layers([LayerListItem::new("Paper")
.thumbnail(thumbnail)
.visible(false)]),
),
);
let fills = solid_fill_colors(&output);
let stroke_widths = solid_stroke_widths(&output);
let stroke_colors = solid_stroke_colors(&output);
assert!(fills.contains(&thumbnail.with_alpha(0.21)));
assert!(fills.contains(&theme.palette.control_hover));
assert!(stroke_colors.contains(&theme.palette.border.with_alpha(0.33)));
assert!(
stroke_widths
.iter()
.any(|width| (*width - 2.75).abs() < f32::EPSILON)
);
assert!(
stroke_widths
.iter()
.any(|width| (*width - 3.25).abs() < f32::EPSILON)
);
}
#[test]
fn layer_list_label_and_detail_visual_centers_match_row_slots() {
let output = render(
SizedBox::new().width(280.0).height(64.0).child(
LayerList::new("Layers").layer(
LayerListItem::new("Paint")
.detail("Normal / 100%")
.thumbnail(Color::rgba(0.16, 0.31, 0.88, 1.0)),
),
),
);
let row = output
.semantics
.iter()
.find(|node| {
node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Paint")
})
.expect("layer row semantics present")
.bounds;
assert_two_line_row_text_matches_slots(&output, "Paint", "Normal / 100%", row);
}
#[test]
fn layer_list_item_dynamic_detail_and_visibility_update_semantics() -> Result<()> {
let detail = Rc::new(RefCell::new("Normal / 100%".to_string()));
let detail_reader = Rc::clone(&detail);
let visible = Rc::new(RefCell::new(true));
let visible_reader = Rc::clone(&visible);
let (mut runtime, window_id) = build_runtime(
SizedBox::new().width(280.0).height(112.0).child(
LayerList::new("Layers")
.layers([
LayerListItem::new("Paint")
.detail_when(move || detail_reader.borrow().clone())
.thumbnail(Color::rgba(0.16, 0.31, 0.88, 1.0))
.visible_when(move || *visible_reader.borrow()),
LayerListItem::new("Paper")
.detail("Background")
.thumbnail(Color::rgba(0.89, 0.91, 0.94, 1.0)),
])
.selected(0),
),
);
let output = runtime.render(window_id)?;
let paint = output
.semantics
.iter()
.find(|node| {
node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Paint")
})
.expect("paint layer row semantics present");
assert_eq!(paint.description.as_deref(), Some("Normal / 100%"));
assert_eq!(
paint.value,
Some(SemanticsValue::Text(
"Normal / 100%; Visible; Unlocked".to_string()
))
);
*detail.borrow_mut() = "Normal / 50%".to_string();
*visible.borrow_mut() = false;
runtime.handle_event(
window_id,
Event::Window(WindowEvent::Resized(Size::new(280.0, 112.0))),
)?;
let output = runtime.render(window_id)?;
let paint = output
.semantics
.iter()
.find(|node| {
node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Paint")
})
.expect("paint layer row semantics present");
assert_eq!(paint.description.as_deref(), Some("Normal / 50%"));
assert_eq!(
paint.value,
Some(SemanticsValue::Text(
"Normal / 50%; Hidden; Unlocked".to_string()
))
);
let visibility = output
.semantics
.iter()
.find(|node| {
node.role == SemanticsRole::Button
&& node.name.as_deref() == Some("Show Paint layer")
})
.expect("paint layer visibility control should update its label");
assert_eq!(
visibility.value,
Some(SemanticsValue::Text("Hidden".to_string()))
);
assert_eq!(visibility.state.checked, Some(ToggleState::Unchecked));
Ok(())
}
#[test]
fn layer_list_visibility_button_toggles_without_selecting_row() -> Result<()> {
let selections = Rc::new(RefCell::new(Vec::new()));
let on_select = Rc::clone(&selections);
let visibility_changes = Rc::new(RefCell::new(Vec::new()));
let on_visibility_change = Rc::clone(&visibility_changes);
let (mut runtime, window_id) = build_runtime(
SizedBox::new().width(280.0).height(112.0).child(
LayerList::new("Layers")
.layers([
LayerListItem::new("Paint")
.detail("Normal / 100%")
.thumbnail(Color::rgba(0.16, 0.31, 0.88, 1.0)),
LayerListItem::new("Paper")
.detail("Background")
.thumbnail(Color::rgba(0.89, 0.91, 0.94, 1.0)),
])
.selected(0)
.on_change(move |index, label| {
on_select.borrow_mut().push((index, label));
})
.on_visibility_change(move |index, visible| {
on_visibility_change.borrow_mut().push((index, visible));
}),
),
);
let output = runtime.render(window_id)?;
let visibility = output
.semantics
.iter()
.find(|node| {
node.role == SemanticsRole::Button
&& node.name.as_deref() == Some("Hide Paper layer")
})
.expect("paper layer visibility control should exist");
let position = Point::new(
visibility.bounds.x() + (visibility.bounds.width() * 0.5),
visibility.bounds.y() + (visibility.bounds.height() * 0.5),
);
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Down, position, true),
)?;
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Up, position, false),
)?;
assert!(selections.borrow().is_empty());
assert_eq!(visibility_changes.borrow().as_slice(), &[(1, false)]);
let output = runtime.render(window_id)?;
let paint = output
.semantics
.iter()
.find(|node| {
node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Paint")
})
.expect("paint layer row should still exist");
assert!(paint.state.selected);
let paper = output
.semantics
.iter()
.find(|node| {
node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Paper")
})
.expect("paper layer row should still exist");
assert!(!paper.state.selected);
assert_eq!(
paper.value,
Some(SemanticsValue::Text(
"Background; Hidden; Unlocked".to_string()
))
);
let visibility = output
.semantics
.iter()
.find(|node| {
node.role == SemanticsRole::Button
&& node.name.as_deref() == Some("Show Paper layer")
})
.expect("paper layer visibility control should update its label");
assert_eq!(
visibility.value,
Some(SemanticsValue::Text("Hidden".to_string()))
);
assert_eq!(visibility.state.checked, Some(ToggleState::Unchecked));
Ok(())
}
#[test]
fn layer_list_lock_button_toggles_without_selecting_row() -> Result<()> {
let selections = Rc::new(RefCell::new(Vec::new()));
let on_select = Rc::clone(&selections);
let lock_changes = Rc::new(RefCell::new(Vec::new()));
let on_lock_change = Rc::clone(&lock_changes);
let (mut runtime, window_id) = build_runtime(
SizedBox::new().width(280.0).height(112.0).child(
LayerList::new("Layers")
.layers([
LayerListItem::new("Paint")
.detail("Normal / 100%")
.thumbnail(Color::rgba(0.16, 0.31, 0.88, 1.0)),
LayerListItem::new("Paper")
.detail("Background")
.thumbnail(Color::rgba(0.89, 0.91, 0.94, 1.0)),
])
.selected(0)
.on_change(move |index, label| {
on_select.borrow_mut().push((index, label));
})
.on_lock_change(move |index, locked| {
on_lock_change.borrow_mut().push((index, locked));
}),
),
);
let output = runtime.render(window_id)?;
let lock = output
.semantics
.iter()
.find(|node| {
node.role == SemanticsRole::Button
&& node.name.as_deref() == Some("Lock Paper layer")
})
.expect("paper layer lock control should exist");
let position = Point::new(
lock.bounds.x() + (lock.bounds.width() * 0.5),
lock.bounds.y() + (lock.bounds.height() * 0.5),
);
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Down, position, true),
)?;
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Up, position, false),
)?;
assert!(selections.borrow().is_empty());
assert_eq!(lock_changes.borrow().as_slice(), &[(1, true)]);
let output = runtime.render(window_id)?;
let paint = output
.semantics
.iter()
.find(|node| {
node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Paint")
})
.expect("paint layer row should still exist");
assert!(paint.state.selected);
let paper = output
.semantics
.iter()
.find(|node| {
node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Paper")
})
.expect("paper layer row should still exist");
assert!(!paper.state.selected);
assert_eq!(
paper.value,
Some(SemanticsValue::Text(
"Background; Visible; Locked".to_string()
))
);
let lock = output
.semantics
.iter()
.find(|node| {
node.role == SemanticsRole::Button
&& node.name.as_deref() == Some("Unlock Paper layer")
})
.expect("paper layer lock control should update its label");
assert_eq!(lock.value, Some(SemanticsValue::Text("Locked".to_string())));
assert_eq!(lock.state.checked, Some(ToggleState::Checked));
Ok(())
}
#[test]
fn layer_list_row_ids_are_javascript_safe_and_distinct() {
let parent = WidgetId::new(402);
let mut ids = (0..8)
.flat_map(|index| {
[
super::layer_list_row_id(parent, index).get(),
super::layer_list_visibility_id(parent, index).get(),
super::layer_list_lock_id(parent, index).get(),
]
})
.collect::<Vec<_>>();
assert!(ids.iter().all(|id| *id <= ((1_u64 << 53) - 1)));
assert!(ids.iter().all(|id| *id != parent.get()));
ids.sort_unstable();
ids.dedup();
assert_eq!(ids.len(), 24);
}
#[test]
fn list_item_child_widget_receives_pointer_events() -> Result<()> {
let presses = Rc::new(RefCell::new(0));
let on_press = Rc::clone(&presses);
let row = Stack::horizontal()
.gap(8.0)
.with_child(SizedBox::new().width(96.0).child(Label::new("Asset")))
.with_child(Button::new("Open").on_press(move || *on_press.borrow_mut() += 1));
let (mut runtime, window_id) = build_runtime(
SizedBox::new()
.width(260.0)
.height(80.0)
.child(ListView::new("Actions").item(ListItem::new("Asset").child(row))),
);
let _ = runtime.render(window_id)?;
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Down, Point::new(136.0, 28.0), true),
)?;
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Up, Point::new(136.0, 28.0), false),
)?;
assert_eq!(*presses.borrow(), 1);
let output = runtime.render(window_id)?;
assert!(
output
.semantics
.iter()
.any(|node| node.role == SemanticsRole::Button
&& node.name.as_deref() == Some("Open"))
);
Ok(())
}
#[test]
fn list_item_child_row_can_opt_into_row_activation() -> Result<()> {
let row_changes = Rc::new(RefCell::new(Vec::new()));
let button_presses = Rc::new(RefCell::new(0));
let on_row = Rc::clone(&row_changes);
let on_button = Rc::clone(&button_presses);
let row = Stack::horizontal()
.gap(8.0)
.with_child(SizedBox::new().width(96.0).child(Label::new("Asset")))
.with_child(Button::new("Open").on_press(move || *on_button.borrow_mut() += 1));
let item = ListItem::new("Asset")
.semantic_name("Asset row")
.description("Selectable asset row")
.activate_with_child(true)
.child(row);
let (mut runtime, window_id) = build_runtime(
SizedBox::new().width(260.0).height(80.0).child(
ListView::new("Actions")
.item(item)
.on_change(move |index, label| {
on_row.borrow_mut().push((index, label));
}),
),
);
let _ = runtime.render(window_id)?;
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Down, Point::new(36.0, 28.0), true),
)?;
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Up, Point::new(36.0, 28.0), false),
)?;
assert_eq!(row_changes.borrow().as_slice(), &[(0, "Asset".to_string())]);
assert_eq!(*button_presses.borrow(), 0);
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Down, Point::new(136.0, 28.0), true),
)?;
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Up, Point::new(136.0, 28.0), false),
)?;
assert_eq!(
row_changes.borrow().as_slice(),
&[(0, "Asset".to_string())],
"nested button clicks should not also activate the row"
);
assert_eq!(*button_presses.borrow(), 1);
let output = runtime.render(window_id)?;
let row = output
.semantics
.iter()
.find(|node| {
node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Asset row")
})
.expect("custom child row should expose list-item semantics");
assert_eq!(row.description.as_deref(), Some("Selectable asset row"));
assert!(row.actions.contains(&SemanticsAction::Activate));
Ok(())
}
#[test]
fn list_item_child_respects_explicit_row_height() -> Result<()> {
let row_changes = Rc::new(RefCell::new(Vec::new()));
let on_row = Rc::clone(&row_changes);
let item = ListItem::new("Tall asset").activate_with_child(true).child(
SizedBox::new()
.height(180.0)
.child(Label::new("Tall custom row")),
);
let (mut runtime, window_id) = build_runtime(
SizedBox::new().width(260.0).height(96.0).child(
ListView::new("Assets")
.row_height(36.0)
.item(item)
.on_change(move |index, label| {
on_row.borrow_mut().push((index, label));
}),
),
);
let output = runtime.render(window_id)?;
let row = output
.semantics
.iter()
.find(|node| {
node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Tall asset")
})
.expect("fixed-height child row should expose list-item semantics");
assert!(
(row.bounds.height() - 36.0).abs() <= 0.5,
"explicit row height should cap oversized child content, got {:?}",
row.bounds
);
let position = Point::new(
row.bounds.x() + row.bounds.width() * 0.5,
row.bounds.y() + row.bounds.height() * 0.5,
);
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Down, position, true),
)?;
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Up, position, false),
)?;
assert_eq!(
row_changes.borrow().as_slice(),
&[(0, "Tall asset".to_string())]
);
Ok(())
}
#[test]
fn list_item_child_widget_rearranges_when_scrolled() -> Result<()> {
let (mut runtime, window_id) = build_runtime(
SizedBox::new().width(260.0).height(96.0).child(
ListView::new("Assets")
.padding(Insets::ZERO)
.row_height(40.0)
.items([
ListItem::new("First"),
ListItem::new("Custom row").child(Label::new("Floating child")),
ListItem::new("Third"),
ListItem::new("Fourth"),
]),
),
);
let before = runtime.render(window_id)?;
let before_child = semantic_bounds(&before, SemanticsRole::Text, "Floating child");
runtime.handle_event(
window_id,
wheel_scroll(Point::new(32.0, 32.0), Vector::new(0.0, -20.0)),
)?;
let after = runtime.render(window_id)?;
let after_child = semantic_bounds(&after, SemanticsRole::Text, "Floating child");
assert!(
(before_child.y() - after_child.y() - 20.0).abs() < 0.5,
"custom list child should move with scroll: before={before_child:?}, after={after_child:?}"
);
Ok(())
}
#[test]
fn list_and_tree_padding_overrides_inset_row_viewports() {
let padding = Insets {
left: 24.0,
top: 16.0,
right: 20.0,
bottom: 12.0,
};
let list = render(
SizedBox::new().width(320.0).height(120.0).child(
ListView::new("Assets")
.padding(padding)
.item(ListItem::new("Asset")),
),
);
let list_row = list
.semantics
.iter()
.find(|node| {
node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Asset")
})
.expect("padded list row semantics");
assert!((list_row.bounds.x() - padding.left).abs() < 0.01);
assert!((list_row.bounds.y() - padding.top).abs() < 0.01);
assert!((list_row.bounds.width() - (320.0 - padding.left - padding.right)).abs() < 0.01);
let tree = render(
SizedBox::new().width(320.0).height(120.0).child(
TreeView::new("Scene")
.padding(padding)
.item(TreeItem::new("Node")),
),
);
let tree_row = tree
.semantics
.iter()
.find(|node| {
node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Node")
})
.expect("padded tree row semantics");
assert!((tree_row.bounds.x() - padding.left).abs() < 0.01);
assert!((tree_row.bounds.y() - padding.top).abs() < 0.01);
assert!((tree_row.bounds.width() - (320.0 - padding.left - padding.right)).abs() < 0.01);
}
#[test]
fn tree_item_content_widget_receives_pointer_events_and_drives_row_height() -> Result<()> {
let presses = Rc::new(RefCell::new(0));
let changes = Rc::new(RefCell::new(Vec::new()));
let on_press = Rc::clone(&presses);
let on_change = Rc::clone(&changes);
let content = SizedBox::new().height(52.0).child(
Stack::horizontal()
.gap(8.0)
.with_child(SizedBox::new().width(96.0).child(Label::new("Asset")))
.with_child(Button::new("Open").on_press(move || *on_press.borrow_mut() += 1)),
);
let padding = Insets::all(12.0);
let (mut runtime, window_id) = build_runtime(
SizedBox::new().width(320.0).height(120.0).child(
TreeView::new("Scene")
.padding(padding)
.item(TreeItem::new("Root").item(TreeItem::new("Asset row").child(content)))
.on_change(move |path, label| {
on_change.borrow_mut().push((path, label));
}),
),
);
let collapsed = runtime.render(window_id)?;
let root_id = collapsed
.semantics
.iter()
.find(|node| {
node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Root")
})
.expect("collapsed tree root semantics")
.id;
assert!(runtime.handle_semantics_action(
window_id,
root_id,
SemanticsActionRequest::Expand,
)?);
let before = runtime.render(window_id)?;
let row = before
.semantics
.iter()
.find(|node| {
node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Asset row")
})
.expect("custom tree row semantics");
let button = before
.semantics
.iter()
.find(|node| node.role == SemanticsRole::Button && node.name.as_deref() == Some("Open"))
.expect("custom tree content button semantics");
assert!(row.bounds.y() > padding.top);
assert!(
row.bounds.height() >= 52.0,
"custom content should determine the tree row height"
);
assert!(
!row.actions.contains(&SemanticsAction::Activate),
"interactive custom content should own pointer activation by default"
);
let position = Point::new(
button.bounds.x() + button.bounds.width() * 0.5,
button.bounds.y() + button.bounds.height() * 0.5,
);
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Down, position, true),
)?;
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Up, position, false),
)?;
assert_eq!(*presses.borrow(), 1);
assert!(changes.borrow().is_empty());
Ok(())
}
#[test]
fn tree_item_child_widget_rearranges_when_scrolled() -> Result<()> {
let (mut runtime, window_id) = build_runtime(
SizedBox::new().width(320.0).height(104.0).child(
TreeView::new("Scene")
.padding(Insets::ZERO)
.row_height(40.0)
.item(
TreeItem::new("Root")
.expanded(true)
.item(TreeItem::new("First child"))
.item(
TreeItem::new("Custom tree row")
.child(Label::new("Floating tree child")),
)
.item(TreeItem::new("Third child")),
),
),
);
let before = runtime.render(window_id)?;
let before_child = semantic_bounds(&before, SemanticsRole::Text, "Floating tree child");
runtime.handle_event(
window_id,
wheel_scroll(Point::new(32.0, 32.0), Vector::new(0.0, -24.0)),
)?;
let after = runtime.render(window_id)?;
let after_child = semantic_bounds(&after, SemanticsRole::Text, "Floating tree child");
assert!(
(before_child.y() - after_child.y() - 24.0).abs() < 0.5,
"custom tree child should move with scroll: before={before_child:?}, after={after_child:?}"
);
Ok(())
}
#[test]
fn a_disabled_collection_ignores_input_and_disables_every_item() -> Result<()> {
let changes = Rc::new(RefCell::new(Vec::new()));
let on_change = Rc::clone(&changes);
let (mut runtime, window_id) = build_runtime(
ListView::new("Files")
.items([ListItem::new("Alpha"), ListItem::new("Beta")])
.enabled(false)
.on_change(move |index, _| on_change.borrow_mut().push(index)),
);
let output = runtime.render(window_id)?;
let nodes = output
.semantics
.iter()
.filter(|node| matches!(node.role, SemanticsRole::List | SemanticsRole::ListItem))
.collect::<Vec<_>>();
assert!(nodes.len() >= 3, "the list and its items are announced");
assert!(
nodes
.iter()
.all(|node| node.state.disabled && node.actions.is_empty())
);
for at in [Point::new(30.0, 20.0), Point::new(30.0, 56.0)] {
runtime.handle_event(window_id, primary_pointer(PointerEventKind::Down, at, true))?;
runtime.handle_event(window_id, primary_pointer(PointerEventKind::Up, at, false))?;
}
assert!(
changes.borrow().is_empty(),
"a disabled list ignores clicks"
);
let on_change = Rc::clone(&changes);
let (mut runtime, window_id) = build_runtime(
ListView::new("Files")
.items([ListItem::new("Alpha"), ListItem::new("Beta")])
.on_change(move |index, _| on_change.borrow_mut().push(index)),
);
let _ = runtime.render(window_id)?;
for at in [Point::new(30.0, 20.0), Point::new(30.0, 56.0)] {
runtime.handle_event(window_id, primary_pointer(PointerEventKind::Down, at, true))?;
runtime.handle_event(window_id, primary_pointer(PointerEventKind::Up, at, false))?;
}
assert!(!changes.borrow().is_empty());
Ok(())
}
#[test]
fn selection_takes_an_optional_index_or_a_tree_path() -> Result<()> {
let list = |selected: Option<usize>| {
ListView::new("Files")
.items([ListItem::new("A"), ListItem::new("B")])
.selected(selected)
};
assert_eq!(list(None).selected_index(), None);
assert_eq!(list(Some(1)).selected_index(), Some(1));
let plain = ListView::new("Files")
.items([ListItem::new("A"), ListItem::new("B")])
.selected(1);
assert_eq!(plain.selected_index(), Some(1));
let (mut runtime, window_id) = build_runtime(
TreeView::new("Scene")
.item(
TreeItem::new("Root")
.expanded(true)
.item(TreeItem::new("Child A"))
.item(TreeItem::new("Child B")),
)
.selected_path([0, 1]),
);
let output = runtime.render(window_id)?;
let tree = output
.semantics
.iter()
.find(|node| node.role == SemanticsRole::Tree)
.expect("tree semantics present");
assert_eq!(
tree.value,
Some(SemanticsValue::Text("Child B".to_string()))
);
Ok(())
}
#[test]
fn tree_view_keyboard_expands_and_selects_child() -> Result<()> {
let changes = Rc::new(RefCell::new(Vec::new()));
let on_change = Rc::clone(&changes);
let (mut runtime, window_id) = build_runtime(
TreeView::new("Scene")
.item(
TreeItem::new("Root")
.item(TreeItem::new("Child A"))
.item(TreeItem::new("Child B")),
)
.on_change(move |path, label| on_change.borrow_mut().push((path, label))),
);
let _ = runtime.render(window_id)?;
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Down, Point::new(48.0, 26.0), true),
)?;
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Up, Point::new(48.0, 26.0), false),
)?;
runtime.handle_event(
window_id,
Event::Keyboard(KeyboardEvent::new("ArrowRight", KeyState::Pressed)),
)?;
runtime.handle_event(
window_id,
Event::Keyboard(KeyboardEvent::new("ArrowDown", KeyState::Pressed)),
)?;
assert!(changes.borrow().iter().any(|(_, label)| label == "Child A"));
let output = runtime.render(window_id)?;
let tree = output
.semantics
.iter()
.find(|node| node.role == SemanticsRole::Tree)
.expect("tree semantics present");
assert_eq!(
tree.value,
Some(SemanticsValue::Text("Child A".to_string()))
);
Ok(())
}
#[test]
fn tree_view_keyed_rows_support_accessible_expansion_and_activation() -> Result<()> {
let changes = Rc::new(RefCell::new(Vec::new()));
let on_change = Rc::clone(&changes);
let (mut runtime, window_id) = build_runtime(
SizedBox::new().width(320.0).height(140.0).child(
TreeView::new("Scene")
.item(
TreeItem::new("Root")
.key(42)
.item(TreeItem::new("Child").key(7)),
)
.on_change(move |path, label| on_change.borrow_mut().push((path, label))),
),
);
let before = runtime.render(window_id)?;
let root = before
.semantics
.iter()
.find(|node| {
node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Root")
})
.expect("root tree item");
let root_id = root.id;
assert!(root.actions.contains(&SemanticsAction::Expand));
assert!(runtime.handle_semantics_action(
window_id,
root_id,
SemanticsActionRequest::Expand,
)?);
let expanded = runtime.render(window_id)?;
let expanded_root = expanded
.semantics
.iter()
.find(|node| node.name.as_deref() == Some("Root"))
.expect("expanded root");
assert_eq!(expanded_root.id, root_id);
let child = expanded
.semantics
.iter()
.find(|node| node.name.as_deref() == Some("Child"))
.expect("child tree item");
assert!(runtime.handle_semantics_action(
window_id,
child.id,
SemanticsActionRequest::Activate,
)?);
assert!(changes.borrow().iter().any(|(_, label)| label == "Child"));
Ok(())
}
#[test]
fn table_keyboard_selects_next_row() -> Result<()> {
let changes = Rc::new(RefCell::new(Vec::new()));
let on_change = Rc::clone(&changes);
let (mut runtime, window_id) = build_runtime(
Table::new("Materials")
.columns([TableColumn::new("Name"), TableColumn::new("Passes")])
.rows([TableRow::new(["Glass", "3"]), TableRow::new(["Water", "4"])])
.on_change(move |index| on_change.borrow_mut().push(index)),
);
let _ = runtime.render(window_id)?;
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Down, Point::new(60.0, 72.0), true),
)?;
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Up, Point::new(60.0, 72.0), false),
)?;
runtime.handle_event(
window_id,
Event::Keyboard(KeyboardEvent::new("ArrowDown", KeyState::Pressed)),
)?;
assert!(changes.borrow().contains(&1));
let output = runtime.render(window_id)?;
let table = output
.semantics
.iter()
.find(|node| node.role == SemanticsRole::Table)
.expect("table semantics present");
assert_eq!(table.value, Some(SemanticsValue::Text("Water".to_string())));
Ok(())
}
#[test]
fn virtual_table_semantics_include_columns_and_visible_rows() {
let output = render(
SizedBox::new().width(360.0).height(120.0).child(
VirtualTable::new("Files")
.columns([
VirtualTableColumn::new("Name").min_width(160.0),
VirtualTableColumn::new("Kind").width(80.0),
])
.row_count(100)
.row_height(20.0)
.header_height(24.0)
.row_name(|index| format!("Row {index}"))
.row_description(|index| format!("File row {index}")),
),
);
let table = output
.semantics
.iter()
.find(|node| node.role == SemanticsRole::Table)
.expect("virtual table semantics present");
assert_eq!(table.name.as_deref(), Some("Files"));
assert_eq!(
table.value,
Some(SemanticsValue::Text("100 rows".to_string()))
);
assert!(table.description.as_deref().is_some_and(|description| {
description.contains("Columns: Name, Kind") && description.contains("of 100")
}));
let rows = output
.semantics
.iter()
.filter(|node| node.role == SemanticsRole::ListItem)
.collect::<Vec<_>>();
assert!(!rows.is_empty());
assert!(
rows.len() < 100,
"virtual table should expose only visible rows, got {}",
rows.len()
);
assert_eq!(rows[0].name.as_deref(), Some("Row 0"));
assert_eq!(
rows[0].description.as_deref(),
Some("File row 0; row 1 of 100")
);
}
#[test]
fn virtual_table_supports_variable_row_heights() {
let output = render(
SizedBox::new().width(360.0).height(180.0).child(
VirtualTable::new("Variable rows")
.columns([VirtualTableColumn::new("Name")])
.row_count(3)
.row_heights([20.0, 44.0, 28.0])
.row_name(|index| format!("Row {index}")),
),
);
let rows = output
.semantics
.iter()
.filter(|node| node.role == SemanticsRole::ListItem)
.collect::<Vec<_>>();
assert_eq!(rows.len(), 3);
assert_eq!(rows[0].bounds.height(), 20.0);
assert_eq!(rows[1].bounds.height(), 44.0);
assert_eq!(rows[2].bounds.height(), 28.0);
assert_eq!(rows[1].bounds.y(), rows[0].bounds.max_y());
}
#[test]
fn virtual_table_row_keys_stabilize_semantics_across_reordering() -> Result<()> {
let keys = Rc::new(RefCell::new(vec![42_u64, 7]));
let key_reader = Rc::clone(&keys);
let name_reader = Rc::clone(&keys);
let (mut runtime, window_id) = build_runtime(
SizedBox::new().width(360.0).height(140.0).child(
VirtualTable::new("Keyed rows")
.columns([VirtualTableColumn::new("Name")])
.row_count(2)
.row_key(move |index| key_reader.borrow()[index])
.row_name(move |index| format!("Row {}", name_reader.borrow()[index])),
),
);
let before = runtime.render(window_id)?;
let before_id = before
.semantics
.iter()
.find(|node| node.name.as_deref() == Some("Row 42"))
.expect("row 42 semantics")
.id;
keys.borrow_mut().swap(0, 1);
runtime.handle_event(
window_id,
Event::Pointer(PointerEvent::new(
PointerEventKind::Move,
Point::new(20.0, 80.0),
)),
)?;
let after = runtime.render(window_id)?;
let after_id = after
.semantics
.iter()
.find(|node| node.name.as_deref() == Some("Row 42"))
.expect("reordered row 42 semantics")
.id;
assert_eq!(before_id, after_id);
Ok(())
}
#[test]
fn virtual_table_state_retains_keyed_selection_across_reordering() -> Result<()> {
let keys = Rc::new(RefCell::new(vec![42_u64, 7]));
let key_reader = Rc::clone(&keys);
let name_reader = Rc::clone(&keys);
let state = VirtualTableState::new();
state.select_key(Some(42));
let (mut runtime, window_id) = build_runtime(
SizedBox::new().width(360.0).height(140.0).child(
VirtualTable::new("Retained keyed rows")
.state(state.clone())
.columns([VirtualTableColumn::new("Name")])
.row_count(2)
.row_key(move |index| key_reader.borrow()[index])
.row_name(move |index| format!("Row {}", name_reader.borrow()[index])),
),
);
let before = runtime.render(window_id)?;
assert!(
before
.semantics
.iter()
.find(|node| node.name.as_deref() == Some("Row 42"))
.is_some_and(|node| node.state.selected)
);
keys.borrow_mut().swap(0, 1);
runtime.handle_event(
window_id,
Event::Pointer(PointerEvent::new(
PointerEventKind::Move,
Point::new(20.0, 80.0),
)),
)?;
let after = runtime.render(window_id)?;
assert!(
after
.semantics
.iter()
.find(|node| node.name.as_deref() == Some("Row 42"))
.is_some_and(|node| node.state.selected)
);
assert_eq!(state.selected_key(), Some(42));
state.select_key(None);
let cleared = runtime.render(window_id)?;
assert!(
cleared
.semantics
.iter()
.filter(|node| node.role == SemanticsRole::ListItem)
.all(|node| !node.state.selected)
);
Ok(())
}
#[test]
fn virtual_table_reports_selection_changes_through_on_change() -> Result<()> {
let changes = Rc::new(RefCell::new(Vec::new()));
let on_change = Rc::clone(&changes);
let ctx_changes = Rc::new(RefCell::new(Vec::new()));
let on_change_with_ctx = Rc::clone(&ctx_changes);
let (mut runtime, window_id) = build_runtime(
SizedBox::new().width(360.0).height(160.0).child(
VirtualTable::new("Selectable rows")
.columns([VirtualTableColumn::new("Name")])
.row_count(3)
.row_name(|index| format!("Row {index}"))
.on_change(move |index| on_change.borrow_mut().push(index))
.on_change_with_ctx(move |_ctx, index| {
on_change_with_ctx.borrow_mut().push(index)
}),
),
);
let output = runtime.render(window_id)?;
let row = semantic_bounds(&output, SemanticsRole::ListItem, "Row 0");
let at = Point::new(row.x() + 8.0, crate::draw::rect_center(row).y);
for _ in 0..2 {
runtime.handle_event(window_id, primary_pointer(PointerEventKind::Down, at, true))?;
runtime.handle_event(window_id, primary_pointer(PointerEventKind::Up, at, false))?;
}
runtime.handle_event(
window_id,
Event::Keyboard(KeyboardEvent::new("ArrowDown", KeyState::Pressed)),
)?;
assert_eq!(
changes.borrow().as_slice(),
&[0, 1],
"clicking the selected row again is not a change"
);
assert_eq!(ctx_changes.borrow().as_slice(), &[0, 1]);
Ok(())
}
#[test]
fn paged_virtual_table_reports_global_range_and_supports_keyed_scroll() -> Result<()> {
let state = VirtualTableState::new();
state.scroll_to(900, ScrollAlignment::Start);
let (mut runtime, window_id) = build_runtime(
SizedBox::new().width(360.0).height(140.0).child(
VirtualTable::new("Files")
.state(state.clone())
.columns([VirtualTableColumn::new("Name")])
.collection_window(CollectionWindow::loaded(
500..1_012,
Some(5_000),
true,
true,
))
.row_count(512)
.row_height(20.0)
.row_key(|index| 500 + index as u64)
.row_name(|index| format!("File {}", 500 + index)),
),
);
let output = runtime.render(window_id)?;
let viewport = state.viewport();
assert_eq!(viewport.loaded_range, 500..1_012);
assert_eq!(viewport.visible_range.start, 900);
assert_eq!(viewport.total_count, Some(5_000));
assert_eq!(viewport.anchor.as_ref().map(|anchor| anchor.key), Some(900));
let table = output
.semantics
.iter()
.find(|node| node.role == SemanticsRole::Table)
.expect("table semantics");
assert_eq!(
table.value,
Some(SemanticsValue::Text("5000 rows".to_string()))
);
assert!(
table
.description
.as_deref()
.is_some_and(|description| description.contains("of 5000"))
);
let first_visible = output
.semantics
.iter()
.find(|node| node.role == SemanticsRole::ListItem)
.expect("visible table row");
assert!(
first_visible
.description
.as_deref()
.is_some_and(|description| description.contains("901 of 5000"))
);
Ok(())
}
#[test]
fn virtual_table_state_retains_width_by_column_key() {
let state = VirtualTableState::new();
state.set_column_width(11, 184.0);
let painted_width = Rc::new(RefCell::new(0.0));
let width = Rc::clone(&painted_width);
let _ = render(
SizedBox::new().width(360.0).height(140.0).child(
VirtualTable::new("Retained widths")
.state(state.clone())
.columns([
VirtualTableColumn::new("Name").key(11),
VirtualTableColumn::new("Kind").key(12).width(80.0),
])
.row_count(1)
.row_painter(move |_ctx, row| {
*width.borrow_mut() = row.column_rects[0].width();
}),
),
);
assert_eq!(*painted_width.borrow(), 184.0);
assert_eq!(state.column_width(11), Some(184.0));
}
#[test]
fn virtual_table_column_separator_drag_resizes_column() -> Result<()> {
let resized = Rc::new(RefCell::new(Vec::new()));
let resize_events = Rc::clone(&resized);
let theme = DefaultTheme::default();
let width = 360.0;
let padding = theme.metrics.data_viewport_padding;
let available = width - padding.left - padding.right;
let separator_x = padding.left + available - 80.0;
let header_y = padding.top + theme.metrics.table_header_height * 0.5;
let (mut runtime, window_id) = build_runtime(
SizedBox::new().width(width).height(140.0).child(
VirtualTable::new("Resizable")
.theme(theme)
.columns([
VirtualTableColumn::new("Name").min_width(120.0),
VirtualTableColumn::new("Kind").width(80.0).resizable(false),
])
.row_count(2)
.on_column_resize(move |index, width| {
resize_events.borrow_mut().push((index, width));
}),
),
);
runtime.render(window_id)?;
runtime.handle_event(
window_id,
primary_pointer(
PointerEventKind::Down,
Point::new(separator_x, header_y),
true,
),
)?;
runtime.handle_event(
window_id,
primary_pointer(
PointerEventKind::Move,
Point::new(separator_x + 32.0, header_y),
true,
),
)?;
runtime.handle_event(
window_id,
primary_pointer(
PointerEventKind::Up,
Point::new(separator_x + 32.0, header_y),
false,
),
)?;
let events = resized.borrow();
assert!(!events.is_empty());
assert_eq!(events.last().map(|event| event.0), Some(0));
assert!(
events
.last()
.is_some_and(|event| event.1 > available - 80.0)
);
Ok(())
}
#[test]
fn virtual_table_pinned_columns_hold_position_during_horizontal_scroll() -> Result<()> {
let painted = Rc::new(RefCell::new(Vec::<Vec<Rect>>::new()));
let row_rects = Rc::clone(&painted);
let (mut runtime, window_id) = build_runtime(
SizedBox::new().width(220.0).height(140.0).child(
VirtualTable::new("Pinned")
.columns([
VirtualTableColumn::new("Name").width(100.0).pinned(true),
VirtualTableColumn::new("Kind").width(100.0),
VirtualTableColumn::new("Status").width(100.0),
])
.row_count(2)
.row_painter(move |_ctx, row| {
if row.row_index == 0 {
row_rects.borrow_mut().push(row.column_rects.to_vec());
}
}),
),
);
runtime.render(window_id)?;
let before = painted.borrow().last().cloned().expect("first row painted");
runtime.handle_event(
window_id,
wheel_scroll(Point::new(120.0, 80.0), Vector::new(-80.0, 0.0)),
)?;
runtime.render(window_id)?;
let after = painted
.borrow()
.last()
.cloned()
.expect("scrolled row painted");
assert_eq!(before[0].x(), after[0].x());
assert!(after[1].width() < before[1].width());
assert!(after[2].x() < before[2].x());
Ok(())
}
#[test]
fn table_numeric_column_uses_tabular_figures_and_shared_right_edge() {
let output = render(
SizedBox::new().width(360.0).height(140.0).child(
Table::new("Materials")
.columns([
TableColumn::new("Name"),
TableColumn::new("Passes").numeric(),
])
.rows([
TableRow::new(["Glass", "3"]),
TableRow::new(["Water", "128"]),
]),
),
);
let short = text_runs_for(&output, "3")
.into_iter()
.find(|run| {
run.style
.features
.iter()
.any(|feature| feature.tag == FontFeature::TABULAR_FIGURES)
})
.expect("short numeric cell should be tabular");
let long = text_runs_for(&output, "128")
.into_iter()
.next()
.expect("long numeric cell should render");
assert!(
long.style
.features
.iter()
.any(|feature| feature.tag == FontFeature::TABULAR_FIGURES && feature.value == 1)
);
assert!((short.rect.max_x() - long.rect.max_x()).abs() < 0.75);
}
#[test]
fn selected_table_cells_preserve_body_metrics_and_numeric_alignment() {
let mut theme = DefaultTheme::default();
theme.typography.body_font_size = 13.0;
theme.typography.body_line_height = 21.0;
let output = render(
SizedBox::new().width(360.0).height(140.0).child(
Table::new("Materials")
.theme(theme)
.columns([
TableColumn::new("Name"),
TableColumn::new("Passes").numeric(),
])
.rows([
TableRow::new(["Glass", "8642"]),
TableRow::new(["Water", "7"]),
])
.selected(0),
),
);
let selected_label = text_runs_for(&output, "Glass")
.into_iter()
.next()
.expect("selected text cell should render");
let selected_number = text_runs_for(&output, "8642")
.into_iter()
.next()
.expect("selected numeric cell should render");
let unselected_number = text_runs_for(&output, "7")
.into_iter()
.next()
.expect("unselected numeric cell should render");
assert_eq!(selected_label.style.color, theme.palette.text);
assert_eq!(
selected_label.style.font_size,
theme.typography.body_font_size
);
assert_eq!(
selected_label.style.line_height,
theme.typography.body_line_height
);
assert_eq!(selected_number.style.color, theme.palette.text);
assert_eq!(
selected_number.style.font_size,
theme.typography.body_font_size
);
assert_eq!(
selected_number.style.line_height,
theme.typography.body_line_height
);
assert!(
selected_number
.style
.features
.iter()
.any(|feature| feature.tag == FontFeature::TABULAR_FIGURES && feature.value == 1)
);
assert!((selected_number.rect.max_x() - unselected_number.rect.max_x()).abs() < 0.75);
}
#[test]
fn collection_and_path_widgets_theme_when_paints_dark_tokens() {
let theme = DefaultTheme::dark();
let list = render(
SizedBox::new().width(320.0).height(120.0).child(
ListView::new("Assets")
.theme_when(move || theme)
.item(ListItem::new("Hero texture").detail("2048 x 2048 RGBA")),
),
);
assert_eq!(
text_runs_for(&list, "Hero texture")[0].style.color,
theme.palette.text
);
assert!(solid_fill_colors(&list).contains(&theme.palette.surface));
let theme = DefaultTheme::dark();
let tree = render(
SizedBox::new().width(320.0).height(120.0).child(
TreeView::new("Scene")
.theme_when(move || theme)
.item(TreeItem::new("Environment").detail("Visible")),
),
);
assert_eq!(
text_runs_for(&tree, "Environment")[0].style.color,
theme.palette.text
);
assert!(solid_fill_colors(&tree).contains(&theme.palette.surface));
let theme = DefaultTheme::dark();
let table = render(
SizedBox::new().width(320.0).height(140.0).child(
Table::new("Materials")
.theme_when(move || theme)
.columns([TableColumn::new("Name")])
.rows([TableRow::new(["Glass"])]),
),
);
let table_fills = solid_fill_colors(&table);
assert!(table_fills.contains(&theme.palette.surface));
assert!(table_fills.contains(&theme.palette.control));
assert!(
!table_fills.contains(&Color::rgba(0.95, 0.965, 0.985, 1.0)),
"dark table header should not use the old hardcoded light fill"
);
let theme = DefaultTheme::dark();
let breadcrumb = render(Breadcrumb::new("Path").theme_when(move || theme).items([
BreadcrumbItem::new("Workspace"),
BreadcrumbItem::new("Project"),
]));
assert_eq!(
text_runs_for(&breadcrumb, "Workspace")[0].style.color,
theme.palette.text
);
assert!(solid_fill_colors(&breadcrumb).contains(&theme.palette.surface));
}
#[test]
fn table_chrome_uses_theme_metrics() {
let mut theme = DefaultTheme::default();
theme.metrics.table_header_separator_inset = 7.0;
theme.metrics.table_separator_width = 2.75;
theme.metrics.table_row_border_opacity = 0.29;
theme.metrics.data_scroll_thumb_width = 5.5;
theme.metrics.data_scroll_thumb_inset = 9.0;
theme.metrics.data_scroll_thumb_radius = 2.75;
theme.metrics.data_scroll_thumb_min_length = 35.0;
theme.metrics.data_scroll_thumb_opacity = 0.41;
let rows = (0..10).map(|index| TableRow::new([format!("Row {index}"), format!("{index}")]));
let output = render(
SizedBox::new().width(320.0).height(120.0).child(
Table::new("Materials")
.theme(theme)
.columns([
TableColumn::new("Name").width(160.0),
TableColumn::new("Passes").width(80.0),
])
.rows(rows),
),
);
let expected_separator_height =
theme.metrics.table_header_height - (theme.metrics.table_header_separator_inset * 2.0);
assert!(solid_stroke_rects(&output).iter().any(|rect| {
(rect.width() - theme.metrics.table_separator_width).abs() < 0.01
&& (rect.height() - expected_separator_height).abs() < 0.01
}));
assert!(
solid_stroke_widths(&output)
.iter()
.any(|width| { (*width - theme.metrics.table_separator_width).abs() < 0.01 })
);
assert!(
solid_stroke_colors(&output).contains(
&theme
.palette
.border
.with_alpha(theme.metrics.table_row_border_opacity)
)
);
assert!(
solid_fill_colors(&output).contains(
&theme
.palette
.border_hover
.with_alpha(theme.metrics.data_scroll_thumb_opacity)
)
);
let thumb_color = theme
.palette
.border_hover
.with_alpha(theme.metrics.data_scroll_thumb_opacity);
let thumbs = solid_fill_bounds_for_color(&output, thumb_color);
let header = solid_fill_bounds_for_color(&output, theme.palette.control)
.into_iter()
.find(|rect| (rect.height() - theme.metrics.table_header_height).abs() < 0.01)
.expect("table header");
assert!(!thumbs.is_empty());
for thumb in thumbs {
assert!(
header.max_x() <= thumb.x(),
"table columns must end before the scrollbar gutter"
);
assert!(thumb.max_x() <= 320.0 - theme.metrics.data_viewport_padding.right);
}
}
#[test]
fn list_view_detail_text_does_not_overlap_primary_label() {
let output = render(SizedBox::new().width(320.0).height(120.0).child(
ListView::new("Assets").item(ListItem::new("Hero texture").detail("2048 x 2048 RGBA")),
));
let label = text_rects_for(&output, "Hero texture")[0];
let detail = text_rects_for(&output, "2048 x 2048 RGBA")[0];
assert!(label.max_y() <= detail.y());
}
#[test]
fn list_view_label_and_detail_visual_centers_match_row_slots() {
let theme = DefaultTheme::default();
let output = render(SizedBox::new().width(320.0).height(72.0).child(
ListView::new("Assets").item(ListItem::new("Hero texture").detail("2048 x 2048 RGBA")),
));
let label = text_runs_for(&output, "Hero texture")
.into_iter()
.next()
.expect("list row label draw command present");
let detail = text_runs_for(&output, "2048 x 2048 RGBA")
.into_iter()
.next()
.expect("list row detail draw command present");
let viewport_padding = theme.metrics.data_viewport_padding;
let row_height = theme
.metrics
.list_row_height
.max(super::two_line_row_height(
label.style.line_height,
detail.style.line_height,
));
let row = Rect::new(
viewport_padding.left,
viewport_padding.top,
(output.frame.viewport.width - viewport_padding.left - viewport_padding.right).max(0.0),
row_height,
);
assert_two_line_row_text_matches_slots(&output, "Hero texture", "2048 x 2048 RGBA", row);
}
#[test]
fn data_detail_text_styles_follow_theme_xs_token() {
let mut theme = DefaultTheme::default();
theme.text.xs = ThemeTextToken {
size: 10.5,
line_height: 17.5,
};
theme.sync_derived_fields();
let list = render(
SizedBox::new().width(320.0).height(72.0).child(
ListView::new("Assets")
.theme(theme)
.item(ListItem::new("Hero texture").detail("2048 x 2048 RGBA")),
),
);
assert_text_run_uses_token(
&text_runs_for(&list, "2048 x 2048 RGBA")
.into_iter()
.next()
.expect("list detail should render"),
theme.text.xs,
);
let layer = render(
SizedBox::new().width(280.0).height(72.0).child(
LayerList::new("Layers").theme(theme).layer(
LayerListItem::new("Paint")
.detail("Normal / 100%")
.thumbnail(Color::rgba(0.16, 0.31, 0.88, 1.0)),
),
),
);
assert_text_run_uses_token(
&text_runs_for(&layer, "Normal / 100%")
.into_iter()
.next()
.expect("layer detail should render"),
theme.text.xs,
);
let tree = render(
SizedBox::new().width(320.0).height(72.0).child(
TreeView::new("Scene")
.theme(theme)
.item(TreeItem::new("Environment").detail("Visible")),
),
);
assert_text_run_uses_token(
&text_runs_for(&tree, "Visible")
.into_iter()
.next()
.expect("tree detail should render"),
theme.text.xs,
);
}
#[test]
fn list_view_long_label_clips_to_single_line() {
let title = "What tools are available to you when the session title is very long";
let output = render(
SizedBox::new()
.width(170.0)
.height(56.0)
.child(ListView::new("Sessions").item(ListItem::new(title))),
);
let run = text_runs_for(&output, title)
.into_iter()
.next()
.expect("long title should be drawn");
let clips = draw_clip_rects_for(&output, title);
assert_eq!(clips.len(), 1);
assert!(
clips[0].height() <= run.style.line_height + 0.5,
"long single-line labels should clip wrapped overflow to one line; clip={:?}, line_height={}",
clips[0],
run.style.line_height
);
}
#[test]
fn tree_view_detail_text_does_not_overlap_primary_label() {
let output =
render(SizedBox::new().width(320.0).height(120.0).child(
TreeView::new("Scene").item(TreeItem::new("Environment").detail("Visible")),
));
let label = text_rects_for(&output, "Environment")[0];
let detail = text_rects_for(&output, "Visible")[0];
assert!(label.max_y() <= detail.y());
}
#[test]
fn list_and_tree_detail_text_stays_grouped_with_primary_label() {
let list = render(SizedBox::new().width(320.0).height(120.0).child(
ListView::new("Assets").item(ListItem::new("Hero texture").detail("2048 x 2048 RGBA")),
));
let tree =
render(SizedBox::new().width(320.0).height(120.0).child(
TreeView::new("Scene").item(TreeItem::new("Environment").detail("Visible")),
));
for (output, label_text, detail_text) in [
(&list, "Hero texture", "2048 x 2048 RGBA"),
(&tree, "Environment", "Visible"),
] {
let label = text_rects_for(output, label_text)[0];
let detail = text_rects_for(output, detail_text)[0];
let gap = detail.y() - label.max_y();
assert!(
(0.0..=2.5).contains(&gap),
"expected {label_text:?} and {detail_text:?} to read as one row; gap was {gap}"
);
}
}
#[test]
fn tree_view_label_and_detail_visual_centers_match_row_slots() {
let theme = DefaultTheme::default();
let output =
render(SizedBox::new().width(320.0).height(72.0).child(
TreeView::new("Scene").item(TreeItem::new("Environment").detail("Visible")),
));
let label = text_runs_for(&output, "Environment")
.into_iter()
.next()
.expect("tree row label draw command present");
let detail = text_runs_for(&output, "Visible")
.into_iter()
.next()
.expect("tree row detail draw command present");
let viewport_padding = theme.metrics.data_viewport_padding;
let row_height = theme
.metrics
.tree_row_height
.max(super::two_line_row_height(
label.style.line_height,
detail.style.line_height,
));
let row = Rect::new(
viewport_padding.left,
viewport_padding.top,
(output.frame.viewport.width - viewport_padding.left - viewport_padding.right).max(0.0),
row_height,
);
assert_two_line_row_text_matches_slots(&output, "Environment", "Visible", row);
}
#[test]
fn list_view_does_not_paint_internal_scroll_thumb() {
let output = render(
SizedBox::new().width(320.0).height(100.0).child(
ListView::new("Assets")
.items([
ListItem::new("Hero texture").detail("2048 x 2048 RGBA"),
ListItem::new("UI icon sheet").detail("Tagged for export"),
ListItem::new("Archive cache").detail("Read only"),
ListItem::new("Normals atlas").detail("Streaming mip chain"),
])
.selected(1),
),
);
assert!(vertical_scroll_thumb_rects(&output).is_empty());
}
#[test]
fn list_view_scrolls_overflowing_rows_without_thumb() -> Result<()> {
let (mut runtime, window_id) =
build_runtime(SizedBox::new().width(320.0).height(100.0).child(
ListView::new("Assets").items([
ListItem::new("Hero texture").detail("2048 x 2048 RGBA"),
ListItem::new("UI icon sheet").detail("Tagged for export"),
ListItem::new("Archive cache").detail("Read only"),
ListItem::new("Normals atlas").detail("Streaming mip chain"),
]),
));
let before = runtime.render(window_id)?;
let before_y = text_rects_for(&before, "Hero texture")[0].y();
runtime.handle_event(
window_id,
wheel_scroll(Point::new(60.0, 60.0), Vector::new(0.0, -24.0)),
)?;
let after = runtime.render(window_id)?;
let after_y = text_rects_for(&after, "Hero texture")[0].y();
assert!(after_y < before_y);
assert!(vertical_scroll_thumb_rects(&after).is_empty());
Ok(())
}
#[test]
fn list_view_clips_scrolled_selection_highlight_to_viewport() -> Result<()> {
let theme = DefaultTheme::default();
let (mut runtime, window_id) = build_runtime(
SizedBox::new().width(320.0).height(100.0).child(
ListView::new("Assets")
.theme(theme)
.items([
ListItem::new("Hero texture").detail("2048 x 2048 RGBA"),
ListItem::new("UI icon sheet").detail("Tagged for export"),
ListItem::new("Archive cache").detail("Read only"),
ListItem::new("Normals atlas").detail("Streaming mip chain"),
])
.selected(0),
),
);
let _ = runtime.render(window_id)?;
runtime.handle_event(
window_id,
wheel_scroll(Point::new(60.0, 60.0), Vector::new(0.0, -24.0)),
)?;
let output = runtime.render(window_id)?;
let highlight = selected_highlight_rects(&output)
.first()
.copied()
.expect("selected list row highlight should be painted");
assert!(highlight.y() >= theme.metrics.data_viewport_padding.top);
assert!(highlight.max_y() <= 100.0 - theme.metrics.data_viewport_padding.bottom);
Ok(())
}
#[test]
fn tree_view_does_not_paint_internal_scroll_thumb() {
let output = render(
SizedBox::new().width(320.0).height(120.0).child(
TreeView::new("Scene").item(
TreeItem::new("Environment")
.item(TreeItem::new("Sky dome").detail("Visible"))
.item(TreeItem::new("Fog volume").detail("Animated"))
.item(TreeItem::new("Characters").detail("Selected")),
),
),
);
assert!(vertical_scroll_thumb_rects(&output).is_empty());
}
#[test]
fn tree_view_scrolls_overflowing_rows_without_thumb() -> Result<()> {
let (mut runtime, window_id) = build_runtime(
SizedBox::new().width(320.0).height(120.0).child(
TreeView::new("Scene").item(
TreeItem::new("Scene")
.expanded(true)
.item(TreeItem::new("Environment").detail("Visible"))
.item(TreeItem::new("Sky dome").detail("Visible"))
.item(TreeItem::new("Fog volume").detail("Animated"))
.item(TreeItem::new("Pilot").detail("Selected")),
),
),
);
let before = runtime.render(window_id)?;
let before_y = text_rects_for(&before, "Scene")[0].y();
runtime.handle_event(
window_id,
wheel_scroll(Point::new(60.0, 60.0), Vector::new(0.0, -24.0)),
)?;
let after = runtime.render(window_id)?;
let after_y = text_rects_for(&after, "Scene")[0].y();
assert!(after_y < before_y);
assert!(vertical_scroll_thumb_rects(&after).is_empty());
Ok(())
}
#[test]
fn tree_view_clips_scrolled_selection_highlight_to_viewport() -> Result<()> {
let theme = DefaultTheme::default();
let (mut runtime, window_id) = build_runtime(
SizedBox::new().width(320.0).height(120.0).child(
TreeView::new("Scene").item(
TreeItem::new("Scene")
.expanded(true)
.item(TreeItem::new("Environment").detail("Visible"))
.item(TreeItem::new("Sky dome").detail("Visible"))
.item(TreeItem::new("Fog volume").detail("Animated"))
.item(TreeItem::new("Pilot").detail("Selected")),
),
),
);
let _ = runtime.render(window_id)?;
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Down, Point::new(60.0, 24.0), true),
)?;
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Up, Point::new(60.0, 24.0), false),
)?;
runtime.handle_event(
window_id,
wheel_scroll(Point::new(60.0, 60.0), Vector::new(0.0, -24.0)),
)?;
let output = runtime.render(window_id)?;
let highlight = selected_highlight_rects(&output)
.first()
.copied()
.expect("selected tree row highlight should be painted");
assert!(highlight.y() >= theme.metrics.data_viewport_padding.top);
assert!(highlight.max_y() <= 120.0 - theme.metrics.data_viewport_padding.bottom);
Ok(())
}
#[test]
fn tree_view_disclosure_does_not_overlap_primary_label() {
let output = render(SizedBox::new().width(320.0).height(120.0).child(
TreeView::new("Scene").item(
TreeItem::new("Environment").item(TreeItem::new("Sky dome").detail("Visible")),
),
));
let label = text_rects_for(&output, "Environment")[0];
let mut disclosure_bounds = Vec::new();
output.frame.scene.visit_commands(&mut |command| {
if let SceneCommand::FillPath { path, .. } = command {
let bounds = path.bounds();
if bounds.width() <= 12.0 && bounds.height() <= 12.0 {
disclosure_bounds.push(bounds);
}
}
});
let disclosure = disclosure_bounds
.first()
.expect("tree disclosure should be painted");
assert!(
disclosure.max_x() + DefaultTheme::default().metrics.tree_disclosure_gap <= label.x()
);
}
#[test]
fn table_text_rect_uses_full_line_height() {
let output = render(
SizedBox::new().width(320.0).height(140.0).child(
Table::new("Materials")
.columns([TableColumn::new("Name")])
.rows([TableRow::new(["Glass"])]),
),
);
let header = text_rects_for(&output, "Name")[0];
let cell = text_rects_for(&output, "Glass")[0];
let line_height = DefaultTheme::default().body_text_style().line_height;
assert!(header.height() >= line_height);
assert!(cell.height() >= line_height);
}
#[test]
fn table_aligned_text_preserves_tall_measurements_and_cell_alignment() {
let mut theme = DefaultTheme::default();
theme.typography.body_font_size = 28.0;
theme.typography.body_line_height = 12.0;
theme.metrics.table_header_height = 44.0;
theme.metrics.table_row_height = 48.0;
let output = render(
SizedBox::new().width(360.0).height(136.0).child(
Table::new("Materials")
.theme(theme)
.columns([
TableColumn::new("Name")
.width(180.0)
.alignment(TableColumnAlignment::Center),
TableColumn::new("Passes").width(120.0).numeric(),
])
.rows([TableRow::new(["Glass", "128"])]),
),
);
let header = text_runs_for(&output, "Name")
.into_iter()
.next()
.expect("centered table header should render");
let header_clip = draw_clip_rects_for(&output, "Name")
.into_iter()
.next()
.expect("centered table header should be clipped to its cell");
let cell = text_runs_for(&output, "Glass")
.into_iter()
.next()
.expect("table cell should render");
let cell_clip = draw_clip_rects_for(&output, "Glass")
.into_iter()
.next()
.expect("table cell should be clipped to its cell");
let numeric = text_runs_for(&output, "128")
.into_iter()
.next()
.expect("numeric table cell should render");
let numeric_clip = draw_clip_rects_for(&output, "128")
.into_iter()
.next()
.expect("numeric table cell should be clipped to its cell");
let measured_height = |run: &sui_text::TextRun| {
TextSystem::new()
.shape_text_run(run, &FontRegistry::new())
.expect("table text should shape")
.measurement()
.height
};
assert!(header.rect.height() >= measured_height(&header) - 0.01);
assert!(cell.rect.height() >= measured_height(&cell) - 0.01);
assert!(numeric.rect.height() >= measured_height(&numeric) - 0.01);
assert!(
(rect_center(header.rect).x - rect_center(header_clip).x).abs() < 0.75,
"centered table header should align to cell center: text={:?}, cell={:?}",
header.rect,
header_clip
);
assert!(
(numeric.rect.max_x() - numeric_clip.max_x()).abs() < 0.75,
"numeric table cell should align to trailing edge: text={:?}, cell={:?}",
numeric.rect,
numeric_clip
);
assert!(
(text_visual_center_for(&output, "Name") - rect_center(header_clip).y).abs() < 0.75,
"centered table header should be optically centered in its cell"
);
assert!(
(text_visual_center_for(&output, "Glass") - rect_center(cell_clip).y).abs() < 0.75,
"table body cell should be optically centered in its cell"
);
assert!(
(text_visual_center_for(&output, "128") - rect_center(numeric_clip).y).abs() < 0.75,
"numeric table body cell should be optically centered in its cell"
);
}
#[test]
fn non_scrollable_table_allows_wheel_to_bubble_to_parent_scroll_view() -> Result<()> {
let (mut runtime, window_id) = build_runtime(
SizedBox::new()
.size(Size::new(220.0, 120.0))
.child(ScrollView::vertical(
Stack::vertical()
.with_child(SizedBox::new().width(220.0).height(80.0))
.with_child(
SizedBox::new().width(220.0).height(120.0).child(
Table::new("Materials")
.columns([
TableColumn::new("Name"),
TableColumn::new("Passes").width(80.0),
])
.rows([
TableRow::new(["Glass", "3"]),
TableRow::new(["Water", "4"]),
]),
),
)
.with_child(SizedBox::new().width(220.0).height(160.0)),
)),
);
let _ = runtime.render(window_id)?;
let mut scroll = PointerEvent::new(PointerEventKind::Scroll, Point::new(60.0, 90.0));
scroll.scroll_delta = Some(ScrollDelta::Pixels(Vector::new(0.0, -24.0)));
runtime.handle_event(window_id, Event::Pointer(scroll))?;
let _ = runtime.render(window_id)?;
let graph = runtime.widget_graph(window_id)?;
let outer_content = graph
.nodes
.iter()
.find(|node| {
node.bounds.width() == 220.0 - DefaultTheme::default().metrics.scroll_bar_thickness
&& node.bounds.height() == 360.0
})
.expect("outer scroll content present");
assert_eq!(outer_content.bounds.y(), -24.0);
Ok(())
}
#[test]
fn breadcrumb_keyboard_activates_last_segment() -> Result<()> {
let changes = Rc::new(RefCell::new(Vec::new()));
let on_activate = Rc::clone(&changes);
let (mut runtime, window_id) = build_runtime(
Breadcrumb::new("Path")
.items([
BreadcrumbItem::new("Workspace"),
BreadcrumbItem::new("Project"),
BreadcrumbItem::new("Scene"),
])
.current(0)
.on_activate(move |index, label| on_activate.borrow_mut().push((index, label))),
);
let _ = runtime.render(window_id)?;
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Down, Point::new(28.0, 20.0), true),
)?;
runtime.handle_event(
window_id,
primary_pointer(PointerEventKind::Up, Point::new(28.0, 20.0), false),
)?;
runtime.handle_event(
window_id,
Event::Keyboard(KeyboardEvent::new("End", KeyState::Pressed)),
)?;
runtime.handle_event(
window_id,
Event::Keyboard(KeyboardEvent::new("Enter", KeyState::Pressed)),
)?;
assert_eq!(changes.borrow().last(), Some(&(2, "Scene".to_string())));
let output = runtime.render(window_id)?;
let breadcrumb = output
.semantics
.iter()
.find(|node| node.role == SemanticsRole::Breadcrumb)
.expect("breadcrumb semantics present");
assert_eq!(
breadcrumb.value,
Some(SemanticsValue::Text("Scene".to_string()))
);
Ok(())
}
#[test]
fn breadcrumb_paints_segment_labels_with_line_height() {
let output = render(Breadcrumb::new("Path").items([
BreadcrumbItem::new("Workspace"),
BreadcrumbItem::new("Project"),
BreadcrumbItem::new("Scene"),
]));
let run = text_runs_for(&output, "Workspace")
.into_iter()
.next()
.expect("breadcrumb label draw command present");
let theme = DefaultTheme::default();
let line_height = theme.body_text_style().line_height;
let available_height = (theme.metrics.breadcrumb_height
- theme.metrics.breadcrumb_item_padding.top
- theme.metrics.breadcrumb_item_padding.bottom)
.max(0.0);
let layout = TextSystem::new()
.shape_text_run(&run, &FontRegistry::new())
.expect("breadcrumb label should shape");
let line = layout.lines().first().expect("breadcrumb line present");
let actual_visual_center =
run.rect.y() + line.baseline + optical_visual_center(layout.measurement());
let slot_center = theme.metrics.breadcrumb_item_padding.top + (available_height * 0.5);
assert!((run.rect.height() - line_height.min(available_height)).abs() < 0.001);
assert!(run.rect.width() > 0.0);
assert!(
(actual_visual_center - slot_center).abs() < 0.75,
"breadcrumb label visual center {actual_visual_center} did not match slot center {slot_center}; text rect {:?}",
run.rect
);
}
#[test]
fn breadcrumb_label_stays_within_vertical_item_bounds() {
let output = render(Breadcrumb::new("Path").items([BreadcrumbItem::new("Workspace")]));
let label = text_rects_for(&output, "Workspace")[0];
assert!(label.y() >= -0.01);
assert!(label.max_y() <= output.frame.viewport.height + 0.01);
}
#[test]
fn list_row_label_visual_center_matches_row_center() {
let output = render(ListView::new("Assets").item(ListItem::new("Hero texture")));
let run = text_runs_for(&output, "Hero texture")
.into_iter()
.next()
.expect("list row label draw command present");
let layout = TextSystem::new()
.shape_text_run(&run, &FontRegistry::new())
.expect("list row label should shape");
let line = layout.lines().first().expect("list row line present");
let actual_visual_center =
run.rect.y() + line.baseline + optical_visual_center(layout.measurement());
let row_center = output.frame.viewport.height * 0.5;
assert!((actual_visual_center - row_center).abs() < 0.75);
}
struct LeadingLabelCellFixture {
theme: DefaultTheme,
}
impl Widget for LeadingLabelCellFixture {
fn measure(
&mut self,
_ctx: &mut sui_runtime::MeasureCtx,
constraints: Constraints,
) -> Size {
constraints.clamp(Size::new(132.0, 32.0))
}
fn paint(&self, ctx: &mut PaintCtx) {
super::paint_leading_label_cell(
ctx,
&self.theme,
ctx.bounds(),
"artifact.txt",
LeadingLabelCellPaint::new()
.icon(crate::IconGlyph::File)
.icon_color(self.theme.palette.text_muted)
.label_color(self.theme.palette.text)
.label_weight(FontWeight::MEDIUM)
.icon_slot_side(20.0)
.icon_inset(2.0)
.gap(8.0)
.padding(6.0, 8.0),
);
}
}
#[test]
fn leading_label_cell_uses_compact_token_and_clips_to_cell() {
let theme = DefaultTheme::default();
let output = render(LeadingLabelCellFixture { theme });
let label = text_runs_for(&output, "artifact.txt")
.into_iter()
.next()
.expect("leading-label cell text should paint");
assert_text_run_uses_token(&label, theme.text.sm);
assert_eq!(label.style.weight, FontWeight::MEDIUM);
assert!(label.rect.x() >= 34.0);
assert!(
label.rect.max_x() <= output.frame.viewport.width + 0.75,
"label should stay within the cell bounds: {:?}",
label.rect
);
let layout = TextSystem::new()
.shape_text_run(&label, &FontRegistry::new())
.expect("leading-label cell text should shape");
let line = layout.lines().first().expect("leading-label line present");
let visual_center =
label.rect.y() + line.baseline + optical_visual_center(layout.measurement());
assert!(
(visual_center - (output.frame.viewport.height * 0.5)).abs() < 0.75,
"leading-label visual center {visual_center} did not match cell center; text rect {:?}",
label.rect
);
}
struct TextCellFixture {
theme: DefaultTheme,
}
impl Widget for TextCellFixture {
fn measure(
&mut self,
_ctx: &mut sui_runtime::MeasureCtx,
constraints: Constraints,
) -> Size {
constraints.clamp(Size::new(160.0, 32.0))
}
fn paint(&self, ctx: &mut PaintCtx) {
super::paint_text_cell(
ctx,
&self.theme,
ctx.bounds(),
"128",
TextCellPaint::new()
.text_token(self.theme.text.xs)
.color(self.theme.palette.text_muted)
.weight(FontWeight::MEDIUM)
.padding(10.0, 18.0)
.alignment(TableColumnAlignment::End)
.numeric(true),
);
}
}
#[test]
fn text_cell_paint_uses_alignment_numeric_token_and_clipping() {
let mut theme = DefaultTheme::default();
theme.text.xs = ThemeTextToken {
size: 10.5,
line_height: 17.5,
};
theme.sync_derived_fields();
let output = render(TextCellFixture { theme });
let run = text_runs_for(&output, "128")
.into_iter()
.next()
.expect("text-cell text should paint");
let clip = draw_clip_rects_for(&output, "128")
.into_iter()
.next()
.expect("text-cell text should clip to padded content");
let content_right = output.frame.viewport.width - 18.0;
assert_text_run_uses_token(&run, theme.text.xs);
assert_eq!(run.style.color, theme.palette.text_muted);
assert_eq!(run.style.weight, FontWeight::MEDIUM);
assert!(
run.style
.features
.iter()
.any(|feature| feature.tag == FontFeature::TABULAR_FIGURES && feature.value == 1),
"numeric text cells should opt into tabular figures"
);
assert!((run.rect.max_x() - content_right).abs() < 0.75);
assert!((clip.x() - 10.0).abs() < 0.01);
assert!((clip.max_x() - content_right).abs() < 0.01);
let layout = TextSystem::new()
.shape_text_run(&run, &FontRegistry::new())
.expect("text-cell text should shape");
let line = layout.lines().first().expect("text-cell line present");
let visual_center =
run.rect.y() + line.baseline + optical_visual_center(layout.measurement());
assert!(
(visual_center - (output.frame.viewport.height * 0.5)).abs() < 0.75,
"text-cell visual center {visual_center} did not match cell center; text rect {:?}",
run.rect
);
}
struct TextBlockFixture {
theme: DefaultTheme,
text: String,
}
impl Widget for TextBlockFixture {
fn measure(
&mut self,
_ctx: &mut sui_runtime::MeasureCtx,
constraints: Constraints,
) -> Size {
constraints.clamp(Size::new(178.0, 76.0))
}
fn paint(&self, ctx: &mut PaintCtx) {
super::paint_text_block(
ctx,
&self.theme,
ctx.bounds(),
&self.text,
TextBlockPaint::new()
.text_token(self.theme.text.sm)
.color(self.theme.palette.text_muted)
.weight(FontWeight::MEDIUM)
.padding(Insets {
left: 12.0,
top: 7.0,
right: 16.0,
bottom: 9.0,
}),
);
}
}
#[test]
fn text_block_paint_wraps_top_aligns_and_clips_to_padding() {
let mut theme = DefaultTheme::default();
theme.text.sm = ThemeTextToken {
size: 12.0,
line_height: 18.0,
};
theme.sync_derived_fields();
let text =
"This preview line wraps through SUI text layout.\nSecond paragraph stays compact."
.to_string();
let output = render(TextBlockFixture {
theme,
text: text.clone(),
});
let (origin, layout, color) = output
.frame
.scene
.commands()
.iter()
.find_map(|command| {
let SceneCommand::DrawShapedText(run) = command else {
return None;
};
let layout = run.resolve(output.frame.text_layout_registry.as_ref())?;
(layout.text() == text).then_some((run.origin, layout.clone(), run.color_override))
})
.expect("text block should paint as a shaped text layout");
let clip = draw_clip_rects_for(&output, &text)
.into_iter()
.next()
.expect("text block should clip to padded content");
assert_eq!(color, Some(theme.palette.text_muted));
assert!((origin.x - 12.0).abs() < 0.01);
assert!((origin.y - 7.0).abs() < 0.01);
assert!((layout.box_size().width - 150.0).abs() < 0.01);
assert!((layout.box_size().height - 60.0).abs() < 0.01);
assert!(layout.lines().len() >= 2, "text block should wrap");
assert_text_run_uses_token(
&sui_text::TextRun {
rect: Rect::ZERO,
text,
style: layout.style().clone(),
},
theme.text.sm,
);
assert_eq!(layout.style().weight, FontWeight::MEDIUM);
assert!((clip.x() - 12.0).abs() < 0.01);
assert!((clip.y() - 7.0).abs() < 0.01);
assert!((clip.width() - 150.0).abs() < 0.01);
assert!((clip.height() - 60.0).abs() < 0.01);
}
#[test]
fn list_row_text_preserves_tall_measurement_in_compact_line_box() {
let mut theme = DefaultTheme::default();
theme.typography.body_font_size = 28.0;
theme.typography.body_line_height = 12.0;
theme.metrics.list_row_height = 52.0;
let output = render(
SizedBox::new().width(320.0).height(72.0).child(
ListView::new("Assets")
.theme(theme)
.item(ListItem::new("Glass")),
),
);
let run = text_runs_for(&output, "Glass")
.into_iter()
.next()
.expect("list row label draw command present");
let layout = TextSystem::new()
.shape_text_run(&run, &FontRegistry::new())
.expect("list row label should shape");
let row_center =
theme.metrics.data_viewport_padding.top + theme.metrics.list_row_height * 0.5;
assert!(
run.rect.height() >= layout.measurement().height - 0.01,
"list row text rect should preserve measured glyph height: rect={:?}, measurement={:?}",
run.rect,
layout.measurement()
);
assert!(
run.rect.height() > run.style.line_height,
"test theme should exercise measured-height preservation"
);
assert!(
(text_run_visual_center(&run) - row_center).abs() < 0.75,
"list row label visual center should remain row-centered"
);
}
#[test]
fn list_row_leading_and_trailing_text_align_to_row_center_and_edge() {
let theme = DefaultTheme::default();
let output = render(
SizedBox::new().width(260.0).child(
ListView::new("Assets").item(
ListItem::new("Hero texture")
.leading_text("A")
.trailing("42"),
),
),
);
let leading = text_runs_for(&output, "A")
.into_iter()
.next()
.expect("leading text draw command present");
let trailing = text_runs_for(&output, "42")
.into_iter()
.next()
.expect("trailing text draw command present");
let text_system = TextSystem::new();
let leading_layout = text_system
.shape_text_run(&leading, &FontRegistry::new())
.expect("leading text should shape");
let trailing_layout = text_system
.shape_text_run(&trailing, &FontRegistry::new())
.expect("trailing text should shape");
let leading_line = leading_layout
.lines()
.first()
.expect("leading line present");
let trailing_line = trailing_layout
.lines()
.first()
.expect("trailing line present");
let leading_visual_center = leading.rect.y()
+ leading_line.baseline
+ optical_visual_center(leading_layout.measurement());
let trailing_visual_center = trailing.rect.y()
+ trailing_line.baseline
+ optical_visual_center(trailing_layout.measurement());
let row_center = output.frame.viewport.height * 0.5;
let trailing_edge = output.frame.viewport.width
- theme.metrics.data_viewport_padding.right
- theme.metrics.data_row_padding.right;
assert!((leading_visual_center - row_center).abs() < 0.75);
assert!((trailing_visual_center - row_center).abs() < 0.75);
assert!(
(trailing.rect.max_x() - trailing_edge).abs() < 0.75,
"trailing text max_x {} did not align to content edge {trailing_edge}",
trailing.rect.max_x()
);
}
#[test]
fn list_row_leading_and_trailing_text_preserve_tall_measurements() {
let mut theme = DefaultTheme::default();
theme.typography.body_font_size = 28.0;
theme.typography.body_line_height = 12.0;
theme.text.xs = ThemeTextToken {
size: 26.0,
line_height: 10.0,
};
theme.metrics.list_row_height = 64.0;
let output = render(
SizedBox::new().width(320.0).height(88.0).child(
ListView::new("Assets").theme(theme).item(
ListItem::new("Hero texture")
.leading_text("A")
.trailing("42"),
),
),
);
let row = output
.semantics
.iter()
.find(|node| node.role == SemanticsRole::ListItem)
.expect("list row semantics present")
.bounds;
let leading = text_runs_for(&output, "A")
.into_iter()
.next()
.expect("leading text draw command present");
let trailing = text_runs_for(&output, "42")
.into_iter()
.next()
.expect("trailing text draw command present");
let leading_layout = TextSystem::new()
.shape_text_run(&leading, &FontRegistry::new())
.expect("leading text should shape");
let trailing_layout = TextSystem::new()
.shape_text_run(&trailing, &FontRegistry::new())
.expect("trailing text should shape");
let trailing_clip = draw_clip_rects_for(&output, "42")
.into_iter()
.next()
.expect("trailing text should be clipped to reserved slot");
let row_center = row.y() + (row.height() * 0.5);
let trailing_edge = row.max_x() - theme.metrics.data_row_padding.right;
assert_eq!(leading.style.font_size, 28.0);
assert_eq!(leading.style.line_height, 12.0);
assert_text_run_uses_token(&trailing, theme.text.xs);
assert!(leading.rect.height() >= leading_layout.measurement().height - 0.01);
assert!(trailing.rect.height() >= trailing_layout.measurement().height - 0.01);
assert!(leading.rect.height() > leading.style.line_height);
assert!(trailing.rect.height() > trailing.style.line_height);
assert!((text_run_visual_center(&leading) - row_center).abs() < 0.75);
assert!((text_run_visual_center(&trailing) - row_center).abs() < 0.75);
assert!((trailing.rect.max_x() - trailing_edge).abs() < 0.75);
assert!((trailing_clip.max_x() - trailing_edge).abs() < 0.75);
}
#[test]
fn selected_list_row_trailing_text_preserves_caption_metrics() {
let mut theme = DefaultTheme::default();
theme.text.xs = ThemeTextToken {
size: 10.5,
line_height: 17.5,
};
theme.sync_derived_fields();
let output = render(
SizedBox::new().width(260.0).child(
ListView::new("Assets")
.theme(theme)
.selected(0)
.item(ListItem::new("Hero texture").trailing("42")),
),
);
let trailing = text_runs_for(&output, "42")
.into_iter()
.next()
.expect("selected trailing text draw command present");
let trailing_layout = TextSystem::new()
.shape_text_run(&trailing, &FontRegistry::new())
.expect("selected trailing text should shape");
let trailing_line = trailing_layout
.lines()
.first()
.expect("selected trailing line present");
let trailing_visual_center = trailing.rect.y()
+ trailing_line.baseline
+ optical_visual_center(trailing_layout.measurement());
let row_center = output.frame.viewport.height * 0.5;
let trailing_edge = output.frame.viewport.width
- theme.metrics.data_viewport_padding.right
- theme.metrics.data_row_padding.right;
assert_text_run_uses_token(&trailing, theme.text.xs);
assert_eq!(trailing.style.color, theme.palette.placeholder);
assert!((trailing_visual_center - row_center).abs() < 0.75);
assert!(
(trailing.rect.max_x() - trailing_edge).abs() < 0.75,
"selected trailing text max_x {} did not align to content edge {trailing_edge}",
trailing.rect.max_x()
);
}
}