1use std::{
2 cell::{Cell, RefCell},
3 collections::HashMap,
4 fmt,
5 ops::Range,
6 rc::Rc,
7 time::{Duration, Instant},
8};
9
10use sui_core::{
11 Color, Event, KeyState, Path, PathBuilder, Point, PointerButton, PointerEventKind, Rect,
12 SemanticsAction, SemanticsNode, SemanticsRole, SemanticsValue, Size, ToggleState, Transform,
13 Vector, WakeEvent, WidgetId,
14};
15use sui_layout::{Constraints, Padding as Insets};
16use sui_reactive::Signal;
17use sui_runtime::{
18 ArrangeCtx, EventCtx, EventPhase, MeasureCtx, PaintCtx, SemanticsCtx, SingleChild, Widget,
19 WidgetPodMutVisitor, WidgetPodVisitor,
20};
21use sui_text::{
22 FontFeature, FontWeight, TextAlign, TextDocument, TextLayoutRequest, TextMeasurement,
23 TextStyle, TextWrap,
24};
25
26use crate::{
27 DefaultTheme, MotionScalar, ThemeTextToken,
28 collection::{
29 CollectionAnchor, CollectionAnchorGravity, CollectionExtentIndex, CollectionWindow,
30 ScrollAlignment, VirtualViewportSnapshot,
31 },
32 containers::{ScrollAxes, ScrollState},
33 controls::{IconGlyph, draw_icon_glyph},
34 text_align::{paint_aligned_text, vertically_centered_text_rect_y},
35};
36
37pub struct ListItem {
38 label: String,
39 detail: Option<String>,
40 semantic_name: Option<String>,
41 semantic_description: Option<String>,
42 trailing: Option<String>,
43 leading_icon: Option<IconGlyph>,
44 leading_text: Option<String>,
45 leading_color: Option<Color>,
46 accent: Option<Color>,
47 disabled: bool,
48 activate_with_child: bool,
49 content: Option<SingleChild>,
50}
51
52impl ListItem {
53 pub fn new(label: impl Into<String>) -> Self {
54 Self {
55 label: label.into(),
56 detail: None,
57 semantic_name: None,
58 semantic_description: None,
59 trailing: None,
60 leading_icon: None,
61 leading_text: None,
62 leading_color: None,
63 accent: None,
64 disabled: false,
65 activate_with_child: false,
66 content: None,
67 }
68 }
69
70 pub fn detail(mut self, detail: impl Into<String>) -> Self {
71 self.detail = Some(detail.into());
72 self
73 }
74
75 pub fn subtitle(self, subtitle: impl Into<String>) -> Self {
76 self.detail(subtitle)
77 }
78
79 pub fn semantic_name(mut self, name: impl Into<String>) -> Self {
80 self.semantic_name = Some(name.into());
81 self
82 }
83
84 pub fn description(mut self, description: impl Into<String>) -> Self {
85 self.semantic_description = Some(description.into());
86 self
87 }
88
89 pub fn trailing(mut self, trailing: impl Into<String>) -> Self {
90 self.trailing = Some(trailing.into());
91 self
92 }
93
94 pub fn leading_icon(mut self, icon: IconGlyph) -> Self {
95 self.leading_icon = Some(icon);
96 self.leading_text = None;
97 self
98 }
99
100 pub fn leading_text(mut self, text: impl Into<String>) -> Self {
101 self.leading_text = Some(text.into());
102 self.leading_icon = None;
103 self
104 }
105
106 pub fn leading_color(mut self, color: Color) -> Self {
107 self.leading_color = Some(color);
108 self
109 }
110
111 pub fn accent(mut self, accent: Color) -> Self {
112 self.accent = Some(accent);
113 self
114 }
115
116 pub fn disabled(mut self) -> Self {
117 self.disabled = true;
118 self
119 }
120
121 pub fn activate_with_child(mut self) -> Self {
122 self.activate_with_child = true;
123 self
124 }
125
126 pub fn activate_with_content(self) -> Self {
129 self.activate_with_child()
130 }
131
132 pub fn with_child<W>(mut self, child: W) -> Self
133 where
134 W: Widget + 'static,
135 {
136 self.content = Some(SingleChild::new(child));
137 self
138 }
139
140 pub fn with_content<W>(self, content: W) -> Self
143 where
144 W: Widget + 'static,
145 {
146 self.with_child(content)
147 }
148
149 pub fn label(&self) -> &str {
150 &self.label
151 }
152
153 pub fn has_child(&self) -> bool {
154 self.content.is_some()
155 }
156
157 fn can_activate_from_row(&self) -> bool {
158 !self.disabled && (self.content.is_none() || self.activate_with_child)
159 }
160}
161
162pub struct ListView {
163 theme: Box<DefaultTheme>,
164 theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
165 name: String,
166 items: Vec<ListItem>,
167 selected: Option<usize>,
168 selected_reader: Option<Box<dyn Fn() -> Option<usize>>>,
169 hovered: Option<usize>,
170 pressed: Option<usize>,
171 hover_motion: IndexedInteractionMotion<usize>,
172 press_motion: IndexedInteractionMotion<usize>,
173 focus_animation: AnimatedScalar,
174 row_height: Option<f32>,
175 padding: Option<Insets>,
176 scroll_y: f32,
177 row_heights: Vec<f32>,
178 row_offsets: Vec<f32>,
179 content_height: f32,
180 on_change: Option<ListViewChange>,
181 on_change_with_ctx: Option<ListViewContextChange>,
182}
183
184impl ListView {
185 pub fn new(name: impl Into<String>) -> Self {
186 Self {
187 theme: Box::new(DefaultTheme::default()),
188 theme_reader: None,
189 name: name.into(),
190 items: Vec::new(),
191 selected: None,
192 selected_reader: None,
193 hovered: None,
194 pressed: None,
195 hover_motion: IndexedInteractionMotion::new(),
196 press_motion: IndexedInteractionMotion::new(),
197 focus_animation: AnimatedScalar::new(0.0),
198 row_height: None,
199 padding: None,
200 scroll_y: 0.0,
201 row_heights: Vec::new(),
202 row_offsets: Vec::new(),
203 content_height: 0.0,
204 on_change: None,
205 on_change_with_ctx: None,
206 }
207 }
208
209 pub fn theme(mut self, theme: DefaultTheme) -> Self {
210 self.theme = Box::new(theme);
211 self.theme_reader = None;
212 self
213 }
214
215 pub fn theme_when<F>(mut self, theme: F) -> Self
216 where
217 F: Fn() -> DefaultTheme + 'static,
218 {
219 self.theme_reader = Some(Box::new(theme));
220 self
221 }
222
223 pub fn item(mut self, item: ListItem) -> Self {
224 self.items.push(item);
225 self
226 }
227
228 pub fn items<I>(mut self, items: I) -> Self
229 where
230 I: IntoIterator<Item = ListItem>,
231 {
232 self.items.extend(items);
233 self
234 }
235
236 pub fn selected(mut self, selected: usize) -> Self {
237 self.selected = Some(selected);
238 self.selected_reader = None;
239 self
240 }
241
242 pub fn selected_when<F>(mut self, selected: F) -> Self
243 where
244 F: Fn() -> Option<usize> + 'static,
245 {
246 self.selected_reader = Some(Box::new(selected));
247 self
248 }
249
250 pub fn row_height(mut self, row_height: f32) -> Self {
251 self.row_height = Some(row_height.max(0.0));
252 self
253 }
254
255 pub fn padding(mut self, padding: Insets) -> Self {
258 self.padding = Some(padding);
259 self
260 }
261
262 pub fn on_change<F>(mut self, on_change: F) -> Self
263 where
264 F: FnMut(usize, String) + 'static,
265 {
266 self.on_change = Some(Box::new(on_change));
267 self
268 }
269
270 pub fn on_change_with_ctx<F>(mut self, on_change: F) -> Self
271 where
272 F: FnMut(usize, String, &mut EventCtx) + 'static,
273 {
274 self.on_change_with_ctx = Some(Box::new(on_change));
275 self
276 }
277
278 pub fn selected_index(&self) -> Option<usize> {
279 self.current_selected()
280 }
281
282 fn sync_selected(&mut self) {
283 if self.selected_reader.is_some() {
284 self.selected = self.current_selected();
285 } else if self
286 .selected
287 .is_some_and(|selected| selected >= self.items.len())
288 {
289 self.selected = None;
290 }
291 }
292
293 fn current_selected(&self) -> Option<usize> {
294 self.selected_reader
295 .as_ref()
296 .map(|selected| selected())
297 .unwrap_or(self.selected)
298 .filter(|index| *index < self.items.len())
299 }
300
301 fn resolved_theme(&self) -> DefaultTheme {
302 self.theme_reader
303 .as_ref()
304 .map(|theme| theme())
305 .unwrap_or(*self.theme)
306 }
307
308 fn resolved_row_height(&self) -> f32 {
309 let theme = self.resolved_theme();
310 let base = self.row_height.unwrap_or(theme.metrics.list_row_height);
311 if self.items.iter().any(|item| item.detail.is_some()) {
312 base.max(two_line_row_height(
313 theme.body_text_style().line_height,
314 caption_style(&theme).line_height,
315 ))
316 } else {
317 base
318 }
319 }
320
321 fn viewport_rect(&self, bounds: Rect) -> Rect {
322 inset_rect(bounds, self.resolved_padding())
323 }
324
325 fn resolved_padding(&self) -> Insets {
326 self.padding
327 .unwrap_or(self.resolved_theme().metrics.data_viewport_padding)
328 }
329
330 fn measured_content_height(&self) -> f32 {
331 if self.row_heights.len() == self.items.len() {
332 self.content_height
333 } else {
334 self.items.len() as f32 * self.resolved_row_height()
335 }
336 }
337
338 fn clamp_scroll(&self, viewport_height: f32, scroll_y: f32) -> f32 {
339 let max_scroll = (self.measured_content_height() - viewport_height).max(0.0);
340 scroll_y.clamp(0.0, max_scroll)
341 }
342
343 fn row_metrics(&self, index: usize) -> Option<(f32, f32)> {
344 self.row_offsets
345 .get(index)
346 .zip(self.row_heights.get(index))
347 .map(|(offset, height)| (*offset, *height))
348 .or_else(|| {
349 (index < self.items.len()).then(|| {
350 let row_height = self.resolved_row_height();
351 (index as f32 * row_height, row_height)
352 })
353 })
354 }
355
356 fn visible_row_rect(&self, bounds: Rect, index: usize) -> Option<Rect> {
357 let viewport = self.viewport_rect(bounds);
358 let (top, row_height) = self.row_metrics(index)?;
359 let y = viewport.y() + top - self.scroll_y;
360 Rect::new(viewport.x(), y, viewport.width(), row_height)
361 .intersection(viewport)
362 .filter(|rect| !rect.is_empty())
363 }
364
365 fn row_at_position(&self, bounds: Rect, position: Point) -> Option<usize> {
366 let viewport = self.viewport_rect(bounds);
367 if !viewport.contains(position) {
368 return None;
369 }
370
371 let y = position.y - viewport.y() + self.scroll_y;
372 (0..self.items.len()).find(|index| {
373 self.row_metrics(*index)
374 .is_some_and(|(top, height)| y >= top && y < top + height)
375 })
376 }
377
378 fn ensure_visible(&mut self, viewport_height: f32, index: usize) {
379 let Some((top, row_height)) = self.row_metrics(index) else {
380 return;
381 };
382 let bottom = top + row_height;
383 if top < self.scroll_y {
384 self.scroll_y = top;
385 } else if bottom > self.scroll_y + viewport_height {
386 self.scroll_y = bottom - viewport_height;
387 }
388 self.scroll_y = self.clamp_scroll(viewport_height, self.scroll_y);
389 }
390
391 fn row_blocks_parent_activation(&self, index: usize) -> bool {
392 self.items
393 .get(index)
394 .is_some_and(|item| item.has_child() && !item.activate_with_child)
395 }
396
397 fn row_activation_waits_for_child_target(&self, index: usize) -> bool {
398 self.items
399 .get(index)
400 .is_some_and(|item| item.has_child() && item.activate_with_child)
401 }
402
403 fn activate(&mut self, index: usize, ctx: &mut EventCtx) {
404 let Some(item) = self.items.get(index) else {
405 return;
406 };
407 if item.disabled {
408 return;
409 }
410 let label = item.label.clone();
411
412 self.selected = Some(index);
413 if let Some(on_change) = &mut self.on_change {
414 on_change(index, label.clone());
415 }
416 if let Some(on_change) = &mut self.on_change_with_ctx {
417 on_change(index, label, ctx);
418 }
419 }
420
421 fn move_selection(&mut self, delta: isize, viewport_height: f32, ctx: &mut EventCtx) {
422 if self.items.is_empty() {
423 return;
424 }
425
426 let current = self.selected.unwrap_or(0) as isize;
427 let next = (current + delta).clamp(0, self.items.len() as isize - 1) as usize;
428 self.activate(next, ctx);
429 self.ensure_visible(viewport_height, next);
430 }
431
432 fn set_hovered(&mut self, hovered: Option<usize>, ctx: &mut EventCtx) {
433 if self.hovered == hovered {
434 return;
435 }
436
437 self.hovered = hovered;
438 let theme = self.resolved_theme();
439 self.hover_motion.set_hover_target(hovered, &theme, ctx);
440 ctx.request_paint();
441 ctx.request_semantics();
442 }
443
444 fn set_pressed(&mut self, pressed: Option<usize>, ctx: &mut EventCtx) {
445 if self.pressed == pressed {
446 return;
447 }
448
449 self.pressed = pressed;
450 let theme = self.resolved_theme();
451 self.press_motion.set_press_target(pressed, &theme, ctx);
452 ctx.request_paint();
453 ctx.request_semantics();
454 }
455
456 fn advance_animations(&mut self, time: f64, ctx: &mut EventCtx) {
457 let (hover_changed, hover_active) = self.hover_motion.advance(time);
458 let (press_changed, press_active) = self.press_motion.advance(time);
459 let (focus_changed, focus_active) = advance_scalar(&mut self.focus_animation, time);
460
461 if hover_changed || press_changed || focus_changed {
462 ctx.request_paint();
463 }
464 if hover_active || press_active || focus_active {
465 ctx.request_animation_frame();
466 }
467 }
468}
469
470impl Widget for ListView {
471 fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
472 self.sync_selected();
473 let viewport = self.viewport_rect(ctx.bounds());
474
475 match event {
476 Event::Pointer(pointer) if pointer.kind == PointerEventKind::Move => {
477 let hovered = self.row_at_position(ctx.bounds(), pointer.position);
478 self.set_hovered(hovered, ctx);
479 }
480 Event::Pointer(pointer)
481 if pointer.kind == PointerEventKind::Scroll
482 && viewport.contains(pointer.position) =>
483 {
484 let delta = pointer
485 .scroll_delta
486 .map(scroll_delta_to_offset)
487 .unwrap_or(pointer.delta);
488 let next = self.clamp_scroll(viewport.height(), self.scroll_y - delta.y);
489 if (next - self.scroll_y).abs() > f32::EPSILON {
490 self.scroll_y = next;
491 ctx.request_arrange();
492 ctx.request_paint();
493 ctx.request_semantics();
494 ctx.set_handled();
495 }
496 }
497 Event::Pointer(pointer)
498 if pointer.kind == PointerEventKind::Down
499 && pointer.button == Some(PointerButton::Primary)
500 && viewport.contains(pointer.position) =>
501 {
502 let row = self.row_at_position(ctx.bounds(), pointer.position);
503 if row.is_some_and(|index| self.row_blocks_parent_activation(index)) {
504 return;
505 }
506 if ctx.phase() == EventPhase::Capture
507 && row.is_some_and(|index| self.row_activation_waits_for_child_target(index))
508 {
509 return;
510 }
511 self.set_hovered(row, ctx);
512 self.set_pressed(row, ctx);
513 ctx.request_focus();
514 ctx.request_pointer_capture(pointer.pointer_id);
515 ctx.set_handled();
516 }
517 Event::Pointer(pointer)
518 if pointer.kind == PointerEventKind::Up
519 && pointer.button == Some(PointerButton::Primary) =>
520 {
521 if self.pressed.is_none() {
522 return;
523 }
524 let hovered = self.row_at_position(ctx.bounds(), pointer.position);
525 if let Some(index) = self
526 .pressed
527 .zip(hovered)
528 .filter(|(pressed, hovered)| pressed == hovered)
529 .map(|(index, _)| index)
530 && !self.row_blocks_parent_activation(index)
531 {
532 self.activate(index, ctx);
533 }
534 self.set_hovered(hovered, ctx);
535 self.set_pressed(None, ctx);
536 ctx.release_pointer_capture(pointer.pointer_id);
537 ctx.set_handled();
538 }
539 Event::Pointer(pointer) if pointer.kind == PointerEventKind::Leave => {
540 self.set_hovered(None, ctx);
541 }
542 Event::Pointer(pointer) if pointer.kind == PointerEventKind::Cancel => {
543 if self.pressed.is_some() {
544 self.set_pressed(None, ctx);
545 self.set_hovered(None, ctx);
546 ctx.release_pointer_capture(pointer.pointer_id);
547 ctx.set_handled();
548 }
549 }
550 Event::Wake(WakeEvent::AnimationFrame { time, .. }) => {
551 self.advance_animations(*time, ctx);
552 }
553 Event::Keyboard(key) if ctx.is_focused() && key.state == KeyState::Pressed => {
554 match key.key.as_str() {
555 "ArrowUp" => self.move_selection(-1, viewport.height(), ctx),
556 "ArrowDown" => self.move_selection(1, viewport.height(), ctx),
557 "Home" => {
558 if !self.items.is_empty() {
559 self.activate(0, ctx);
560 self.ensure_visible(viewport.height(), 0);
561 }
562 }
563 "End" => {
564 if !self.items.is_empty() {
565 let last = self.items.len() - 1;
566 self.activate(last, ctx);
567 self.ensure_visible(viewport.height(), last);
568 }
569 }
570 "PageUp" => {
571 let next = self.clamp_scroll(
572 viewport.height(),
573 self.scroll_y - viewport.height() * 0.85,
574 );
575 if (next - self.scroll_y).abs() > f32::EPSILON {
576 self.scroll_y = next;
577 }
578 }
579 "PageDown" => {
580 let next = self.clamp_scroll(
581 viewport.height(),
582 self.scroll_y + viewport.height() * 0.85,
583 );
584 if (next - self.scroll_y).abs() > f32::EPSILON {
585 self.scroll_y = next;
586 }
587 }
588 _ => return,
589 }
590 ctx.request_arrange();
591 ctx.request_paint();
592 ctx.request_semantics();
593 ctx.set_handled();
594 }
595 _ => {}
596 }
597 }
598
599 fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
600 self.sync_selected();
601 let theme = self.resolved_theme();
602 let metrics = theme.metrics;
603 let text_style = theme.body_text_style();
604 let detail_style = caption_style(&theme);
605 let base_row_height = self.resolved_row_height();
606 let padding = self.resolved_padding();
607 let child_max_width = if constraints.max.width.is_finite() {
608 (constraints.max.width
609 - padding.left
610 - padding.right
611 - metrics.data_row_padding.left
612 - metrics.data_row_padding.right)
613 .max(0.0)
614 } else {
615 260.0
616 };
617 let child_constraints =
618 Constraints::new(Size::ZERO, Size::new(child_max_width, f32::INFINITY));
619 let explicit_row_height = self.row_height.is_some();
620 let mut content_width: f32 = 220.0;
621 let mut content_height = 0.0;
622 self.row_offsets.clear();
623 self.row_heights.clear();
624
625 for item in &mut self.items {
626 self.row_offsets.push(content_height);
627 let (row_width, row_height) = if let Some(content) = &mut item.content {
628 let content_constraints = if explicit_row_height {
629 let child_height = (base_row_height
630 - metrics.data_row_padding.top
631 - metrics.data_row_padding.bottom)
632 .max(0.0);
633 Constraints::new(
634 Size::new(0.0, child_height),
635 Size::new(child_max_width, child_height),
636 )
637 } else {
638 child_constraints
639 };
640 let child_size = content.measure(ctx, content_constraints);
641 (
642 (child_size.width
643 + metrics.data_row_padding.left
644 + metrics.data_row_padding.right)
645 .max(220.0),
646 if explicit_row_height {
647 base_row_height
648 } else {
649 (child_size.height
650 + metrics.data_row_padding.top
651 + metrics.data_row_padding.bottom)
652 .max(base_row_height)
653 },
654 )
655 } else {
656 let label = measure_text(ctx, &item.label, &text_style).width;
657 let detail = item
658 .detail
659 .as_deref()
660 .map(|detail| measure_text(ctx, detail, &detail_style).width)
661 .unwrap_or(0.0);
662 let leading = measure_list_item_leading_width(ctx, item, &text_style, &theme);
663 let trailing = item
664 .trailing
665 .as_deref()
666 .map(|trailing| measure_text(ctx, trailing, &detail_style).width)
667 .unwrap_or(0.0);
668 let trailing_gap = if trailing > 0.0 {
669 metrics.data_row_trailing_gap
670 } else {
671 0.0
672 };
673 (
674 metrics.data_row_padding.left
675 + leading
676 + label.max(detail)
677 + trailing_gap
678 + trailing
679 + metrics.data_row_padding.right,
680 base_row_height,
681 )
682 };
683 content_width = content_width.max(row_width);
684 content_height += row_height;
685 self.row_heights.push(row_height);
686 }
687
688 self.content_height = content_height;
689 let desired = Size::new(
690 content_width + padding.left + padding.right,
691 self.measured_content_height() + padding.top + padding.bottom,
692 );
693 let size = constraints.clamp(Size::new(
694 if constraints.max.width.is_finite() {
695 constraints.max.width
696 } else {
697 desired.width
698 },
699 desired.height,
700 ));
701
702 self.scroll_y = self.clamp_scroll(
703 self.viewport_rect(Rect::from_origin_size(Point::ZERO, size))
704 .height(),
705 self.scroll_y,
706 );
707 size
708 }
709
710 fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
711 self.sync_selected();
712 let theme = self.resolved_theme();
713 let viewport = self.viewport_rect(bounds);
714 for index in 0..self.items.len() {
715 let Some((top, row_height)) = self.row_metrics(index) else {
716 continue;
717 };
718 let Some(content) = self.items[index].content.as_mut() else {
719 continue;
720 };
721 let row_y = viewport.y() + top - self.scroll_y;
722 if row_y + row_height < viewport.y() || row_y > viewport.max_y() {
723 content.arrange(ctx, Rect::from_origin_size(Point::ZERO, Size::ZERO));
724 continue;
725 }
726 let child_size = content.child().measured_size();
727 content.arrange(
728 ctx,
729 Rect::from_origin_size(
730 Point::new(
731 viewport.x() + theme.metrics.data_row_padding.left,
732 row_y + theme.metrics.data_row_padding.top,
733 ),
734 Size::new(
735 (viewport.width()
736 - theme.metrics.data_row_padding.left
737 - theme.metrics.data_row_padding.right)
738 .max(0.0),
739 child_size.height,
740 ),
741 ),
742 );
743 }
744 }
745
746 fn paint(&self, ctx: &mut PaintCtx) {
747 let theme = self.resolved_theme();
748 let palette = theme.palette;
749 let metrics = theme.metrics;
750 let viewport = self.viewport_rect(ctx.bounds());
751 let label_style = theme.body_text_style();
752 let detail_style = caption_style(&theme);
753
754 draw_surface(ctx, ctx.bounds(), &theme, self.focus_animation.value);
755 ctx.push_clip_rect(viewport);
756
757 for index in 0..self.items.len() {
758 let Some((top, row_height)) = self.row_metrics(index) else {
759 continue;
760 };
761 let y = viewport.y() + top - self.scroll_y;
762 if y + row_height < viewport.y() || y > viewport.max_y() {
763 continue;
764 }
765 let row = Rect::new(viewport.x(), y, viewport.width(), row_height);
766 let selected = self.current_selected() == Some(index);
767 let hover_amount = self.hover_motion.amount_for(&index);
768 let press_amount = self.press_motion.amount_for(&index);
769
770 paint_data_row_state(
771 ctx,
772 row,
773 viewport,
774 &theme,
775 selected,
776 hover_amount,
777 press_amount,
778 );
779
780 let Some(item) = self.items.get(index) else {
781 continue;
782 };
783 if let Some(accent) = item.accent {
784 ctx.fill_rect(
785 Rect::new(row.x() + 4.0, row.y() + 5.0, 3.0, row.height() - 10.0),
786 accent,
787 );
788 }
789
790 if let Some(content) = &item.content {
791 content.paint(ctx);
792 continue;
793 }
794
795 let mut text_x = row.x() + metrics.data_row_padding.left;
796 let leading_color = item.leading_color.unwrap_or({
797 if item.disabled {
798 palette.placeholder
799 } else {
800 palette.text_muted
801 }
802 });
803 if let Some(icon) = item.leading_icon {
804 let side = metrics
805 .data_row_icon_size
806 .min((row.height() - 8.0).max(0.0))
807 .max(0.0);
808 let icon_rect = Rect::new(
809 text_x,
810 row.y() + ((row.height() - side) * 0.5).max(0.0),
811 side,
812 side,
813 );
814 draw_icon_glyph(ctx, icon, icon_rect, leading_color);
815 text_x += side + metrics.data_row_icon_gap;
816 } else if let Some(leading) = &item.leading_text {
817 let leading_style = TextStyle {
818 color: leading_color,
819 ..label_style.clone()
820 };
821 let leading_measurement = paint_text_measurement(ctx, leading, &leading_style);
822 let leading_slot =
823 Rect::new(text_x, row.y(), leading_measurement.width, row.height());
824 paint_aligned_text(
825 ctx,
826 leading_slot,
827 leading,
828 &leading_style,
829 leading_style.line_height,
830 0.0,
831 );
832 text_x += leading_measurement.width + metrics.data_row_icon_gap;
833 }
834
835 let trailing_measurement = item
836 .trailing
837 .as_deref()
838 .map(|trailing| paint_text_measurement(ctx, trailing, &detail_style));
839 let trailing_width = trailing_measurement
840 .map(|measurement| (measurement.width + 8.0).min(row.width() * 0.42))
841 .unwrap_or(0.0);
842 let trailing_rect = item.trailing.as_ref().map(|_| {
843 Rect::new(
844 row.max_x() - metrics.data_row_padding.right - trailing_width,
845 row.y(),
846 trailing_width,
847 row.height(),
848 )
849 });
850 let text_right = trailing_rect
851 .map(|rect| rect.x() - metrics.data_row_trailing_gap)
852 .unwrap_or(row.max_x() - metrics.data_row_padding.right);
853 let text_bounds = Rect::new(
854 text_x,
855 row.y(),
856 (text_right - text_x).max(0.0),
857 row.height(),
858 );
859 let label_measurement = paint_text_measurement(ctx, &item.label, &label_style);
860 let detail_measurement = item
861 .detail
862 .as_deref()
863 .map(|detail| paint_text_measurement(ctx, detail, &detail_style));
864 let (label_rect, detail_rect) = row_text_rects(
865 ctx,
866 text_bounds,
867 label_measurement,
868 label_style.line_height,
869 detail_measurement,
870 item.detail.as_ref().map(|_| detail_style.line_height),
871 );
872 ctx.push_clip_rect(label_rect);
873 ctx.draw_text(
874 label_rect,
875 item.label.clone(),
876 if item.disabled {
877 theme.text_style(palette.placeholder)
878 } else {
879 label_style.clone()
880 },
881 );
882 ctx.pop_clip();
883 if let Some(detail) = &item.detail {
884 let detail_rect = detail_rect.unwrap_or(text_bounds);
885 ctx.push_clip_rect(detail_rect);
886 ctx.draw_text(detail_rect, detail.clone(), detail_style.clone());
887 ctx.pop_clip();
888 }
889 if let (Some(trailing), Some(rect)) = (&item.trailing, trailing_rect) {
890 let style = detail_style.clone();
891 ctx.push_clip_rect(rect);
892 paint_aligned_text(ctx, rect, trailing, &style, style.line_height, 1.0);
893 ctx.pop_clip();
894 }
895 }
896
897 ctx.pop_clip();
898 }
899
900 fn semantics(&self, ctx: &mut SemanticsCtx) {
901 let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::List, ctx.bounds());
902 node.name = Some(self.name.clone());
903 node.state.focused = ctx.is_focused();
904 node.value = self
905 .current_selected()
906 .and_then(|index| self.items.get(index))
907 .map(|item| SemanticsValue::Text(item.label.clone()));
908 node.actions = vec![SemanticsAction::Focus, SemanticsAction::SetValue];
909 ctx.push(node);
910
911 for (index, item) in self.items.iter().enumerate() {
912 if let Some(bounds) = self.visible_row_rect(ctx.bounds(), index) {
913 let mut row = SemanticsNode::new(
914 list_view_row_id(ctx.widget_id(), index),
915 SemanticsRole::ListItem,
916 bounds,
917 );
918 row.parent = Some(ctx.widget_id());
919 row.name = Some(
920 item.semantic_name
921 .clone()
922 .unwrap_or_else(|| item.label.clone()),
923 );
924 row.description = item
925 .semantic_description
926 .clone()
927 .or_else(|| item.detail.clone());
928 row.value = Some(SemanticsValue::Text(
929 item.detail.clone().unwrap_or_else(|| item.label.clone()),
930 ));
931 row.state.disabled = item.disabled;
932 row.state.hovered = self.hovered == Some(index);
933 row.state.selected = self.current_selected() == Some(index);
934 if item.can_activate_from_row() {
935 row.actions = vec![SemanticsAction::Activate];
936 }
937 ctx.push(row);
938 }
939
940 if let Some(content) = &item.content {
941 content.semantics(ctx);
942 }
943 }
944 }
945
946 fn accepts_focus(&self) -> bool {
947 true
948 }
949
950 fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
951 let theme = self.resolved_theme();
952 set_focus_animation_target(&mut self.focus_animation, focused as u8 as f32, &theme, ctx);
953 ctx.request_paint();
954 ctx.request_semantics();
955 }
956
957 fn visit_children(&self, visitor: &mut dyn WidgetPodVisitor) {
958 for item in &self.items {
959 if let Some(content) = &item.content {
960 content.visit_children(visitor);
961 }
962 }
963 }
964
965 fn visit_children_mut(&mut self, visitor: &mut dyn WidgetPodMutVisitor) {
966 for item in &mut self.items {
967 if let Some(content) = &mut item.content {
968 content.visit_children_mut(visitor);
969 }
970 }
971 }
972}
973
974#[derive(Clone)]
975pub struct LayerListItem {
976 label: String,
977 detail: Option<String>,
978 detail_reader: Option<Rc<dyn Fn() -> String>>,
979 thumbnail: Option<Color>,
980 visible: bool,
981 visible_reader: Option<Rc<dyn Fn() -> bool>>,
982 locked: bool,
983 locked_reader: Option<Rc<dyn Fn() -> bool>>,
984 disabled: bool,
985}
986
987impl fmt::Debug for LayerListItem {
988 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
989 f.debug_struct("LayerListItem")
990 .field("label", &self.label)
991 .field("detail", &self.detail)
992 .field("thumbnail", &self.thumbnail)
993 .field("visible", &self.visible)
994 .field("locked", &self.locked)
995 .field("disabled", &self.disabled)
996 .finish_non_exhaustive()
997 }
998}
999
1000impl PartialEq for LayerListItem {
1001 fn eq(&self, other: &Self) -> bool {
1002 self.label == other.label
1003 && self.detail == other.detail
1004 && self.thumbnail == other.thumbnail
1005 && self.visible == other.visible
1006 && self.locked == other.locked
1007 && self.disabled == other.disabled
1008 }
1009}
1010
1011impl LayerListItem {
1012 pub fn new(label: impl Into<String>) -> Self {
1013 Self {
1014 label: label.into(),
1015 detail: None,
1016 detail_reader: None,
1017 thumbnail: None,
1018 visible: true,
1019 visible_reader: None,
1020 locked: false,
1021 locked_reader: None,
1022 disabled: false,
1023 }
1024 }
1025
1026 pub fn detail(mut self, detail: impl Into<String>) -> Self {
1027 self.detail = Some(detail.into());
1028 self.detail_reader = None;
1029 self
1030 }
1031
1032 pub fn detail_when<F>(mut self, detail: F) -> Self
1033 where
1034 F: Fn() -> String + 'static,
1035 {
1036 self.detail_reader = Some(Rc::new(detail));
1037 self
1038 }
1039
1040 pub fn thumbnail(mut self, color: Color) -> Self {
1041 self.thumbnail = Some(color);
1042 self
1043 }
1044
1045 pub fn visible(mut self, visible: bool) -> Self {
1046 self.visible = visible;
1047 self.visible_reader = None;
1048 self
1049 }
1050
1051 pub fn visible_when<F>(mut self, visible: F) -> Self
1052 where
1053 F: Fn() -> bool + 'static,
1054 {
1055 self.visible_reader = Some(Rc::new(visible));
1056 self
1057 }
1058
1059 pub fn locked(mut self, locked: bool) -> Self {
1060 self.locked = locked;
1061 self.locked_reader = None;
1062 self
1063 }
1064
1065 pub fn locked_when<F>(mut self, locked: F) -> Self
1066 where
1067 F: Fn() -> bool + 'static,
1068 {
1069 self.locked_reader = Some(Rc::new(locked));
1070 self
1071 }
1072
1073 pub fn disabled(mut self) -> Self {
1074 self.disabled = true;
1075 self
1076 }
1077
1078 pub fn label(&self) -> &str {
1079 &self.label
1080 }
1081
1082 fn current_detail(&self) -> Option<String> {
1083 self.detail_reader
1084 .as_ref()
1085 .map(|reader| reader())
1086 .or_else(|| self.detail.clone())
1087 }
1088
1089 fn current_visible(&self) -> bool {
1090 self.visible_reader
1091 .as_ref()
1092 .map(|reader| reader())
1093 .unwrap_or(self.visible)
1094 }
1095
1096 fn current_locked(&self) -> bool {
1097 self.locked_reader
1098 .as_ref()
1099 .map(|reader| reader())
1100 .unwrap_or(self.locked)
1101 }
1102}
1103
1104#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1105enum LayerListHit {
1106 Row(usize),
1107 Visibility(usize),
1108 Lock(usize),
1109}
1110
1111#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1112pub struct LayerListReorderChange {
1113 pub item: usize,
1114 pub from: usize,
1115 pub to: usize,
1116}
1117
1118#[derive(Debug, Clone, Copy)]
1119struct LayerListReorderPress {
1120 pointer_id: u64,
1121 start_position: Point,
1122 row: usize,
1123 drag_offset_y: f32,
1124}
1125
1126#[derive(Debug, Clone, Copy)]
1127struct LayerListReorderDrag {
1128 pointer_id: u64,
1129 row: usize,
1130 target: usize,
1131 position: Point,
1132 drag_offset_y: f32,
1133}
1134
1135type LayerListReorderCallback = Box<dyn FnMut(&mut EventCtx, LayerListReorderChange)>;
1136
1137pub struct LayerList {
1138 theme: Box<DefaultTheme>,
1139 theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
1140 name: String,
1141 layers: Vec<LayerListItem>,
1142 selected: Option<usize>,
1143 selected_reader: Option<Box<dyn Fn() -> Option<usize>>>,
1144 hovered: Option<LayerListHit>,
1145 pressed: Option<LayerListHit>,
1146 reorder_press: Option<LayerListReorderPress>,
1147 reorder_drag: Option<LayerListReorderDrag>,
1148 hover_motion: IndexedInteractionMotion<LayerListHit>,
1149 press_motion: IndexedInteractionMotion<LayerListHit>,
1150 focus_animation: AnimatedScalar,
1151 row_height: Option<f32>,
1152 drag_threshold: f32,
1153 on_select: Option<Box<dyn FnMut(usize, String)>>,
1154 on_select_with_ctx: Option<Box<dyn FnMut(&mut EventCtx, usize, String)>>,
1155 on_visibility_change: Option<Box<dyn FnMut(usize, bool)>>,
1156 on_visibility_change_with_ctx: Option<Box<dyn FnMut(&mut EventCtx, usize, bool)>>,
1157 on_lock_change: Option<Box<dyn FnMut(usize, bool)>>,
1158 on_lock_change_with_ctx: Option<Box<dyn FnMut(&mut EventCtx, usize, bool)>>,
1159 on_reorder: Option<LayerListReorderCallback>,
1160}
1161
1162impl LayerList {
1163 pub fn new(name: impl Into<String>) -> Self {
1164 Self {
1165 theme: Box::new(DefaultTheme::default()),
1166 theme_reader: None,
1167 name: name.into(),
1168 layers: Vec::new(),
1169 selected: None,
1170 selected_reader: None,
1171 hovered: None,
1172 pressed: None,
1173 reorder_press: None,
1174 reorder_drag: None,
1175 hover_motion: IndexedInteractionMotion::new(),
1176 press_motion: IndexedInteractionMotion::new(),
1177 focus_animation: AnimatedScalar::new(0.0),
1178 row_height: None,
1179 drag_threshold: 4.0,
1180 on_select: None,
1181 on_select_with_ctx: None,
1182 on_visibility_change: None,
1183 on_visibility_change_with_ctx: None,
1184 on_lock_change: None,
1185 on_lock_change_with_ctx: None,
1186 on_reorder: None,
1187 }
1188 }
1189
1190 pub fn theme(mut self, theme: DefaultTheme) -> Self {
1191 self.theme = Box::new(theme);
1192 self.theme_reader = None;
1193 self
1194 }
1195
1196 pub fn theme_when<F>(mut self, theme: F) -> Self
1197 where
1198 F: Fn() -> DefaultTheme + 'static,
1199 {
1200 self.theme_reader = Some(Box::new(theme));
1201 self
1202 }
1203
1204 pub fn layer(mut self, layer: LayerListItem) -> Self {
1205 self.layers.push(layer);
1206 self
1207 }
1208
1209 pub fn layers<I>(mut self, layers: I) -> Self
1210 where
1211 I: IntoIterator<Item = LayerListItem>,
1212 {
1213 self.layers.extend(layers);
1214 self
1215 }
1216
1217 pub fn selected(mut self, selected: usize) -> Self {
1218 self.selected = Some(selected);
1219 self.selected_reader = None;
1220 self
1221 }
1222
1223 pub fn selected_when<F>(mut self, selected: F) -> Self
1224 where
1225 F: Fn() -> Option<usize> + 'static,
1226 {
1227 self.selected_reader = Some(Box::new(selected));
1228 self
1229 }
1230
1231 pub fn row_height(mut self, row_height: f32) -> Self {
1232 self.row_height = Some(row_height.max(0.0));
1233 self
1234 }
1235
1236 pub fn drag_threshold(mut self, threshold: f32) -> Self {
1237 self.drag_threshold = threshold.max(0.0);
1238 self
1239 }
1240
1241 pub fn on_select<F>(mut self, on_select: F) -> Self
1242 where
1243 F: FnMut(usize, String) + 'static,
1244 {
1245 self.on_select = Some(Box::new(on_select));
1246 self
1247 }
1248
1249 pub fn on_select_with_ctx<F>(mut self, on_select: F) -> Self
1250 where
1251 F: FnMut(&mut EventCtx, usize, String) + 'static,
1252 {
1253 self.on_select_with_ctx = Some(Box::new(on_select));
1254 self
1255 }
1256
1257 pub fn on_visibility_change<F>(mut self, on_visibility_change: F) -> Self
1258 where
1259 F: FnMut(usize, bool) + 'static,
1260 {
1261 self.on_visibility_change = Some(Box::new(on_visibility_change));
1262 self
1263 }
1264
1265 pub fn on_visibility_change_with_ctx<F>(mut self, on_visibility_change: F) -> Self
1266 where
1267 F: FnMut(&mut EventCtx, usize, bool) + 'static,
1268 {
1269 self.on_visibility_change_with_ctx = Some(Box::new(on_visibility_change));
1270 self
1271 }
1272
1273 pub fn on_lock_change<F>(mut self, on_lock_change: F) -> Self
1274 where
1275 F: FnMut(usize, bool) + 'static,
1276 {
1277 self.on_lock_change = Some(Box::new(on_lock_change));
1278 self
1279 }
1280
1281 pub fn on_lock_change_with_ctx<F>(mut self, on_lock_change: F) -> Self
1282 where
1283 F: FnMut(&mut EventCtx, usize, bool) + 'static,
1284 {
1285 self.on_lock_change_with_ctx = Some(Box::new(on_lock_change));
1286 self
1287 }
1288
1289 pub fn on_reorder<F>(mut self, on_reorder: F) -> Self
1290 where
1291 F: FnMut(LayerListReorderChange) + 'static,
1292 {
1293 let mut on_reorder = on_reorder;
1294 self.on_reorder = Some(Box::new(move |_, change| on_reorder(change)));
1295 self
1296 }
1297
1298 pub fn on_reorder_with_ctx<F>(mut self, on_reorder: F) -> Self
1299 where
1300 F: FnMut(&mut EventCtx, LayerListReorderChange) + 'static,
1301 {
1302 self.on_reorder = Some(Box::new(on_reorder));
1303 self
1304 }
1305
1306 pub fn selected_index(&self) -> Option<usize> {
1307 self.current_selected()
1308 }
1309
1310 fn sync_selected(&mut self) {
1311 if self.selected_reader.is_some() {
1312 self.selected = self.current_selected();
1313 } else if self
1314 .selected
1315 .is_some_and(|selected| selected >= self.layers.len())
1316 {
1317 self.selected = None;
1318 }
1319 }
1320
1321 fn current_selected(&self) -> Option<usize> {
1322 self.selected_reader
1323 .as_ref()
1324 .map(|selected| selected())
1325 .unwrap_or(self.selected)
1326 .filter(|index| *index < self.layers.len())
1327 }
1328
1329 fn resolved_theme(&self) -> DefaultTheme {
1330 self.theme_reader
1331 .as_ref()
1332 .map(|theme| theme())
1333 .unwrap_or(*self.theme)
1334 }
1335
1336 fn viewport_rect(&self, bounds: Rect) -> Rect {
1337 inset_rect(bounds, self.resolved_theme().metrics.data_viewport_padding)
1338 }
1339
1340 fn resolved_row_height(&self) -> f32 {
1341 self.row_height
1342 .unwrap_or(self.resolved_theme().metrics.layer_row_height)
1343 }
1344
1345 fn row_rect(&self, bounds: Rect, index: usize) -> Option<Rect> {
1346 if index >= self.layers.len() {
1347 return None;
1348 }
1349
1350 let viewport = self.viewport_rect(bounds);
1351 let row_height = self.resolved_row_height();
1352 let y = viewport.y() + index as f32 * row_height;
1353 Rect::new(viewport.x(), y, viewport.width(), row_height)
1354 .intersection(viewport)
1355 .filter(|rect| !rect.is_empty())
1356 }
1357
1358 fn visibility_rect(&self, row: Rect) -> Rect {
1359 let size = self
1360 .resolved_theme()
1361 .metrics
1362 .layer_action_size
1363 .min(row.height())
1364 .max(18.0);
1365 Rect::new(
1366 row.x() + self.resolved_theme().metrics.data_row_padding.left.min(8.0),
1367 row.y() + ((row.height() - size) * 0.5),
1368 size,
1369 size,
1370 )
1371 }
1372
1373 fn thumbnail_rect(&self, row: Rect) -> Rect {
1374 let theme = self.resolved_theme();
1375 let action = self.visibility_rect(row);
1376 let size = theme
1377 .metrics
1378 .layer_thumbnail_size
1379 .min((row.height() - 8.0).max(0.0))
1380 .max(18.0);
1381 Rect::new(
1382 action.max_x() + theme.metrics.data_row_icon_gap,
1383 row.y() + ((row.height() - size) * 0.5),
1384 size,
1385 size,
1386 )
1387 }
1388
1389 fn lock_rect(&self, row: Rect) -> Rect {
1390 let theme = self.resolved_theme();
1391 let size = theme.metrics.layer_action_size.min(row.height()).max(18.0);
1392 Rect::new(
1393 row.max_x() - size - theme.metrics.data_row_padding.right.min(8.0),
1394 row.y() + ((row.height() - size) * 0.5),
1395 size,
1396 size,
1397 )
1398 }
1399
1400 fn text_rect(&self, row: Rect) -> Rect {
1401 let thumb = self.thumbnail_rect(row);
1402 let lock = self.lock_rect(row);
1403 let theme = self.resolved_theme();
1404 Rect::new(
1405 thumb.max_x() + theme.metrics.data_row_icon_gap,
1406 row.y(),
1407 (lock.x() - thumb.max_x() - theme.metrics.data_row_trailing_gap).max(0.0),
1408 row.height(),
1409 )
1410 }
1411
1412 fn hit_at(&self, bounds: Rect, position: Point) -> Option<LayerListHit> {
1413 let viewport = self.viewport_rect(bounds);
1414 if !viewport.contains(position) {
1415 return None;
1416 }
1417
1418 (0..self.layers.len()).find_map(|index| {
1419 let row = self.row_rect(bounds, index)?;
1420 if self.visibility_rect(row).contains(position) {
1421 return Some(LayerListHit::Visibility(index));
1422 }
1423 if self.lock_rect(row).contains(position) {
1424 return Some(LayerListHit::Lock(index));
1425 }
1426 row.contains(position).then_some(LayerListHit::Row(index))
1427 })
1428 }
1429
1430 fn reorder_enabled(&self) -> bool {
1431 self.on_reorder.is_some() && self.layers.len() > 1
1432 }
1433
1434 fn reorder_press_at(
1435 &self,
1436 bounds: Rect,
1437 pointer_id: u64,
1438 position: Point,
1439 ) -> Option<LayerListReorderPress> {
1440 if !self.reorder_enabled() {
1441 return None;
1442 }
1443 let LayerListHit::Row(row) = self.hit_at(bounds, position)? else {
1444 return None;
1445 };
1446 let layer = self.layers.get(row)?;
1447 if layer.disabled {
1448 return None;
1449 }
1450 let rect = self.row_rect(bounds, row)?;
1451 Some(LayerListReorderPress {
1452 pointer_id,
1453 start_position: position,
1454 row,
1455 drag_offset_y: position.y - rect.y(),
1456 })
1457 }
1458
1459 fn insertion_index_at(&self, bounds: Rect, position: Point) -> usize {
1460 let viewport = self.viewport_rect(bounds);
1461 let row_height = self.resolved_row_height();
1462 if row_height <= 0.0 {
1463 return 0;
1464 }
1465 let local_y = position.y - viewport.y();
1466 for index in 0..self.layers.len() {
1467 let midpoint = index as f32 * row_height + row_height * 0.5;
1468 if local_y < midpoint {
1469 return index;
1470 }
1471 }
1472 self.layers.len()
1473 }
1474
1475 fn reorder_target_at(&self, bounds: Rect, row: usize, position: Point) -> usize {
1476 if self.layers.is_empty() {
1477 return 0;
1478 }
1479 let insertion = self.insertion_index_at(bounds, position);
1480 let target = if insertion > row {
1481 insertion.saturating_sub(1)
1482 } else {
1483 insertion
1484 };
1485 target.min(self.layers.len().saturating_sub(1))
1486 }
1487
1488 fn start_reorder_drag(
1489 &mut self,
1490 ctx: &mut EventCtx,
1491 press: LayerListReorderPress,
1492 position: Point,
1493 ) {
1494 let target = self.reorder_target_at(ctx.bounds(), press.row, position);
1495 self.reorder_drag = Some(LayerListReorderDrag {
1496 pointer_id: press.pointer_id,
1497 row: press.row,
1498 target,
1499 position,
1500 drag_offset_y: press.drag_offset_y,
1501 });
1502 self.pressed = None;
1503 ctx.request_paint();
1504 ctx.request_semantics();
1505 }
1506
1507 fn update_reorder_drag(&mut self, ctx: &mut EventCtx, position: Point) {
1508 let Some(drag) = self.reorder_drag else {
1509 return;
1510 };
1511 let target = self.reorder_target_at(ctx.bounds(), drag.row, position);
1512 self.reorder_drag = Some(LayerListReorderDrag {
1513 target,
1514 position,
1515 ..drag
1516 });
1517 ctx.request_paint();
1518 ctx.request_semantics();
1519 }
1520
1521 fn remap_index_after_reorder(index: usize, from: usize, to: usize) -> usize {
1522 if index == from {
1523 to
1524 } else if from < to && index > from && index <= to {
1525 index - 1
1526 } else if to < from && index >= to && index < from {
1527 index + 1
1528 } else {
1529 index
1530 }
1531 }
1532
1533 fn finish_reorder_drag(&mut self, ctx: &mut EventCtx) {
1534 let Some(drag) = self.reorder_drag.take() else {
1535 return;
1536 };
1537 self.reorder_press = None;
1538 self.pressed = None;
1539
1540 let from = drag.row;
1541 let to = drag.target.min(self.layers.len().saturating_sub(1));
1542 if from >= self.layers.len() || from == to {
1543 ctx.request_paint();
1544 ctx.request_semantics();
1545 return;
1546 }
1547
1548 let item = self.layers.remove(from);
1549 self.layers.insert(to, item);
1550 if self.selected_reader.is_none() {
1551 self.selected = self
1552 .selected
1553 .map(|selected| Self::remap_index_after_reorder(selected, from, to));
1554 }
1555 if let Some(callback) = &mut self.on_reorder {
1556 callback(
1557 ctx,
1558 LayerListReorderChange {
1559 item: from,
1560 from,
1561 to,
1562 },
1563 );
1564 }
1565 ctx.request_paint();
1566 ctx.request_semantics();
1567 }
1568
1569 fn cancel_reorder_drag(&mut self, ctx: &mut EventCtx) {
1570 if self.reorder_press.is_some() || self.reorder_drag.is_some() {
1571 self.reorder_press = None;
1572 self.reorder_drag = None;
1573 ctx.request_paint();
1574 ctx.request_semantics();
1575 }
1576 }
1577
1578 fn reorder_marker_y(&self, bounds: Rect) -> Option<f32> {
1579 let drag = self.reorder_drag?;
1580 let target = drag.target.min(self.layers.len().saturating_sub(1));
1581 let row = self.row_rect(bounds, target)?;
1582 if target > drag.row {
1583 Some(row.max_y())
1584 } else {
1585 Some(row.y())
1586 }
1587 }
1588
1589 fn select(&mut self, ctx: &mut EventCtx, index: usize) {
1590 let Some(layer) = self.layers.get(index) else {
1591 return;
1592 };
1593 if layer.disabled {
1594 return;
1595 }
1596 let label = layer.label.clone();
1597
1598 self.selected = Some(index);
1599 if let Some(on_select) = &mut self.on_select {
1600 on_select(index, label.clone());
1601 }
1602 if let Some(on_select) = &mut self.on_select_with_ctx {
1603 on_select(ctx, index, label);
1604 }
1605 }
1606
1607 fn toggle_visibility(&mut self, ctx: &mut EventCtx, index: usize) {
1608 let Some(layer) = self.layers.get_mut(index) else {
1609 return;
1610 };
1611 if layer.disabled {
1612 return;
1613 }
1614
1615 layer.visible = !layer.current_visible();
1616 if let Some(on_visibility_change) = &mut self.on_visibility_change {
1617 on_visibility_change(index, layer.visible);
1618 }
1619 if let Some(on_visibility_change) = &mut self.on_visibility_change_with_ctx {
1620 on_visibility_change(ctx, index, layer.visible);
1621 }
1622 }
1623
1624 fn toggle_lock(&mut self, ctx: &mut EventCtx, index: usize) {
1625 let Some(layer) = self.layers.get_mut(index) else {
1626 return;
1627 };
1628 if layer.disabled {
1629 return;
1630 }
1631
1632 layer.locked = !layer.current_locked();
1633 if let Some(on_lock_change) = &mut self.on_lock_change {
1634 on_lock_change(index, layer.locked);
1635 }
1636 if let Some(on_lock_change) = &mut self.on_lock_change_with_ctx {
1637 on_lock_change(ctx, index, layer.locked);
1638 }
1639 }
1640
1641 fn move_selection(&mut self, ctx: &mut EventCtx, delta: isize) {
1642 if self.layers.is_empty() {
1643 return;
1644 }
1645
1646 let current = self.current_selected().unwrap_or(0) as isize;
1647 let last = self.layers.len() as isize - 1;
1648 self.select(ctx, (current + delta).clamp(0, last) as usize);
1649 }
1650
1651 fn set_hovered(&mut self, hovered: Option<LayerListHit>, ctx: &mut EventCtx) {
1652 if self.hovered == hovered {
1653 return;
1654 }
1655
1656 self.hovered = hovered;
1657 let theme = self.resolved_theme();
1658 self.hover_motion.set_hover_target(hovered, &theme, ctx);
1659 ctx.request_paint();
1660 ctx.request_semantics();
1661 }
1662
1663 fn set_pressed(&mut self, pressed: Option<LayerListHit>, ctx: &mut EventCtx) {
1664 if self.pressed == pressed {
1665 return;
1666 }
1667
1668 self.pressed = pressed;
1669 let theme = self.resolved_theme();
1670 self.press_motion.set_press_target(pressed, &theme, ctx);
1671 ctx.request_paint();
1672 ctx.request_semantics();
1673 }
1674
1675 fn advance_animations(&mut self, time: f64, ctx: &mut EventCtx) {
1676 let (hover_changed, hover_active) = self.hover_motion.advance(time);
1677 let (press_changed, press_active) = self.press_motion.advance(time);
1678 let (focus_changed, focus_active) = advance_scalar(&mut self.focus_animation, time);
1679
1680 if hover_changed || press_changed || focus_changed {
1681 ctx.request_paint();
1682 }
1683 if hover_active || press_active || focus_active {
1684 ctx.request_animation_frame();
1685 }
1686 }
1687
1688 fn paint_row(
1689 &self,
1690 ctx: &mut PaintCtx,
1691 viewport: Rect,
1692 index: usize,
1693 row: Rect,
1694 theme: &DefaultTheme,
1695 label_style: &TextStyle,
1696 detail_style: &TextStyle,
1697 ) {
1698 let Some(layer) = self.layers.get(index) else {
1699 return;
1700 };
1701 let palette = theme.palette;
1702 let visible = layer.current_visible();
1703 let locked = layer.current_locked();
1704 let detail = layer.current_detail();
1705 let selected = self.current_selected() == Some(index);
1706 let row_hit = LayerListHit::Row(index);
1707 let row_hover_amount = self.hover_motion.amount_for(&row_hit);
1708 let row_press_amount = self.press_motion.amount_for(&row_hit);
1709 paint_data_row_state(
1710 ctx,
1711 row,
1712 viewport,
1713 theme,
1714 selected,
1715 row_hover_amount,
1716 row_press_amount,
1717 );
1718
1719 let visibility_hit = LayerListHit::Visibility(index);
1720 paint_layer_visibility_button(
1721 ctx,
1722 self.visibility_rect(row),
1723 theme,
1724 visible,
1725 self.hover_motion.amount_for(&visibility_hit),
1726 self.press_motion.amount_for(&visibility_hit),
1727 );
1728 let lock_hit = LayerListHit::Lock(index);
1729 paint_layer_lock_button(
1730 ctx,
1731 self.lock_rect(row),
1732 theme,
1733 locked,
1734 self.hover_motion.amount_for(&lock_hit),
1735 self.press_motion.amount_for(&lock_hit),
1736 );
1737 paint_layer_thumbnail(
1738 ctx,
1739 self.thumbnail_rect(row),
1740 theme,
1741 layer.thumbnail.unwrap_or(palette.control_hover),
1742 visible,
1743 );
1744
1745 let text_rect = self.text_rect(row);
1746 let label_measurement = paint_text_measurement(ctx, &layer.label, label_style);
1747 let detail_text = detail
1748 .as_deref()
1749 .unwrap_or(if visible { "Visible" } else { "Hidden" });
1750 let detail_measurement = paint_text_measurement(ctx, detail_text, detail_style);
1751 let (label_rect, detail_rect) = row_text_rects(
1752 ctx,
1753 text_rect,
1754 label_measurement,
1755 label_style.line_height,
1756 Some(detail_measurement),
1757 Some(detail_style.line_height),
1758 );
1759 let text_alpha = if visible { 1.0 } else { 0.58 };
1760 ctx.draw_text(
1761 label_rect,
1762 layer.label.clone(),
1763 TextStyle {
1764 color: label_style.color.with_alpha(text_alpha),
1765 ..label_style.clone()
1766 },
1767 );
1768 if let Some(detail_rect) = detail_rect {
1769 ctx.draw_text(
1770 detail_rect,
1771 detail_text.to_string(),
1772 TextStyle {
1773 color: detail_style.color.with_alpha(text_alpha),
1774 ..detail_style.clone()
1775 },
1776 );
1777 }
1778 }
1779}
1780
1781impl Widget for LayerList {
1782 fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
1783 self.sync_selected();
1784
1785 match event {
1786 Event::Pointer(pointer) if pointer.kind == PointerEventKind::Move => {
1787 if self
1788 .reorder_drag
1789 .is_some_and(|drag| drag.pointer_id == pointer.pointer_id)
1790 {
1791 self.update_reorder_drag(ctx, pointer.position);
1792 ctx.set_handled();
1793 return;
1794 }
1795 if self
1796 .reorder_press
1797 .is_some_and(|press| press.pointer_id == pointer.pointer_id)
1798 {
1799 let press = self.reorder_press.unwrap();
1800 let delta = pointer.position - press.start_position;
1801 let distance_sq = delta.x * delta.x + delta.y * delta.y;
1802 if distance_sq >= self.drag_threshold * self.drag_threshold {
1803 self.start_reorder_drag(ctx, press, pointer.position);
1804 ctx.set_handled();
1805 return;
1806 }
1807 }
1808 let hovered = self.hit_at(ctx.bounds(), pointer.position);
1809 self.set_hovered(hovered, ctx);
1810 }
1811 Event::Pointer(pointer)
1812 if pointer.kind == PointerEventKind::Down
1813 && pointer.button == Some(PointerButton::Primary) =>
1814 {
1815 let hovered = self.hit_at(ctx.bounds(), pointer.position);
1816 self.set_hovered(hovered, ctx);
1817 self.set_pressed(hovered, ctx);
1818 self.reorder_press =
1819 self.reorder_press_at(ctx.bounds(), pointer.pointer_id, pointer.position);
1820 if self.pressed.is_some() {
1821 ctx.request_focus();
1822 ctx.request_pointer_capture(pointer.pointer_id);
1823 ctx.set_handled();
1824 }
1825 }
1826 Event::Pointer(pointer)
1827 if pointer.kind == PointerEventKind::Up
1828 && pointer.button == Some(PointerButton::Primary) =>
1829 {
1830 if self
1831 .reorder_drag
1832 .is_some_and(|drag| drag.pointer_id == pointer.pointer_id)
1833 {
1834 self.finish_reorder_drag(ctx);
1835 ctx.release_pointer_capture(pointer.pointer_id);
1836 ctx.set_handled();
1837 return;
1838 }
1839 if self
1840 .reorder_press
1841 .is_some_and(|press| press.pointer_id == pointer.pointer_id)
1842 {
1843 self.reorder_press = None;
1844 }
1845 let hovered = self.hit_at(ctx.bounds(), pointer.position);
1846 if let Some(hit) = self
1847 .pressed
1848 .zip(hovered)
1849 .filter(|(left, right)| left == right)
1850 .map(|(hit, _)| hit)
1851 {
1852 match hit {
1853 LayerListHit::Row(index) => self.select(ctx, index),
1854 LayerListHit::Visibility(index) => self.toggle_visibility(ctx, index),
1855 LayerListHit::Lock(index) => self.toggle_lock(ctx, index),
1856 }
1857 }
1858 self.set_hovered(hovered, ctx);
1859 self.set_pressed(None, ctx);
1860 ctx.release_pointer_capture(pointer.pointer_id);
1861 ctx.set_handled();
1862 }
1863 Event::Pointer(pointer) if pointer.kind == PointerEventKind::Leave => {
1864 self.set_hovered(None, ctx);
1865 }
1866 Event::Pointer(pointer) if pointer.kind == PointerEventKind::Cancel => {
1867 if self
1868 .reorder_drag
1869 .is_some_and(|drag| drag.pointer_id == pointer.pointer_id)
1870 || self
1871 .reorder_press
1872 .is_some_and(|press| press.pointer_id == pointer.pointer_id)
1873 {
1874 self.cancel_reorder_drag(ctx);
1875 ctx.release_pointer_capture(pointer.pointer_id);
1876 ctx.set_handled();
1877 return;
1878 }
1879 if self.pressed.is_some() {
1880 self.set_pressed(None, ctx);
1881 self.set_hovered(None, ctx);
1882 ctx.release_pointer_capture(pointer.pointer_id);
1883 ctx.set_handled();
1884 }
1885 }
1886 Event::Wake(WakeEvent::AnimationFrame { time, .. }) => {
1887 self.advance_animations(*time, ctx);
1888 }
1889 Event::Keyboard(key) if ctx.is_focused() && key.state == KeyState::Pressed => {
1890 match key.key.as_str() {
1891 "ArrowUp" => self.move_selection(ctx, -1),
1892 "ArrowDown" => self.move_selection(ctx, 1),
1893 "Home" => {
1894 if !self.layers.is_empty() {
1895 self.select(ctx, 0);
1896 }
1897 }
1898 "End" => {
1899 if !self.layers.is_empty() {
1900 self.select(ctx, self.layers.len() - 1);
1901 }
1902 }
1903 " " => {
1904 if let Some(index) = self.current_selected() {
1905 self.toggle_visibility(ctx, index);
1906 }
1907 }
1908 "l" | "L" => {
1909 if let Some(index) = self.current_selected() {
1910 self.toggle_lock(ctx, index);
1911 }
1912 }
1913 _ => return,
1914 }
1915 ctx.request_paint();
1916 ctx.request_semantics();
1917 ctx.set_handled();
1918 }
1919 _ => {}
1920 }
1921 }
1922
1923 fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
1924 self.sync_selected();
1925 let theme = self.resolved_theme();
1926 let text_style = theme.body_text_style();
1927 let detail_style = caption_style(&theme);
1928 let mut width: f32 = 260.0;
1929 for layer in &self.layers {
1930 let detail_width = layer
1931 .detail
1932 .as_deref()
1933 .map(|detail| measure_text(ctx, detail, &detail_style).width)
1934 .unwrap_or(0.0)
1935 .min(80.0);
1936 width = width
1937 .max(124.0 + measure_text(ctx, &layer.label, &text_style).width + detail_width);
1938 }
1939 constraints.clamp(Size::new(
1940 if constraints.max.width.is_finite() {
1941 constraints.max.width
1942 } else {
1943 width + 16.0
1944 },
1945 self.layers.len().max(1) as f32 * self.resolved_row_height()
1946 + theme.metrics.data_viewport_padding.top
1947 + theme.metrics.data_viewport_padding.bottom,
1948 ))
1949 }
1950
1951 fn paint(&self, ctx: &mut PaintCtx) {
1952 let theme = self.resolved_theme();
1953 let viewport = self.viewport_rect(ctx.bounds());
1954 let label_style = theme.body_text_style();
1955 let detail_style = caption_style(&theme);
1956 let active_row = self.reorder_drag.map(|drag| drag.row);
1957
1958 draw_surface(ctx, ctx.bounds(), &theme, self.focus_animation.value);
1959 ctx.push_clip_rect(viewport);
1960
1961 for index in 0..self.layers.len() {
1962 if active_row == Some(index) {
1963 continue;
1964 }
1965 let Some(row) = self.row_rect(ctx.bounds(), index) else {
1966 continue;
1967 };
1968 self.paint_row(
1969 ctx,
1970 viewport,
1971 index,
1972 row,
1973 &theme,
1974 &label_style,
1975 &detail_style,
1976 );
1977 }
1978
1979 if let Some(marker_y) = self.reorder_marker_y(ctx.bounds()) {
1980 let marker = Rect::new(
1981 viewport.x() + 6.0,
1982 (marker_y - 1.0).clamp(viewport.y(), viewport.max_y() - 2.0),
1983 (viewport.width() - 12.0).max(0.0),
1984 2.0,
1985 );
1986 ctx.fill(Path::rounded_rect(marker, 1.0), theme.palette.border_focus);
1987 }
1988
1989 if let Some(drag) = self.reorder_drag
1990 && let Some(row) = self.row_rect(ctx.bounds(), drag.row)
1991 {
1992 let y = drag.position.y - drag.drag_offset_y;
1993 ctx.push_transform(Transform::translation(0.0, y - row.y()));
1994 self.paint_row(
1995 ctx,
1996 viewport,
1997 drag.row,
1998 row,
1999 &theme,
2000 &label_style,
2001 &detail_style,
2002 );
2003 ctx.pop_transform();
2004 }
2005
2006 ctx.pop_clip();
2007 }
2008
2009 fn semantics(&self, ctx: &mut SemanticsCtx) {
2010 let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::List, ctx.bounds());
2011 node.name = Some(self.name.clone());
2012 node.state.focused = ctx.is_focused();
2013 node.value = self
2014 .current_selected()
2015 .and_then(|index| self.layers.get(index))
2016 .map(|layer| SemanticsValue::Text(layer.label.clone()));
2017 node.actions = vec![SemanticsAction::Focus, SemanticsAction::SetValue];
2018 ctx.push(node);
2019
2020 for (index, layer) in self.layers.iter().enumerate() {
2021 let Some(row) = self.row_rect(ctx.bounds(), index) else {
2022 continue;
2023 };
2024 let visible = layer.current_visible();
2025 let locked = layer.current_locked();
2026 let detail = layer.current_detail();
2027 let row_id = layer_list_row_id(ctx.widget_id(), index);
2028 let mut row_node = SemanticsNode::new(row_id, SemanticsRole::ListItem, row);
2029 row_node.parent = Some(ctx.widget_id());
2030 row_node.name = Some(layer.label.clone());
2031 row_node.description = detail.clone();
2032 row_node.value = Some(SemanticsValue::Text(format!(
2033 "{}; {}; {}",
2034 detail.as_deref().unwrap_or("Layer"),
2035 if visible { "Visible" } else { "Hidden" },
2036 if locked { "Locked" } else { "Unlocked" }
2037 )));
2038 row_node.state.disabled = layer.disabled;
2039 row_node.state.hovered = self.hovered == Some(LayerListHit::Row(index));
2040 row_node.state.selected = self.current_selected() == Some(index);
2041 if !layer.disabled {
2042 row_node.actions = vec![SemanticsAction::Activate];
2043 }
2044 ctx.push(row_node);
2045
2046 let mut visibility = SemanticsNode::new(
2047 layer_list_visibility_id(ctx.widget_id(), index),
2048 SemanticsRole::Button,
2049 self.visibility_rect(row),
2050 );
2051 visibility.parent = Some(row_id);
2052 visibility.name = Some(if visible {
2053 format!("Hide {} layer", layer.label)
2054 } else {
2055 format!("Show {} layer", layer.label)
2056 });
2057 visibility.value = Some(SemanticsValue::Text(if visible {
2058 "Visible".to_string()
2059 } else {
2060 "Hidden".to_string()
2061 }));
2062 visibility.state.disabled = layer.disabled;
2063 visibility.state.hovered = self.hovered == Some(LayerListHit::Visibility(index));
2064 visibility.state.checked = Some(if visible {
2065 ToggleState::Checked
2066 } else {
2067 ToggleState::Unchecked
2068 });
2069 if !layer.disabled {
2070 visibility.actions = vec![SemanticsAction::Activate];
2071 }
2072 ctx.push(visibility);
2073
2074 let mut lock = SemanticsNode::new(
2075 layer_list_lock_id(ctx.widget_id(), index),
2076 SemanticsRole::Button,
2077 self.lock_rect(row),
2078 );
2079 lock.parent = Some(row_id);
2080 lock.name = Some(if locked {
2081 format!("Unlock {} layer", layer.label)
2082 } else {
2083 format!("Lock {} layer", layer.label)
2084 });
2085 lock.value = Some(SemanticsValue::Text(if locked {
2086 "Locked".to_string()
2087 } else {
2088 "Unlocked".to_string()
2089 }));
2090 lock.state.disabled = layer.disabled;
2091 lock.state.hovered = self.hovered == Some(LayerListHit::Lock(index));
2092 lock.state.checked = Some(if locked {
2093 ToggleState::Checked
2094 } else {
2095 ToggleState::Unchecked
2096 });
2097 if !layer.disabled {
2098 lock.actions = vec![SemanticsAction::Activate];
2099 }
2100 ctx.push(lock);
2101 }
2102 }
2103
2104 fn accepts_focus(&self) -> bool {
2105 !self.layers.is_empty()
2106 }
2107
2108 fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
2109 let theme = self.resolved_theme();
2110 set_focus_animation_target(&mut self.focus_animation, focused as u8 as f32, &theme, ctx);
2111 ctx.request_paint();
2112 ctx.request_semantics();
2113 }
2114}
2115
2116pub struct TreeItem {
2117 key: Option<u64>,
2118 label: String,
2119 detail: Option<String>,
2120 children: Vec<TreeItem>,
2121 expanded: bool,
2122 disabled: bool,
2123 activate_with_content: bool,
2124 content: Option<SingleChild>,
2125}
2126
2127impl fmt::Debug for TreeItem {
2128 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2129 f.debug_struct("TreeItem")
2130 .field("key", &self.key)
2131 .field("label", &self.label)
2132 .field("detail", &self.detail)
2133 .field("children", &self.children)
2134 .field("expanded", &self.expanded)
2135 .field("disabled", &self.disabled)
2136 .field("activate_with_content", &self.activate_with_content)
2137 .field("has_content", &self.content.is_some())
2138 .finish()
2139 }
2140}
2141
2142impl TreeItem {
2143 pub fn new(label: impl Into<String>) -> Self {
2144 Self {
2145 key: None,
2146 label: label.into(),
2147 detail: None,
2148 children: Vec::new(),
2149 expanded: false,
2150 disabled: false,
2151 activate_with_content: false,
2152 content: None,
2153 }
2154 }
2155
2156 pub fn key(mut self, key: u64) -> Self {
2157 self.key = Some(key);
2158 self
2159 }
2160
2161 pub fn detail(mut self, detail: impl Into<String>) -> Self {
2162 self.detail = Some(detail.into());
2163 self
2164 }
2165
2166 pub fn expanded(mut self, expanded: bool) -> Self {
2167 self.expanded = expanded;
2168 self
2169 }
2170
2171 pub fn disabled(mut self) -> Self {
2172 self.disabled = true;
2173 self
2174 }
2175
2176 pub fn activate_with_content(mut self) -> Self {
2179 self.activate_with_content = true;
2180 self
2181 }
2182
2183 pub fn with_content<W>(mut self, content: W) -> Self
2186 where
2187 W: Widget + 'static,
2188 {
2189 self.content = Some(SingleChild::new(content));
2190 self
2191 }
2192
2193 pub fn with_child(mut self, child: TreeItem) -> Self {
2194 self.children.push(child);
2195 self
2196 }
2197
2198 pub fn children<I>(mut self, children: I) -> Self
2199 where
2200 I: IntoIterator<Item = TreeItem>,
2201 {
2202 self.children.extend(children);
2203 self
2204 }
2205
2206 pub fn label(&self) -> &str {
2207 &self.label
2208 }
2209
2210 pub fn has_content(&self) -> bool {
2211 self.content.is_some()
2212 }
2213
2214 fn can_activate_from_row(&self) -> bool {
2215 !self.disabled && (self.content.is_none() || self.activate_with_content)
2216 }
2217}
2218
2219pub struct TreeView {
2220 theme: Box<DefaultTheme>,
2221 theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
2222 name: String,
2223 items: Vec<TreeItem>,
2224 selected: Option<Vec<usize>>,
2225 hovered: Option<Vec<usize>>,
2226 pressed: Option<Vec<usize>>,
2227 hover_motion: IndexedInteractionMotion<Vec<usize>>,
2228 press_motion: IndexedInteractionMotion<Vec<usize>>,
2229 focus_animation: AnimatedScalar,
2230 row_height: Option<f32>,
2231 padding: Option<Insets>,
2232 scroll_y: f32,
2233 visible_rows: Vec<TreeRow>,
2234 visible_rows_dirty: Cell<bool>,
2235 row_heights: Vec<f32>,
2236 row_offsets: Vec<f32>,
2237 content_height: f32,
2238 on_change: Option<Box<dyn FnMut(Vec<usize>, String)>>,
2239}
2240
2241impl TreeView {
2242 pub fn new(name: impl Into<String>) -> Self {
2243 Self {
2244 theme: Box::new(DefaultTheme::default()),
2245 theme_reader: None,
2246 name: name.into(),
2247 items: Vec::new(),
2248 selected: None,
2249 hovered: None,
2250 pressed: None,
2251 hover_motion: IndexedInteractionMotion::new(),
2252 press_motion: IndexedInteractionMotion::new(),
2253 focus_animation: AnimatedScalar::new(0.0),
2254 row_height: None,
2255 padding: None,
2256 scroll_y: 0.0,
2257 visible_rows: Vec::new(),
2258 visible_rows_dirty: Cell::new(true),
2259 row_heights: Vec::new(),
2260 row_offsets: Vec::new(),
2261 content_height: 0.0,
2262 on_change: None,
2263 }
2264 }
2265
2266 pub fn theme(mut self, theme: DefaultTheme) -> Self {
2267 self.theme = Box::new(theme);
2268 self.theme_reader = None;
2269 self
2270 }
2271
2272 pub fn theme_when<F>(mut self, theme: F) -> Self
2273 where
2274 F: Fn() -> DefaultTheme + 'static,
2275 {
2276 self.theme_reader = Some(Box::new(theme));
2277 self
2278 }
2279
2280 pub fn item(mut self, item: TreeItem) -> Self {
2281 self.items.push(item);
2282 self.visible_rows_dirty.set(true);
2283 self
2284 }
2285
2286 pub fn items<I>(mut self, items: I) -> Self
2287 where
2288 I: IntoIterator<Item = TreeItem>,
2289 {
2290 self.items.extend(items);
2291 self.visible_rows_dirty.set(true);
2292 self
2293 }
2294
2295 pub fn row_height(mut self, row_height: f32) -> Self {
2296 self.row_height = Some(row_height.max(0.0));
2297 self
2298 }
2299
2300 pub fn padding(mut self, padding: Insets) -> Self {
2303 self.padding = Some(padding);
2304 self
2305 }
2306
2307 pub fn selected(mut self, index: usize) -> Self {
2308 self.selected = Some(vec![index]);
2309 self
2310 }
2311
2312 pub fn on_change<F>(mut self, on_change: F) -> Self
2313 where
2314 F: FnMut(Vec<usize>, String) + 'static,
2315 {
2316 self.on_change = Some(Box::new(on_change));
2317 self
2318 }
2319
2320 fn resolved_theme(&self) -> DefaultTheme {
2321 self.theme_reader
2322 .as_ref()
2323 .map(|theme| theme())
2324 .unwrap_or(*self.theme)
2325 }
2326
2327 fn resolved_row_height(&self) -> f32 {
2328 let theme = self.resolved_theme();
2329 let base = self.row_height.unwrap_or(theme.metrics.tree_row_height);
2330 if self.visible_rows.iter().any(|row| row.detail.is_some()) {
2331 base.max(two_line_row_height(
2332 theme.body_text_style().line_height,
2333 caption_style(&theme).line_height,
2334 ))
2335 } else {
2336 base
2337 }
2338 }
2339
2340 fn viewport_rect(&self, bounds: Rect) -> Rect {
2341 inset_rect(bounds, self.resolved_padding())
2342 }
2343
2344 fn resolved_padding(&self) -> Insets {
2345 self.padding
2346 .unwrap_or(self.resolved_theme().metrics.data_viewport_padding)
2347 }
2348
2349 fn sync_visible_rows(&mut self) {
2350 if !self.visible_rows_dirty.replace(false) {
2351 return;
2352 }
2353 self.visible_rows.clear();
2354 flatten_tree(&self.items, 0, &mut Vec::new(), &mut self.visible_rows);
2355 self.row_heights.clear();
2356 self.row_offsets.clear();
2357 self.content_height = 0.0;
2358 }
2359
2360 fn measured_content_height(&self) -> f32 {
2361 if self.row_heights.len() == self.visible_rows.len() {
2362 self.content_height
2363 } else {
2364 self.visible_rows.len() as f32 * self.resolved_row_height()
2365 }
2366 }
2367
2368 fn clamp_scroll(&self, viewport_height: f32, scroll_y: f32) -> f32 {
2369 let max_scroll = (self.measured_content_height() - viewport_height).max(0.0);
2370 scroll_y.clamp(0.0, max_scroll)
2371 }
2372
2373 fn row_metrics(&self, index: usize) -> Option<(f32, f32)> {
2374 self.row_offsets
2375 .get(index)
2376 .zip(self.row_heights.get(index))
2377 .map(|(offset, height)| (*offset, *height))
2378 .or_else(|| {
2379 (index < self.visible_rows.len()).then(|| {
2380 let row_height = self.resolved_row_height();
2381 (index as f32 * row_height, row_height)
2382 })
2383 })
2384 }
2385
2386 fn row_at_position(&self, bounds: Rect, position: Point) -> Option<TreeRow> {
2387 let viewport = self.viewport_rect(bounds);
2388 if !viewport.contains(position) {
2389 return None;
2390 }
2391
2392 let y = position.y - viewport.y() + self.scroll_y;
2393 (0..self.visible_rows.len())
2394 .find(|index| {
2395 self.row_metrics(*index)
2396 .is_some_and(|(top, height)| y >= top && y < top + height)
2397 })
2398 .and_then(|index| self.visible_rows.get(index).cloned())
2399 }
2400
2401 fn row_rect(&self, bounds: Rect, index: usize) -> Option<Rect> {
2402 let viewport = self.viewport_rect(bounds);
2403 let (top, height) = self.row_metrics(index)?;
2404 Some(Rect::new(
2405 viewport.x(),
2406 viewport.y() + top - self.scroll_y,
2407 viewport.width(),
2408 height,
2409 ))
2410 }
2411
2412 fn position_targets_disclosure(&self, bounds: Rect, position: Point, row: &TreeRow) -> bool {
2413 if !row.has_children {
2414 return false;
2415 }
2416 let Some(index) = self
2417 .visible_rows
2418 .iter()
2419 .position(|candidate| candidate.path == row.path)
2420 else {
2421 return false;
2422 };
2423 self.row_rect(bounds, index).is_some_and(|row_rect| {
2424 disclosure_rect(&self.resolved_theme(), row_rect, row.depth).contains(position)
2425 })
2426 }
2427
2428 fn row_blocks_parent_activation(&self, path: &[usize]) -> bool {
2429 tree_item(&self.items, path)
2430 .is_some_and(|item| item.content.is_some() && !item.activate_with_content)
2431 }
2432
2433 fn row_activation_waits_for_content_target(&self, path: &[usize]) -> bool {
2434 tree_item(&self.items, path)
2435 .is_some_and(|item| item.content.is_some() && item.activate_with_content)
2436 }
2437
2438 fn select_path(&mut self, path: &[usize]) {
2439 let Some(item) = tree_item(&self.items, path) else {
2440 return;
2441 };
2442 if item.disabled {
2443 return;
2444 }
2445 self.selected = Some(path.to_vec());
2446 if let Some(on_change) = &mut self.on_change {
2447 on_change(path.to_vec(), item.label.clone());
2448 }
2449 }
2450
2451 fn toggle_path(&mut self, path: &[usize]) -> bool {
2452 let Some(item) = tree_item_mut(&mut self.items, path) else {
2453 return false;
2454 };
2455 if item.children.is_empty() {
2456 return false;
2457 }
2458 item.expanded = !item.expanded;
2459 self.visible_rows_dirty.set(true);
2460 true
2461 }
2462
2463 fn ensure_visible(&mut self, viewport_height: f32, path: &[usize]) {
2464 let Some(index) = self.visible_rows.iter().position(|row| row.path == path) else {
2465 return;
2466 };
2467 let Some((top, row_height)) = self.row_metrics(index) else {
2468 return;
2469 };
2470 let bottom = top + row_height;
2471 if top < self.scroll_y {
2472 self.scroll_y = top;
2473 } else if bottom > self.scroll_y + viewport_height {
2474 self.scroll_y = bottom - viewport_height;
2475 }
2476 self.scroll_y = self.clamp_scroll(viewport_height, self.scroll_y);
2477 }
2478
2479 fn set_hovered(&mut self, hovered: Option<Vec<usize>>, ctx: &mut EventCtx) {
2480 if self.hovered == hovered {
2481 return;
2482 }
2483
2484 self.hovered = hovered.clone();
2485 let theme = self.resolved_theme();
2486 self.hover_motion.set_hover_target(hovered, &theme, ctx);
2487 ctx.request_paint();
2488 ctx.request_semantics();
2489 }
2490
2491 fn set_pressed(&mut self, pressed: Option<Vec<usize>>, ctx: &mut EventCtx) {
2492 if self.pressed == pressed {
2493 return;
2494 }
2495
2496 self.pressed = pressed.clone();
2497 let theme = self.resolved_theme();
2498 self.press_motion.set_press_target(pressed, &theme, ctx);
2499 ctx.request_paint();
2500 ctx.request_semantics();
2501 }
2502
2503 fn advance_animations(&mut self, time: f64, ctx: &mut EventCtx) {
2504 let (hover_changed, hover_active) = self.hover_motion.advance(time);
2505 let (press_changed, press_active) = self.press_motion.advance(time);
2506 let (focus_changed, focus_active) = advance_scalar(&mut self.focus_animation, time);
2507
2508 if hover_changed || press_changed || focus_changed {
2509 ctx.request_paint();
2510 }
2511 if hover_active || press_active || focus_active {
2512 ctx.request_animation_frame();
2513 }
2514 }
2515}
2516
2517impl Widget for TreeView {
2518 fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
2519 self.sync_visible_rows();
2520 let viewport = self.viewport_rect(ctx.bounds());
2521
2522 match event {
2523 Event::Pointer(pointer) if pointer.kind == PointerEventKind::Move => {
2524 let hovered = self
2525 .row_at_position(ctx.bounds(), pointer.position)
2526 .map(|row| row.path);
2527 self.set_hovered(hovered, ctx);
2528 }
2529 Event::Pointer(pointer)
2530 if pointer.kind == PointerEventKind::Scroll
2531 && viewport.contains(pointer.position) =>
2532 {
2533 let delta = pointer
2534 .scroll_delta
2535 .map(scroll_delta_to_offset)
2536 .unwrap_or(pointer.delta);
2537 let next = self.clamp_scroll(viewport.height(), self.scroll_y - delta.y);
2538 if (next - self.scroll_y).abs() > f32::EPSILON {
2539 self.scroll_y = next;
2540 ctx.request_arrange();
2541 ctx.request_paint();
2542 ctx.request_semantics();
2543 ctx.set_handled();
2544 }
2545 }
2546 Event::Pointer(pointer)
2547 if pointer.kind == PointerEventKind::Down
2548 && pointer.button == Some(PointerButton::Primary)
2549 && viewport.contains(pointer.position) =>
2550 {
2551 let pressed_row = self.row_at_position(ctx.bounds(), pointer.position);
2552 let targets_disclosure = pressed_row.as_ref().is_some_and(|row| {
2553 self.position_targets_disclosure(ctx.bounds(), pointer.position, row)
2554 });
2555 if !targets_disclosure
2556 && pressed_row
2557 .as_ref()
2558 .is_some_and(|row| self.row_blocks_parent_activation(&row.path))
2559 {
2560 return;
2561 }
2562 if ctx.phase() == EventPhase::Capture
2563 && !targets_disclosure
2564 && pressed_row
2565 .as_ref()
2566 .is_some_and(|row| self.row_activation_waits_for_content_target(&row.path))
2567 {
2568 return;
2569 }
2570 let pressed = pressed_row.map(|row| row.path);
2571 self.set_hovered(pressed.clone(), ctx);
2572 self.set_pressed(pressed, ctx);
2573 ctx.request_focus();
2574 ctx.request_pointer_capture(pointer.pointer_id);
2575 ctx.set_handled();
2576 }
2577 Event::Pointer(pointer)
2578 if pointer.kind == PointerEventKind::Up
2579 && pointer.button == Some(PointerButton::Primary) =>
2580 {
2581 if self.pressed.is_none() {
2582 return;
2583 }
2584 let hovered_row = self.row_at_position(ctx.bounds(), pointer.position);
2585 if let Some(row) = hovered_row
2586 .as_ref()
2587 .filter(|row| self.pressed.as_deref() == Some(row.path.as_slice()))
2588 {
2589 if self.position_targets_disclosure(ctx.bounds(), pointer.position, row) {
2590 if self.toggle_path(&row.path) {
2591 ctx.request_measure();
2592 }
2593 } else {
2594 self.select_path(&row.path);
2595 }
2596 }
2597 self.set_hovered(hovered_row.map(|row| row.path), ctx);
2598 self.set_pressed(None, ctx);
2599 ctx.release_pointer_capture(pointer.pointer_id);
2600 ctx.set_handled();
2601 }
2602 Event::Pointer(pointer) if pointer.kind == PointerEventKind::Leave => {
2603 self.set_hovered(None, ctx);
2604 }
2605 Event::Pointer(pointer) if pointer.kind == PointerEventKind::Cancel => {
2606 if self.pressed.is_some() {
2607 self.set_pressed(None, ctx);
2608 self.set_hovered(None, ctx);
2609 ctx.release_pointer_capture(pointer.pointer_id);
2610 ctx.set_handled();
2611 }
2612 }
2613 Event::Wake(WakeEvent::AnimationFrame { time, .. }) => {
2614 self.advance_animations(*time, ctx);
2615 }
2616 Event::Keyboard(key) if ctx.is_focused() && key.state == KeyState::Pressed => {
2617 let rows = self.visible_rows.clone();
2618 if rows.is_empty() {
2619 return;
2620 }
2621
2622 let current = self
2623 .selected
2624 .as_ref()
2625 .and_then(|selected| rows.iter().position(|row| &row.path == selected))
2626 .unwrap_or(0);
2627
2628 match key.key.as_str() {
2629 "ArrowUp" => {
2630 let next = current.saturating_sub(1);
2631 self.select_path(&rows[next].path);
2632 self.ensure_visible(viewport.height(), &rows[next].path);
2633 }
2634 "ArrowDown" => {
2635 let next = (current + 1).min(rows.len() - 1);
2636 self.select_path(&rows[next].path);
2637 self.ensure_visible(viewport.height(), &rows[next].path);
2638 }
2639 "ArrowRight" => {
2640 let row = &rows[current];
2641 if row.has_children && !row.expanded {
2642 if self.toggle_path(&row.path) {
2643 ctx.request_measure();
2644 }
2645 } else if row.has_children {
2646 let mut child = row.path.clone();
2647 child.push(0);
2648 self.select_path(&child);
2649 self.ensure_visible(viewport.height(), &child);
2650 }
2651 }
2652 "ArrowLeft" => {
2653 let row = &rows[current];
2654 if row.has_children && row.expanded {
2655 if self.toggle_path(&row.path) {
2656 ctx.request_measure();
2657 }
2658 } else if !row.path.is_empty() {
2659 let mut parent = row.path.clone();
2660 parent.pop();
2661 self.select_path(&parent);
2662 self.ensure_visible(viewport.height(), &parent);
2663 }
2664 }
2665 "Home" => {
2666 self.select_path(&rows[0].path);
2667 self.ensure_visible(viewport.height(), &rows[0].path);
2668 }
2669 "End" => {
2670 let last = rows.len() - 1;
2671 self.select_path(&rows[last].path);
2672 self.ensure_visible(viewport.height(), &rows[last].path);
2673 }
2674 _ => return,
2675 }
2676
2677 ctx.request_arrange();
2678 ctx.request_paint();
2679 ctx.request_semantics();
2680 ctx.set_handled();
2681 }
2682 Event::Semantics(semantics) => {
2683 if semantics.target == ctx.widget_id() {
2684 let delta = match semantics.action {
2685 sui_core::SemanticsActionRequest::Increment => {
2686 Some(viewport.height() * 0.85)
2687 }
2688 sui_core::SemanticsActionRequest::Decrement => {
2689 Some(-viewport.height() * 0.85)
2690 }
2691 _ => None,
2692 };
2693 if let Some(delta) = delta {
2694 let next = self.clamp_scroll(viewport.height(), self.scroll_y + delta);
2695 if (next - self.scroll_y).abs() > f32::EPSILON {
2696 self.scroll_y = next;
2697 ctx.request_arrange();
2698 ctx.request_paint();
2699 ctx.request_semantics();
2700 }
2701 ctx.set_handled();
2702 }
2703 return;
2704 }
2705
2706 let Some(row) = self
2707 .visible_rows
2708 .iter()
2709 .find(|row| tree_view_row_id(ctx.widget_id(), row.key) == semantics.target)
2710 .cloned()
2711 else {
2712 return;
2713 };
2714 match semantics.action {
2715 sui_core::SemanticsActionRequest::Activate
2716 | sui_core::SemanticsActionRequest::Focus => {
2717 self.select_path(&row.path);
2718 self.ensure_visible(viewport.height(), &row.path);
2719 ctx.request_focus();
2720 ctx.request_arrange();
2721 ctx.request_paint();
2722 ctx.request_semantics();
2723 ctx.set_handled();
2724 }
2725 sui_core::SemanticsActionRequest::Expand if !row.expanded => {
2726 if self.toggle_path(&row.path) {
2727 ctx.request_measure();
2728 ctx.request_semantics();
2729 }
2730 ctx.set_handled();
2731 }
2732 sui_core::SemanticsActionRequest::Collapse if row.expanded => {
2733 if self.toggle_path(&row.path) {
2734 ctx.request_measure();
2735 ctx.request_semantics();
2736 }
2737 ctx.set_handled();
2738 }
2739 _ => {}
2740 }
2741 }
2742 _ => {}
2743 }
2744 }
2745
2746 fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
2747 self.sync_visible_rows();
2748 let theme = self.resolved_theme();
2749 let metrics = theme.metrics;
2750 let label_style = theme.body_text_style();
2751 let detail_style = caption_style(&theme);
2752 let base_row_height = self.resolved_row_height();
2753 let padding = self.resolved_padding();
2754 let explicit_row_height = self.row_height.is_some();
2755 let mut content_width: f32 = 220.0;
2756 let mut content_height = 0.0;
2757 self.row_offsets.clear();
2758 self.row_heights.clear();
2759
2760 for index in 0..self.visible_rows.len() {
2761 self.row_offsets.push(content_height);
2762 let row = &self.visible_rows[index];
2763 let path = row.path.clone();
2764 let depth = row.depth;
2765 let detail = row.detail.clone();
2766 let label_start = tree_label_offset(&theme, depth);
2767 let child_max_width = if constraints.max.width.is_finite() {
2768 (constraints.max.width
2769 - padding.left
2770 - padding.right
2771 - label_start
2772 - metrics.data_row_padding.right)
2773 .max(0.0)
2774 } else {
2775 260.0
2776 };
2777
2778 let (row_width, row_height) = if let Some(content) =
2779 tree_item_mut(&mut self.items, &path).and_then(|item| item.content.as_mut())
2780 {
2781 let content_constraints = if explicit_row_height {
2782 let child_height = (base_row_height
2783 - metrics.data_row_padding.top
2784 - metrics.data_row_padding.bottom)
2785 .max(0.0);
2786 Constraints::new(
2787 Size::new(0.0, child_height),
2788 Size::new(child_max_width, child_height),
2789 )
2790 } else {
2791 Constraints::new(Size::ZERO, Size::new(child_max_width, f32::INFINITY))
2792 };
2793 let child_size = content.measure(ctx, content_constraints);
2794 (
2795 label_start + child_size.width + metrics.data_row_padding.right,
2796 if explicit_row_height {
2797 base_row_height
2798 } else {
2799 (child_size.height
2800 + metrics.data_row_padding.top
2801 + metrics.data_row_padding.bottom)
2802 .max(base_row_height)
2803 },
2804 )
2805 } else {
2806 let label = measure_text(ctx, &row.label, &label_style).width;
2807 let detail = detail
2808 .as_deref()
2809 .map(|detail| measure_text(ctx, detail, &detail_style).width)
2810 .unwrap_or(0.0);
2811 (
2812 label_start + label.max(detail) + metrics.data_row_padding.right,
2813 base_row_height,
2814 )
2815 };
2816 content_width = content_width.max(row_width);
2817 content_height += row_height;
2818 self.row_heights.push(row_height);
2819 }
2820
2821 self.content_height = content_height;
2822 let desired = Size::new(
2823 content_width + padding.left + padding.right,
2824 self.measured_content_height() + padding.top + padding.bottom,
2825 );
2826 let size = constraints.clamp(Size::new(
2827 if constraints.max.width.is_finite() {
2828 constraints.max.width
2829 } else {
2830 desired.width
2831 },
2832 desired.height,
2833 ));
2834 self.scroll_y = self.clamp_scroll(
2835 self.viewport_rect(Rect::from_origin_size(Point::ZERO, size))
2836 .height(),
2837 self.scroll_y,
2838 );
2839 size
2840 }
2841
2842 fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
2843 self.sync_visible_rows();
2844 let theme = self.resolved_theme();
2845 let viewport = self.viewport_rect(bounds);
2846 for index in 0..self.visible_rows.len() {
2847 let Some((top, row_height)) = self.row_metrics(index) else {
2848 continue;
2849 };
2850 let path = self.visible_rows[index].path.clone();
2851 let depth = self.visible_rows[index].depth;
2852 let Some(content) =
2853 tree_item_mut(&mut self.items, &path).and_then(|item| item.content.as_mut())
2854 else {
2855 continue;
2856 };
2857 let row_y = viewport.y() + top - self.scroll_y;
2858 if row_y + row_height < viewport.y() || row_y > viewport.max_y() {
2859 content.arrange(ctx, Rect::from_origin_size(Point::ZERO, Size::ZERO));
2860 continue;
2861 }
2862 let child_size = content.child().measured_size();
2863 let content_x = viewport.x() + tree_label_offset(&theme, depth);
2864 content.arrange(
2865 ctx,
2866 Rect::from_origin_size(
2867 Point::new(content_x, row_y + theme.metrics.data_row_padding.top),
2868 Size::new(
2869 (viewport.max_x() - content_x - theme.metrics.data_row_padding.right)
2870 .max(0.0),
2871 child_size.height,
2872 ),
2873 ),
2874 );
2875 }
2876 }
2877
2878 fn paint(&self, ctx: &mut PaintCtx) {
2879 let theme = self.resolved_theme();
2880 let palette = theme.palette;
2881 let viewport = self.viewport_rect(ctx.bounds());
2882 let rows = &self.visible_rows;
2883
2884 draw_surface(ctx, ctx.bounds(), &theme, self.focus_animation.value);
2885 ctx.push_clip_rect(viewport);
2886
2887 for (index, row) in rows.iter().enumerate() {
2888 let Some((top, row_height)) = self.row_metrics(index) else {
2889 continue;
2890 };
2891 let y = viewport.y() + top - self.scroll_y;
2892 if y + row_height < viewport.y() || y > viewport.max_y() {
2893 continue;
2894 }
2895 let row_rect = Rect::new(viewport.x(), y, viewport.width(), row_height);
2896 let selected = self.selected.as_deref() == Some(row.path.as_slice());
2897 let hover_amount = self
2898 .hover_motion
2899 .amount_for_by(|path| path.as_slice() == row.path.as_slice());
2900 let press_amount = self
2901 .press_motion
2902 .amount_for_by(|path| path.as_slice() == row.path.as_slice());
2903
2904 paint_data_row_state(
2905 ctx,
2906 row_rect,
2907 viewport,
2908 &theme,
2909 selected,
2910 hover_amount,
2911 press_amount,
2912 );
2913
2914 if row.has_children {
2915 ctx.fill(
2916 disclosure_path(disclosure_rect(&theme, row_rect, row.depth), row.expanded),
2917 if selected {
2918 palette.text_muted
2919 } else {
2920 palette.placeholder
2921 },
2922 );
2923 }
2924
2925 if let Some(content) =
2926 tree_item(&self.items, &row.path).and_then(|item| item.content.as_ref())
2927 {
2928 content.paint(ctx);
2929 continue;
2930 }
2931
2932 let label_x = row_rect.x() + tree_label_offset(&theme, row.depth);
2933 let text_bounds = Rect::new(
2934 label_x,
2935 row_rect.y(),
2936 (row_rect.max_x() - label_x - 8.0).max(0.0),
2937 row_rect.height(),
2938 );
2939 let detail_style = caption_style(&theme);
2940 let label_style = theme.body_text_style();
2941 let label_measurement = paint_text_measurement(ctx, &row.label, &label_style);
2942 let detail_measurement = row
2943 .detail
2944 .as_deref()
2945 .map(|detail| paint_text_measurement(ctx, detail, &detail_style));
2946 let (label_rect, detail_rect) = row_text_rects(
2947 ctx,
2948 text_bounds,
2949 label_measurement,
2950 label_style.line_height,
2951 detail_measurement,
2952 row.detail.as_ref().map(|_| detail_style.line_height),
2953 );
2954 ctx.draw_text(
2955 label_rect,
2956 row.label.clone(),
2957 if row.disabled {
2958 theme.text_style(palette.placeholder)
2959 } else {
2960 label_style
2961 },
2962 );
2963 if let Some(detail) = &row.detail {
2964 ctx.draw_text(
2965 detail_rect.unwrap_or(text_bounds),
2966 detail.clone(),
2967 detail_style,
2968 );
2969 }
2970 }
2971
2972 ctx.pop_clip();
2973 }
2974
2975 fn semantics(&self, ctx: &mut SemanticsCtx) {
2976 let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::Tree, ctx.bounds());
2977 node.name = Some(self.name.clone());
2978 node.state.focused = ctx.is_focused();
2979 let viewport = self.viewport_rect(ctx.bounds());
2980 let visible_indices = (0..self.visible_rows.len())
2981 .filter(|index| {
2982 self.row_rect(ctx.bounds(), *index)
2983 .is_some_and(|rect| rect.intersection(viewport).is_some())
2984 })
2985 .collect::<Vec<_>>();
2986 let start = visible_indices.first().copied().unwrap_or(0);
2987 let end = visible_indices
2988 .last()
2989 .map(|index| index + 1)
2990 .unwrap_or(start);
2991 node.value = self
2992 .selected
2993 .as_ref()
2994 .and_then(|path| tree_item(&self.items, path))
2995 .map(|item| SemanticsValue::Text(item.label.clone()));
2996 node.description = Some(format!(
2997 "{} visible tree items; showing {} through {}",
2998 self.visible_rows.len(),
2999 start.saturating_add(1).min(self.visible_rows.len()),
3000 end,
3001 ));
3002 node.actions = vec![
3003 SemanticsAction::Focus,
3004 SemanticsAction::SetValue,
3005 SemanticsAction::Expand,
3006 SemanticsAction::Collapse,
3007 SemanticsAction::Increment,
3008 SemanticsAction::Decrement,
3009 ];
3010 ctx.push(node);
3011
3012 for index in visible_indices {
3013 let row = &self.visible_rows[index];
3014 let Some(row_rect) = self
3015 .row_rect(ctx.bounds(), index)
3016 .and_then(|rect| rect.intersection(viewport))
3017 else {
3018 continue;
3019 };
3020 let mut item = SemanticsNode::new(
3021 tree_view_row_id(ctx.widget_id(), row.key),
3022 SemanticsRole::ListItem,
3023 row_rect,
3024 );
3025 item.parent = Some(ctx.widget_id());
3026 item.name = Some(row.label.clone());
3027 item.description = Some(format!(
3028 "Tree item {} of {}, level {}{}",
3029 index + 1,
3030 self.visible_rows.len(),
3031 row.depth + 1,
3032 row.detail
3033 .as_deref()
3034 .map(|detail| format!("; {detail}"))
3035 .unwrap_or_default(),
3036 ));
3037 item.state.disabled = row.disabled;
3038 item.state.selected = self.selected.as_deref() == Some(row.path.as_slice());
3039 item.state.expanded = row.has_children.then_some(row.expanded);
3040 let tree_item = tree_item(&self.items, &row.path);
3041 if tree_item.is_some_and(TreeItem::can_activate_from_row) {
3042 item.actions = vec![SemanticsAction::Focus, SemanticsAction::Activate];
3043 }
3044 if !row.disabled && row.has_children {
3045 item.actions.push(if row.expanded {
3046 SemanticsAction::Collapse
3047 } else {
3048 SemanticsAction::Expand
3049 });
3050 }
3051 ctx.push(item);
3052
3053 if let Some(content) = tree_item.and_then(|item| item.content.as_ref()) {
3054 content.semantics(ctx);
3055 }
3056 }
3057 }
3058
3059 fn accepts_focus(&self) -> bool {
3060 true
3061 }
3062
3063 fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
3064 let theme = self.resolved_theme();
3065 set_focus_animation_target(&mut self.focus_animation, focused as u8 as f32, &theme, ctx);
3066 ctx.request_paint();
3067 ctx.request_semantics();
3068 }
3069
3070 fn visit_children(&self, visitor: &mut dyn WidgetPodVisitor) {
3071 for row in &self.visible_rows {
3072 if let Some(content) =
3073 tree_item(&self.items, &row.path).and_then(|item| item.content.as_ref())
3074 {
3075 content.visit_children(visitor);
3076 }
3077 }
3078 }
3079
3080 fn visit_children_mut(&mut self, visitor: &mut dyn WidgetPodMutVisitor) {
3081 let paths = self
3082 .visible_rows
3083 .iter()
3084 .map(|row| row.path.clone())
3085 .collect::<Vec<_>>();
3086 for path in paths {
3087 if let Some(content) =
3088 tree_item_mut(&mut self.items, &path).and_then(|item| item.content.as_mut())
3089 {
3090 content.visit_children_mut(visitor);
3091 }
3092 }
3093 }
3094}
3095
3096#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3097pub enum TableColumnAlignment {
3098 Start,
3099 Center,
3100 End,
3101}
3102
3103#[derive(Debug, Clone, PartialEq)]
3104pub struct TableColumn {
3105 title: String,
3106 width: Option<f32>,
3107 min_width: f32,
3108 alignment: TableColumnAlignment,
3109 numeric: bool,
3110}
3111
3112impl TableColumn {
3113 pub fn new(title: impl Into<String>) -> Self {
3114 Self {
3115 title: title.into(),
3116 width: None,
3117 min_width: 96.0,
3118 alignment: TableColumnAlignment::Start,
3119 numeric: false,
3120 }
3121 }
3122
3123 pub fn width(mut self, width: f32) -> Self {
3124 self.width = Some(width.max(40.0));
3125 self
3126 }
3127
3128 pub fn min_width(mut self, min_width: f32) -> Self {
3129 self.min_width = min_width.max(40.0);
3130 self
3131 }
3132
3133 pub fn alignment(mut self, alignment: TableColumnAlignment) -> Self {
3134 self.alignment = alignment;
3135 self
3136 }
3137
3138 pub fn numeric(mut self) -> Self {
3139 self.alignment = TableColumnAlignment::End;
3140 self.numeric = true;
3141 self
3142 }
3143}
3144
3145#[derive(Debug, Clone, PartialEq)]
3146pub struct TableRow {
3147 cells: Vec<String>,
3148}
3149
3150impl TableRow {
3151 pub fn new<I, S>(cells: I) -> Self
3152 where
3153 I: IntoIterator<Item = S>,
3154 S: Into<String>,
3155 {
3156 Self {
3157 cells: cells.into_iter().map(Into::into).collect(),
3158 }
3159 }
3160}
3161
3162pub type DataGrid = Table;
3163
3164pub struct Table {
3165 theme: Box<DefaultTheme>,
3166 theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
3167 name: String,
3168 name_reader: Option<Box<dyn Fn() -> String>>,
3169 columns: Vec<TableColumn>,
3170 rows: Vec<TableRow>,
3171 selected: Option<usize>,
3172 selected_reader: Option<Box<dyn Fn() -> Option<usize>>>,
3173 hovered: Option<usize>,
3174 pressed: Option<usize>,
3175 hover_motion: IndexedInteractionMotion<usize>,
3176 press_motion: IndexedInteractionMotion<usize>,
3177 focus_animation: AnimatedScalar,
3178 row_height: Option<f32>,
3179 header_height: Option<f32>,
3180 scroll_y: f32,
3181 column_widths: Vec<f32>,
3182 on_change: Option<Box<dyn FnMut(usize)>>,
3183}
3184
3185impl Table {
3186 pub fn new(name: impl Into<String>) -> Self {
3187 Self {
3188 theme: Box::new(DefaultTheme::default()),
3189 theme_reader: None,
3190 name: name.into(),
3191 name_reader: None,
3192 columns: Vec::new(),
3193 rows: Vec::new(),
3194 selected: None,
3195 selected_reader: None,
3196 hovered: None,
3197 pressed: None,
3198 hover_motion: IndexedInteractionMotion::new(),
3199 press_motion: IndexedInteractionMotion::new(),
3200 focus_animation: AnimatedScalar::new(0.0),
3201 row_height: None,
3202 header_height: None,
3203 scroll_y: 0.0,
3204 column_widths: Vec::new(),
3205 on_change: None,
3206 }
3207 }
3208
3209 pub fn theme(mut self, theme: DefaultTheme) -> Self {
3210 self.theme = Box::new(theme);
3211 self.theme_reader = None;
3212 self
3213 }
3214
3215 pub fn theme_when<F>(mut self, theme: F) -> Self
3216 where
3217 F: Fn() -> DefaultTheme + 'static,
3218 {
3219 self.theme_reader = Some(Box::new(theme));
3220 self
3221 }
3222
3223 pub fn name_when<F>(mut self, name: F) -> Self
3224 where
3225 F: Fn() -> String + 'static,
3226 {
3227 self.name_reader = Some(Box::new(name));
3228 self
3229 }
3230
3231 pub fn column(mut self, column: TableColumn) -> Self {
3232 self.columns.push(column);
3233 self
3234 }
3235
3236 pub fn columns<I>(mut self, columns: I) -> Self
3237 where
3238 I: IntoIterator<Item = TableColumn>,
3239 {
3240 self.columns.extend(columns);
3241 self
3242 }
3243
3244 pub fn row(mut self, row: TableRow) -> Self {
3245 self.rows.push(row);
3246 self
3247 }
3248
3249 pub fn rows<I>(mut self, rows: I) -> Self
3250 where
3251 I: IntoIterator<Item = TableRow>,
3252 {
3253 self.rows.extend(rows);
3254 self
3255 }
3256
3257 pub fn selected(mut self, selected: usize) -> Self {
3258 self.selected = Some(selected);
3259 self.selected_reader = None;
3260 self
3261 }
3262
3263 pub fn selected_when<F>(mut self, selected: F) -> Self
3264 where
3265 F: Fn() -> Option<usize> + 'static,
3266 {
3267 self.selected_reader = Some(Box::new(selected));
3268 self
3269 }
3270
3271 pub fn on_change<F>(mut self, on_change: F) -> Self
3272 where
3273 F: FnMut(usize) + 'static,
3274 {
3275 self.on_change = Some(Box::new(on_change));
3276 self
3277 }
3278
3279 fn resolved_theme(&self) -> DefaultTheme {
3280 self.theme_reader
3281 .as_ref()
3282 .map(|theme| theme())
3283 .unwrap_or(*self.theme)
3284 }
3285
3286 fn name(&self) -> String {
3287 self.name_reader
3288 .as_ref()
3289 .map(|reader| reader())
3290 .unwrap_or_else(|| self.name.clone())
3291 }
3292
3293 fn resolved_row_height(&self) -> f32 {
3294 self.row_height
3295 .unwrap_or(self.resolved_theme().metrics.table_row_height)
3296 }
3297
3298 fn resolved_header_height(&self) -> f32 {
3299 self.header_height
3300 .unwrap_or(self.resolved_theme().metrics.table_header_height)
3301 }
3302
3303 fn body_rect(&self, bounds: Rect) -> Rect {
3304 let theme = self.resolved_theme();
3305 let padding = theme.metrics.data_viewport_padding;
3306 let gap = theme.metrics.select_menu_gap;
3307 let body = Rect::new(
3308 bounds.x() + padding.left,
3309 bounds.y() + padding.top + self.resolved_header_height() + gap,
3310 (bounds.width() - padding.left - padding.right).max(0.0),
3311 (bounds.height() - padding.top - padding.bottom - self.resolved_header_height() - gap)
3312 .max(0.0),
3313 );
3314 let gutter = crate::containers::scroll_bar_gutter(
3315 true,
3316 crate::ScrollAxes::Vertical,
3317 body.size,
3318 Size::new(0.0, self.content_height()),
3319 theme.metrics.scroll_bar_thickness,
3320 );
3321 Rect::from_origin_size(
3322 body.origin,
3323 crate::containers::scroll_viewport_size(body.size, gutter),
3324 )
3325 }
3326
3327 fn content_height(&self) -> f32 {
3328 self.rows.len() as f32 * self.resolved_row_height()
3329 }
3330
3331 fn current_selected(&self) -> Option<usize> {
3332 self.selected_reader
3333 .as_ref()
3334 .map(|selected| selected())
3335 .unwrap_or(self.selected)
3336 .filter(|index| *index < self.rows.len())
3337 }
3338
3339 fn clamp_scroll(&self, viewport_height: f32, scroll_y: f32) -> f32 {
3340 let max_scroll = (self.content_height() - viewport_height).max(0.0);
3341 scroll_y.clamp(0.0, max_scroll)
3342 }
3343
3344 fn row_at_position(&self, bounds: Rect, position: Point) -> Option<usize> {
3345 let body = self.body_rect(bounds);
3346 if !body.contains(position) {
3347 return None;
3348 }
3349 let y = position.y - body.y() + self.scroll_y;
3350 let index = (y / self.resolved_row_height()).floor() as usize;
3351 (index < self.rows.len()).then_some(index)
3352 }
3353
3354 fn resolve_column_widths(&mut self, ctx: &mut MeasureCtx, available_width: f32) {
3355 let theme = self.resolved_theme();
3356 let header_style = theme.text_style(theme.palette.placeholder);
3357 let body_style = theme.body_text_style();
3358 let numeric_style = numeric_text_style(body_style.clone());
3359 self.column_widths = self
3360 .columns
3361 .iter()
3362 .enumerate()
3363 .map(|(index, column)| {
3364 let measured_title = measure_text(ctx, &column.title, &header_style).width;
3365 let cell_style = if column.numeric {
3366 &numeric_style
3367 } else {
3368 &body_style
3369 };
3370 let measured_cells = self
3371 .rows
3372 .iter()
3373 .filter_map(|row| row.cells.get(index))
3374 .map(|cell| measure_text(ctx, cell, cell_style).width)
3375 .fold(0.0, f32::max);
3376 column.width.unwrap_or(
3377 (measured_title.max(measured_cells) + (theme.metrics.table_cell_padding * 2.0))
3378 .max(column.min_width),
3379 )
3380 })
3381 .collect();
3382
3383 if available_width <= 0.0 || self.column_widths.is_empty() {
3384 return;
3385 }
3386
3387 let total = self.column_widths.iter().sum::<f32>();
3388 if total < available_width {
3389 let extra = (available_width - total) / self.column_widths.len() as f32;
3390 for width in &mut self.column_widths {
3391 *width += extra;
3392 }
3393 }
3394 }
3395
3396 fn activate(&mut self, index: usize) {
3397 if index >= self.rows.len() {
3398 return;
3399 }
3400 self.selected = Some(index);
3401 if let Some(on_change) = &mut self.on_change {
3402 on_change(index);
3403 }
3404 }
3405
3406 fn set_hovered(&mut self, hovered: Option<usize>, ctx: &mut EventCtx) {
3407 if self.hovered == hovered {
3408 return;
3409 }
3410
3411 self.hovered = hovered;
3412 let theme = self.resolved_theme();
3413 self.hover_motion.set_hover_target(hovered, &theme, ctx);
3414 ctx.request_paint();
3415 ctx.request_semantics();
3416 }
3417
3418 fn set_pressed(&mut self, pressed: Option<usize>, ctx: &mut EventCtx) {
3419 if self.pressed == pressed {
3420 return;
3421 }
3422
3423 self.pressed = pressed;
3424 let theme = self.resolved_theme();
3425 self.press_motion.set_press_target(pressed, &theme, ctx);
3426 ctx.request_paint();
3427 ctx.request_semantics();
3428 }
3429
3430 fn advance_animations(&mut self, time: f64, ctx: &mut EventCtx) {
3431 let (hover_changed, hover_active) = self.hover_motion.advance(time);
3432 let (press_changed, press_active) = self.press_motion.advance(time);
3433 let (focus_changed, focus_active) = advance_scalar(&mut self.focus_animation, time);
3434
3435 if hover_changed || press_changed || focus_changed {
3436 ctx.request_paint();
3437 }
3438 if hover_active || press_active || focus_active {
3439 ctx.request_animation_frame();
3440 }
3441 }
3442}
3443
3444impl Widget for Table {
3445 fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
3446 let body = self.body_rect(ctx.bounds());
3447
3448 match event {
3449 Event::Pointer(pointer) if pointer.kind == PointerEventKind::Move => {
3450 let hovered = self.row_at_position(ctx.bounds(), pointer.position);
3451 self.set_hovered(hovered, ctx);
3452 }
3453 Event::Pointer(pointer)
3454 if pointer.kind == PointerEventKind::Scroll && body.contains(pointer.position) =>
3455 {
3456 let delta = pointer
3457 .scroll_delta
3458 .map(scroll_delta_to_offset)
3459 .unwrap_or(pointer.delta);
3460 let next = self.clamp_scroll(body.height(), self.scroll_y - delta.y);
3461 if (next - self.scroll_y).abs() > f32::EPSILON {
3462 self.scroll_y = next;
3463 ctx.request_paint();
3464 ctx.request_semantics();
3465 ctx.set_handled();
3466 }
3467 }
3468 Event::Pointer(pointer)
3469 if pointer.kind == PointerEventKind::Down
3470 && pointer.button == Some(PointerButton::Primary)
3471 && body.contains(pointer.position) =>
3472 {
3473 let pressed = self.row_at_position(ctx.bounds(), pointer.position);
3474 self.set_hovered(pressed, ctx);
3475 self.set_pressed(pressed, ctx);
3476 ctx.request_focus();
3477 ctx.request_pointer_capture(pointer.pointer_id);
3478 ctx.set_handled();
3479 }
3480 Event::Pointer(pointer)
3481 if pointer.kind == PointerEventKind::Up
3482 && pointer.button == Some(PointerButton::Primary) =>
3483 {
3484 let hovered = self.row_at_position(ctx.bounds(), pointer.position);
3485 if let Some(index) = self
3486 .pressed
3487 .zip(hovered)
3488 .filter(|(pressed, hovered)| pressed == hovered)
3489 .map(|(index, _)| index)
3490 {
3491 self.activate(index);
3492 }
3493 self.set_hovered(hovered, ctx);
3494 self.set_pressed(None, ctx);
3495 ctx.release_pointer_capture(pointer.pointer_id);
3496 ctx.set_handled();
3497 }
3498 Event::Pointer(pointer) if pointer.kind == PointerEventKind::Leave => {
3499 self.set_hovered(None, ctx);
3500 }
3501 Event::Pointer(pointer) if pointer.kind == PointerEventKind::Cancel => {
3502 if self.pressed.is_some() {
3503 self.set_pressed(None, ctx);
3504 self.set_hovered(None, ctx);
3505 ctx.release_pointer_capture(pointer.pointer_id);
3506 ctx.set_handled();
3507 }
3508 }
3509 Event::Wake(WakeEvent::AnimationFrame { time, .. }) => {
3510 self.advance_animations(*time, ctx);
3511 }
3512 Event::Keyboard(key) if ctx.is_focused() && key.state == KeyState::Pressed => {
3513 if self.rows.is_empty() {
3514 return;
3515 }
3516
3517 let current = self.current_selected().unwrap_or(0);
3518 match key.key.as_str() {
3519 "ArrowUp" => self.activate(current.saturating_sub(1)),
3520 "ArrowDown" => self.activate((current + 1).min(self.rows.len() - 1)),
3521 "Home" => self.activate(0),
3522 "End" => self.activate(self.rows.len() - 1),
3523 _ => return,
3524 }
3525 ctx.request_paint();
3526 ctx.request_semantics();
3527 ctx.set_handled();
3528 }
3529 _ => {}
3530 }
3531 }
3532
3533 fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
3534 let desired_width = if constraints.max.width.is_finite() {
3535 constraints.max.width
3536 } else {
3537 540.0
3538 };
3539 let theme = self.resolved_theme();
3540 let padding = theme.metrics.data_viewport_padding;
3541 let desired_height = padding.top
3542 + self.resolved_header_height()
3543 + theme.metrics.select_menu_gap
3544 + self.content_height()
3545 + padding.bottom;
3546 let size = constraints.clamp(Size::new(desired_width, desired_height));
3547 self.resolve_column_widths(
3548 ctx,
3549 self.body_rect(Rect::from_origin_size(Point::ZERO, size))
3550 .width(),
3551 );
3552 self.scroll_y = self.clamp_scroll(
3553 self.body_rect(Rect::from_origin_size(Point::ZERO, size))
3554 .height(),
3555 self.scroll_y,
3556 );
3557 size
3558 }
3559
3560 fn paint(&self, ctx: &mut PaintCtx) {
3561 let theme = self.resolved_theme();
3562 let palette = theme.palette;
3563 let metrics = theme.metrics;
3564 let header_style = theme.text_style(palette.placeholder);
3565 let body_style = theme.body_text_style();
3566 let numeric_body_style = numeric_text_style(body_style.clone());
3567 let body = self.body_rect(ctx.bounds());
3568 let padding = metrics.data_viewport_padding;
3569 let header = Rect::new(
3570 ctx.bounds().x() + padding.left,
3571 ctx.bounds().y() + padding.top,
3572 body.width(),
3573 self.resolved_header_height(),
3574 );
3575 let row_height = self.resolved_row_height();
3576
3577 draw_surface(ctx, ctx.bounds(), &theme, self.focus_animation.value);
3578 ctx.fill(
3579 rounded_rect_path(header, metrics.corner_radius),
3580 palette.control,
3581 );
3582
3583 ctx.push_clip_rect(header);
3584 let mut x = header.x();
3585 for (index, column) in self.columns.iter().enumerate() {
3586 let width = *self.column_widths.get(index).unwrap_or(&column.min_width);
3587 let cell = Rect::new(x, header.y(), width, header.height());
3588 if index > 0 {
3589 let separator_inset = metrics
3590 .table_header_separator_inset
3591 .min(cell.height() * 0.5);
3592 ctx.stroke_rect(
3593 Rect::new(
3594 cell.x(),
3595 cell.y() + separator_inset,
3596 metrics.table_separator_width,
3597 (cell.height() - (separator_inset * 2.0)).max(0.0),
3598 ),
3599 palette.border,
3600 sui_scene::StrokeStyle::new(metrics.table_separator_width.max(1.0)),
3601 );
3602 }
3603 draw_aligned_text(
3604 ctx,
3605 horizontal_inset_rect(cell, metrics.table_cell_padding),
3606 &column.title,
3607 &header_style,
3608 column.alignment,
3609 );
3610 x += width;
3611 }
3612
3613 ctx.pop_clip();
3614 ctx.push_clip_rect(body);
3615 let start = (self.scroll_y / row_height).floor().max(0.0) as usize;
3616 let end = (((self.scroll_y + body.height()) / row_height).ceil() as usize + 1)
3617 .min(self.rows.len());
3618
3619 for row_index in start..end {
3620 let row_y = body.y() + (row_index as f32 * row_height) - self.scroll_y;
3621 let row_rect = Rect::new(body.x(), row_y, body.width(), row_height);
3622 let selected = self.current_selected() == Some(row_index);
3623 let hover_amount = self.hover_motion.amount_for(&row_index);
3624 let press_amount = self.press_motion.amount_for(&row_index);
3625 let background = if row_index % 2 == 0 {
3626 palette.surface.with_alpha(0.88)
3627 } else {
3628 palette.surface_raised
3629 };
3630 ctx.fill_rect(row_rect, background);
3631 paint_data_row_state(
3632 ctx,
3633 row_rect,
3634 body,
3635 &theme,
3636 selected,
3637 hover_amount,
3638 press_amount,
3639 );
3640 ctx.stroke_rect(
3641 row_rect,
3642 palette.border.with_alpha(metrics.table_row_border_opacity),
3643 sui_scene::StrokeStyle::new(metrics.table_separator_width.max(1.0)),
3644 );
3645
3646 let mut cell_x = row_rect.x();
3647 for (column_index, column) in self.columns.iter().enumerate() {
3648 let width = *self
3649 .column_widths
3650 .get(column_index)
3651 .unwrap_or(&column.min_width);
3652 let cell_rect = Rect::new(cell_x, row_rect.y(), width, row_rect.height());
3653 if let Some(value) = self.rows[row_index].cells.get(column_index) {
3654 let style = if column.numeric {
3655 numeric_body_style.clone()
3656 } else {
3657 body_style.clone()
3658 };
3659 draw_aligned_text(
3660 ctx,
3661 horizontal_inset_rect(cell_rect, metrics.table_cell_padding),
3662 value,
3663 &style,
3664 column.alignment,
3665 );
3666 }
3667 cell_x += width;
3668 }
3669 }
3670
3671 ctx.pop_clip();
3672 draw_vertical_scroll_thumb(
3673 ctx,
3674 &theme,
3675 body,
3676 self.content_height(),
3677 self.scroll_y,
3678 palette.border_hover,
3679 );
3680 }
3681
3682 fn semantics(&self, ctx: &mut SemanticsCtx) {
3683 let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::Table, ctx.bounds());
3684 node.name = Some(self.name());
3685 node.state.focused = ctx.is_focused();
3686 node.value = self
3687 .current_selected()
3688 .and_then(|row| self.rows.get(row))
3689 .and_then(|row| row.cells.first())
3690 .cloned()
3691 .map(SemanticsValue::Text);
3692 node.actions = vec![SemanticsAction::Focus, SemanticsAction::SetValue];
3693 ctx.push(node);
3694 }
3695
3696 fn accepts_focus(&self) -> bool {
3697 true
3698 }
3699
3700 fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
3701 let theme = self.resolved_theme();
3702 set_focus_animation_target(&mut self.focus_animation, focused as u8 as f32, &theme, ctx);
3703 ctx.request_paint();
3704 ctx.request_semantics();
3705 }
3706}
3707
3708#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3709pub enum VirtualTableSortDirection {
3710 Ascending,
3711 Descending,
3712}
3713
3714#[derive(Clone)]
3719pub struct VirtualTableState {
3720 inner: Rc<RefCell<VirtualTableStateInner>>,
3721 revision: Signal<u64>,
3722 viewport: Signal<VirtualViewportSnapshot<u64>>,
3723 scroll: ScrollState,
3724}
3725
3726#[derive(Default)]
3727struct VirtualTableStateInner {
3728 selected_key: Option<u64>,
3729 pending_scroll: Option<(u64, ScrollAlignment)>,
3730 column_widths: HashMap<u64, f32>,
3731}
3732
3733impl VirtualTableState {
3734 pub fn new() -> Self {
3735 let scroll = ScrollState::new();
3736 scroll.sync_unmeasured_axes(ScrollAxes::Both);
3737 Self {
3738 inner: Rc::new(RefCell::new(VirtualTableStateInner::default())),
3739 revision: Signal::named("VirtualTableState", 0),
3740 viewport: Signal::named("VirtualTableViewport", VirtualViewportSnapshot::default()),
3741 scroll,
3742 }
3743 }
3744
3745 pub fn selected_key(&self) -> Option<u64> {
3746 self.inner.borrow().selected_key
3747 }
3748
3749 pub fn select_key(&self, key: Option<u64>) -> bool {
3750 let changed = {
3751 let mut inner = self.inner.borrow_mut();
3752 if inner.selected_key == key {
3753 false
3754 } else {
3755 inner.selected_key = key;
3756 true
3757 }
3758 };
3759 if changed {
3760 self.bump();
3761 }
3762 changed
3763 }
3764
3765 pub fn scroll_to(&self, key: u64, alignment: ScrollAlignment) {
3766 self.inner.borrow_mut().pending_scroll = Some((key, alignment));
3767 self.bump();
3768 }
3769
3770 pub fn column_width(&self, key: u64) -> Option<f32> {
3771 self.inner.borrow().column_widths.get(&key).copied()
3772 }
3773
3774 pub fn set_column_width(&self, key: u64, width: f32) -> bool {
3775 let width = width.max(32.0);
3776 let changed = {
3777 let mut inner = self.inner.borrow_mut();
3778 if inner
3779 .column_widths
3780 .get(&key)
3781 .is_some_and(|current| (*current - width).abs() <= f32::EPSILON)
3782 {
3783 false
3784 } else {
3785 inner.column_widths.insert(key, width);
3786 true
3787 }
3788 };
3789 if changed {
3790 self.bump();
3791 }
3792 changed
3793 }
3794
3795 pub fn scroll_state(&self) -> ScrollState {
3796 self.scroll.clone()
3797 }
3798
3799 pub fn viewport(&self) -> VirtualViewportSnapshot<u64> {
3800 self.viewport.get()
3801 }
3802
3803 pub fn viewport_signal(&self) -> Signal<VirtualViewportSnapshot<u64>> {
3804 self.viewport.clone()
3805 }
3806
3807 fn bump(&self) {
3808 let _ = self.revision.update(|revision| {
3809 *revision = revision.wrapping_add(1);
3810 });
3811 }
3812
3813 fn take_pending_scroll(&self) -> Option<(u64, ScrollAlignment)> {
3814 self.inner.borrow_mut().pending_scroll.take()
3815 }
3816
3817 fn publish_viewport(&self, viewport: VirtualViewportSnapshot<u64>) {
3818 let _ = self.viewport.set(viewport);
3819 }
3820}
3821
3822impl Default for VirtualTableState {
3823 fn default() -> Self {
3824 Self::new()
3825 }
3826}
3827
3828#[derive(Debug, Clone, PartialEq)]
3829pub struct VirtualTableColumn {
3830 key: Option<u64>,
3831 title: String,
3832 width: Option<f32>,
3833 min_width: f32,
3834 max_width: Option<f32>,
3835 resizable: bool,
3836 pinned: bool,
3837 alignment: TableColumnAlignment,
3838 sort_direction: Option<VirtualTableSortDirection>,
3839}
3840
3841impl VirtualTableColumn {
3842 pub fn new(title: impl Into<String>) -> Self {
3843 Self {
3844 key: None,
3845 title: title.into(),
3846 width: None,
3847 min_width: 96.0,
3848 max_width: None,
3849 resizable: true,
3850 pinned: false,
3851 alignment: TableColumnAlignment::Start,
3852 sort_direction: None,
3853 }
3854 }
3855
3856 pub fn key(mut self, key: u64) -> Self {
3858 self.key = Some(key);
3859 self
3860 }
3861
3862 pub fn width(mut self, width: f32) -> Self {
3863 self.width = Some(width.max(32.0));
3864 self
3865 }
3866
3867 pub fn min_width(mut self, min_width: f32) -> Self {
3868 self.min_width = min_width.max(32.0);
3869 self
3870 }
3871
3872 pub fn max_width(mut self, max_width: f32) -> Self {
3873 self.max_width = Some(max_width.max(self.min_width));
3874 self
3875 }
3876
3877 pub fn resizable(mut self, resizable: bool) -> Self {
3878 self.resizable = resizable;
3879 self
3880 }
3881
3882 pub fn pinned(mut self, pinned: bool) -> Self {
3883 self.pinned = pinned;
3884 self
3885 }
3886
3887 pub fn alignment(mut self, alignment: TableColumnAlignment) -> Self {
3888 self.alignment = alignment;
3889 self
3890 }
3891
3892 pub fn sort_direction(mut self, direction: Option<VirtualTableSortDirection>) -> Self {
3893 self.sort_direction = direction;
3894 self
3895 }
3896}
3897
3898#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3899pub enum VirtualTableRowActivationKind {
3900 Single,
3901 Double,
3902}
3903
3904pub struct VirtualTableRowContext<'a> {
3905 pub row_index: usize,
3906 pub row_key: u64,
3907 pub row_rect: Rect,
3908 pub column_rects: &'a [Rect],
3909 pub selected: bool,
3910 pub hovered: bool,
3911 pub pressed: bool,
3912}
3913
3914type ListViewChange = Box<dyn FnMut(usize, String)>;
3915type ListViewContextChange = Box<dyn FnMut(usize, String, &mut EventCtx)>;
3916type VirtualTableRowPainter = Box<dyn for<'a> Fn(&mut PaintCtx, &VirtualTableRowContext<'a>)>;
3917type VirtualTableRowName = Box<dyn Fn(usize) -> String>;
3918type VirtualTableRowDescription = Box<dyn Fn(usize) -> String>;
3919type VirtualTableCellActivation =
3920 Box<dyn FnMut(usize, usize, VirtualTableRowActivationKind) -> bool>;
3921
3922#[derive(Clone, Copy)]
3923struct VirtualTableColumnResize {
3924 column_index: usize,
3925 pointer_id: u64,
3926 start_x: f32,
3927 start_width: f32,
3928}
3929
3930pub struct VirtualTable {
3931 theme: Box<DefaultTheme>,
3932 theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
3933 name: String,
3934 columns: Vec<VirtualTableColumn>,
3935 state: Option<VirtualTableState>,
3936 window: CollectionWindow,
3937 window_explicit: bool,
3938 row_count: usize,
3939 selected: Option<usize>,
3940 selected_reader: Option<Box<dyn Fn() -> Option<usize>>>,
3941 hovered_row: Option<usize>,
3942 pressed_row: Option<usize>,
3943 pressed_header: Option<usize>,
3944 row_height: Option<f32>,
3945 row_heights: Option<Vec<f32>>,
3946 row_extents: CollectionExtentIndex,
3947 row_extents_default_height: f32,
3948 row_key: Option<Box<dyn Fn(usize) -> u64>>,
3949 header_height: Option<f32>,
3950 scroll_y: f32,
3951 scroll_x: f32,
3952 column_widths: Vec<f32>,
3953 focus_animation: AnimatedScalar,
3954 row_painter: Option<VirtualTableRowPainter>,
3955 row_name: Option<VirtualTableRowName>,
3956 row_description: Option<VirtualTableRowDescription>,
3957 on_row_activate: Option<Box<dyn FnMut(usize, VirtualTableRowActivationKind)>>,
3958 on_cell_activate: Option<VirtualTableCellActivation>,
3959 on_header_activate: Option<Box<dyn FnMut(usize)>>,
3960 on_column_resize: Option<Box<dyn FnMut(usize, f32)>>,
3961 on_near_end: Option<Box<dyn FnMut()>>,
3962 last_click: Option<(usize, Instant)>,
3963 column_resize: Option<VirtualTableColumnResize>,
3964}
3965
3966impl VirtualTable {
3967 const DOUBLE_CLICK_WINDOW: Duration = Duration::from_millis(450);
3968
3969 pub fn new(name: impl Into<String>) -> Self {
3970 Self {
3971 theme: Box::new(DefaultTheme::default()),
3972 theme_reader: None,
3973 name: name.into(),
3974 columns: Vec::new(),
3975 state: None,
3976 window: CollectionWindow::complete(0),
3977 window_explicit: false,
3978 row_count: 0,
3979 selected: None,
3980 selected_reader: None,
3981 hovered_row: None,
3982 pressed_row: None,
3983 pressed_header: None,
3984 row_height: None,
3985 row_heights: None,
3986 row_extents: CollectionExtentIndex::new(),
3987 row_extents_default_height: 0.0,
3988 row_key: None,
3989 header_height: None,
3990 scroll_y: 0.0,
3991 scroll_x: 0.0,
3992 column_widths: Vec::new(),
3993 focus_animation: AnimatedScalar::new(0.0),
3994 row_painter: None,
3995 row_name: None,
3996 row_description: None,
3997 on_row_activate: None,
3998 on_cell_activate: None,
3999 on_header_activate: None,
4000 on_column_resize: None,
4001 on_near_end: None,
4002 last_click: None,
4003 column_resize: None,
4004 }
4005 }
4006
4007 pub fn theme(mut self, theme: DefaultTheme) -> Self {
4008 self.theme = Box::new(theme);
4009 self.theme_reader = None;
4010 self
4011 }
4012
4013 pub fn theme_when<F>(mut self, theme: F) -> Self
4014 where
4015 F: Fn() -> DefaultTheme + 'static,
4016 {
4017 self.theme_reader = Some(Box::new(theme));
4018 self
4019 }
4020
4021 pub fn columns<I>(mut self, columns: I) -> Self
4022 where
4023 I: IntoIterator<Item = VirtualTableColumn>,
4024 {
4025 self.columns.extend(columns);
4026 self
4027 }
4028
4029 pub fn state(mut self, state: VirtualTableState) -> Self {
4031 self.state = Some(state);
4032 self
4033 }
4034
4035 pub fn collection_window(mut self, window: CollectionWindow) -> Self {
4037 self.window = window;
4038 self.window_explicit = true;
4039 self
4040 }
4041
4042 pub fn row_count(mut self, row_count: usize) -> Self {
4043 self.row_count = row_count;
4044 if !self.window_explicit {
4045 self.window = CollectionWindow::complete(row_count);
4046 }
4047 self.row_extents.clear();
4048 self
4049 }
4050
4051 pub fn row_height(mut self, row_height: f32) -> Self {
4052 self.row_height = Some(row_height.max(1.0));
4053 self.row_heights = None;
4054 self.row_extents.clear();
4055 self
4056 }
4057
4058 pub fn row_heights<I>(mut self, row_heights: I) -> Self
4059 where
4060 I: IntoIterator<Item = f32>,
4061 {
4062 self.row_heights = Some(
4063 row_heights
4064 .into_iter()
4065 .map(|height| height.max(1.0))
4066 .collect(),
4067 );
4068 self.row_extents.clear();
4069 self
4070 }
4071
4072 pub fn row_key<F>(mut self, row_key: F) -> Self
4077 where
4078 F: Fn(usize) -> u64 + 'static,
4079 {
4080 self.row_key = Some(Box::new(row_key));
4081 self
4082 }
4083
4084 pub fn header_height(mut self, header_height: f32) -> Self {
4085 self.header_height = Some(header_height.max(1.0));
4086 self
4087 }
4088
4089 pub fn selected(mut self, selected: usize) -> Self {
4090 self.selected = Some(selected);
4091 self
4092 }
4093
4094 pub fn selected_when<F>(mut self, selected: F) -> Self
4095 where
4096 F: Fn() -> Option<usize> + 'static,
4097 {
4098 self.selected_reader = Some(Box::new(selected));
4099 self
4100 }
4101
4102 pub fn row_painter<F>(mut self, painter: F) -> Self
4103 where
4104 F: for<'a> Fn(&mut PaintCtx, &VirtualTableRowContext<'a>) + 'static,
4105 {
4106 self.row_painter = Some(Box::new(painter));
4107 self
4108 }
4109
4110 pub fn row_name<F>(mut self, name: F) -> Self
4111 where
4112 F: Fn(usize) -> String + 'static,
4113 {
4114 self.row_name = Some(Box::new(name));
4115 self
4116 }
4117
4118 pub fn row_description<F>(mut self, description: F) -> Self
4119 where
4120 F: Fn(usize) -> String + 'static,
4121 {
4122 self.row_description = Some(Box::new(description));
4123 self
4124 }
4125
4126 pub fn on_row_activate<F>(mut self, on_activate: F) -> Self
4127 where
4128 F: FnMut(usize, VirtualTableRowActivationKind) + 'static,
4129 {
4130 self.on_row_activate = Some(Box::new(on_activate));
4131 self
4132 }
4133
4134 pub fn on_cell_activate<F>(mut self, on_activate: F) -> Self
4135 where
4136 F: FnMut(usize, usize, VirtualTableRowActivationKind) -> bool + 'static,
4137 {
4138 self.on_cell_activate = Some(Box::new(on_activate));
4139 self
4140 }
4141
4142 pub fn on_header_activate<F>(mut self, on_activate: F) -> Self
4143 where
4144 F: FnMut(usize) + 'static,
4145 {
4146 self.on_header_activate = Some(Box::new(on_activate));
4147 self
4148 }
4149
4150 pub fn on_column_resize<F>(mut self, on_resize: F) -> Self
4151 where
4152 F: FnMut(usize, f32) + 'static,
4153 {
4154 self.on_column_resize = Some(Box::new(on_resize));
4155 self
4156 }
4157
4158 pub fn on_near_end<F>(mut self, on_near_end: F) -> Self
4159 where
4160 F: FnMut() + 'static,
4161 {
4162 self.on_near_end = Some(Box::new(on_near_end));
4163 self
4164 }
4165
4166 fn resolved_theme(&self) -> DefaultTheme {
4167 self.theme_reader
4168 .as_ref()
4169 .map(|theme| theme())
4170 .unwrap_or(*self.theme)
4171 }
4172
4173 fn resolved_selected(&self) -> Option<usize> {
4174 let selected = if let Some(selected_reader) = &self.selected_reader {
4175 selected_reader()
4176 } else if let Some(state) = &self.state {
4177 state.selected_key().and_then(|selected_key| {
4178 (0..self.row_count).find(|index| self.resolved_row_key(*index) == selected_key)
4179 })
4180 } else {
4181 self.selected
4182 };
4183 selected.filter(|index| *index < self.row_count)
4184 }
4185
4186 fn normalized_window(&self) -> CollectionWindow {
4187 self.window
4188 .clone()
4189 .normalized_for_loaded_count(self.row_count)
4190 }
4191
4192 fn resolved_row_height(&self) -> f32 {
4193 self.row_height
4194 .unwrap_or(self.resolved_theme().metrics.table_row_height)
4195 }
4196
4197 fn row_height_at(&self, index: usize) -> f32 {
4198 self.row_heights
4199 .as_ref()
4200 .and_then(|heights| heights.get(index).copied())
4201 .unwrap_or_else(|| self.resolved_row_height())
4202 .max(1.0)
4203 }
4204
4205 fn sync_row_extents(&mut self) {
4206 let default_height = self.resolved_row_height();
4207 let needs_rebuild = self.row_extents.len() != self.row_count
4208 || (self.row_heights.is_none()
4209 && (self.row_extents_default_height - default_height).abs() > f32::EPSILON);
4210 if needs_rebuild {
4211 let heights = (0..self.row_count)
4212 .map(|index| self.row_height_at(index))
4213 .collect::<Vec<_>>();
4214 self.row_extents.rebuild(heights);
4215 self.row_extents_default_height = default_height;
4216 }
4217 }
4218
4219 fn resolved_row_key(&self, index: usize) -> u64 {
4220 self.row_key
4221 .as_ref()
4222 .map(|row_key| row_key(index))
4223 .unwrap_or(index as u64)
4224 }
4225
4226 fn resolved_column_key(&self, index: usize) -> u64 {
4227 self.columns
4228 .get(index)
4229 .and_then(|column| column.key)
4230 .unwrap_or(index as u64)
4231 }
4232
4233 fn resolved_header_height(&self) -> f32 {
4234 self.header_height
4235 .unwrap_or(self.resolved_theme().metrics.table_header_height)
4236 }
4237
4238 fn body_rect(&self, bounds: Rect) -> Rect {
4239 let theme = self.resolved_theme();
4240 let padding = theme.metrics.data_viewport_padding;
4241 let gap = theme.metrics.select_menu_gap;
4242 let body = Rect::new(
4243 bounds.x() + padding.left,
4244 bounds.y() + padding.top + self.resolved_header_height() + gap,
4245 (bounds.width() - padding.left - padding.right).max(0.0),
4246 (bounds.height() - padding.top - padding.bottom - self.resolved_header_height() - gap)
4247 .max(0.0),
4248 );
4249 let gutter = crate::containers::scroll_bar_gutter(
4250 true,
4251 crate::ScrollAxes::Vertical,
4252 body.size,
4253 Size::new(0.0, self.content_height()),
4254 theme.metrics.scroll_bar_thickness,
4255 );
4256 Rect::from_origin_size(
4257 body.origin,
4258 crate::containers::scroll_viewport_size(body.size, gutter),
4259 )
4260 }
4261
4262 fn header_rect(&self, bounds: Rect) -> Rect {
4263 let theme = self.resolved_theme();
4264 let padding = theme.metrics.data_viewport_padding;
4265 Rect::new(
4266 bounds.x() + padding.left,
4267 bounds.y() + padding.top,
4268 self.body_rect(bounds).width(),
4269 self.resolved_header_height(),
4270 )
4271 }
4272
4273 fn content_height(&self) -> f32 {
4274 if self.row_extents.len() == self.row_count {
4275 self.row_extents.total()
4276 } else {
4277 self.row_count as f32 * self.resolved_row_height()
4278 }
4279 }
4280
4281 fn clamp_scroll(&self, viewport_height: f32, scroll_y: f32) -> f32 {
4282 let max_scroll = (self.content_height() - viewport_height).max(0.0);
4283 scroll_y.clamp(0.0, max_scroll)
4284 }
4285
4286 fn pinned_width(&self) -> f32 {
4287 self.columns
4288 .iter()
4289 .enumerate()
4290 .filter(|(_, column)| column.pinned)
4291 .map(|(index, column)| *self.column_widths.get(index).unwrap_or(&column.min_width))
4292 .sum()
4293 }
4294
4295 fn unpinned_content_width(&self) -> f32 {
4296 self.columns
4297 .iter()
4298 .enumerate()
4299 .filter(|(_, column)| !column.pinned)
4300 .map(|(index, column)| *self.column_widths.get(index).unwrap_or(&column.min_width))
4301 .sum()
4302 }
4303
4304 fn clamp_horizontal_scroll(&self, viewport_width: f32, scroll_x: f32) -> f32 {
4305 let unpinned_viewport = (viewport_width - self.pinned_width()).max(0.0);
4306 let max_scroll = (self.unpinned_content_width() - unpinned_viewport).max(0.0);
4307 scroll_x.clamp(0.0, max_scroll)
4308 }
4309
4310 fn row_at_position(&self, bounds: Rect, position: Point) -> Option<usize> {
4311 let body = self.body_rect(bounds);
4312 if !body.contains(position) {
4313 return None;
4314 }
4315 let y = position.y - body.y() + self.scroll_y;
4316 self.row_extents
4317 .index_at_offset(y)
4318 .filter(|index| *index < self.row_count)
4319 }
4320
4321 fn body_column_at_position(&self, bounds: Rect, position: Point) -> Option<usize> {
4322 let body = self.body_rect(bounds);
4323 if !body.contains(position) {
4324 return None;
4325 }
4326 self.column_rects(body)
4327 .iter()
4328 .position(|rect| rect.contains(position))
4329 }
4330
4331 fn header_at_position(&self, bounds: Rect, position: Point) -> Option<usize> {
4332 let header = self.header_rect(bounds);
4333 if !header.contains(position) {
4334 return None;
4335 }
4336 self.column_rects(header)
4337 .iter()
4338 .position(|rect| rect.contains(position))
4339 }
4340
4341 fn resolve_column_widths(&mut self, ctx: &mut MeasureCtx, available_width: f32) {
4342 let theme = self.resolved_theme();
4343 let header_style = theme.text_style(theme.palette.placeholder);
4344 self.column_widths = self
4345 .columns
4346 .iter()
4347 .enumerate()
4348 .map(|(index, column)| {
4349 let retained_width = self
4350 .state
4351 .as_ref()
4352 .and_then(|state| state.column_width(self.resolved_column_key(index)));
4353 let width = retained_width.or(column.width).unwrap_or_else(|| {
4354 (measure_text(ctx, &column.title, &header_style).width
4355 + (theme.metrics.table_cell_padding * 2.0))
4356 .max(column.min_width)
4357 });
4358 width
4359 .max(32.0)
4360 .min(column.max_width.unwrap_or(f32::INFINITY))
4361 })
4362 .collect();
4363
4364 if available_width <= 0.0 || self.column_widths.is_empty() {
4365 return;
4366 }
4367
4368 let total = self.column_widths.iter().sum::<f32>();
4369 let flexible = self
4370 .columns
4371 .iter()
4372 .enumerate()
4373 .filter_map(|(index, column)| {
4374 let retained = self
4375 .state
4376 .as_ref()
4377 .and_then(|state| state.column_width(self.resolved_column_key(index)));
4378 (column.width.is_none() && retained.is_none()).then_some(index)
4379 })
4380 .collect::<Vec<_>>();
4381 if total < available_width && !flexible.is_empty() {
4382 let extra = (available_width - total) / flexible.len() as f32;
4383 for index in flexible {
4384 self.column_widths[index] += extra;
4385 }
4386 }
4387 }
4388
4389 fn column_rects(&self, row_rect: Rect) -> Vec<Rect> {
4390 let pinned_width = self.pinned_width().min(row_rect.width());
4391 let unpinned_clip = Rect::new(
4392 row_rect.x() + pinned_width,
4393 row_rect.y(),
4394 (row_rect.width() - pinned_width).max(0.0),
4395 row_rect.height(),
4396 );
4397 let mut pinned_x = row_rect.x();
4398 let mut unpinned_x = row_rect.x() + pinned_width - self.scroll_x;
4399 self.columns
4400 .iter()
4401 .enumerate()
4402 .map(|(index, column)| {
4403 let width = *self.column_widths.get(index).unwrap_or(&column.min_width);
4404 if column.pinned {
4405 let rect = Rect::new(pinned_x, row_rect.y(), width, row_rect.height());
4406 pinned_x += width;
4407 rect.intersection(row_rect).unwrap_or(Rect::ZERO)
4408 } else {
4409 let rect = Rect::new(unpinned_x, row_rect.y(), width, row_rect.height());
4410 unpinned_x += width;
4411 rect.intersection(unpinned_clip).unwrap_or(Rect::ZERO)
4412 }
4413 })
4414 .collect()
4415 }
4416
4417 fn row_activation_kind(&mut self, row_index: usize) -> VirtualTableRowActivationKind {
4418 let now = Instant::now();
4419 let double_click = self.last_click.take().is_some_and(|(index, instant)| {
4420 index == row_index && now.duration_since(instant) <= Self::DOUBLE_CLICK_WINDOW
4421 });
4422 if double_click {
4423 VirtualTableRowActivationKind::Double
4424 } else {
4425 self.last_click = Some((row_index, now));
4426 VirtualTableRowActivationKind::Single
4427 }
4428 }
4429
4430 fn row_rect(&self, body: Rect, row_index: usize) -> Rect {
4431 let row_y = body.y() + self.row_extents.offset_of(row_index) - self.scroll_y;
4432 Rect::new(
4433 body.x(),
4434 row_y,
4435 body.width(),
4436 self.row_extents
4437 .extent(row_index)
4438 .unwrap_or_else(|| self.row_height_at(row_index)),
4439 )
4440 }
4441
4442 fn visible_row_range(&self, body: Rect) -> Range<usize> {
4443 if self.row_count == 0 {
4444 return 0..0;
4445 }
4446 let start = self.row_extents.index_at_offset(self.scroll_y).unwrap_or(0);
4447 let end = self
4448 .row_extents
4449 .index_at_offset(self.scroll_y + body.height())
4450 .map_or(self.row_count, |index| index + 2)
4451 .min(self.row_count);
4452 start..end
4453 }
4454
4455 fn viewport_row_range(&self, body: Rect) -> Range<usize> {
4456 if self.row_count == 0 || body.height() <= 0.0 {
4457 return 0..0;
4458 }
4459 let start = self.row_extents.index_at_offset(self.scroll_y).unwrap_or(0);
4460 let end = self
4461 .row_extents
4462 .index_at_offset(self.scroll_y + body.height())
4463 .map_or(self.row_count, |index| index + 1)
4464 .min(self.row_count);
4465 start..end
4466 }
4467
4468 fn offset_for_row_alignment(
4469 &self,
4470 row_index: usize,
4471 viewport_height: f32,
4472 alignment: ScrollAlignment,
4473 ) -> f32 {
4474 let top = self.row_extents.offset_of(row_index);
4475 let height = self
4476 .row_extents
4477 .extent(row_index)
4478 .unwrap_or_else(|| self.row_height_at(row_index));
4479 let bottom = top + height;
4480 let offset = match alignment {
4481 ScrollAlignment::Nearest if top < self.scroll_y => top,
4482 ScrollAlignment::Nearest if bottom > self.scroll_y + viewport_height => {
4483 bottom - viewport_height
4484 }
4485 ScrollAlignment::Nearest => self.scroll_y,
4486 ScrollAlignment::Start => top,
4487 ScrollAlignment::Center => top - (viewport_height - height) * 0.5,
4488 ScrollAlignment::End => bottom - viewport_height,
4489 };
4490 self.clamp_scroll(viewport_height, offset)
4491 }
4492
4493 fn apply_pending_keyed_scroll(&mut self, body_height: f32) {
4494 let Some((key, alignment)) = self
4495 .state
4496 .as_ref()
4497 .and_then(VirtualTableState::take_pending_scroll)
4498 else {
4499 return;
4500 };
4501 let Some(index) = (0..self.row_count).find(|index| self.resolved_row_key(*index) == key)
4502 else {
4503 return;
4504 };
4505 self.scroll_y = self.offset_for_row_alignment(index, body_height, alignment);
4506 }
4507
4508 fn sync_retained_scroll_state<C>(&mut self, ctx: &mut C, body: Rect)
4509 where
4510 C: crate::containers::ScrollInvalidationCtx + crate::containers::ScrollWidgetCtx,
4511 {
4512 let Some(state) = self.state.as_ref() else {
4513 return;
4514 };
4515 state
4516 .scroll
4517 .bind_scroll_view(ctx.widget_id(), ctx.widget_id());
4518 let content_width = self.column_widths.iter().sum::<f32>();
4519 let changed = state.scroll.sync_metrics(
4520 ScrollAxes::Both,
4521 body.size,
4522 Size::new(content_width, self.content_height()),
4523 );
4524 if changed {
4525 for scroll_bar_id in state.scroll.subscribers().scroll_bar_ids {
4526 crate::containers::request_scroll_bar_refresh(ctx, scroll_bar_id);
4527 }
4528 }
4529 }
4530
4531 fn sync_retained_offset(&self) {
4532 if let Some(state) = &self.state {
4533 let _ = state
4534 .scroll
4535 .set_offset(Vector::new(self.scroll_x, self.scroll_y));
4536 }
4537 }
4538
4539 fn publish_retained_viewport(&self, body: Rect) {
4540 let Some(state) = &self.state else {
4541 return;
4542 };
4543 let window = self.normalized_window();
4544 let local_visible = self.viewport_row_range(body);
4545 let visible_range = window
4546 .loaded_range
4547 .start
4548 .saturating_add(local_visible.start)
4549 ..window.loaded_range.start.saturating_add(local_visible.end);
4550 let visible_keys = local_visible
4551 .clone()
4552 .map(|index| self.resolved_row_key(index))
4553 .collect::<Vec<_>>();
4554 let anchor = (local_visible.start < self.row_count).then(|| {
4555 let index = local_visible.start;
4556 CollectionAnchor {
4557 key: self.resolved_row_key(index),
4558 offset_within_item: self.scroll_y - self.row_extents.offset_of(index),
4559 gravity: CollectionAnchorGravity::Start,
4560 }
4561 });
4562 let max_offset = (self.content_height() - body.height()).max(0.0);
4563 state.publish_viewport(VirtualViewportSnapshot {
4564 loaded_range: window.loaded_range,
4565 visible_range,
4566 visible_keys,
4567 total_count: window.total_count,
4568 has_before: window.has_before,
4569 has_after: window.has_after,
4570 anchor,
4571 offset: self.scroll_y,
4572 max_offset,
4573 at_loaded_start: self.scroll_y <= f32::EPSILON,
4574 at_loaded_end: max_offset - self.scroll_y <= f32::EPSILON,
4575 following_end: false,
4576 });
4577 }
4578
4579 fn ensure_row_visible(&mut self, body_height: f32, row_index: usize) {
4580 if row_index >= self.row_count {
4581 return;
4582 }
4583 let top = self.row_extents.offset_of(row_index);
4584 let bottom = top
4585 + self
4586 .row_extents
4587 .extent(row_index)
4588 .unwrap_or_else(|| self.row_height_at(row_index));
4589 if top < self.scroll_y {
4590 self.scroll_y = top;
4591 } else if bottom > self.scroll_y + body_height {
4592 self.scroll_y = bottom - body_height;
4593 }
4594 self.scroll_y = self.clamp_scroll(body_height, self.scroll_y);
4595 }
4596
4597 fn column_separator_at_position(&self, bounds: Rect, position: Point) -> Option<usize> {
4598 let header = self.header_rect(bounds);
4599 if !header.contains(position) {
4600 return None;
4601 }
4602 for (index, (column, rect)) in self
4603 .columns
4604 .iter()
4605 .zip(self.column_rects(header))
4606 .enumerate()
4607 {
4608 if !rect.is_empty() && column.resizable && (position.x - rect.max_x()).abs() <= 5.0 {
4609 return Some(index);
4610 }
4611 }
4612 None
4613 }
4614
4615 fn resize_column(&mut self, resize: VirtualTableColumnResize, position_x: f32) -> bool {
4616 let Some(column) = self.columns.get_mut(resize.column_index) else {
4617 return false;
4618 };
4619 let maximum = column.max_width.unwrap_or(f32::INFINITY);
4620 let width =
4621 (resize.start_width + position_x - resize.start_x).clamp(column.min_width, maximum);
4622 if (column.width.unwrap_or(resize.start_width) - width).abs() <= f32::EPSILON {
4623 return false;
4624 }
4625 column.width = Some(width);
4626 if let Some(current) = self.column_widths.get_mut(resize.column_index) {
4627 *current = width;
4628 }
4629 if let Some(state) = &self.state {
4630 let _ = state.set_column_width(self.resolved_column_key(resize.column_index), width);
4631 }
4632 if let Some(on_resize) = &mut self.on_column_resize {
4633 on_resize(resize.column_index, width);
4634 }
4635 true
4636 }
4637
4638 fn activate_row(&mut self, row_index: usize, column_index: Option<usize>) {
4639 if row_index >= self.row_count {
4640 return;
4641 }
4642 self.selected = Some(row_index);
4643 if let Some(state) = &self.state {
4644 let _ = state.select_key(Some(self.resolved_row_key(row_index)));
4645 }
4646 let kind = self.row_activation_kind(row_index);
4647 if let Some(column_index) = column_index
4648 && let Some(on_activate) = &mut self.on_cell_activate
4649 && on_activate(row_index, column_index, kind)
4650 {
4651 return;
4652 }
4653 if let Some(on_activate) = &mut self.on_row_activate {
4654 on_activate(row_index, kind);
4655 }
4656 }
4657
4658 fn maybe_notify_near_end(&mut self, viewport_height: f32) {
4659 let remaining = (self.content_height() - viewport_height - self.scroll_y).max(0.0);
4660 if remaining <= self.resolved_row_height() * 12.0
4661 && let Some(on_near_end) = &mut self.on_near_end
4662 {
4663 on_near_end();
4664 }
4665 }
4666
4667 fn advance_animations(&mut self, time: f64, ctx: &mut EventCtx) {
4668 let (focus_changed, focus_active) = advance_scalar(&mut self.focus_animation, time);
4669 if focus_changed {
4670 ctx.request_paint();
4671 }
4672 if focus_active {
4673 ctx.request_animation_frame();
4674 }
4675 }
4676}
4677
4678impl Widget for VirtualTable {
4679 fn layer_options(&self) -> sui_runtime::LayerOptions {
4680 sui_runtime::LayerOptions {
4682 paint_boundary: sui_runtime::PaintBoundaryMode::Explicit,
4683 ..sui_runtime::LayerOptions::default()
4684 }
4685 }
4686
4687 fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
4688 let bounds = ctx.bounds();
4689 let body = self.body_rect(bounds);
4690
4691 match event {
4692 Event::Pointer(pointer)
4693 if pointer.kind == PointerEventKind::Move
4694 && self
4695 .column_resize
4696 .is_some_and(|resize| resize.pointer_id == pointer.pointer_id) =>
4697 {
4698 let resize = self.column_resize.expect("checked resize gesture");
4699 if self.resize_column(resize, pointer.position.x) {
4700 ctx.request_measure();
4701 ctx.request_paint();
4702 ctx.request_semantics();
4703 }
4704 ctx.set_handled();
4705 }
4706 Event::Pointer(pointer) if pointer.kind == PointerEventKind::Move => {
4707 let hovered = self.row_at_position(bounds, pointer.position);
4708 if self.hovered_row != hovered {
4709 self.hovered_row = hovered;
4710 ctx.request_paint();
4711 ctx.request_semantics();
4712 }
4713 }
4714 Event::Pointer(pointer)
4715 if pointer.kind == PointerEventKind::Scroll && body.contains(pointer.position) =>
4716 {
4717 let delta = pointer
4718 .scroll_delta
4719 .map(scroll_delta_to_offset)
4720 .unwrap_or(pointer.delta);
4721 let next_y = self.clamp_scroll(body.height(), self.scroll_y - delta.y);
4722 let next_x = self.clamp_horizontal_scroll(body.width(), self.scroll_x - delta.x);
4723 if (next_y - self.scroll_y).abs() > f32::EPSILON
4724 || (next_x - self.scroll_x).abs() > f32::EPSILON
4725 {
4726 self.scroll_y = next_y;
4727 self.scroll_x = next_x;
4728 self.sync_retained_offset();
4729 self.publish_retained_viewport(body);
4730 self.maybe_notify_near_end(body.height());
4731 ctx.request_paint();
4732 ctx.request_semantics();
4733 ctx.set_handled();
4734 }
4735 }
4736 Event::Pointer(pointer)
4737 if pointer.kind == PointerEventKind::Down
4738 && pointer.button == Some(PointerButton::Primary) =>
4739 {
4740 if let Some(column_index) =
4741 self.column_separator_at_position(bounds, pointer.position)
4742 {
4743 let start_width = self.column_widths[column_index];
4744 self.column_resize = Some(VirtualTableColumnResize {
4745 column_index,
4746 pointer_id: pointer.pointer_id,
4747 start_x: pointer.position.x,
4748 start_width,
4749 });
4750 ctx.request_focus();
4751 ctx.request_pointer_capture(pointer.pointer_id);
4752 ctx.request_paint();
4753 ctx.set_handled();
4754 } else if let Some(header) = self.header_at_position(bounds, pointer.position) {
4755 self.pressed_header = Some(header);
4756 ctx.request_focus();
4757 ctx.request_pointer_capture(pointer.pointer_id);
4758 ctx.request_paint();
4759 ctx.set_handled();
4760 } else if let Some(row) = self.row_at_position(bounds, pointer.position) {
4761 self.pressed_row = Some(row);
4762 self.hovered_row = Some(row);
4763 ctx.request_focus();
4764 ctx.request_pointer_capture(pointer.pointer_id);
4765 ctx.request_paint();
4766 ctx.request_semantics();
4767 ctx.set_handled();
4768 }
4769 }
4770 Event::Pointer(pointer)
4771 if pointer.kind == PointerEventKind::Up
4772 && pointer.button == Some(PointerButton::Primary) =>
4773 {
4774 if self
4775 .column_resize
4776 .take()
4777 .is_some_and(|resize| resize.pointer_id == pointer.pointer_id)
4778 {
4779 ctx.release_pointer_capture(pointer.pointer_id);
4780 ctx.request_paint();
4781 ctx.request_semantics();
4782 ctx.set_handled();
4783 return;
4784 }
4785 let header = self.header_at_position(bounds, pointer.position);
4786 if let Some(index) = self
4787 .pressed_header
4788 .zip(header)
4789 .filter(|(pressed, hovered)| pressed == hovered)
4790 .map(|(index, _)| index)
4791 {
4792 if let Some(on_activate) = &mut self.on_header_activate {
4793 on_activate(index);
4794 }
4795 } else {
4796 let hovered = self.row_at_position(bounds, pointer.position);
4797 if let Some(index) = self
4798 .pressed_row
4799 .zip(hovered)
4800 .filter(|(pressed, hovered)| pressed == hovered)
4801 .map(|(index, _)| index)
4802 {
4803 let column = self.body_column_at_position(bounds, pointer.position);
4804 self.activate_row(index, column);
4805 }
4806 self.hovered_row = hovered;
4807 }
4808 self.pressed_row = None;
4809 self.pressed_header = None;
4810 ctx.release_pointer_capture(pointer.pointer_id);
4811 ctx.request_paint();
4812 ctx.request_semantics();
4813 ctx.set_handled();
4814 }
4815 Event::Pointer(pointer) if pointer.kind == PointerEventKind::Leave => {
4816 if self.hovered_row.take().is_some() {
4817 ctx.request_paint();
4818 ctx.request_semantics();
4819 }
4820 }
4821 Event::Pointer(pointer) if pointer.kind == PointerEventKind::Cancel => {
4822 if self.column_resize.take().is_some()
4823 || self.pressed_row.take().is_some()
4824 || self.pressed_header.take().is_some()
4825 {
4826 ctx.release_pointer_capture(pointer.pointer_id);
4827 ctx.request_paint();
4828 ctx.set_handled();
4829 }
4830 if self.hovered_row.take().is_some() {
4831 ctx.request_paint();
4832 ctx.request_semantics();
4833 }
4834 }
4835 Event::Keyboard(key) if ctx.is_focused() && key.state == KeyState::Pressed => {
4836 if self.row_count == 0 {
4837 return;
4838 }
4839 let current = self.resolved_selected().unwrap_or(0);
4840 match key.key.as_str() {
4841 "ArrowUp" => {
4842 let next = current.saturating_sub(1);
4843 self.activate_row(next, None);
4844 self.ensure_row_visible(body.height(), next);
4845 }
4846 "ArrowDown" => {
4847 let next = (current + 1).min(self.row_count - 1);
4848 self.activate_row(next, None);
4849 self.ensure_row_visible(body.height(), next);
4850 }
4851 "Home" => {
4852 self.activate_row(0, None);
4853 self.ensure_row_visible(body.height(), 0);
4854 }
4855 "End" => {
4856 let last = self.row_count - 1;
4857 self.activate_row(last, None);
4858 self.ensure_row_visible(body.height(), last);
4859 }
4860 "PageUp" => {
4861 self.scroll_y =
4862 self.clamp_scroll(body.height(), self.scroll_y - body.height() * 0.85);
4863 }
4864 "PageDown" => {
4865 self.scroll_y =
4866 self.clamp_scroll(body.height(), self.scroll_y + body.height() * 0.85);
4867 }
4868 _ => return,
4869 }
4870 self.sync_retained_offset();
4871 self.publish_retained_viewport(body);
4872 ctx.request_paint();
4873 ctx.request_semantics();
4874 ctx.set_handled();
4875 }
4876 Event::Semantics(semantics) if semantics.target == ctx.widget_id() => {
4877 let delta = match semantics.action {
4878 sui_core::SemanticsActionRequest::Increment => Some(body.height() * 0.85),
4879 sui_core::SemanticsActionRequest::Decrement => Some(-body.height() * 0.85),
4880 _ => None,
4881 };
4882 if let Some(delta) = delta {
4883 let next = self.clamp_scroll(body.height(), self.scroll_y + delta);
4884 if (next - self.scroll_y).abs() > f32::EPSILON {
4885 self.scroll_y = next;
4886 self.sync_retained_offset();
4887 self.publish_retained_viewport(body);
4888 ctx.request_paint();
4889 ctx.request_semantics();
4890 }
4891 ctx.set_handled();
4892 }
4893 }
4894 Event::Wake(WakeEvent::AnimationFrame { time, .. }) => {
4895 self.advance_animations(*time, ctx);
4896 }
4897 _ => {}
4898 }
4899 }
4900
4901 fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
4902 if let Some(state) = &self.state {
4903 let _ = ctx.observe(&state.revision);
4904 }
4905 self.sync_row_extents();
4906 let desired_width = if constraints.max.width.is_finite() {
4907 constraints.max.width
4908 } else {
4909 540.0
4910 };
4911 let desired_height = if constraints.max.height.is_finite() {
4912 constraints.max.height
4913 } else {
4914 let theme = self.resolved_theme();
4915 let padding = theme.metrics.data_viewport_padding;
4916 (padding.top
4917 + self.resolved_header_height()
4918 + theme.metrics.select_menu_gap
4919 + self.content_height()
4920 + padding.bottom)
4921 .min(420.0)
4922 };
4923 let size = constraints.clamp(Size::new(desired_width, desired_height));
4924 let body = self.body_rect(Rect::from_origin_size(Point::ZERO, size));
4925 self.resolve_column_widths(ctx, body.width());
4926 self.sync_retained_scroll_state(ctx, body);
4927 if let Some(state) = &self.state {
4928 let offset = state.scroll.current_offset();
4929 self.scroll_y = offset.y;
4930 self.scroll_x = offset.x;
4931 }
4932 self.apply_pending_keyed_scroll(body.height());
4933 self.scroll_y = self.clamp_scroll(body.height(), self.scroll_y);
4934 self.scroll_x = self.clamp_horizontal_scroll(body.width(), self.scroll_x);
4935 self.sync_retained_offset();
4936 self.publish_retained_viewport(body);
4937 size
4938 }
4939
4940 fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
4941 let body = self.body_rect(bounds);
4942 let previous = Vector::new(self.scroll_x, self.scroll_y);
4943 self.sync_retained_scroll_state(ctx, body);
4944 if let Some(state) = &self.state {
4945 let offset = state.scroll.current_offset();
4946 self.scroll_y = self.clamp_scroll(body.height(), offset.y);
4947 self.scroll_x = self.clamp_horizontal_scroll(body.width(), offset.x);
4948 }
4949 self.apply_pending_keyed_scroll(body.height());
4950 self.sync_retained_offset();
4951 self.publish_retained_viewport(body);
4952 if previous != Vector::new(self.scroll_x, self.scroll_y) {
4953 ctx.request_paint();
4954 ctx.request_semantics();
4955 }
4956 }
4957
4958 fn paint(&self, ctx: &mut PaintCtx) {
4959 let theme = self.resolved_theme();
4960 let palette = theme.palette;
4961 let metrics = theme.metrics;
4962 let header_style = theme.text_style(palette.placeholder);
4963 let bounds = ctx.bounds();
4964 let body = self.body_rect(bounds);
4965 let header = self.header_rect(bounds);
4966 let selected = self.resolved_selected();
4967
4968 draw_surface(ctx, bounds, &theme, self.focus_animation.value);
4969 ctx.fill(
4970 rounded_rect_path(header, metrics.corner_radius),
4971 palette.control,
4972 );
4973
4974 let header_cells = self.column_rects(header);
4975 let paint_order = self
4976 .columns
4977 .iter()
4978 .enumerate()
4979 .filter_map(|(index, column)| (!column.pinned).then_some(index))
4980 .chain(
4981 self.columns
4982 .iter()
4983 .enumerate()
4984 .filter_map(|(index, column)| column.pinned.then_some(index)),
4985 )
4986 .collect::<Vec<_>>();
4987 ctx.push_clip_rect(header);
4988 for index in paint_order {
4989 let column = &self.columns[index];
4990 let cell = header_cells[index];
4991 if cell.is_empty() {
4992 continue;
4993 }
4994 if index > 0 {
4995 let separator_inset = metrics
4996 .table_header_separator_inset
4997 .min(cell.height() * 0.5);
4998 ctx.stroke_rect(
4999 Rect::new(
5000 cell.x(),
5001 cell.y() + separator_inset,
5002 metrics.table_separator_width,
5003 (cell.height() - (separator_inset * 2.0)).max(0.0),
5004 ),
5005 palette.border,
5006 sui_scene::StrokeStyle::new(metrics.table_separator_width.max(1.0)),
5007 );
5008 }
5009 let title = match column.sort_direction {
5010 Some(VirtualTableSortDirection::Ascending) => format!("{} ^", column.title),
5011 Some(VirtualTableSortDirection::Descending) => format!("{} v", column.title),
5012 None => column.title.clone(),
5013 };
5014 draw_aligned_text(
5015 ctx,
5016 horizontal_inset_rect(cell, metrics.table_cell_padding),
5017 &title,
5018 &header_style,
5019 column.alignment,
5020 );
5021 }
5022 ctx.pop_clip();
5023
5024 ctx.push_clip_rect(body);
5025 for row_index in self.visible_row_range(body) {
5026 let row_rect = self.row_rect(body, row_index);
5027 let row_selected = selected == Some(row_index);
5028 let row_hovered = self.hovered_row == Some(row_index);
5029 let row_pressed = self.pressed_row == Some(row_index);
5030 paint_data_row_state(
5031 ctx,
5032 row_rect,
5033 body,
5034 &theme,
5035 row_selected,
5036 row_hovered as u8 as f32,
5037 row_pressed as u8 as f32,
5038 );
5039 let columns = self.column_rects(row_rect);
5040 if let Some(painter) = &self.row_painter {
5041 let row = VirtualTableRowContext {
5042 row_index,
5043 row_key: self.resolved_row_key(row_index),
5044 row_rect,
5045 column_rects: &columns,
5046 selected: row_selected,
5047 hovered: row_hovered,
5048 pressed: row_pressed,
5049 };
5050 painter(ctx, &row);
5051 }
5052 }
5053 ctx.pop_clip();
5054
5055 draw_vertical_scroll_thumb(
5056 ctx,
5057 &theme,
5058 body,
5059 self.content_height(),
5060 self.scroll_y,
5061 palette.placeholder,
5062 );
5063 }
5064
5065 fn semantics(&self, ctx: &mut SemanticsCtx) {
5066 let window = self.normalized_window();
5067 let total_count = window.total_count;
5068 let described_count = total_count.unwrap_or(window.loaded_range.end);
5069 let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::Table, ctx.bounds());
5070 node.name = Some(self.name.clone());
5071 node.state.focused = ctx.is_focused();
5072 node.value = Some(SemanticsValue::Text(match total_count {
5073 Some(total_count) => format!("{total_count} rows"),
5074 None => format!("{} loaded rows", self.row_count),
5075 }));
5076 let columns = self
5077 .columns
5078 .iter()
5079 .filter_map(|column| {
5080 let title = column.title.trim();
5081 (!title.is_empty()).then(|| title.to_string())
5082 })
5083 .collect::<Vec<_>>();
5084 if !columns.is_empty() {
5085 let visible = self.viewport_row_range(self.body_rect(ctx.bounds()));
5086 let visible_start = window
5087 .loaded_range
5088 .start
5089 .saturating_add(visible.start)
5090 .saturating_add(1)
5091 .min(described_count);
5092 let visible_end = window
5093 .loaded_range
5094 .start
5095 .saturating_add(visible.end)
5096 .min(described_count);
5097 node.description = Some(match total_count {
5098 Some(total_count) => format!(
5099 "Columns: {}; showing rows {} through {} of {}",
5100 columns.join(", "),
5101 visible_start,
5102 visible_end,
5103 total_count,
5104 ),
5105 None => format!(
5106 "Columns: {}; showing loaded rows {} through {}",
5107 columns.join(", "),
5108 visible_start,
5109 visible_end,
5110 ),
5111 });
5112 }
5113 node.actions = vec![
5114 SemanticsAction::Focus,
5115 SemanticsAction::Increment,
5116 SemanticsAction::Decrement,
5117 SemanticsAction::SetValue,
5118 ];
5119 ctx.push(node);
5120
5121 let body = self.body_rect(ctx.bounds());
5122 let selected = self.resolved_selected();
5123 for row_index in self.visible_row_range(body) {
5124 let row_rect = self.row_rect(body, row_index);
5125 let row_key = self.resolved_row_key(row_index);
5126 let dataset_index = window.loaded_range.start.saturating_add(row_index);
5127 let mut row = SemanticsNode::new(
5128 virtual_table_row_id(ctx.widget_id(), row_key),
5129 SemanticsRole::ListItem,
5130 row_rect,
5131 );
5132 row.parent = Some(ctx.widget_id());
5133 row.name = self.row_name.as_ref().map(|name| name(row_index));
5134 row.description = self
5135 .row_description
5136 .as_ref()
5137 .map(|description| {
5138 let position = match total_count {
5139 Some(total_count) => {
5140 format!("row {} of {}", dataset_index + 1, total_count)
5141 }
5142 None => format!("loaded row {}", dataset_index + 1),
5143 };
5144 format!("{}; {}", description(row_index), position)
5145 })
5146 .or_else(|| {
5147 Some(match total_count {
5148 Some(total_count) => {
5149 format!("Row {} of {}", dataset_index + 1, total_count)
5150 }
5151 None => format!("Loaded row {}", dataset_index + 1),
5152 })
5153 });
5154 row.state.selected = selected == Some(row_index);
5155 row.state.hovered = self.hovered_row == Some(row_index);
5156 row.actions = vec![SemanticsAction::Activate];
5157 ctx.push(row);
5158 }
5159 }
5160
5161 fn accepts_focus(&self) -> bool {
5162 true
5163 }
5164
5165 fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
5166 let theme = self.resolved_theme();
5167 set_focus_animation_target(&mut self.focus_animation, focused as u8 as f32, &theme, ctx);
5168 ctx.request_paint();
5169 ctx.request_semantics();
5170 }
5171}
5172
5173#[derive(Debug, Clone, PartialEq)]
5174pub struct BreadcrumbItem {
5175 label: String,
5176}
5177
5178impl BreadcrumbItem {
5179 pub fn new(label: impl Into<String>) -> Self {
5180 Self {
5181 label: label.into(),
5182 }
5183 }
5184}
5185
5186pub type PathBar = Breadcrumb;
5187
5188pub struct Breadcrumb {
5189 theme: Box<DefaultTheme>,
5190 theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
5191 name: String,
5192 name_reader: Option<Box<dyn Fn() -> String>>,
5193 items: Vec<BreadcrumbItem>,
5194 current: usize,
5195 current_reader: Option<Box<dyn Fn() -> Option<usize>>>,
5196 focused_index: usize,
5197 hovered: Option<usize>,
5198 pressed: Option<usize>,
5199 hover_motion: IndexedInteractionMotion<usize>,
5200 press_motion: IndexedInteractionMotion<usize>,
5201 focus_animation: AnimatedScalar,
5202 measured_widths: Vec<f32>,
5203 content_width: f32,
5204 scroll_x: f32,
5205 auto_scroll_to_end: bool,
5206 drag_anchor: Option<(Point, f32)>,
5207 drag_moved: bool,
5208 on_activate: Option<Box<dyn FnMut(usize, String)>>,
5209}
5210
5211impl Breadcrumb {
5212 pub fn new(name: impl Into<String>) -> Self {
5213 Self {
5214 theme: Box::new(DefaultTheme::default()),
5215 theme_reader: None,
5216 name: name.into(),
5217 name_reader: None,
5218 items: Vec::new(),
5219 current: 0,
5220 current_reader: None,
5221 focused_index: 0,
5222 hovered: None,
5223 pressed: None,
5224 hover_motion: IndexedInteractionMotion::new(),
5225 press_motion: IndexedInteractionMotion::new(),
5226 focus_animation: AnimatedScalar::new(0.0),
5227 measured_widths: Vec::new(),
5228 content_width: 0.0,
5229 scroll_x: 0.0,
5230 auto_scroll_to_end: true,
5231 drag_anchor: None,
5232 drag_moved: false,
5233 on_activate: None,
5234 }
5235 }
5236
5237 pub fn theme(mut self, theme: DefaultTheme) -> Self {
5238 self.theme = Box::new(theme);
5239 self.theme_reader = None;
5240 self
5241 }
5242
5243 pub fn theme_when<F>(mut self, theme: F) -> Self
5244 where
5245 F: Fn() -> DefaultTheme + 'static,
5246 {
5247 self.theme_reader = Some(Box::new(theme));
5248 self
5249 }
5250
5251 pub fn item(mut self, item: BreadcrumbItem) -> Self {
5252 self.items.push(item);
5253 self
5254 }
5255
5256 pub fn items<I>(mut self, items: I) -> Self
5257 where
5258 I: IntoIterator<Item = BreadcrumbItem>,
5259 {
5260 self.items.extend(items);
5261 self
5262 }
5263
5264 pub fn current(mut self, current: usize) -> Self {
5265 self.current = current;
5266 self.current_reader = None;
5267 self.focused_index = current;
5268 self
5269 }
5270
5271 pub fn name_when<F>(mut self, name: F) -> Self
5272 where
5273 F: Fn() -> String + 'static,
5274 {
5275 self.name_reader = Some(Box::new(name));
5276 self
5277 }
5278
5279 pub fn current_when<F>(mut self, current: F) -> Self
5280 where
5281 F: Fn() -> Option<usize> + 'static,
5282 {
5283 self.current_reader = Some(Box::new(current));
5284 self
5285 }
5286
5287 pub fn on_activate<F>(mut self, on_activate: F) -> Self
5288 where
5289 F: FnMut(usize, String) + 'static,
5290 {
5291 self.on_activate = Some(Box::new(on_activate));
5292 self
5293 }
5294
5295 fn normalized_current(&self) -> usize {
5296 let current = self
5297 .current_reader
5298 .as_ref()
5299 .and_then(|reader| reader())
5300 .unwrap_or(self.current);
5301 if self.items.is_empty() {
5302 0
5303 } else {
5304 current.min(self.items.len() - 1)
5305 }
5306 }
5307
5308 fn name(&self) -> String {
5309 self.name_reader
5310 .as_ref()
5311 .map(|reader| reader())
5312 .unwrap_or_else(|| self.name.clone())
5313 }
5314
5315 fn resolved_theme(&self) -> DefaultTheme {
5316 self.theme_reader
5317 .as_ref()
5318 .map(|theme| theme())
5319 .unwrap_or(*self.theme)
5320 }
5321
5322 fn activate(&mut self, index: usize) {
5323 if index >= self.items.len() {
5324 return;
5325 }
5326 self.current = index;
5327 self.focused_index = index;
5328 if let Some(on_activate) = &mut self.on_activate {
5329 on_activate(index, self.items[index].label.clone());
5330 }
5331 }
5332
5333 fn max_scroll_x(&self, bounds: Rect) -> f32 {
5334 (self.content_width - bounds.width()).max(0.0)
5335 }
5336
5337 fn content_overflows(&self, bounds: Rect) -> bool {
5338 self.max_scroll_x(bounds) > 0.5
5339 }
5340
5341 fn sync_scroll_to_bounds(&mut self, bounds: Rect) {
5342 let max_scroll = self.max_scroll_x(bounds);
5343 self.scroll_x = if self.auto_scroll_to_end {
5344 max_scroll
5345 } else {
5346 self.scroll_x.clamp(0.0, max_scroll)
5347 };
5348 }
5349
5350 fn set_scroll_x(&mut self, bounds: Rect, next_scroll_x: f32) -> bool {
5351 let max_scroll = self.max_scroll_x(bounds);
5352 let next_scroll_x = next_scroll_x.clamp(0.0, max_scroll);
5353 if (self.scroll_x - next_scroll_x).abs() <= 0.5 {
5354 return false;
5355 }
5356
5357 self.scroll_x = next_scroll_x;
5358 self.auto_scroll_to_end = false;
5359 true
5360 }
5361
5362 fn wheel_scroll_delta(delta: Vector) -> f32 {
5363 if delta.x.abs() > 0.0 {
5364 -delta.x
5365 } else {
5366 -delta.y
5367 }
5368 }
5369
5370 fn item_rect(&self, bounds: Rect, index: usize) -> Option<Rect> {
5371 let widths = &self.measured_widths;
5372 if index >= widths.len() {
5373 return None;
5374 }
5375 let theme = self.resolved_theme();
5376 let padding = theme.metrics.breadcrumb_item_padding;
5377 let gap = theme.metrics.breadcrumb_gap;
5378 let mut x = bounds.x() + padding.left - self.scroll_x;
5379 for (current, width) in widths.iter().enumerate() {
5380 let rect = Rect::new(
5381 x,
5382 bounds.y() + padding.top,
5383 *width,
5384 (bounds.height() - padding.top - padding.bottom).max(0.0),
5385 );
5386 if current == index {
5387 return Some(rect);
5388 }
5389 x += *width + gap;
5390 }
5391 None
5392 }
5393
5394 fn item_at(&self, bounds: Rect, position: Point) -> Option<usize> {
5395 if !bounds.contains(position) {
5396 return None;
5397 }
5398
5399 (0..self.items.len()).find(|index| {
5400 self.item_rect(bounds, *index)
5401 .is_some_and(|rect| rect.contains(position))
5402 })
5403 }
5404
5405 fn set_hovered(&mut self, hovered: Option<usize>, ctx: &mut EventCtx) {
5406 if self.hovered == hovered {
5407 return;
5408 }
5409
5410 self.hovered = hovered;
5411 let theme = self.resolved_theme();
5412 self.hover_motion.set_hover_target(hovered, &theme, ctx);
5413 ctx.request_paint();
5414 ctx.request_semantics();
5415 }
5416
5417 fn set_pressed(&mut self, pressed: Option<usize>, ctx: &mut EventCtx) {
5418 if self.pressed == pressed {
5419 return;
5420 }
5421
5422 self.pressed = pressed;
5423 let theme = self.resolved_theme();
5424 self.press_motion.set_press_target(pressed, &theme, ctx);
5425 ctx.request_paint();
5426 ctx.request_semantics();
5427 }
5428
5429 fn advance_animations(&mut self, time: f64, ctx: &mut EventCtx) {
5430 let (hover_changed, hover_active) = self.hover_motion.advance(time);
5431 let (press_changed, press_active) = self.press_motion.advance(time);
5432 let (focus_changed, focus_active) = advance_scalar(&mut self.focus_animation, time);
5433
5434 if hover_changed || press_changed || focus_changed {
5435 ctx.request_paint();
5436 }
5437 if hover_active || press_active || focus_active {
5438 ctx.request_animation_frame();
5439 }
5440 }
5441}
5442
5443impl Widget for Breadcrumb {
5444 fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
5445 match event {
5446 Event::Pointer(pointer) if pointer.kind == PointerEventKind::Move => {
5447 if pointer.buttons.contains(PointerButton::Primary)
5448 && let Some((anchor_position, anchor_scroll_x)) = self.drag_anchor
5449 {
5450 let bounds = ctx.bounds();
5451 if self.content_overflows(bounds) {
5452 let next_scroll_x =
5453 anchor_scroll_x - (pointer.position.x - anchor_position.x);
5454 if self.set_scroll_x(bounds, next_scroll_x) {
5455 self.drag_moved = true;
5456 self.set_pressed(None, ctx);
5457 ctx.request_paint();
5458 ctx.request_semantics();
5459 ctx.set_handled();
5460 }
5461
5462 if (pointer.position.x - anchor_position.x).abs() > 3.0 {
5463 self.drag_moved = true;
5464 }
5465 }
5466 }
5467
5468 let hovered = self.item_at(ctx.bounds(), pointer.position);
5469 self.set_hovered(hovered, ctx);
5470 }
5471 Event::Pointer(pointer) if pointer.kind == PointerEventKind::Scroll => {
5472 let bounds = ctx.bounds();
5473 if bounds.contains(pointer.position) && self.content_overflows(bounds) {
5474 let delta = pointer
5475 .scroll_delta
5476 .map(scroll_delta_to_offset)
5477 .unwrap_or(pointer.delta);
5478 if self.set_scroll_x(bounds, self.scroll_x + Self::wheel_scroll_delta(delta)) {
5479 let hovered = self.item_at(bounds, pointer.position);
5480 self.set_hovered(hovered, ctx);
5481 ctx.request_paint();
5482 ctx.request_semantics();
5483 ctx.set_handled();
5484 }
5485 }
5486 }
5487 Event::Pointer(pointer)
5488 if pointer.kind == PointerEventKind::Down
5489 && pointer.button == Some(PointerButton::Primary) =>
5490 {
5491 let pressed = self.item_at(ctx.bounds(), pointer.position);
5492 self.drag_anchor = Some((pointer.position, self.scroll_x));
5493 self.drag_moved = false;
5494 self.set_hovered(pressed, ctx);
5495 self.set_pressed(pressed, ctx);
5496 ctx.request_focus();
5497 ctx.request_pointer_capture(pointer.pointer_id);
5498 ctx.set_handled();
5499 }
5500 Event::Pointer(pointer)
5501 if pointer.kind == PointerEventKind::Up
5502 && pointer.button == Some(PointerButton::Primary) =>
5503 {
5504 let hovered = self.item_at(ctx.bounds(), pointer.position);
5505 if !self.drag_moved
5506 && let Some(index) = self
5507 .pressed
5508 .zip(hovered)
5509 .filter(|(pressed, hovered)| pressed == hovered)
5510 .map(|(index, _)| index)
5511 {
5512 self.activate(index);
5513 }
5514 self.set_hovered(hovered, ctx);
5515 self.set_pressed(None, ctx);
5516 self.drag_anchor = None;
5517 self.drag_moved = false;
5518 ctx.release_pointer_capture(pointer.pointer_id);
5519 ctx.set_handled();
5520 }
5521 Event::Pointer(pointer) if pointer.kind == PointerEventKind::Leave => {
5522 if self.drag_anchor.is_none() {
5523 self.set_hovered(None, ctx);
5524 }
5525 }
5526 Event::Pointer(pointer) if pointer.kind == PointerEventKind::Cancel => {
5527 if self.pressed.is_some() || self.drag_anchor.is_some() {
5528 self.set_pressed(None, ctx);
5529 self.set_hovered(None, ctx);
5530 self.drag_anchor = None;
5531 self.drag_moved = false;
5532 ctx.release_pointer_capture(pointer.pointer_id);
5533 ctx.set_handled();
5534 }
5535 }
5536 Event::Wake(WakeEvent::AnimationFrame { time, .. }) => {
5537 self.advance_animations(*time, ctx);
5538 }
5539 Event::Keyboard(key) if ctx.is_focused() && key.state == KeyState::Pressed => {
5540 if self.items.is_empty() {
5541 return;
5542 }
5543 match key.key.as_str() {
5544 "ArrowLeft" => {
5545 self.focused_index = self.focused_index.saturating_sub(1);
5546 }
5547 "ArrowRight" => {
5548 self.focused_index = (self.focused_index + 1).min(self.items.len() - 1);
5549 }
5550 "Enter" | " " => self.activate(self.focused_index),
5551 "Home" => self.focused_index = 0,
5552 "End" => self.focused_index = self.items.len() - 1,
5553 _ => return,
5554 }
5555 ctx.request_paint();
5556 ctx.request_semantics();
5557 ctx.set_handled();
5558 }
5559 _ => {}
5560 }
5561 }
5562
5563 fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
5564 let theme = self.resolved_theme();
5565 let text_style = theme.body_text_style();
5566 self.measured_widths = self
5567 .items
5568 .iter()
5569 .map(|item| {
5570 measure_text(ctx, &item.label, &text_style).width
5571 + theme.metrics.breadcrumb_item_padding.left
5572 + theme.metrics.breadcrumb_item_padding.right
5573 })
5574 .collect();
5575 let desired_width = self.measured_widths.iter().sum::<f32>()
5576 + (self.items.len().saturating_sub(1) as f32 * theme.metrics.breadcrumb_gap)
5577 + theme.metrics.breadcrumb_item_padding.left
5578 + theme.metrics.breadcrumb_item_padding.right;
5579 if (self.content_width - desired_width).abs() > 0.5 {
5580 self.content_width = desired_width;
5581 self.auto_scroll_to_end = true;
5582 }
5583 constraints.clamp(Size::new(
5584 desired_width.max(180.0),
5585 theme.metrics.breadcrumb_height,
5586 ))
5587 }
5588
5589 fn arrange(&mut self, _ctx: &mut ArrangeCtx, bounds: Rect) {
5590 self.sync_scroll_to_bounds(bounds);
5591 }
5592
5593 fn paint(&self, ctx: &mut PaintCtx) {
5594 let theme = self.resolved_theme();
5595 let palette = theme.palette;
5596 let bounds = ctx.bounds();
5597 draw_surface(ctx, bounds, &theme, self.focus_animation.value);
5598
5599 ctx.push_clip_rect(bounds);
5600 for (index, item) in self.items.iter().enumerate() {
5601 let Some(rect) = self.item_rect(bounds, index) else {
5602 continue;
5603 };
5604 if rect.max_x() < bounds.x() || rect.x() > bounds.max_x() {
5605 continue;
5606 }
5607
5608 let current = self.normalized_current() == index;
5609 let focused = ctx.is_focused() && self.focused_index == index;
5610 let hover_amount = self.hover_motion.amount_for(&index);
5611 let press_amount = self.press_motion.amount_for(&index);
5612
5613 if current
5614 || focused
5615 || hover_amount > AnimatedScalar::EPSILON
5616 || press_amount > AnimatedScalar::EPSILON
5617 {
5618 ctx.fill(
5619 rounded_rect_path(rect, theme.metrics.corner_radius),
5620 data_row_state_fill(&theme, current || focused, hover_amount, press_amount),
5621 );
5622 }
5623
5624 let style = theme.body_text_style();
5625 draw_aligned_text(
5626 ctx,
5627 horizontal_inset_rect(rect, 8.0),
5628 &item.label,
5629 &style,
5630 TableColumnAlignment::Start,
5631 );
5632
5633 if index + 1 < self.items.len() {
5634 let separator = chevron_path(Rect::new(
5635 rect.max_x()
5636 + ((theme.metrics.breadcrumb_gap
5637 - theme.metrics.breadcrumb_separator_size)
5638 * 0.5)
5639 .max(0.0),
5640 rect.y() + ((rect.height() - theme.metrics.breadcrumb_separator_size) * 0.5),
5641 theme.metrics.breadcrumb_separator_size,
5642 theme.metrics.breadcrumb_separator_size,
5643 ));
5644 ctx.stroke(
5645 separator,
5646 palette.placeholder.with_alpha(0.9),
5647 sui_scene::StrokeStyle::new(1.5),
5648 );
5649 }
5650 }
5651 ctx.pop_clip();
5652 }
5653
5654 fn semantics(&self, ctx: &mut SemanticsCtx) {
5655 let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::Breadcrumb, ctx.bounds());
5656 node.name = Some(self.name());
5657 node.state.focused = ctx.is_focused();
5658 node.value = self
5659 .items
5660 .get(self.normalized_current())
5661 .map(|item| SemanticsValue::Text(item.label.clone()));
5662 node.actions = vec![SemanticsAction::Focus, SemanticsAction::SetValue];
5663 ctx.push(node);
5664 }
5665
5666 fn accepts_focus(&self) -> bool {
5667 true
5668 }
5669
5670 fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
5671 let theme = self.resolved_theme();
5672 set_focus_animation_target(&mut self.focus_animation, focused as u8 as f32, &theme, ctx);
5673 ctx.request_paint();
5674 ctx.request_semantics();
5675 }
5676}
5677
5678#[derive(Debug, Clone, PartialEq)]
5679struct TreeRow {
5680 key: u64,
5681 path: Vec<usize>,
5682 depth: usize,
5683 label: String,
5684 detail: Option<String>,
5685 has_children: bool,
5686 expanded: bool,
5687 disabled: bool,
5688}
5689
5690fn flatten_tree(items: &[TreeItem], depth: usize, path: &mut Vec<usize>, rows: &mut Vec<TreeRow>) {
5691 for (index, item) in items.iter().enumerate() {
5692 path.push(index);
5693 rows.push(TreeRow {
5694 key: item.key.unwrap_or_else(|| tree_path_key(path.as_slice())),
5695 path: path.clone(),
5696 depth,
5697 label: item.label.clone(),
5698 detail: item.detail.clone(),
5699 has_children: !item.children.is_empty(),
5700 expanded: item.expanded,
5701 disabled: item.disabled,
5702 });
5703 if item.expanded {
5704 flatten_tree(&item.children, depth + 1, path, rows);
5705 }
5706 path.pop();
5707 }
5708}
5709
5710fn tree_path_key(path: &[usize]) -> u64 {
5711 path.iter().fold(0xcbf2_9ce4_8422_2325, |hash, index| {
5712 (hash ^ (*index as u64).wrapping_add(1)).wrapping_mul(0x1000_0000_01b3)
5713 })
5714}
5715
5716fn tree_view_row_id(parent: WidgetId, key: u64) -> WidgetId {
5717 const TAG: u64 = 8_u64 << 50;
5718 const LOW_MASK: u64 = (1_u64 << 50) - 1;
5719 let mixed = key
5720 .wrapping_add(parent.get().rotate_left(23))
5721 .wrapping_mul(0x9e37_79b9_7f4a_7c15);
5722 WidgetId::new(TAG | ((mixed ^ (mixed >> 29)) & LOW_MASK))
5723}
5724
5725fn tree_item<'a>(items: &'a [TreeItem], path: &[usize]) -> Option<&'a TreeItem> {
5726 let (first, rest) = path.split_first()?;
5727 let item = items.get(*first)?;
5728 if rest.is_empty() {
5729 Some(item)
5730 } else {
5731 tree_item(&item.children, rest)
5732 }
5733}
5734
5735fn tree_item_mut<'a>(items: &'a mut [TreeItem], path: &[usize]) -> Option<&'a mut TreeItem> {
5736 let (first, rest) = path.split_first()?;
5737 let item = items.get_mut(*first)?;
5738 if rest.is_empty() {
5739 Some(item)
5740 } else {
5741 tree_item_mut(&mut item.children, rest)
5742 }
5743}
5744
5745fn disclosure_rect(theme: &DefaultTheme, row: Rect, depth: usize) -> Rect {
5746 let metrics = theme.metrics;
5747 Rect::new(
5748 row.x() + metrics.data_row_padding.left + depth as f32 * metrics.tree_indent,
5749 row.y() + ((row.height() - metrics.tree_disclosure_size) * 0.5),
5750 metrics.tree_disclosure_size,
5751 metrics.tree_disclosure_size,
5752 )
5753}
5754
5755fn tree_label_offset(theme: &DefaultTheme, depth: usize) -> f32 {
5756 theme.metrics.data_row_padding.left
5757 + depth as f32 * theme.metrics.tree_indent
5758 + theme.metrics.tree_disclosure_size
5759 + theme.metrics.tree_disclosure_gap
5760}
5761
5762fn disclosure_path(rect: Rect, expanded: bool) -> Path {
5763 let mut builder = PathBuilder::new();
5764 if expanded {
5765 builder
5766 .move_to(Point::new(rect.x(), rect.y() + 2.0))
5767 .line_to(Point::new(rect.max_x(), rect.y() + 2.0))
5768 .line_to(Point::new(
5769 rect.x() + (rect.width() * 0.5),
5770 rect.max_y() - 2.0,
5771 ))
5772 .close();
5773 } else {
5774 builder
5775 .move_to(Point::new(rect.x() + 2.0, rect.y()))
5776 .line_to(Point::new(
5777 rect.max_x() - 2.0,
5778 rect.y() + (rect.height() * 0.5),
5779 ))
5780 .line_to(Point::new(rect.x() + 2.0, rect.max_y()))
5781 .close();
5782 }
5783 builder.build()
5784}
5785
5786fn chevron_path(rect: Rect) -> Path {
5787 let mut builder = PathBuilder::new();
5788 builder
5789 .move_to(Point::new(rect.x(), rect.y()))
5790 .line_to(Point::new(rect.max_x(), rect.y() + (rect.height() * 0.5)))
5791 .line_to(Point::new(rect.x(), rect.max_y()));
5792 builder.build()
5793}
5794
5795pub(crate) fn draw_surface(
5796 ctx: &mut PaintCtx,
5797 rect: Rect,
5798 theme: &DefaultTheme,
5799 _focus_progress: f32,
5800) {
5801 let palette = theme.palette;
5802 let metrics = theme.metrics;
5803 ctx.fill(
5804 rounded_rect_path(rect, metrics.corner_radius),
5805 palette.surface,
5806 );
5807 ctx.stroke(
5808 rounded_rect_path(rect, metrics.corner_radius),
5809 palette.border,
5810 sui_scene::StrokeStyle::new(metrics.border_width.max(1.0)),
5811 );
5812}
5813
5814fn draw_vertical_scroll_thumb(
5815 ctx: &mut PaintCtx,
5816 theme: &DefaultTheme,
5817 viewport: Rect,
5818 content_height: f32,
5819 scroll_y: f32,
5820 color: Color,
5821) {
5822 if content_height <= viewport.height() || viewport.height() <= 0.0 {
5823 return;
5824 }
5825
5826 let ratio = (viewport.height() / content_height).clamp(0.08, 1.0);
5827 let metrics = theme.metrics;
5828 let thumb_height = (viewport.height() * ratio)
5829 .max(metrics.data_scroll_thumb_min_length)
5830 .min(viewport.height());
5831 let gutter_width =
5832 (ctx.bounds().max_x() - metrics.data_viewport_padding.right - viewport.max_x())
5833 .max(0.0)
5834 .min(metrics.scroll_bar_thickness);
5835 if gutter_width <= 0.0 {
5836 return;
5837 }
5838 let max_scroll = (content_height - viewport.height()).max(1.0);
5839 let thumb_y = viewport.y() + ((viewport.height() - thumb_height) * (scroll_y / max_scroll));
5840 let thumb_width = metrics.data_scroll_thumb_width.min(gutter_width).max(0.0);
5841 let thumb_inset = metrics
5842 .data_scroll_thumb_inset
5843 .min((gutter_width - thumb_width).max(0.0));
5844 ctx.fill(
5845 rounded_rect_path(
5846 Rect::new(
5847 viewport.max_x() + gutter_width - thumb_inset - thumb_width,
5848 thumb_y,
5849 thumb_width,
5850 thumb_height,
5851 ),
5852 metrics.data_scroll_thumb_radius,
5853 ),
5854 color.with_alpha(metrics.data_scroll_thumb_opacity),
5855 );
5856}
5857
5858fn draw_aligned_text(
5859 ctx: &mut PaintCtx,
5860 rect: Rect,
5861 text: &str,
5862 style: &TextStyle,
5863 alignment: TableColumnAlignment,
5864) {
5865 let horizontal_alignment = match alignment {
5866 TableColumnAlignment::Start => 0.0,
5867 TableColumnAlignment::Center => 0.5,
5868 TableColumnAlignment::End => 1.0,
5869 };
5870 ctx.push_clip_rect(rect);
5871 paint_aligned_text(
5872 ctx,
5873 rect,
5874 text,
5875 style,
5876 style.line_height,
5877 horizontal_alignment,
5878 );
5879 ctx.pop_clip();
5880}
5881
5882const TWO_LINE_ROW_TEXT_GAP: f32 = 2.0;
5883
5884fn row_text_rects(
5885 ctx: &PaintCtx,
5886 rect: Rect,
5887 primary_measurement: TextMeasurement,
5888 primary_line_height: f32,
5889 secondary_measurement: Option<TextMeasurement>,
5890 secondary_line_height: Option<f32>,
5891) -> (Rect, Option<Rect>) {
5892 match secondary_line_height {
5893 Some(secondary_line_height) => {
5894 let secondary_measurement = secondary_measurement.unwrap_or(primary_measurement);
5895 let primary_height = primary_line_height.max(primary_measurement.height);
5896 let secondary_height = secondary_line_height.max(secondary_measurement.height);
5897 let total_height = primary_height + secondary_height + TWO_LINE_ROW_TEXT_GAP;
5898 let top = rect.y() + ((rect.height() - total_height) * 0.5).max(0.0);
5899 let primary_rect = Rect::new(rect.x(), top, rect.width(), primary_height);
5900 let secondary_rect = Rect::new(
5901 rect.x(),
5902 top + primary_height + TWO_LINE_ROW_TEXT_GAP,
5903 rect.width(),
5904 secondary_height,
5905 );
5906 (
5907 Rect::new(
5908 primary_rect.x(),
5909 vertically_centered_text_rect_y(
5910 ctx,
5911 primary_rect,
5912 primary_measurement,
5913 primary_height,
5914 ),
5915 primary_rect.width(),
5916 primary_rect.height(),
5917 ),
5918 Some(Rect::new(
5919 secondary_rect.x(),
5920 vertically_centered_text_rect_y(
5921 ctx,
5922 secondary_rect,
5923 secondary_measurement,
5924 secondary_height,
5925 ),
5926 secondary_rect.width(),
5927 secondary_rect.height(),
5928 )),
5929 )
5930 }
5931 None => {
5932 let height = primary_line_height
5933 .max(primary_measurement.height)
5934 .min(rect.height());
5935 let y = vertically_centered_text_rect_y(ctx, rect, primary_measurement, height);
5936 (Rect::new(rect.x(), y, rect.width(), height), None)
5937 }
5938 }
5939}
5940
5941fn two_line_row_height(primary_line_height: f32, secondary_line_height: f32) -> f32 {
5942 primary_line_height + secondary_line_height + TWO_LINE_ROW_TEXT_GAP
5943}
5944
5945fn horizontal_inset_rect(rect: Rect, inset: f32) -> Rect {
5946 Rect::new(
5947 rect.x() + inset,
5948 rect.y(),
5949 (rect.width() - (inset * 2.0)).max(0.0),
5950 rect.height(),
5951 )
5952}
5953
5954fn estimate_text_width(text: &str, style: &TextStyle) -> f32 {
5955 text.chars().count() as f32 * style.font_size * 0.56
5956}
5957
5958fn numeric_text_style(mut style: TextStyle) -> TextStyle {
5959 style.features.enable(FontFeature::TABULAR_FIGURES);
5960 style
5961}
5962
5963#[derive(Clone, Copy, Debug, PartialEq)]
5964pub struct LeadingLabelCellPaint {
5965 pub icon: Option<IconGlyph>,
5966 pub icon_color: Option<Color>,
5967 pub label_color: Option<Color>,
5968 pub label_weight: FontWeight,
5969 pub padding_left: f32,
5970 pub padding_right: f32,
5971 pub icon_slot_side: Option<f32>,
5972 pub icon_inset: f32,
5973 pub gap: Option<f32>,
5974}
5975
5976impl LeadingLabelCellPaint {
5977 pub const fn new() -> Self {
5978 Self {
5979 icon: None,
5980 icon_color: None,
5981 label_color: None,
5982 label_weight: FontWeight::NORMAL,
5983 padding_left: 6.0,
5984 padding_right: 8.0,
5985 icon_slot_side: None,
5986 icon_inset: 2.0,
5987 gap: None,
5988 }
5989 }
5990
5991 pub const fn icon(mut self, icon: IconGlyph) -> Self {
5992 self.icon = Some(icon);
5993 self
5994 }
5995
5996 pub const fn icon_color(mut self, color: Color) -> Self {
5997 self.icon_color = Some(color);
5998 self
5999 }
6000
6001 pub const fn label_color(mut self, color: Color) -> Self {
6002 self.label_color = Some(color);
6003 self
6004 }
6005
6006 pub const fn label_weight(mut self, weight: FontWeight) -> Self {
6007 self.label_weight = weight;
6008 self
6009 }
6010
6011 pub const fn padding(mut self, left: f32, right: f32) -> Self {
6012 self.padding_left = left;
6013 self.padding_right = right;
6014 self
6015 }
6016
6017 pub const fn icon_slot_side(mut self, side: f32) -> Self {
6018 self.icon_slot_side = Some(side);
6019 self
6020 }
6021
6022 pub const fn icon_inset(mut self, inset: f32) -> Self {
6023 self.icon_inset = inset;
6024 self
6025 }
6026
6027 pub const fn gap(mut self, gap: f32) -> Self {
6028 self.gap = Some(gap);
6029 self
6030 }
6031}
6032
6033impl Default for LeadingLabelCellPaint {
6034 fn default() -> Self {
6035 Self::new()
6036 }
6037}
6038
6039#[derive(Clone, Copy, Debug, PartialEq)]
6040pub struct TextCellPaint {
6041 pub color: Option<Color>,
6042 pub weight: FontWeight,
6043 pub padding_left: f32,
6044 pub padding_right: f32,
6045 pub alignment: TableColumnAlignment,
6046 pub numeric: bool,
6047 pub text_token: Option<ThemeTextToken>,
6048}
6049
6050impl TextCellPaint {
6051 pub const fn new() -> Self {
6052 Self {
6053 color: None,
6054 weight: FontWeight::NORMAL,
6055 padding_left: 8.0,
6056 padding_right: 8.0,
6057 alignment: TableColumnAlignment::Start,
6058 numeric: false,
6059 text_token: None,
6060 }
6061 }
6062
6063 pub const fn color(mut self, color: Color) -> Self {
6064 self.color = Some(color);
6065 self
6066 }
6067
6068 pub const fn weight(mut self, weight: FontWeight) -> Self {
6069 self.weight = weight;
6070 self
6071 }
6072
6073 pub const fn padding(mut self, left: f32, right: f32) -> Self {
6074 self.padding_left = left;
6075 self.padding_right = right;
6076 self
6077 }
6078
6079 pub const fn alignment(mut self, alignment: TableColumnAlignment) -> Self {
6080 self.alignment = alignment;
6081 self
6082 }
6083
6084 pub const fn numeric(mut self) -> Self {
6085 self.numeric = true;
6086 self
6087 }
6088
6089 pub const fn text_token(mut self, token: ThemeTextToken) -> Self {
6090 self.text_token = Some(token);
6091 self
6092 }
6093}
6094
6095impl Default for TextCellPaint {
6096 fn default() -> Self {
6097 Self::new()
6098 }
6099}
6100
6101#[derive(Clone, Copy, Debug, PartialEq)]
6102pub struct TextBlockPaint {
6103 pub color: Option<Color>,
6104 pub weight: FontWeight,
6105 pub padding: Insets,
6106 pub text_token: Option<ThemeTextToken>,
6107 pub wrap: TextWrap,
6108 pub alignment: TextAlign,
6109}
6110
6111impl TextBlockPaint {
6112 pub const fn new() -> Self {
6113 Self {
6114 color: None,
6115 weight: FontWeight::NORMAL,
6116 padding: Insets::ZERO,
6117 text_token: None,
6118 wrap: TextWrap::Word,
6119 alignment: TextAlign::Start,
6120 }
6121 }
6122
6123 pub const fn color(mut self, color: Color) -> Self {
6124 self.color = Some(color);
6125 self
6126 }
6127
6128 pub const fn weight(mut self, weight: FontWeight) -> Self {
6129 self.weight = weight;
6130 self
6131 }
6132
6133 pub const fn padding(mut self, padding: Insets) -> Self {
6134 self.padding = padding;
6135 self
6136 }
6137
6138 pub const fn text_token(mut self, token: ThemeTextToken) -> Self {
6139 self.text_token = Some(token);
6140 self
6141 }
6142
6143 pub const fn wrap(mut self, wrap: TextWrap) -> Self {
6144 self.wrap = wrap;
6145 self
6146 }
6147
6148 pub const fn alignment(mut self, alignment: TextAlign) -> Self {
6149 self.alignment = alignment;
6150 self
6151 }
6152}
6153
6154impl Default for TextBlockPaint {
6155 fn default() -> Self {
6156 Self::new()
6157 }
6158}
6159
6160pub fn paint_leading_label_cell(
6161 ctx: &mut PaintCtx,
6162 theme: &DefaultTheme,
6163 rect: Rect,
6164 label: &str,
6165 style: LeadingLabelCellPaint,
6166) {
6167 if rect.width() <= 0.0 || rect.height() <= 0.0 {
6168 return;
6169 }
6170
6171 let mut text_x = rect.x() + style.padding_left.max(0.0);
6172 if let Some(icon) = style.icon {
6173 let slot_side = style
6174 .icon_slot_side
6175 .unwrap_or(theme.metrics.data_row_icon_size)
6176 .min((rect.height() - 6.0).max(0.0))
6177 .max(0.0);
6178 let icon_rect = Rect::new(
6179 text_x,
6180 rect.y() + ((rect.height() - slot_side) * 0.5).max(0.0),
6181 slot_side,
6182 slot_side,
6183 );
6184 let icon_inset = style.icon_inset.max(0.0).min(slot_side * 0.45);
6185 draw_icon_glyph(
6186 ctx,
6187 icon,
6188 icon_rect.inflate(-icon_inset, -icon_inset),
6189 style.icon_color.unwrap_or(theme.palette.text_muted),
6190 );
6191 text_x = icon_rect.max_x()
6192 + style
6193 .gap
6194 .unwrap_or(theme.metrics.data_row_icon_gap)
6195 .max(0.0);
6196 }
6197
6198 let label_rect = Rect::new(
6199 text_x,
6200 rect.y(),
6201 (rect.max_x() - text_x - style.padding_right.max(0.0)).max(0.0),
6202 rect.height(),
6203 );
6204 if label_rect.width() <= 0.0 {
6205 return;
6206 }
6207
6208 let mut label_style = TextStyle {
6209 font_size: theme.text.sm.size.max(1.0),
6210 line_height: theme.text.sm.line_height.max(1.0),
6211 color: style.label_color.unwrap_or(theme.palette.text),
6212 ..theme.body_text_style()
6213 };
6214 label_style.weight = style.label_weight;
6215
6216 ctx.push_clip_rect(label_rect);
6217 paint_aligned_text(
6218 ctx,
6219 label_rect,
6220 label,
6221 &label_style,
6222 label_style.line_height,
6223 0.0,
6224 );
6225 ctx.pop_clip();
6226}
6227
6228pub fn paint_text_block(
6229 ctx: &mut PaintCtx,
6230 theme: &DefaultTheme,
6231 rect: Rect,
6232 text: &str,
6233 style: TextBlockPaint,
6234) {
6235 if rect.width() <= 0.0 || rect.height() <= 0.0 {
6236 return;
6237 }
6238
6239 let content = Rect::new(
6240 rect.x() + style.padding.left.max(0.0),
6241 rect.y() + style.padding.top.max(0.0),
6242 (rect.width() - style.padding.left.max(0.0) - style.padding.right.max(0.0)).max(0.0),
6243 (rect.height() - style.padding.top.max(0.0) - style.padding.bottom.max(0.0)).max(0.0),
6244 );
6245 if content.width() <= 0.0 || content.height() <= 0.0 {
6246 return;
6247 }
6248
6249 let token = style.text_token.unwrap_or(theme.text.sm);
6250 let mut text_style = TextStyle {
6251 font_size: token.size.max(1.0),
6252 line_height: token.line_height.max(1.0),
6253 color: style.color.unwrap_or(theme.palette.text),
6254 ..theme.body_text_style()
6255 };
6256 text_style.weight = style.weight;
6257
6258 let color = text_style.color;
6259 let mut layout_style = text_style.clone();
6260 layout_style.color = Color::WHITE;
6261 let mut document = TextDocument::from_plain_text(text.to_string(), layout_style);
6262 for paragraph in &mut document.paragraphs {
6263 paragraph.style.align = style.alignment;
6264 paragraph.style.wrap = style.wrap;
6265 }
6266
6267 ctx.push_clip_rect(content);
6268 if let Ok(layout) = ctx.layout_text_document(TextLayoutRequest::new(document).with_box_size(
6269 Size::new(content.width().max(1.0), content.height().max(1.0)),
6270 )) {
6271 ctx.draw_text_layout_with_color(content.origin, &layout, color);
6272 } else {
6273 ctx.draw_text(content, text.to_string(), text_style);
6274 }
6275 ctx.pop_clip();
6276}
6277
6278pub fn paint_text_cell(
6279 ctx: &mut PaintCtx,
6280 theme: &DefaultTheme,
6281 rect: Rect,
6282 text: &str,
6283 style: TextCellPaint,
6284) {
6285 if rect.width() <= 0.0 || rect.height() <= 0.0 {
6286 return;
6287 }
6288
6289 let left = style.padding_left.max(0.0);
6290 let right = style.padding_right.max(0.0);
6291 let content = Rect::new(
6292 rect.x() + left,
6293 rect.y(),
6294 (rect.width() - left - right).max(0.0),
6295 rect.height(),
6296 );
6297 if content.width() <= 0.0 {
6298 return;
6299 }
6300
6301 let token = style.text_token.unwrap_or(theme.text.sm);
6302 let mut text_style = TextStyle {
6303 font_size: token.size.max(1.0),
6304 line_height: token.line_height.max(1.0),
6305 color: style.color.unwrap_or(theme.palette.text),
6306 ..theme.body_text_style()
6307 };
6308 text_style.weight = style.weight;
6309 if style.numeric {
6310 text_style = numeric_text_style(text_style);
6311 }
6312
6313 ctx.push_clip_rect(content);
6314 paint_aligned_text(
6315 ctx,
6316 content,
6317 text,
6318 &text_style,
6319 text_style.line_height,
6320 match style.alignment {
6321 TableColumnAlignment::Start => 0.0,
6322 TableColumnAlignment::Center => 0.5,
6323 TableColumnAlignment::End => 1.0,
6324 },
6325 );
6326 ctx.pop_clip();
6327}
6328
6329fn measure_list_item_leading_width(
6330 ctx: &mut MeasureCtx,
6331 item: &ListItem,
6332 style: &TextStyle,
6333 theme: &DefaultTheme,
6334) -> f32 {
6335 if item.leading_icon.is_some() {
6336 return theme.metrics.data_row_icon_size + theme.metrics.data_row_icon_gap;
6337 }
6338 item.leading_text
6339 .as_deref()
6340 .map(|text| measure_text(ctx, text, style).width + theme.metrics.data_row_icon_gap)
6341 .unwrap_or(0.0)
6342}
6343
6344fn measure_text(ctx: &mut MeasureCtx, text: &str, style: &TextStyle) -> TextMeasurement {
6345 ctx.layout()
6346 .measure_text(text.to_string(), style.clone())
6347 .unwrap_or(TextMeasurement {
6348 width: estimate_text_width(text, style),
6349 height: style.line_height,
6350 bounds: Rect::ZERO,
6351 ascent: style.font_size,
6352 descent: 0.0,
6353 cap_height: Some(style.font_size),
6354 })
6355}
6356
6357fn paint_text_measurement(ctx: &PaintCtx, text: &str, style: &TextStyle) -> TextMeasurement {
6358 ctx.measure_text(text.to_string(), style.clone())
6359 .unwrap_or(TextMeasurement {
6360 width: estimate_text_width(text, style),
6361 height: style.line_height,
6362 bounds: Rect::ZERO,
6363 ascent: style.font_size,
6364 descent: 0.0,
6365 cap_height: Some(style.font_size),
6366 })
6367}
6368
6369fn caption_style(theme: &DefaultTheme) -> TextStyle {
6370 TextStyle {
6371 font_size: theme.text.xs.size.max(1.0),
6372 line_height: theme.text.xs.line_height.max(1.0),
6373 color: theme.palette.placeholder,
6374 ..theme.body_text_style()
6375 }
6376}
6377
6378fn rounded_rect_path(rect: Rect, radius: f32) -> Path {
6379 let mut builder = PathBuilder::new();
6380 builder.push_rounded_rect(rect, radius);
6381 builder.build()
6382}
6383
6384fn row_highlight_rect(row: Rect, viewport: Rect) -> Option<Rect> {
6385 row.intersection(viewport)
6386 .map(|visible| inset_rect(visible, Insets::all(1.0)))
6387 .filter(|rect| !rect.is_empty())
6388}
6389
6390type AnimatedScalar = MotionScalar;
6391
6392fn set_animation_target(
6393 animation: &mut AnimatedScalar,
6394 target: f32,
6395 duration: f64,
6396 easing: crate::Easing,
6397 ctx: &mut EventCtx,
6398) -> bool {
6399 animation.set_target_event(target, duration, easing, ctx)
6400}
6401
6402fn set_hover_animation_target(
6403 animation: &mut AnimatedScalar,
6404 target: f32,
6405 theme: &DefaultTheme,
6406 ctx: &mut EventCtx,
6407) -> bool {
6408 set_animation_target(
6409 animation,
6410 target,
6411 theme.motion.hover_duration(),
6412 theme.motion.hover_easing(),
6413 ctx,
6414 )
6415}
6416
6417fn set_press_animation_target(
6418 animation: &mut AnimatedScalar,
6419 target: f32,
6420 theme: &DefaultTheme,
6421 ctx: &mut EventCtx,
6422) -> bool {
6423 set_animation_target(
6424 animation,
6425 target,
6426 theme.motion.press_duration(),
6427 theme.motion.press_easing(),
6428 ctx,
6429 )
6430}
6431
6432fn set_focus_animation_target(
6433 animation: &mut AnimatedScalar,
6434 target: f32,
6435 theme: &DefaultTheme,
6436 ctx: &mut EventCtx,
6437) -> bool {
6438 set_animation_target(
6439 animation,
6440 target,
6441 theme.motion.focus_duration(),
6442 theme.motion.focus_easing(),
6443 ctx,
6444 )
6445}
6446
6447fn advance_scalar(animation: &mut AnimatedScalar, time: f64) -> (bool, bool) {
6448 let previous = animation.value;
6449 let active = animation.advance(time);
6450 (animation.changed_since(previous), active)
6451}
6452
6453#[derive(Debug, Clone, PartialEq)]
6454struct IndexedInteractionMotion<T>
6455where
6456 T: Clone + PartialEq,
6457{
6458 visual: Option<T>,
6459 animation: AnimatedScalar,
6460}
6461
6462impl<T> IndexedInteractionMotion<T>
6463where
6464 T: Clone + PartialEq,
6465{
6466 const fn new() -> Self {
6467 Self {
6468 visual: None,
6469 animation: AnimatedScalar::new(0.0),
6470 }
6471 }
6472
6473 fn set_hover_target(
6474 &mut self,
6475 target: Option<T>,
6476 theme: &DefaultTheme,
6477 ctx: &mut EventCtx,
6478 ) -> bool {
6479 self.set_target(target, theme, ctx, |animation, target, theme, ctx| {
6480 set_hover_animation_target(animation, target, theme, ctx)
6481 })
6482 }
6483
6484 fn set_press_target(
6485 &mut self,
6486 target: Option<T>,
6487 theme: &DefaultTheme,
6488 ctx: &mut EventCtx,
6489 ) -> bool {
6490 self.set_target(target, theme, ctx, |animation, target, theme, ctx| {
6491 set_press_animation_target(animation, target, theme, ctx)
6492 })
6493 }
6494
6495 fn set_target(
6496 &mut self,
6497 target: Option<T>,
6498 theme: &DefaultTheme,
6499 ctx: &mut EventCtx,
6500 set_animation: impl FnOnce(&mut AnimatedScalar, f32, &DefaultTheme, &mut EventCtx) -> bool,
6501 ) -> bool {
6502 match target {
6503 Some(target) => {
6504 if self.visual.as_ref() != Some(&target) {
6505 self.visual = Some(target);
6506 self.animation = AnimatedScalar::new(0.0);
6507 }
6508 set_animation(&mut self.animation, 1.0, theme, ctx)
6509 }
6510 None => {
6511 let changed = set_animation(&mut self.animation, 0.0, theme, ctx);
6512 if !changed && !self.animation.is_presented() {
6513 self.visual = None;
6514 }
6515 changed
6516 }
6517 }
6518 }
6519
6520 fn amount_for(&self, key: &T) -> f32 {
6521 self.amount_for_by(|visual| visual == key)
6522 }
6523
6524 fn amount_for_by(&self, matches: impl FnOnce(&T) -> bool) -> f32 {
6525 self.visual
6526 .as_ref()
6527 .filter(|visual| matches(visual))
6528 .map(|_| self.animation.value)
6529 .unwrap_or(0.0)
6530 }
6531
6532 fn advance(&mut self, time: f64) -> (bool, bool) {
6533 let previous = self.animation.value;
6534 let active = self.animation.advance(time);
6535 let changed = self.animation.changed_since(previous);
6536 if !self.animation.is_presented() {
6537 self.visual = None;
6538 }
6539 (changed, active)
6540 }
6541}
6542
6543fn data_row_state_fill(
6544 theme: &DefaultTheme,
6545 selected: bool,
6546 hover_amount: f32,
6547 press_amount: f32,
6548) -> Color {
6549 let palette = theme.palette;
6550 let interaction = theme.interaction;
6551 if selected {
6552 palette.selection
6556 } else {
6557 let overlay = theme.surfaces.hover;
6558 let hover_alpha = overlay.alpha * interaction.hover_blend * hover_amount.clamp(0.0, 1.0);
6559 let press_alpha =
6560 overlay.alpha * 1.75 * interaction.pressed_blend * press_amount.clamp(0.0, 1.0);
6561 let alpha = hover_alpha.max(press_alpha).min(0.18);
6562 if alpha > AnimatedScalar::EPSILON {
6563 overlay.with_alpha(alpha)
6564 } else {
6565 Color::TRANSPARENT
6566 }
6567 }
6568}
6569
6570pub(crate) fn paint_data_row_state(
6571 ctx: &mut PaintCtx,
6572 row: Rect,
6573 viewport: Rect,
6574 theme: &DefaultTheme,
6575 selected: bool,
6576 hover_amount: f32,
6577 press_amount: f32,
6578) {
6579 if !selected
6580 && hover_amount <= AnimatedScalar::EPSILON
6581 && press_amount <= AnimatedScalar::EPSILON
6582 {
6583 return;
6584 }
6585
6586 let Some(highlight) = row_highlight_rect(row, viewport) else {
6587 return;
6588 };
6589 ctx.fill_rect(
6590 highlight,
6591 data_row_state_fill(theme, selected, hover_amount, press_amount),
6592 );
6593
6594 if selected {
6595 let indicator_width = 2.0_f32.min(highlight.width());
6596 let indicator_inset = (highlight.height() * 0.18).min(5.0);
6597 let indicator = Rect::new(
6598 highlight.x(),
6599 highlight.y() + indicator_inset,
6600 indicator_width,
6601 (highlight.height() - indicator_inset * 2.0).max(0.0),
6602 );
6603 if !indicator.is_empty() {
6604 ctx.fill(
6605 rounded_rect_path(indicator, indicator_width * 0.5),
6606 theme.palette.accent,
6607 );
6608 }
6609 }
6610}
6611
6612fn list_view_row_id(parent: WidgetId, index: usize) -> WidgetId {
6613 const TAG: u64 = 5_u64 << 50;
6614 const LOW_MASK: u64 = (1_u64 << 50) - 1;
6615
6616 WidgetId::new(
6617 TAG | (parent
6618 .get()
6619 .wrapping_mul(359)
6620 .wrapping_add(index as u64 + 1)
6621 & LOW_MASK),
6622 )
6623}
6624
6625fn virtual_table_row_id(parent: WidgetId, row_key: u64) -> WidgetId {
6626 const TAG: u64 = 7_u64 << 50;
6627 const LOW_MASK: u64 = (1_u64 << 50) - 1;
6628
6629 let mixed = row_key
6630 .wrapping_add(0x9e37_79b9_7f4a_7c15)
6631 .wrapping_add(parent.get().rotate_left(17));
6632 let mixed = (mixed ^ (mixed >> 30)).wrapping_mul(0xbf58_476d_1ce4_e5b9);
6633 let mixed = (mixed ^ (mixed >> 27)).wrapping_mul(0x94d0_49bb_1331_11eb);
6634 WidgetId::new(TAG | ((mixed ^ (mixed >> 31)) & LOW_MASK))
6635}
6636
6637fn layer_list_row_id(parent: WidgetId, index: usize) -> WidgetId {
6638 const TAG: u64 = 6_u64 << 50;
6639 const LOW_MASK: u64 = (1_u64 << 50) - 1;
6640
6641 WidgetId::new(
6642 TAG | (parent
6643 .get()
6644 .wrapping_mul(383)
6645 .wrapping_add(index as u64 + 1)
6646 & LOW_MASK),
6647 )
6648}
6649
6650fn layer_list_visibility_id(parent: WidgetId, index: usize) -> WidgetId {
6651 const TAG: u64 = 7_u64 << 50;
6652 const LOW_MASK: u64 = (1_u64 << 50) - 1;
6653
6654 WidgetId::new(
6655 TAG | (parent
6656 .get()
6657 .wrapping_mul(389)
6658 .wrapping_add(index as u64 + 1)
6659 & LOW_MASK),
6660 )
6661}
6662
6663fn layer_list_lock_id(parent: WidgetId, index: usize) -> WidgetId {
6664 const TAG: u64 = 4_u64 << 50;
6665 const LOW_MASK: u64 = (1_u64 << 50) - 1;
6666
6667 WidgetId::new(
6668 TAG | (parent
6669 .get()
6670 .wrapping_mul(397)
6671 .wrapping_add(index as u64 + 1)
6672 & LOW_MASK),
6673 )
6674}
6675
6676fn paint_layer_visibility_button(
6677 ctx: &mut PaintCtx,
6678 rect: Rect,
6679 theme: &DefaultTheme,
6680 visible: bool,
6681 hover_amount: f32,
6682 press_amount: f32,
6683) {
6684 let palette = theme.palette;
6685 if hover_amount > AnimatedScalar::EPSILON || press_amount > AnimatedScalar::EPSILON {
6686 ctx.fill(
6687 rounded_rect_path(rect, theme.metrics.corner_radius.min(rect.height() * 0.35)),
6688 data_row_state_fill(theme, false, hover_amount, press_amount),
6689 );
6690 }
6691
6692 let metrics = theme.metrics;
6693 let icon = inset_rect(rect, Insets::all(metrics.layer_action_icon_inset));
6694 let color = if visible {
6695 palette.accent
6696 } else {
6697 palette.placeholder
6698 };
6699 ctx.stroke(
6700 layer_visibility_eye_path(icon),
6701 color,
6702 sui_scene::StrokeStyle::new(metrics.layer_visibility_stroke_width),
6703 );
6704 if visible {
6705 ctx.fill(
6706 Path::circle(
6707 Point::new(
6708 icon.x() + icon.width() * 0.5,
6709 icon.y() + icon.height() * 0.5,
6710 ),
6711 icon.width().min(icon.height()) * 0.17,
6712 ),
6713 color,
6714 );
6715 } else {
6716 ctx.stroke(
6717 line_path(
6718 Point::new(
6719 icon.x() + icon.width() * 0.1,
6720 icon.max_y() - icon.height() * 0.05,
6721 ),
6722 Point::new(
6723 icon.max_x() - icon.width() * 0.1,
6724 icon.y() + icon.height() * 0.05,
6725 ),
6726 ),
6727 color,
6728 sui_scene::StrokeStyle::new(metrics.layer_visibility_slash_stroke_width),
6729 );
6730 }
6731}
6732
6733fn paint_layer_lock_button(
6734 ctx: &mut PaintCtx,
6735 rect: Rect,
6736 theme: &DefaultTheme,
6737 locked: bool,
6738 hover_amount: f32,
6739 press_amount: f32,
6740) {
6741 let palette = theme.palette;
6742 if hover_amount > AnimatedScalar::EPSILON || press_amount > AnimatedScalar::EPSILON {
6743 ctx.fill(
6744 rounded_rect_path(rect, theme.metrics.corner_radius.min(rect.height() * 0.35)),
6745 data_row_state_fill(theme, false, hover_amount, press_amount),
6746 );
6747 }
6748
6749 let metrics = theme.metrics;
6750 draw_icon_glyph(
6751 ctx,
6752 if locked {
6753 IconGlyph::Lock
6754 } else {
6755 IconGlyph::Unlock
6756 },
6757 inset_rect(rect, Insets::all(metrics.layer_lock_icon_inset)),
6758 if locked {
6759 palette.accent
6760 } else {
6761 palette.placeholder
6762 },
6763 );
6764}
6765
6766fn paint_layer_thumbnail(
6767 ctx: &mut PaintCtx,
6768 rect: Rect,
6769 theme: &DefaultTheme,
6770 color: Color,
6771 visible: bool,
6772) {
6773 let palette = theme.palette;
6774 let metrics = theme.metrics;
6775 let radius = metrics.layer_thumbnail_radius;
6776 ctx.fill(rounded_rect_path(rect, radius), palette.control_hover);
6777 let fill = inset_rect(rect, Insets::all(metrics.layer_thumbnail_inset));
6778 ctx.fill(
6779 rounded_rect_path(
6780 fill,
6781 (radius - metrics.layer_thumbnail_inset * 0.5).max(0.0),
6782 ),
6783 if visible {
6784 color
6785 } else {
6786 color.with_alpha(color.alpha * metrics.layer_thumbnail_disabled_opacity)
6787 },
6788 );
6789 ctx.stroke(
6790 rounded_rect_path(rect, radius),
6791 palette.border.with_alpha(if visible {
6792 1.0
6793 } else {
6794 metrics.layer_thumbnail_disabled_border_opacity
6795 }),
6796 sui_scene::StrokeStyle::new(metrics.border_width.max(1.0)),
6797 );
6798}
6799
6800fn layer_visibility_eye_path(rect: Rect) -> Path {
6801 let mut builder = PathBuilder::new();
6802 let cx = rect.x() + rect.width() * 0.5;
6803 let cy = rect.y() + rect.height() * 0.5;
6804 builder
6805 .move_to(Point::new(rect.x(), cy))
6806 .cubic_to(
6807 Point::new(rect.x() + rect.width() * 0.22, rect.y()),
6808 Point::new(rect.x() + rect.width() * 0.78, rect.y()),
6809 Point::new(rect.max_x(), cy),
6810 )
6811 .cubic_to(
6812 Point::new(rect.x() + rect.width() * 0.78, rect.max_y()),
6813 Point::new(rect.x() + rect.width() * 0.22, rect.max_y()),
6814 Point::new(rect.x(), cy),
6815 )
6816 .close();
6817 let _ = (cx, cy);
6818 builder.build()
6819}
6820
6821fn line_path(from: Point, to: Point) -> Path {
6822 let mut builder = PathBuilder::new();
6823 builder.move_to(from).line_to(to);
6824 builder.build()
6825}
6826
6827fn inset_rect(rect: Rect, padding: Insets) -> Rect {
6828 Rect::new(
6829 rect.x() + padding.left,
6830 rect.y() + padding.top,
6831 (rect.width() - padding.left - padding.right).max(0.0),
6832 (rect.height() - padding.top - padding.bottom).max(0.0),
6833 )
6834}
6835
6836fn scroll_delta_to_offset(delta: sui_core::ScrollDelta) -> Vector {
6837 match delta {
6838 sui_core::ScrollDelta::Lines(delta) => Vector::new(delta.x * 40.0, delta.y * 40.0),
6839 sui_core::ScrollDelta::Pixels(delta) => delta,
6840 }
6841}
6842
6843#[cfg(test)]
6844mod tests {
6845 use std::{cell::RefCell, rc::Rc};
6846
6847 use super::{
6848 Breadcrumb, BreadcrumbItem, DefaultTheme, LayerList, LayerListItem, LayerListReorderChange,
6849 LeadingLabelCellPaint, ListItem, ListView, Table, TableColumn, TableColumnAlignment,
6850 TableRow, TextBlockPaint, TextCellPaint, TreeItem, TreeView, VirtualTable,
6851 VirtualTableColumn, VirtualTableState,
6852 };
6853 use crate::{
6854 Button, CollectionWindow, Label, ScrollAlignment, ScrollView, SizedBox, Stack,
6855 ThemeTextToken,
6856 };
6857 use sui_core::{
6858 Color, Event, KeyState, KeyboardEvent, Modifiers, Point, PointerButton, PointerButtons,
6859 PointerEvent, PointerEventKind, PointerKind, Rect, Result, ScrollDelta, SemanticsAction,
6860 SemanticsActionRequest, SemanticsRole, SemanticsValue, Size, ToggleState, Vector, WidgetId,
6861 WindowEvent,
6862 };
6863 use sui_layout::{Constraints, Padding as Insets};
6864 use sui_runtime::{Application, PaintCtx, RenderOutput, Runtime, Widget, WindowBuilder};
6865 use sui_scene::{Brush, SceneCommand};
6866 use sui_text::{FontFeature, FontRegistry, FontWeight, TextSystem};
6867
6868 fn build_runtime<W>(root: W) -> (Runtime, sui_core::WindowId)
6869 where
6870 W: Widget + 'static,
6871 {
6872 let runtime = Application::new()
6873 .window(WindowBuilder::new().title("Data widgets").root(root))
6874 .build()
6875 .unwrap();
6876 let window_id = runtime.window_ids()[0];
6877 (runtime, window_id)
6878 }
6879
6880 fn render<W>(root: W) -> RenderOutput
6881 where
6882 W: Widget + 'static,
6883 {
6884 let (mut runtime, window_id) = build_runtime(root);
6885 runtime.render(window_id).expect("render should succeed")
6886 }
6887
6888 #[test]
6889 fn density_modes_resize_data_widgets() {
6890 let compact = DefaultTheme::compact();
6891 let touch = DefaultTheme::touch();
6892
6893 assert!(
6894 render(
6895 ListView::new("Layers")
6896 .theme(compact)
6897 .items([ListItem::new("Paint"), ListItem::new("Ink")])
6898 )
6899 .frame
6900 .viewport
6901 .height
6902 < render(
6903 ListView::new("Layers")
6904 .theme(touch)
6905 .items([ListItem::new("Paint"), ListItem::new("Ink")])
6906 )
6907 .frame
6908 .viewport
6909 .height
6910 );
6911 assert!(
6912 render(
6913 LayerList::new("Layers")
6914 .theme(compact)
6915 .layers([LayerListItem::new("Paint"), LayerListItem::new("Ink")])
6916 )
6917 .frame
6918 .viewport
6919 .height
6920 < render(
6921 LayerList::new("Layers")
6922 .theme(touch)
6923 .layers([LayerListItem::new("Paint"), LayerListItem::new("Ink")])
6924 )
6925 .frame
6926 .viewport
6927 .height
6928 );
6929 assert!(
6930 render(
6931 TreeView::new("Scene")
6932 .theme(compact)
6933 .items([TreeItem::new("Canvas"), TreeItem::new("Lighting")])
6934 )
6935 .frame
6936 .viewport
6937 .height
6938 < render(
6939 TreeView::new("Scene")
6940 .theme(touch)
6941 .items([TreeItem::new("Canvas"), TreeItem::new("Lighting")])
6942 )
6943 .frame
6944 .viewport
6945 .height
6946 );
6947 assert!(
6948 render(
6949 Table::new("Objects")
6950 .theme(compact)
6951 .columns([TableColumn::new("Name")])
6952 .rows([TableRow::new(["Canvas"]), TableRow::new(["Lighting"])])
6953 )
6954 .frame
6955 .viewport
6956 .height
6957 < render(
6958 Table::new("Objects")
6959 .theme(touch)
6960 .columns([TableColumn::new("Name")])
6961 .rows([TableRow::new(["Canvas"]), TableRow::new(["Lighting"])])
6962 )
6963 .frame
6964 .viewport
6965 .height
6966 );
6967 assert!(
6968 render(
6969 Breadcrumb::new("Path")
6970 .theme(compact)
6971 .items([BreadcrumbItem::new("Scene"), BreadcrumbItem::new("Layers")])
6972 )
6973 .frame
6974 .viewport
6975 .height
6976 < render(
6977 Breadcrumb::new("Path")
6978 .theme(touch)
6979 .items([BreadcrumbItem::new("Scene"), BreadcrumbItem::new("Layers")])
6980 )
6981 .frame
6982 .viewport
6983 .height
6984 );
6985 }
6986
6987 fn text_rects_for(output: &RenderOutput, text: &str) -> Vec<Rect> {
6988 let mut rects = Vec::new();
6989 output
6990 .frame
6991 .scene
6992 .visit_commands(&mut |command| match command {
6993 SceneCommand::DrawText(run) if run.text == text => rects.push(run.rect),
6994 SceneCommand::DrawShapedText(run) => {
6995 if let Some(layout) = run
6996 .resolve(output.frame.text_layout_registry.as_ref())
6997 .filter(|layout| layout.text() == text)
6998 {
6999 rects.push(shaped_text_run_rect(run.origin, layout));
7000 }
7001 }
7002 _ => {}
7003 });
7004
7005 rects
7006 }
7007
7008 fn shaped_text_run_rect(origin: Point, layout: &sui_text::TextLayout) -> Rect {
7009 let measurement = layout.measurement();
7010 let bounds = measurement.bounds;
7011 let width = if bounds.width().is_finite() && bounds.width() > 0.0 {
7012 bounds.width()
7013 } else {
7014 measurement.width
7015 };
7016 Rect::new(
7017 origin.x + bounds.x(),
7018 origin.y + ((layout.box_size().height - measurement.height).max(0.0) * 0.5),
7019 width,
7020 layout.style().line_height.max(measurement.height),
7021 )
7022 }
7023
7024 fn text_runs_for(output: &RenderOutput, text: &str) -> Vec<sui_text::TextRun> {
7025 let mut runs = Vec::new();
7026 output
7027 .frame
7028 .scene
7029 .visit_commands(&mut |command| match command {
7030 SceneCommand::DrawText(run) if run.text == text => runs.push(run.clone()),
7031 SceneCommand::DrawShapedText(run) => {
7032 if let Some(layout) = run
7033 .resolve(output.frame.text_layout_registry.as_ref())
7034 .filter(|layout| layout.text() == text)
7035 {
7036 let mut style = layout.style().clone();
7037 if let Some(color) = run.color_override {
7038 style.color = color;
7039 }
7040 runs.push(sui_text::TextRun {
7041 rect: shaped_text_run_rect(run.origin, layout),
7042 text: layout.text().to_string(),
7043 style,
7044 });
7045 }
7046 }
7047 _ => {}
7048 });
7049
7050 runs
7051 }
7052
7053 fn draw_clip_rects_for(output: &RenderOutput, text: &str) -> Vec<Rect> {
7054 let mut clips = Vec::new();
7055 let mut stack = Vec::new();
7056 output
7057 .frame
7058 .scene
7059 .visit_commands(&mut |command| match command {
7060 SceneCommand::PushClip { rect } => stack.push(*rect),
7061 SceneCommand::PopClip => {
7062 stack.pop();
7063 }
7064 SceneCommand::DrawText(run) if run.text == text => {
7065 if let Some(rect) = stack.last() {
7066 clips.push(*rect);
7067 }
7068 }
7069 SceneCommand::DrawShapedText(run)
7070 if run
7071 .resolve(output.frame.text_layout_registry.as_ref())
7072 .filter(|layout| layout.text() == text)
7073 .is_some_and(|layout| !layout.text().is_empty()) =>
7074 {
7075 if let Some(rect) = stack.last() {
7076 clips.push(*rect);
7077 }
7078 }
7079 _ => {}
7080 });
7081
7082 clips
7083 }
7084
7085 fn selected_highlight_rects(output: &RenderOutput) -> Vec<Rect> {
7086 let theme = DefaultTheme::default();
7087 let selected_brush = Brush::Solid(super::data_row_state_fill(&theme, true, 0.0, 0.0));
7088 let mut rects = Vec::new();
7089 output
7090 .frame
7091 .scene
7092 .visit_commands(&mut |command| match command {
7093 SceneCommand::FillPath { path, brush } if *brush == selected_brush => {
7094 rects.push(path.bounds());
7095 }
7096 SceneCommand::FillRect { rect, brush } if *brush == selected_brush => {
7097 rects.push(*rect);
7098 }
7099 _ => {}
7100 });
7101 rects
7102 }
7103
7104 fn solid_fill_colors(output: &RenderOutput) -> Vec<Color> {
7105 let mut colors = Vec::new();
7106 output
7107 .frame
7108 .scene
7109 .visit_commands(&mut |command| match command {
7110 SceneCommand::FillRect {
7111 brush: Brush::Solid(color),
7112 ..
7113 }
7114 | SceneCommand::FillPath {
7115 brush: Brush::Solid(color),
7116 ..
7117 } => colors.push(*color),
7118 _ => {}
7119 });
7120 colors
7121 }
7122
7123 fn solid_fill_bounds_for_color(output: &RenderOutput, expected: Color) -> Vec<Rect> {
7124 let mut rects = Vec::new();
7125 output
7126 .frame
7127 .scene
7128 .visit_commands(&mut |command| match command {
7129 SceneCommand::FillRect {
7130 rect,
7131 brush: Brush::Solid(color),
7132 } if *color == expected => rects.push(*rect),
7133 SceneCommand::FillPath {
7134 path,
7135 brush: Brush::Solid(color),
7136 } if *color == expected => rects.push(path.bounds()),
7137 _ => {}
7138 });
7139 rects
7140 }
7141
7142 fn solid_stroke_widths(output: &RenderOutput) -> Vec<f32> {
7143 let mut widths = Vec::new();
7144 output
7145 .frame
7146 .scene
7147 .visit_commands(&mut |command| match command {
7148 SceneCommand::StrokeRect { stroke, .. }
7149 | SceneCommand::StrokePath { stroke, .. } => {
7150 widths.push(stroke.width);
7151 }
7152 _ => {}
7153 });
7154 widths
7155 }
7156
7157 fn solid_stroke_colors(output: &RenderOutput) -> Vec<Color> {
7158 let mut colors = Vec::new();
7159 output
7160 .frame
7161 .scene
7162 .visit_commands(&mut |command| match command {
7163 SceneCommand::StrokeRect {
7164 brush: Brush::Solid(color),
7165 ..
7166 }
7167 | SceneCommand::StrokePath {
7168 brush: Brush::Solid(color),
7169 ..
7170 } => colors.push(*color),
7171 _ => {}
7172 });
7173 colors
7174 }
7175
7176 fn solid_stroke_rects(output: &RenderOutput) -> Vec<Rect> {
7177 let mut rects = Vec::new();
7178 output.frame.scene.visit_commands(&mut |command| {
7179 if let SceneCommand::StrokeRect { rect, .. } = command {
7180 rects.push(*rect);
7181 }
7182 });
7183 rects
7184 }
7185
7186 fn optical_visual_center(measurement: sui_text::TextMeasurement) -> f32 {
7187 let top = -measurement.cap_height.unwrap_or(measurement.ascent);
7188 let bottom = measurement.descent * 0.5;
7189 (top + bottom) * 0.5
7190 }
7191
7192 fn rect_center(rect: Rect) -> Point {
7193 Point::new(
7194 rect.x() + rect.width() * 0.5,
7195 rect.y() + rect.height() * 0.5,
7196 )
7197 }
7198
7199 fn text_run_visual_center(run: &sui_text::TextRun) -> f32 {
7200 let layout = TextSystem::new()
7201 .shape_text(
7202 run.text.clone(),
7203 Size::new(f32::INFINITY, run.rect.height().max(1.0)),
7204 run.style.clone(),
7205 &FontRegistry::new(),
7206 )
7207 .expect("text run should shape");
7208 let line = layout.lines().first().expect("text run should have a line");
7209 run.rect.y() + line.baseline + optical_visual_center(layout.measurement())
7210 }
7211
7212 fn text_visual_center_for(output: &RenderOutput, text: &str) -> f32 {
7213 output
7214 .frame
7215 .scene
7216 .commands()
7217 .iter()
7218 .find_map(|command| match command {
7219 SceneCommand::DrawText(run) if run.text == text => {
7220 Some(text_run_visual_center(run))
7221 }
7222 SceneCommand::DrawShapedText(run) => {
7223 let layout = run.resolve(output.frame.text_layout_registry.as_ref())?;
7224 if layout.text() != text {
7225 return None;
7226 }
7227 let line = layout.lines().first().expect("text run should have a line");
7228 Some(run.origin.y + line.baseline + optical_visual_center(layout.measurement()))
7229 }
7230 _ => None,
7231 })
7232 .expect("text draw command present")
7233 }
7234
7235 fn assert_two_line_row_text_matches_slots(
7236 output: &RenderOutput,
7237 label: &str,
7238 detail: &str,
7239 row: Rect,
7240 ) {
7241 let label = text_runs_for(output, label)
7242 .into_iter()
7243 .next()
7244 .expect("row label draw command present");
7245 let detail = text_runs_for(output, detail)
7246 .into_iter()
7247 .next()
7248 .expect("row detail draw command present");
7249 let total_height =
7250 label.style.line_height + detail.style.line_height + super::TWO_LINE_ROW_TEXT_GAP;
7251 let top = row.y() + ((row.height() - total_height) * 0.5).max(0.0);
7252 let label_slot_center = top + (label.style.line_height * 0.5);
7253 let detail_slot_center = top
7254 + label.style.line_height
7255 + super::TWO_LINE_ROW_TEXT_GAP
7256 + (detail.style.line_height * 0.5);
7257
7258 assert!((text_run_visual_center(&label) - label_slot_center).abs() < 0.75);
7259 assert!((text_run_visual_center(&detail) - detail_slot_center).abs() < 0.75);
7260 }
7261
7262 fn assert_text_run_uses_token(run: &sui_text::TextRun, token: ThemeTextToken) {
7263 assert!(
7264 (run.style.font_size - token.size).abs() < 0.001,
7265 "text '{}' used font size {}, expected token size {}",
7266 run.text,
7267 run.style.font_size,
7268 token.size
7269 );
7270 assert!(
7271 (run.style.line_height - token.line_height).abs() < 0.001,
7272 "text '{}' used line height {}, expected token line height {}",
7273 run.text,
7274 run.style.line_height,
7275 token.line_height
7276 );
7277 }
7278
7279 fn vertical_scroll_thumb_rects(output: &RenderOutput) -> Vec<Rect> {
7280 let mut rects = Vec::new();
7281 output.frame.scene.visit_commands(&mut |command| {
7282 if let SceneCommand::FillPath { path, .. } = command {
7283 let bounds = path.bounds();
7284 if (bounds.width() - 4.0).abs() <= f32::EPSILON && bounds.height() >= 28.0 {
7285 rects.push(bounds);
7286 }
7287 }
7288 });
7289 rects
7290 }
7291
7292 fn primary_pointer(kind: PointerEventKind, position: Point, pressed: bool) -> Event {
7293 let mut buttons = PointerButtons::NONE;
7294 if pressed {
7295 buttons.insert(PointerButton::Primary);
7296 }
7297
7298 Event::Pointer(PointerEvent {
7299 pointer_id: 1,
7300 kind,
7301 position,
7302 delta: Vector::ZERO,
7303 scroll_delta: None,
7304 button: Some(PointerButton::Primary),
7305 buttons,
7306 modifiers: Modifiers::NONE,
7307 pointer_kind: PointerKind::Mouse,
7308 is_primary: true,
7309 })
7310 }
7311
7312 fn wheel_scroll(position: Point, delta: Vector) -> Event {
7313 let mut scroll = PointerEvent::new(PointerEventKind::Scroll, position);
7314 scroll.scroll_delta = Some(ScrollDelta::Pixels(delta));
7315 Event::Pointer(scroll)
7316 }
7317
7318 fn semantic_bounds(output: &RenderOutput, role: SemanticsRole, name: &str) -> Rect {
7319 output
7320 .semantics
7321 .iter()
7322 .find(|node| node.role == role && node.name.as_deref() == Some(name))
7323 .map(|node| node.bounds)
7324 .unwrap_or_else(|| panic!("{role:?} semantics named {name:?} should be present"))
7325 }
7326
7327 fn handle_ready_events(runtime: &mut Runtime) -> Result<usize> {
7328 let ready = runtime.drain_ready_events();
7329 let count = ready.len();
7330 for (ready_window, event) in ready {
7331 runtime.handle_event(ready_window, event)?;
7332 }
7333 Ok(count)
7334 }
7335
7336 fn assert_focus_surface_keeps_chrome_neutral<W>(root: W, position: Point) -> Result<()>
7337 where
7338 W: Widget + 'static,
7339 {
7340 let theme = DefaultTheme::default();
7341 let (mut runtime, window_id) = build_runtime(root);
7342 let _ = runtime.render(window_id)?;
7343
7344 runtime.handle_event(
7345 window_id,
7346 primary_pointer(PointerEventKind::Down, position, true),
7347 )?;
7348
7349 let focused = runtime.render(window_id)?;
7350 let focused_strokes = solid_stroke_colors(&focused);
7351 assert!(
7352 !focused_strokes.contains(&theme.palette.focus_ring),
7353 "focused data containers should not paint a focus ring; strokes={focused_strokes:?}"
7354 );
7355 assert_eq!(
7356 focused_strokes.first().copied(),
7357 Some(theme.palette.border),
7358 "focused data containers should keep their surface border neutral; strokes={focused_strokes:?}"
7359 );
7360
7361 Ok(())
7362 }
7363
7364 fn assert_pointer_hover_and_press_use_theme_motion(
7365 runtime: &mut Runtime,
7366 window_id: sui_core::WindowId,
7367 position: Point,
7368 theme: &DefaultTheme,
7369 ) -> Result<()> {
7370 let hover_duration = theme.motion.hover_duration();
7371 let press_duration = theme.motion.press_duration();
7372 let expected_hover = super::data_row_state_fill(theme, false, 1.0, 0.0);
7373 let expected_press = super::data_row_state_fill(theme, false, 0.0, 1.0);
7374
7375 runtime.handle_event(
7376 window_id,
7377 primary_pointer(PointerEventKind::Move, position, false),
7378 )?;
7379 runtime.tick(hover_duration * 0.5);
7380 assert_eq!(handle_ready_events(runtime)?, 1);
7381 let mid_hover = runtime.render(window_id)?;
7382 assert!(
7383 !solid_fill_colors(&mid_hover).contains(&expected_hover),
7384 "hover fill should not snap to the settled hover color"
7385 );
7386
7387 runtime.tick(hover_duration);
7388 assert_eq!(handle_ready_events(runtime)?, 1);
7389 let settled_hover = runtime.render(window_id)?;
7390 assert!(
7391 solid_fill_colors(&settled_hover).contains(&expected_hover),
7392 "hover fill should settle to the theme interaction color"
7393 );
7394
7395 runtime.handle_event(
7396 window_id,
7397 primary_pointer(PointerEventKind::Down, position, true),
7398 )?;
7399 runtime.tick(hover_duration + press_duration * 0.5);
7400 assert_eq!(handle_ready_events(runtime)?, 1);
7401 let mid_press = runtime.render(window_id)?;
7402 assert!(
7403 !solid_fill_colors(&mid_press).contains(&expected_press),
7404 "press fill should not snap to the settled pressed color"
7405 );
7406
7407 runtime.tick(hover_duration + press_duration);
7408 assert_eq!(handle_ready_events(runtime)?, 1);
7409 let settled_press = runtime.render(window_id)?;
7410 assert!(
7411 solid_fill_colors(&settled_press).contains(&expected_press),
7412 "press fill should settle to the theme interaction color"
7413 );
7414
7415 Ok(())
7416 }
7417
7418 #[test]
7419 fn data_row_hover_and_press_fills_are_translucent_overlays() {
7420 let theme = DefaultTheme::default();
7421 let hover = super::data_row_state_fill(&theme, false, 1.0, 0.0);
7422 let press = super::data_row_state_fill(&theme, false, 0.0, 1.0);
7423
7424 assert_eq!(
7425 super::data_row_state_fill(&theme, false, 0.0, 0.0),
7426 Color::TRANSPARENT
7427 );
7428 assert!(hover.alpha > 0.0 && hover.alpha < 1.0);
7429 assert!(press.alpha > hover.alpha && press.alpha < 1.0);
7430 assert_ne!(hover, theme.palette.control);
7431 assert_ne!(hover, theme.palette.control_hover);
7432
7433 let dark_hover = super::data_row_state_fill(&DefaultTheme::dark(), false, 1.0, 0.0);
7434 assert!(dark_hover.alpha > 0.0 && dark_hover.alpha < 1.0);
7435 }
7436
7437 #[test]
7438 fn data_focus_surfaces_keep_chrome_neutral() -> Result<()> {
7439 assert_focus_surface_keeps_chrome_neutral(
7440 SizedBox::new().width(260.0).height(120.0).with_child(
7441 ListView::new("Assets").items([ListItem::new("First"), ListItem::new("Second")]),
7442 ),
7443 Point::new(24.0, 24.0),
7444 )?;
7445
7446 assert_focus_surface_keeps_chrome_neutral(
7447 SizedBox::new().width(280.0).height(120.0).with_child(
7448 LayerList::new("Layers")
7449 .layers([LayerListItem::new("Paint"), LayerListItem::new("Ink")]),
7450 ),
7451 Point::new(24.0, 24.0),
7452 )?;
7453
7454 assert_focus_surface_keeps_chrome_neutral(
7455 SizedBox::new().width(260.0).height(120.0).with_child(
7456 TreeView::new("Scene").items([TreeItem::new("Canvas"), TreeItem::new("Lighting")]),
7457 ),
7458 Point::new(24.0, 24.0),
7459 )?;
7460
7461 assert_focus_surface_keeps_chrome_neutral(
7462 SizedBox::new().width(280.0).height(140.0).with_child(
7463 Table::new("Objects")
7464 .columns([TableColumn::new("Name")])
7465 .rows([TableRow::new(["Canvas"]), TableRow::new(["Lighting"])]),
7466 ),
7467 Point::new(24.0, 58.0),
7468 )?;
7469
7470 assert_focus_surface_keeps_chrome_neutral(
7471 Breadcrumb::new("Path").items([
7472 BreadcrumbItem::new("Scene"),
7473 BreadcrumbItem::new("Layers"),
7474 BreadcrumbItem::new("Ink"),
7475 ]),
7476 Point::new(24.0, 18.0),
7477 )
7478 }
7479
7480 #[test]
7481 fn list_view_row_hover_and_press_use_theme_motion() -> Result<()> {
7482 let theme = DefaultTheme::default();
7483 let (mut runtime, window_id) =
7484 build_runtime(SizedBox::new().width(260.0).height(140.0).with_child(
7485 ListView::new("Assets").theme(theme).items([
7486 ListItem::new("First"),
7487 ListItem::new("Second"),
7488 ListItem::new("Third"),
7489 ]),
7490 ));
7491
7492 let output = runtime.render(window_id)?;
7493 let row = output
7494 .semantics
7495 .iter()
7496 .find(|node| {
7497 node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Second")
7498 })
7499 .expect("second row semantics present");
7500
7501 assert_pointer_hover_and_press_use_theme_motion(
7502 &mut runtime,
7503 window_id,
7504 rect_center(row.bounds),
7505 &theme,
7506 )
7507 }
7508
7509 #[test]
7510 fn layer_list_action_hover_and_press_use_theme_motion() -> Result<()> {
7511 let theme = DefaultTheme::default();
7512 let (mut runtime, window_id) = build_runtime(
7513 SizedBox::new().width(280.0).height(120.0).with_child(
7514 LayerList::new("Layers")
7515 .theme(theme)
7516 .layers([LayerListItem::new("Paint"), LayerListItem::new("Ink")]),
7517 ),
7518 );
7519
7520 let output = runtime.render(window_id)?;
7521 let visibility = output
7522 .semantics
7523 .iter()
7524 .find(|node| {
7525 node.role == SemanticsRole::Button
7526 && node.name.as_deref() == Some("Hide Paint layer")
7527 })
7528 .expect("visibility button semantics present");
7529
7530 assert_pointer_hover_and_press_use_theme_motion(
7531 &mut runtime,
7532 window_id,
7533 rect_center(visibility.bounds),
7534 &theme,
7535 )
7536 }
7537
7538 #[test]
7539 fn layer_list_drag_reorders_rows_without_activating_buttons() -> Result<()> {
7540 let changes = Rc::new(RefCell::new(Vec::new()));
7541 let captured = Rc::clone(&changes);
7542 let (mut runtime, window_id) = build_runtime(
7543 SizedBox::new().width(280.0).height(168.0).with_child(
7544 LayerList::new("Layers")
7545 .layers([
7546 LayerListItem::new("Paint"),
7547 LayerListItem::new("Paper"),
7548 LayerListItem::new("Ink"),
7549 ])
7550 .on_reorder(move |change| captured.borrow_mut().push(change)),
7551 ),
7552 );
7553 let output = runtime.render(window_id)?;
7554 let paint = output
7555 .semantics
7556 .iter()
7557 .find(|node| {
7558 node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Paint")
7559 })
7560 .expect("paint layer semantics present");
7561 let paper = output
7562 .semantics
7563 .iter()
7564 .find(|node| {
7565 node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Paper")
7566 })
7567 .expect("paper layer semantics present");
7568
7569 let start = rect_center(paint.bounds);
7570 let end = Point::new(start.x, paper.bounds.max_y() + 4.0);
7571 runtime.handle_event(
7572 window_id,
7573 primary_pointer(PointerEventKind::Down, start, true),
7574 )?;
7575 runtime.handle_event(
7576 window_id,
7577 primary_pointer(PointerEventKind::Move, end, true),
7578 )?;
7579 runtime.handle_event(window_id, primary_pointer(PointerEventKind::Up, end, false))?;
7580
7581 assert_eq!(
7582 changes.borrow().as_slice(),
7583 &[LayerListReorderChange {
7584 item: 0,
7585 from: 0,
7586 to: 1
7587 }]
7588 );
7589
7590 let output = runtime.render(window_id)?;
7591 let paint = output
7592 .semantics
7593 .iter()
7594 .find(|node| {
7595 node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Paint")
7596 })
7597 .expect("paint layer semantics present after reorder");
7598 let paper = output
7599 .semantics
7600 .iter()
7601 .find(|node| {
7602 node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Paper")
7603 })
7604 .expect("paper layer semantics present after reorder");
7605 assert!(paper.bounds.y() < paint.bounds.y());
7606 assert!(
7607 output.semantics.iter().any(|node| {
7608 node.role == SemanticsRole::Button
7609 && node.name.as_deref() == Some("Hide Paint layer")
7610 && node.value == Some(SemanticsValue::Text("Visible".to_string()))
7611 }),
7612 "visibility button should remain a normal button after enabling row reorder"
7613 );
7614 Ok(())
7615 }
7616
7617 #[test]
7618 fn table_row_hover_and_press_use_theme_motion() -> Result<()> {
7619 let theme = DefaultTheme::default();
7620 let position = Point::new(
7621 theme.metrics.data_viewport_padding.left + 24.0,
7622 theme.metrics.data_viewport_padding.top
7623 + theme.metrics.table_header_height
7624 + theme.metrics.select_menu_gap
7625 + theme.metrics.table_row_height * 0.5,
7626 );
7627 let (mut runtime, window_id) = build_runtime(
7628 SizedBox::new().width(360.0).height(180.0).with_child(
7629 Table::new("Objects")
7630 .theme(theme)
7631 .columns([TableColumn::new("Name"), TableColumn::new("State")])
7632 .rows([
7633 TableRow::new(["Canvas", "Visible"]),
7634 TableRow::new(["Lighting", "Locked"]),
7635 ]),
7636 ),
7637 );
7638
7639 let _ = runtime.render(window_id)?;
7640 assert_pointer_hover_and_press_use_theme_motion(&mut runtime, window_id, position, &theme)
7641 }
7642
7643 #[test]
7644 fn table_row_hover_keeps_row_base_under_overlay() -> Result<()> {
7645 let theme = DefaultTheme::default();
7646 let position = Point::new(
7647 theme.metrics.data_viewport_padding.left + 24.0,
7648 theme.metrics.data_viewport_padding.top
7649 + theme.metrics.table_header_height
7650 + theme.metrics.select_menu_gap
7651 + theme.metrics.table_row_height * 0.5,
7652 );
7653 let (mut runtime, window_id) = build_runtime(
7654 SizedBox::new().width(360.0).height(180.0).with_child(
7655 Table::new("Objects")
7656 .theme(theme)
7657 .columns([TableColumn::new("Name"), TableColumn::new("State")])
7658 .rows([
7659 TableRow::new(["Canvas", "Visible"]),
7660 TableRow::new(["Lighting", "Locked"]),
7661 ]),
7662 ),
7663 );
7664
7665 let _ = runtime.render(window_id)?;
7666 runtime.handle_event(
7667 window_id,
7668 primary_pointer(PointerEventKind::Move, position, false),
7669 )?;
7670 runtime.tick(theme.motion.hover_duration());
7671 assert_eq!(handle_ready_events(&mut runtime)?, 1);
7672 let hovered = runtime.render(window_id)?;
7673 let fills = solid_fill_colors(&hovered);
7674
7675 assert!(fills.contains(&theme.palette.surface.with_alpha(0.88)));
7676 assert!(fills.contains(&super::data_row_state_fill(&theme, false, 1.0, 0.0)));
7677 assert!(
7678 !fills.contains(&theme.palette.control_hover),
7679 "hovered table rows should paint a translucent overlay, not an opaque control fill"
7680 );
7681 Ok(())
7682 }
7683
7684 #[test]
7685 fn selected_data_rows_share_soft_fill_and_leading_indicator() {
7686 let theme = DefaultTheme::default();
7687 let outputs = [
7688 (
7689 "list view",
7690 render(
7691 SizedBox::new().width(300.0).height(96.0).with_child(
7692 ListView::new("Assets")
7693 .theme(theme)
7694 .items([ListItem::new("Canvas"), ListItem::new("Lighting")])
7695 .selected(0),
7696 ),
7697 ),
7698 ),
7699 (
7700 "layer list",
7701 render(
7702 SizedBox::new().width(300.0).height(96.0).with_child(
7703 LayerList::new("Layers")
7704 .theme(theme)
7705 .layers([LayerListItem::new("Canvas"), LayerListItem::new("Lighting")])
7706 .selected(0),
7707 ),
7708 ),
7709 ),
7710 (
7711 "tree view",
7712 render(
7713 SizedBox::new().width(300.0).height(96.0).with_child(
7714 TreeView::new("Scene")
7715 .theme(theme)
7716 .items([TreeItem::new("Canvas"), TreeItem::new("Lighting")])
7717 .selected(0),
7718 ),
7719 ),
7720 ),
7721 (
7722 "table",
7723 render(
7724 SizedBox::new().width(300.0).height(128.0).with_child(
7725 Table::new("Objects")
7726 .theme(theme)
7727 .columns([TableColumn::new("Name")])
7728 .rows([TableRow::new(["Canvas"]), TableRow::new(["Lighting"])])
7729 .selected(0),
7730 ),
7731 ),
7732 ),
7733 (
7734 "virtual table",
7735 render(
7736 SizedBox::new().width(300.0).height(128.0).with_child(
7737 VirtualTable::new("Virtual objects")
7738 .theme(theme)
7739 .columns([VirtualTableColumn::new("Name")])
7740 .row_count(2)
7741 .selected(0),
7742 ),
7743 ),
7744 ),
7745 ];
7746
7747 for (name, output) in outputs {
7748 assert!(
7749 solid_fill_colors(&output).contains(&theme.palette.selection),
7750 "{name} should use the semantic soft selection fill"
7751 );
7752 let indicators = solid_fill_bounds_for_color(&output, theme.palette.accent)
7753 .into_iter()
7754 .filter(|rect| (rect.width() - 2.0).abs() < 0.01 && rect.height() > rect.width())
7755 .collect::<Vec<_>>();
7756 assert_eq!(
7757 indicators.len(),
7758 1,
7759 "{name} should paint one slim leading selection indicator; indicators={indicators:?}"
7760 );
7761 }
7762 }
7763
7764 #[test]
7765 fn breadcrumb_item_hover_and_press_use_theme_motion() -> Result<()> {
7766 let theme = DefaultTheme::default();
7767 let (mut runtime, window_id) = build_runtime(Breadcrumb::new("Path").theme(theme).items([
7768 BreadcrumbItem::new("Workspace"),
7769 BreadcrumbItem::new("Project"),
7770 BreadcrumbItem::new("Scene"),
7771 ]));
7772
7773 let output = runtime.render(window_id)?;
7774 let project_label = text_rects_for(&output, "Project")
7775 .into_iter()
7776 .next()
7777 .expect("project label should render");
7778
7779 assert_pointer_hover_and_press_use_theme_motion(
7780 &mut runtime,
7781 window_id,
7782 rect_center(project_label),
7783 &theme,
7784 )
7785 }
7786
7787 #[test]
7788 fn breadcrumb_overflow_clips_and_defaults_to_trailing_items() {
7789 let output = render(SizedBox::new().width(180.0).with_child(
7790 Breadcrumb::new("Path").items([
7791 BreadcrumbItem::new("SIFS"),
7792 BreadcrumbItem::new("sinomo"),
7793 BreadcrumbItem::new("nodes"),
7794 BreadcrumbItem::new("node 01kvbbd...3fsrx"),
7795 BreadcrumbItem::new("attachments"),
7796 ]),
7797 ));
7798
7799 assert!(
7800 output.frame.scene.commands().iter().any(|command| matches!(
7801 command,
7802 SceneCommand::PushClip { rect }
7803 if (rect.width() - 180.0).abs() < 0.01
7804 && (rect.height() - output.frame.viewport.height).abs() < 0.01
7805 )),
7806 "overflowing breadcrumb content should be clipped to the widget bounds"
7807 );
7808
7809 let trailing_label = text_rects_for(&output, "attachments")
7810 .into_iter()
7811 .next()
7812 .expect("trailing breadcrumb item should render");
7813 assert!(
7814 trailing_label.x() >= -0.01 && trailing_label.max_x() <= 180.01,
7815 "default overflow position should keep the last item visible: {trailing_label:?}"
7816 );
7817 }
7818
7819 #[test]
7820 fn breadcrumb_wheel_scrolls_overflowing_content_leftward() -> Result<()> {
7821 let (mut runtime, window_id) = build_runtime(SizedBox::new().width(180.0).with_child(
7822 Breadcrumb::new("Path").items([
7823 BreadcrumbItem::new("SIFS"),
7824 BreadcrumbItem::new("sinomo"),
7825 BreadcrumbItem::new("nodes"),
7826 BreadcrumbItem::new("node 01kvbbd...3fsrx"),
7827 BreadcrumbItem::new("attachments"),
7828 ]),
7829 ));
7830
7831 let before = runtime.render(window_id)?;
7832 let before_x = text_rects_for(&before, "attachments")[0].x();
7833
7834 runtime.handle_event(
7835 window_id,
7836 wheel_scroll(Point::new(90.0, 18.0), Vector::new(0.0, 24.0)),
7837 )?;
7838
7839 let after = runtime.render(window_id)?;
7840 let after_x = text_rects_for(&after, "attachments")[0].x();
7841 assert!(
7842 after_x > before_x,
7843 "wheel scrolling upward should reveal earlier breadcrumb items by moving content right"
7844 );
7845 Ok(())
7846 }
7847
7848 #[test]
7849 fn breadcrumb_drag_scrolls_overflowing_content_leftward() -> Result<()> {
7850 let (mut runtime, window_id) = build_runtime(SizedBox::new().width(180.0).with_child(
7851 Breadcrumb::new("Path").items([
7852 BreadcrumbItem::new("SIFS"),
7853 BreadcrumbItem::new("sinomo"),
7854 BreadcrumbItem::new("nodes"),
7855 BreadcrumbItem::new("node 01kvbbd...3fsrx"),
7856 BreadcrumbItem::new("attachments"),
7857 ]),
7858 ));
7859
7860 let before = runtime.render(window_id)?;
7861 let before_x = text_rects_for(&before, "attachments")[0].x();
7862
7863 runtime.handle_event(
7864 window_id,
7865 primary_pointer(PointerEventKind::Down, Point::new(90.0, 18.0), true),
7866 )?;
7867 runtime.handle_event(
7868 window_id,
7869 primary_pointer(PointerEventKind::Move, Point::new(126.0, 18.0), true),
7870 )?;
7871 runtime.handle_event(
7872 window_id,
7873 primary_pointer(PointerEventKind::Up, Point::new(126.0, 18.0), false),
7874 )?;
7875
7876 let after = runtime.render(window_id)?;
7877 let after_x = text_rects_for(&after, "attachments")[0].x();
7878 assert!(
7879 after_x > before_x,
7880 "dragging right should reveal earlier breadcrumb items by moving content right"
7881 );
7882 Ok(())
7883 }
7884
7885 #[test]
7886 fn list_view_click_selects_row_and_updates_semantics() -> Result<()> {
7887 let changes = Rc::new(RefCell::new(Vec::new()));
7888 let on_change = Rc::clone(&changes);
7889 let (mut runtime, window_id) = build_runtime(
7890 ListView::new("Assets")
7891 .items([
7892 ListItem::new("First"),
7893 ListItem::new("Second"),
7894 ListItem::new("Third"),
7895 ])
7896 .on_change(move |index, label| on_change.borrow_mut().push((index, label))),
7897 );
7898
7899 let _ = runtime.render(window_id)?;
7900 runtime.handle_event(
7901 window_id,
7902 primary_pointer(PointerEventKind::Down, Point::new(44.0, 44.0), true),
7903 )?;
7904 runtime.handle_event(
7905 window_id,
7906 primary_pointer(PointerEventKind::Up, Point::new(44.0, 44.0), false),
7907 )?;
7908
7909 assert_eq!(changes.borrow().as_slice(), &[(1, "Second".to_string())]);
7910
7911 let output = runtime.render(window_id)?;
7912 let list = output
7913 .semantics
7914 .iter()
7915 .find(|node| node.role == SemanticsRole::List)
7916 .expect("list semantics present");
7917 assert_eq!(list.value, Some(SemanticsValue::Text("Second".to_string())));
7918 let row = output
7919 .semantics
7920 .iter()
7921 .find(|node| {
7922 node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Second")
7923 })
7924 .expect("selected row semantics present");
7925 assert_eq!(row.parent, Some(list.id));
7926 assert!(row.state.selected);
7927 assert!(row.actions.contains(&SemanticsAction::Activate));
7928 Ok(())
7929 }
7930
7931 #[test]
7932 fn list_view_change_callback_can_request_relayout() -> Result<()> {
7933 let changes = Rc::new(RefCell::new(Vec::new()));
7934 let requests = Rc::new(RefCell::new(0_usize));
7935 let on_change = Rc::clone(&changes);
7936 let requested = Rc::clone(&requests);
7937 let (mut runtime, window_id) = build_runtime(
7938 ListView::new("Assets")
7939 .items([ListItem::new("First"), ListItem::new("Second")])
7940 .on_change_with_ctx(move |index, label, ctx| {
7941 on_change.borrow_mut().push((index, label));
7942 *requested.borrow_mut() += 1;
7943 ctx.request_measure();
7944 ctx.request_arrange();
7945 ctx.request_paint();
7946 ctx.request_semantics();
7947 }),
7948 );
7949
7950 let _ = runtime.render(window_id)?;
7951 runtime.handle_event(
7952 window_id,
7953 primary_pointer(PointerEventKind::Down, Point::new(44.0, 44.0), true),
7954 )?;
7955 runtime.handle_event(
7956 window_id,
7957 primary_pointer(PointerEventKind::Up, Point::new(44.0, 44.0), false),
7958 )?;
7959
7960 assert_eq!(changes.borrow().as_slice(), &[(1, "Second".to_string())]);
7961 assert_eq!(*requests.borrow(), 1);
7962 Ok(())
7963 }
7964
7965 #[test]
7966 fn list_view_exposes_visible_row_semantics() -> Result<()> {
7967 let (mut runtime, window_id) = build_runtime(
7968 SizedBox::new().width(260.0).height(132.0).with_child(
7969 ListView::new("Layers")
7970 .items([
7971 ListItem::new("Paint").detail("Normal / 100%"),
7972 ListItem::new("Paper").detail("Background"),
7973 ListItem::new("Locked").detail("Read only").disabled(),
7974 ])
7975 .selected(0),
7976 ),
7977 );
7978
7979 let output = runtime.render(window_id)?;
7980 let list = output
7981 .semantics
7982 .iter()
7983 .find(|node| node.role == SemanticsRole::List)
7984 .expect("list semantics present");
7985 let rows = output
7986 .semantics
7987 .iter()
7988 .filter(|node| node.role == SemanticsRole::ListItem)
7989 .collect::<Vec<_>>();
7990
7991 assert_eq!(rows.len(), 3);
7992 let paint = rows
7993 .iter()
7994 .find(|node| node.name.as_deref() == Some("Paint"))
7995 .expect("paint row semantics present");
7996 assert_eq!(paint.parent, Some(list.id));
7997 assert_eq!(paint.description.as_deref(), Some("Normal / 100%"));
7998 assert_eq!(
7999 paint.value,
8000 Some(SemanticsValue::Text("Normal / 100%".to_string()))
8001 );
8002 assert!(paint.state.selected);
8003 assert!(!paint.state.disabled);
8004 assert!(paint.actions.contains(&SemanticsAction::Activate));
8005
8006 let paper = rows
8007 .iter()
8008 .find(|node| node.name.as_deref() == Some("Paper"))
8009 .expect("paper row semantics present");
8010 assert_eq!(paper.parent, Some(list.id));
8011 assert_eq!(paper.description.as_deref(), Some("Background"));
8012 assert_eq!(
8013 paper.value,
8014 Some(SemanticsValue::Text("Background".to_string()))
8015 );
8016 assert!(!paper.state.selected);
8017
8018 let locked = rows
8019 .iter()
8020 .find(|node| node.name.as_deref() == Some("Locked"))
8021 .expect("locked row semantics present");
8022 assert!(locked.state.disabled);
8023 assert!(locked.actions.is_empty());
8024 Ok(())
8025 }
8026
8027 #[test]
8028 fn list_view_selected_when_reads_external_selection() -> Result<()> {
8029 let selected = Rc::new(RefCell::new(0_usize));
8030 let selected_reader = Rc::clone(&selected);
8031 let (mut runtime, window_id) = build_runtime(
8032 SizedBox::new().width(260.0).height(132.0).with_child(
8033 ListView::new("Layers")
8034 .items([
8035 ListItem::new("Paint").detail("Normal / 100%"),
8036 ListItem::new("Paper").detail("Background"),
8037 ])
8038 .selected_when(move || Some(*selected_reader.borrow())),
8039 ),
8040 );
8041
8042 let output = runtime.render(window_id)?;
8043 let paint = output
8044 .semantics
8045 .iter()
8046 .find(|node| {
8047 node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Paint")
8048 })
8049 .expect("paint row semantics present");
8050 assert!(paint.state.selected);
8051
8052 *selected.borrow_mut() = 1;
8053 runtime.handle_event(
8054 window_id,
8055 Event::Window(WindowEvent::Resized(Size::new(260.0, 132.0))),
8056 )?;
8057 let output = runtime.render(window_id)?;
8058 let list = output
8059 .semantics
8060 .iter()
8061 .find(|node| node.role == SemanticsRole::List)
8062 .expect("list semantics present");
8063 assert_eq!(list.value, Some(SemanticsValue::Text("Paper".to_string())));
8064 let paper = output
8065 .semantics
8066 .iter()
8067 .find(|node| {
8068 node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Paper")
8069 })
8070 .expect("paper row semantics present");
8071 assert!(paper.state.selected);
8072 Ok(())
8073 }
8074
8075 #[test]
8076 fn list_view_row_ids_are_javascript_safe_and_distinct() {
8077 let parent = WidgetId::new(402);
8078 let mut ids = (0..8)
8079 .map(|index| super::list_view_row_id(parent, index).get())
8080 .collect::<Vec<_>>();
8081
8082 assert!(ids.iter().all(|id| *id <= ((1_u64 << 53) - 1)));
8083 assert!(ids.iter().all(|id| *id != parent.get()));
8084 ids.sort_unstable();
8085 ids.dedup();
8086 assert_eq!(ids.len(), 8);
8087 }
8088
8089 #[test]
8090 fn layer_list_exposes_visibility_semantics() {
8091 let output = render(
8092 SizedBox::new().width(280.0).height(112.0).with_child(
8093 LayerList::new("Layers")
8094 .layers([
8095 LayerListItem::new("Paint")
8096 .detail("Normal / 100%")
8097 .thumbnail(Color::rgba(0.16, 0.31, 0.88, 1.0)),
8098 LayerListItem::new("Paper")
8099 .detail("Background")
8100 .thumbnail(Color::rgba(0.89, 0.91, 0.94, 1.0)),
8101 ])
8102 .selected(0),
8103 ),
8104 );
8105
8106 let list = output
8107 .semantics
8108 .iter()
8109 .find(|node| node.role == SemanticsRole::List)
8110 .expect("layer list semantics present");
8111 assert_eq!(list.name.as_deref(), Some("Layers"));
8112 assert_eq!(list.value, Some(SemanticsValue::Text("Paint".to_string())));
8113
8114 let paint = output
8115 .semantics
8116 .iter()
8117 .find(|node| {
8118 node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Paint")
8119 })
8120 .expect("paint layer row semantics present");
8121 assert_eq!(paint.parent, Some(list.id));
8122 assert_eq!(paint.description.as_deref(), Some("Normal / 100%"));
8123 assert_eq!(
8124 paint.value,
8125 Some(SemanticsValue::Text(
8126 "Normal / 100%; Visible; Unlocked".to_string()
8127 ))
8128 );
8129 assert!(paint.state.selected);
8130
8131 let visibility = output
8132 .semantics
8133 .iter()
8134 .find(|node| {
8135 node.role == SemanticsRole::Button
8136 && node.name.as_deref() == Some("Hide Paint layer")
8137 })
8138 .expect("paint layer visibility control semantics present");
8139 assert_eq!(visibility.parent, Some(paint.id));
8140 assert_eq!(
8141 visibility.value,
8142 Some(SemanticsValue::Text("Visible".to_string()))
8143 );
8144 assert_eq!(visibility.state.checked, Some(ToggleState::Checked));
8145 assert!(visibility.actions.contains(&SemanticsAction::Activate));
8146
8147 let lock = output
8148 .semantics
8149 .iter()
8150 .find(|node| {
8151 node.role == SemanticsRole::Button
8152 && node.name.as_deref() == Some("Lock Paint layer")
8153 })
8154 .expect("paint layer lock control semantics present");
8155 assert_eq!(lock.parent, Some(paint.id));
8156 assert_eq!(
8157 lock.value,
8158 Some(SemanticsValue::Text("Unlocked".to_string()))
8159 );
8160 assert_eq!(lock.state.checked, Some(ToggleState::Unchecked));
8161 assert!(lock.actions.contains(&SemanticsAction::Activate));
8162 }
8163
8164 #[test]
8165 fn layer_list_chrome_uses_theme_metrics() {
8166 let mut theme = DefaultTheme::default();
8167 theme.metrics.layer_visibility_stroke_width = 2.75;
8168 theme.metrics.layer_visibility_slash_stroke_width = 3.25;
8169 theme.metrics.layer_thumbnail_disabled_opacity = 0.21;
8170 theme.metrics.layer_thumbnail_disabled_border_opacity = 0.33;
8171 let thumbnail = Color::rgba(0.30, 0.50, 0.70, 1.0);
8172
8173 let output = render(
8174 SizedBox::new().width(280.0).height(64.0).with_child(
8175 LayerList::new("Layers")
8176 .theme(theme)
8177 .layers([LayerListItem::new("Paper")
8178 .thumbnail(thumbnail)
8179 .visible(false)]),
8180 ),
8181 );
8182 let fills = solid_fill_colors(&output);
8183 let stroke_widths = solid_stroke_widths(&output);
8184 let stroke_colors = solid_stroke_colors(&output);
8185
8186 assert!(fills.contains(&thumbnail.with_alpha(0.21)));
8187 assert!(fills.contains(&theme.palette.control_hover));
8188 assert!(stroke_colors.contains(&theme.palette.border.with_alpha(0.33)));
8189 assert!(
8190 stroke_widths
8191 .iter()
8192 .any(|width| (*width - 2.75).abs() < f32::EPSILON)
8193 );
8194 assert!(
8195 stroke_widths
8196 .iter()
8197 .any(|width| (*width - 3.25).abs() < f32::EPSILON)
8198 );
8199 }
8200
8201 #[test]
8202 fn layer_list_label_and_detail_visual_centers_match_row_slots() {
8203 let output = render(
8204 SizedBox::new().width(280.0).height(64.0).with_child(
8205 LayerList::new("Layers").layer(
8206 LayerListItem::new("Paint")
8207 .detail("Normal / 100%")
8208 .thumbnail(Color::rgba(0.16, 0.31, 0.88, 1.0)),
8209 ),
8210 ),
8211 );
8212 let row = output
8213 .semantics
8214 .iter()
8215 .find(|node| {
8216 node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Paint")
8217 })
8218 .expect("layer row semantics present")
8219 .bounds;
8220
8221 assert_two_line_row_text_matches_slots(&output, "Paint", "Normal / 100%", row);
8222 }
8223
8224 #[test]
8225 fn layer_list_item_dynamic_detail_and_visibility_update_semantics() -> Result<()> {
8226 let detail = Rc::new(RefCell::new("Normal / 100%".to_string()));
8227 let detail_reader = Rc::clone(&detail);
8228 let visible = Rc::new(RefCell::new(true));
8229 let visible_reader = Rc::clone(&visible);
8230 let (mut runtime, window_id) = build_runtime(
8231 SizedBox::new().width(280.0).height(112.0).with_child(
8232 LayerList::new("Layers")
8233 .layers([
8234 LayerListItem::new("Paint")
8235 .detail_when(move || detail_reader.borrow().clone())
8236 .thumbnail(Color::rgba(0.16, 0.31, 0.88, 1.0))
8237 .visible_when(move || *visible_reader.borrow()),
8238 LayerListItem::new("Paper")
8239 .detail("Background")
8240 .thumbnail(Color::rgba(0.89, 0.91, 0.94, 1.0)),
8241 ])
8242 .selected(0),
8243 ),
8244 );
8245
8246 let output = runtime.render(window_id)?;
8247 let paint = output
8248 .semantics
8249 .iter()
8250 .find(|node| {
8251 node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Paint")
8252 })
8253 .expect("paint layer row semantics present");
8254 assert_eq!(paint.description.as_deref(), Some("Normal / 100%"));
8255 assert_eq!(
8256 paint.value,
8257 Some(SemanticsValue::Text(
8258 "Normal / 100%; Visible; Unlocked".to_string()
8259 ))
8260 );
8261
8262 *detail.borrow_mut() = "Normal / 50%".to_string();
8263 *visible.borrow_mut() = false;
8264 runtime.handle_event(
8265 window_id,
8266 Event::Window(WindowEvent::Resized(Size::new(280.0, 112.0))),
8267 )?;
8268 let output = runtime.render(window_id)?;
8269 let paint = output
8270 .semantics
8271 .iter()
8272 .find(|node| {
8273 node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Paint")
8274 })
8275 .expect("paint layer row semantics present");
8276 assert_eq!(paint.description.as_deref(), Some("Normal / 50%"));
8277 assert_eq!(
8278 paint.value,
8279 Some(SemanticsValue::Text(
8280 "Normal / 50%; Hidden; Unlocked".to_string()
8281 ))
8282 );
8283
8284 let visibility = output
8285 .semantics
8286 .iter()
8287 .find(|node| {
8288 node.role == SemanticsRole::Button
8289 && node.name.as_deref() == Some("Show Paint layer")
8290 })
8291 .expect("paint layer visibility control should update its label");
8292 assert_eq!(
8293 visibility.value,
8294 Some(SemanticsValue::Text("Hidden".to_string()))
8295 );
8296 assert_eq!(visibility.state.checked, Some(ToggleState::Unchecked));
8297 Ok(())
8298 }
8299
8300 #[test]
8301 fn layer_list_visibility_button_toggles_without_selecting_row() -> Result<()> {
8302 let selections = Rc::new(RefCell::new(Vec::new()));
8303 let on_select = Rc::clone(&selections);
8304 let visibility_changes = Rc::new(RefCell::new(Vec::new()));
8305 let on_visibility_change = Rc::clone(&visibility_changes);
8306 let (mut runtime, window_id) = build_runtime(
8307 SizedBox::new().width(280.0).height(112.0).with_child(
8308 LayerList::new("Layers")
8309 .layers([
8310 LayerListItem::new("Paint")
8311 .detail("Normal / 100%")
8312 .thumbnail(Color::rgba(0.16, 0.31, 0.88, 1.0)),
8313 LayerListItem::new("Paper")
8314 .detail("Background")
8315 .thumbnail(Color::rgba(0.89, 0.91, 0.94, 1.0)),
8316 ])
8317 .selected(0)
8318 .on_select(move |index, label| {
8319 on_select.borrow_mut().push((index, label));
8320 })
8321 .on_visibility_change(move |index, visible| {
8322 on_visibility_change.borrow_mut().push((index, visible));
8323 }),
8324 ),
8325 );
8326
8327 let output = runtime.render(window_id)?;
8328 let visibility = output
8329 .semantics
8330 .iter()
8331 .find(|node| {
8332 node.role == SemanticsRole::Button
8333 && node.name.as_deref() == Some("Hide Paper layer")
8334 })
8335 .expect("paper layer visibility control should exist");
8336 let position = Point::new(
8337 visibility.bounds.x() + (visibility.bounds.width() * 0.5),
8338 visibility.bounds.y() + (visibility.bounds.height() * 0.5),
8339 );
8340
8341 runtime.handle_event(
8342 window_id,
8343 primary_pointer(PointerEventKind::Down, position, true),
8344 )?;
8345 runtime.handle_event(
8346 window_id,
8347 primary_pointer(PointerEventKind::Up, position, false),
8348 )?;
8349
8350 assert!(selections.borrow().is_empty());
8351 assert_eq!(visibility_changes.borrow().as_slice(), &[(1, false)]);
8352
8353 let output = runtime.render(window_id)?;
8354 let paint = output
8355 .semantics
8356 .iter()
8357 .find(|node| {
8358 node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Paint")
8359 })
8360 .expect("paint layer row should still exist");
8361 assert!(paint.state.selected);
8362
8363 let paper = output
8364 .semantics
8365 .iter()
8366 .find(|node| {
8367 node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Paper")
8368 })
8369 .expect("paper layer row should still exist");
8370 assert!(!paper.state.selected);
8371 assert_eq!(
8372 paper.value,
8373 Some(SemanticsValue::Text(
8374 "Background; Hidden; Unlocked".to_string()
8375 ))
8376 );
8377
8378 let visibility = output
8379 .semantics
8380 .iter()
8381 .find(|node| {
8382 node.role == SemanticsRole::Button
8383 && node.name.as_deref() == Some("Show Paper layer")
8384 })
8385 .expect("paper layer visibility control should update its label");
8386 assert_eq!(
8387 visibility.value,
8388 Some(SemanticsValue::Text("Hidden".to_string()))
8389 );
8390 assert_eq!(visibility.state.checked, Some(ToggleState::Unchecked));
8391 Ok(())
8392 }
8393
8394 #[test]
8395 fn layer_list_lock_button_toggles_without_selecting_row() -> Result<()> {
8396 let selections = Rc::new(RefCell::new(Vec::new()));
8397 let on_select = Rc::clone(&selections);
8398 let lock_changes = Rc::new(RefCell::new(Vec::new()));
8399 let on_lock_change = Rc::clone(&lock_changes);
8400 let (mut runtime, window_id) = build_runtime(
8401 SizedBox::new().width(280.0).height(112.0).with_child(
8402 LayerList::new("Layers")
8403 .layers([
8404 LayerListItem::new("Paint")
8405 .detail("Normal / 100%")
8406 .thumbnail(Color::rgba(0.16, 0.31, 0.88, 1.0)),
8407 LayerListItem::new("Paper")
8408 .detail("Background")
8409 .thumbnail(Color::rgba(0.89, 0.91, 0.94, 1.0)),
8410 ])
8411 .selected(0)
8412 .on_select(move |index, label| {
8413 on_select.borrow_mut().push((index, label));
8414 })
8415 .on_lock_change(move |index, locked| {
8416 on_lock_change.borrow_mut().push((index, locked));
8417 }),
8418 ),
8419 );
8420
8421 let output = runtime.render(window_id)?;
8422 let lock = output
8423 .semantics
8424 .iter()
8425 .find(|node| {
8426 node.role == SemanticsRole::Button
8427 && node.name.as_deref() == Some("Lock Paper layer")
8428 })
8429 .expect("paper layer lock control should exist");
8430 let position = Point::new(
8431 lock.bounds.x() + (lock.bounds.width() * 0.5),
8432 lock.bounds.y() + (lock.bounds.height() * 0.5),
8433 );
8434
8435 runtime.handle_event(
8436 window_id,
8437 primary_pointer(PointerEventKind::Down, position, true),
8438 )?;
8439 runtime.handle_event(
8440 window_id,
8441 primary_pointer(PointerEventKind::Up, position, false),
8442 )?;
8443
8444 assert!(selections.borrow().is_empty());
8445 assert_eq!(lock_changes.borrow().as_slice(), &[(1, true)]);
8446
8447 let output = runtime.render(window_id)?;
8448 let paint = output
8449 .semantics
8450 .iter()
8451 .find(|node| {
8452 node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Paint")
8453 })
8454 .expect("paint layer row should still exist");
8455 assert!(paint.state.selected);
8456
8457 let paper = output
8458 .semantics
8459 .iter()
8460 .find(|node| {
8461 node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Paper")
8462 })
8463 .expect("paper layer row should still exist");
8464 assert!(!paper.state.selected);
8465 assert_eq!(
8466 paper.value,
8467 Some(SemanticsValue::Text(
8468 "Background; Visible; Locked".to_string()
8469 ))
8470 );
8471
8472 let lock = output
8473 .semantics
8474 .iter()
8475 .find(|node| {
8476 node.role == SemanticsRole::Button
8477 && node.name.as_deref() == Some("Unlock Paper layer")
8478 })
8479 .expect("paper layer lock control should update its label");
8480 assert_eq!(lock.value, Some(SemanticsValue::Text("Locked".to_string())));
8481 assert_eq!(lock.state.checked, Some(ToggleState::Checked));
8482 Ok(())
8483 }
8484
8485 #[test]
8486 fn layer_list_row_ids_are_javascript_safe_and_distinct() {
8487 let parent = WidgetId::new(402);
8488 let mut ids = (0..8)
8489 .flat_map(|index| {
8490 [
8491 super::layer_list_row_id(parent, index).get(),
8492 super::layer_list_visibility_id(parent, index).get(),
8493 super::layer_list_lock_id(parent, index).get(),
8494 ]
8495 })
8496 .collect::<Vec<_>>();
8497
8498 assert!(ids.iter().all(|id| *id <= ((1_u64 << 53) - 1)));
8499 assert!(ids.iter().all(|id| *id != parent.get()));
8500 ids.sort_unstable();
8501 ids.dedup();
8502 assert_eq!(ids.len(), 24);
8503 }
8504
8505 #[test]
8506 fn list_item_child_widget_receives_pointer_events() -> Result<()> {
8507 let presses = Rc::new(RefCell::new(0));
8508 let on_press = Rc::clone(&presses);
8509 let row = Stack::horizontal()
8510 .spacing(8.0)
8511 .with_child(SizedBox::new().width(96.0).with_child(Label::new("Asset")))
8512 .with_child(Button::new("Open").on_press(move || *on_press.borrow_mut() += 1));
8513 let (mut runtime, window_id) =
8514 build_runtime(SizedBox::new().width(260.0).height(80.0).with_child(
8515 ListView::new("Actions").item(ListItem::new("Asset").with_content(row)),
8516 ));
8517
8518 let _ = runtime.render(window_id)?;
8519 runtime.handle_event(
8520 window_id,
8521 primary_pointer(PointerEventKind::Down, Point::new(136.0, 28.0), true),
8522 )?;
8523 runtime.handle_event(
8524 window_id,
8525 primary_pointer(PointerEventKind::Up, Point::new(136.0, 28.0), false),
8526 )?;
8527
8528 assert_eq!(*presses.borrow(), 1);
8529 let output = runtime.render(window_id)?;
8530 assert!(
8531 output
8532 .semantics
8533 .iter()
8534 .any(|node| node.role == SemanticsRole::Button
8535 && node.name.as_deref() == Some("Open"))
8536 );
8537 Ok(())
8538 }
8539
8540 #[test]
8541 fn list_item_child_row_can_opt_into_row_activation() -> Result<()> {
8542 let row_changes = Rc::new(RefCell::new(Vec::new()));
8543 let button_presses = Rc::new(RefCell::new(0));
8544 let on_row = Rc::clone(&row_changes);
8545 let on_button = Rc::clone(&button_presses);
8546 let row = Stack::horizontal()
8547 .spacing(8.0)
8548 .with_child(SizedBox::new().width(96.0).with_child(Label::new("Asset")))
8549 .with_child(Button::new("Open").on_press(move || *on_button.borrow_mut() += 1));
8550 let item = ListItem::new("Asset")
8551 .semantic_name("Asset row")
8552 .description("Selectable asset row")
8553 .activate_with_content()
8554 .with_content(row);
8555 let (mut runtime, window_id) = build_runtime(
8556 SizedBox::new().width(260.0).height(80.0).with_child(
8557 ListView::new("Actions")
8558 .item(item)
8559 .on_change(move |index, label| {
8560 on_row.borrow_mut().push((index, label));
8561 }),
8562 ),
8563 );
8564
8565 let _ = runtime.render(window_id)?;
8566 runtime.handle_event(
8567 window_id,
8568 primary_pointer(PointerEventKind::Down, Point::new(36.0, 28.0), true),
8569 )?;
8570 runtime.handle_event(
8571 window_id,
8572 primary_pointer(PointerEventKind::Up, Point::new(36.0, 28.0), false),
8573 )?;
8574
8575 assert_eq!(row_changes.borrow().as_slice(), &[(0, "Asset".to_string())]);
8576 assert_eq!(*button_presses.borrow(), 0);
8577
8578 runtime.handle_event(
8579 window_id,
8580 primary_pointer(PointerEventKind::Down, Point::new(136.0, 28.0), true),
8581 )?;
8582 runtime.handle_event(
8583 window_id,
8584 primary_pointer(PointerEventKind::Up, Point::new(136.0, 28.0), false),
8585 )?;
8586
8587 assert_eq!(
8588 row_changes.borrow().as_slice(),
8589 &[(0, "Asset".to_string())],
8590 "nested button clicks should not also activate the row"
8591 );
8592 assert_eq!(*button_presses.borrow(), 1);
8593
8594 let output = runtime.render(window_id)?;
8595 let row = output
8596 .semantics
8597 .iter()
8598 .find(|node| {
8599 node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Asset row")
8600 })
8601 .expect("custom child row should expose list-item semantics");
8602 assert_eq!(row.description.as_deref(), Some("Selectable asset row"));
8603 assert!(row.actions.contains(&SemanticsAction::Activate));
8604 Ok(())
8605 }
8606
8607 #[test]
8608 fn list_item_child_respects_explicit_row_height() -> Result<()> {
8609 let row_changes = Rc::new(RefCell::new(Vec::new()));
8610 let on_row = Rc::clone(&row_changes);
8611 let item = ListItem::new("Tall asset")
8612 .activate_with_child()
8613 .with_child(
8614 SizedBox::new()
8615 .height(180.0)
8616 .with_child(Label::new("Tall custom row")),
8617 );
8618 let (mut runtime, window_id) = build_runtime(
8619 SizedBox::new().width(260.0).height(96.0).with_child(
8620 ListView::new("Assets")
8621 .row_height(36.0)
8622 .item(item)
8623 .on_change(move |index, label| {
8624 on_row.borrow_mut().push((index, label));
8625 }),
8626 ),
8627 );
8628
8629 let output = runtime.render(window_id)?;
8630 let row = output
8631 .semantics
8632 .iter()
8633 .find(|node| {
8634 node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Tall asset")
8635 })
8636 .expect("fixed-height child row should expose list-item semantics");
8637 assert!(
8638 (row.bounds.height() - 36.0).abs() <= 0.5,
8639 "explicit row height should cap oversized child content, got {:?}",
8640 row.bounds
8641 );
8642
8643 let position = Point::new(
8644 row.bounds.x() + row.bounds.width() * 0.5,
8645 row.bounds.y() + row.bounds.height() * 0.5,
8646 );
8647 runtime.handle_event(
8648 window_id,
8649 primary_pointer(PointerEventKind::Down, position, true),
8650 )?;
8651 runtime.handle_event(
8652 window_id,
8653 primary_pointer(PointerEventKind::Up, position, false),
8654 )?;
8655
8656 assert_eq!(
8657 row_changes.borrow().as_slice(),
8658 &[(0, "Tall asset".to_string())]
8659 );
8660 Ok(())
8661 }
8662
8663 #[test]
8664 fn list_item_child_widget_rearranges_when_scrolled() -> Result<()> {
8665 let (mut runtime, window_id) = build_runtime(
8666 SizedBox::new().width(260.0).height(96.0).with_child(
8667 ListView::new("Assets")
8668 .padding(Insets::ZERO)
8669 .row_height(40.0)
8670 .items([
8671 ListItem::new("First"),
8672 ListItem::new("Custom row").with_content(Label::new("Floating child")),
8673 ListItem::new("Third"),
8674 ListItem::new("Fourth"),
8675 ]),
8676 ),
8677 );
8678
8679 let before = runtime.render(window_id)?;
8680 let before_child = semantic_bounds(&before, SemanticsRole::Text, "Floating child");
8681
8682 runtime.handle_event(
8683 window_id,
8684 wheel_scroll(Point::new(32.0, 32.0), Vector::new(0.0, -20.0)),
8685 )?;
8686
8687 let after = runtime.render(window_id)?;
8688 let after_child = semantic_bounds(&after, SemanticsRole::Text, "Floating child");
8689
8690 assert!(
8691 (before_child.y() - after_child.y() - 20.0).abs() < 0.5,
8692 "custom list child should move with scroll: before={before_child:?}, after={after_child:?}"
8693 );
8694 Ok(())
8695 }
8696
8697 #[test]
8698 fn list_and_tree_padding_overrides_inset_row_viewports() {
8699 let padding = Insets {
8700 left: 24.0,
8701 top: 16.0,
8702 right: 20.0,
8703 bottom: 12.0,
8704 };
8705 let list = render(
8706 SizedBox::new().width(320.0).height(120.0).with_child(
8707 ListView::new("Assets")
8708 .padding(padding)
8709 .item(ListItem::new("Asset")),
8710 ),
8711 );
8712 let list_row = list
8713 .semantics
8714 .iter()
8715 .find(|node| {
8716 node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Asset")
8717 })
8718 .expect("padded list row semantics");
8719 assert!((list_row.bounds.x() - padding.left).abs() < 0.01);
8720 assert!((list_row.bounds.y() - padding.top).abs() < 0.01);
8721 assert!((list_row.bounds.width() - (320.0 - padding.left - padding.right)).abs() < 0.01);
8722
8723 let tree = render(
8724 SizedBox::new().width(320.0).height(120.0).with_child(
8725 TreeView::new("Scene")
8726 .padding(padding)
8727 .item(TreeItem::new("Node")),
8728 ),
8729 );
8730 let tree_row = tree
8731 .semantics
8732 .iter()
8733 .find(|node| {
8734 node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Node")
8735 })
8736 .expect("padded tree row semantics");
8737 assert!((tree_row.bounds.x() - padding.left).abs() < 0.01);
8738 assert!((tree_row.bounds.y() - padding.top).abs() < 0.01);
8739 assert!((tree_row.bounds.width() - (320.0 - padding.left - padding.right)).abs() < 0.01);
8740 }
8741
8742 #[test]
8743 fn tree_item_content_widget_receives_pointer_events_and_drives_row_height() -> Result<()> {
8744 let presses = Rc::new(RefCell::new(0));
8745 let changes = Rc::new(RefCell::new(Vec::new()));
8746 let on_press = Rc::clone(&presses);
8747 let on_change = Rc::clone(&changes);
8748 let content = SizedBox::new().height(52.0).with_child(
8749 Stack::horizontal()
8750 .spacing(8.0)
8751 .with_child(SizedBox::new().width(96.0).with_child(Label::new("Asset")))
8752 .with_child(Button::new("Open").on_press(move || *on_press.borrow_mut() += 1)),
8753 );
8754 let padding = Insets::all(12.0);
8755 let (mut runtime, window_id) = build_runtime(
8756 SizedBox::new().width(320.0).height(120.0).with_child(
8757 TreeView::new("Scene")
8758 .padding(padding)
8759 .item(
8760 TreeItem::new("Root")
8761 .with_child(TreeItem::new("Asset row").with_content(content)),
8762 )
8763 .on_change(move |path, label| {
8764 on_change.borrow_mut().push((path, label));
8765 }),
8766 ),
8767 );
8768
8769 let collapsed = runtime.render(window_id)?;
8770 let root_id = collapsed
8771 .semantics
8772 .iter()
8773 .find(|node| {
8774 node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Root")
8775 })
8776 .expect("collapsed tree root semantics")
8777 .id;
8778 assert!(runtime.handle_semantics_action(
8779 window_id,
8780 root_id,
8781 SemanticsActionRequest::Expand,
8782 )?);
8783 let before = runtime.render(window_id)?;
8784 let row = before
8785 .semantics
8786 .iter()
8787 .find(|node| {
8788 node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Asset row")
8789 })
8790 .expect("custom tree row semantics");
8791 let button = before
8792 .semantics
8793 .iter()
8794 .find(|node| node.role == SemanticsRole::Button && node.name.as_deref() == Some("Open"))
8795 .expect("custom tree content button semantics");
8796 assert!(row.bounds.y() > padding.top);
8797 assert!(
8798 row.bounds.height() >= 52.0,
8799 "custom content should determine the tree row height"
8800 );
8801 assert!(
8802 !row.actions.contains(&SemanticsAction::Activate),
8803 "interactive custom content should own pointer activation by default"
8804 );
8805
8806 let position = Point::new(
8807 button.bounds.x() + button.bounds.width() * 0.5,
8808 button.bounds.y() + button.bounds.height() * 0.5,
8809 );
8810 runtime.handle_event(
8811 window_id,
8812 primary_pointer(PointerEventKind::Down, position, true),
8813 )?;
8814 runtime.handle_event(
8815 window_id,
8816 primary_pointer(PointerEventKind::Up, position, false),
8817 )?;
8818
8819 assert_eq!(*presses.borrow(), 1);
8820 assert!(changes.borrow().is_empty());
8821 Ok(())
8822 }
8823
8824 #[test]
8825 fn tree_item_child_widget_rearranges_when_scrolled() -> Result<()> {
8826 let (mut runtime, window_id) = build_runtime(
8827 SizedBox::new().width(320.0).height(104.0).with_child(
8828 TreeView::new("Scene")
8829 .padding(Insets::ZERO)
8830 .row_height(40.0)
8831 .item(
8832 TreeItem::new("Root")
8833 .expanded(true)
8834 .with_child(TreeItem::new("First child"))
8835 .with_child(
8836 TreeItem::new("Custom tree row")
8837 .with_content(Label::new("Floating tree child")),
8838 )
8839 .with_child(TreeItem::new("Third child")),
8840 ),
8841 ),
8842 );
8843
8844 let before = runtime.render(window_id)?;
8845 let before_child = semantic_bounds(&before, SemanticsRole::Text, "Floating tree child");
8846
8847 runtime.handle_event(
8848 window_id,
8849 wheel_scroll(Point::new(32.0, 32.0), Vector::new(0.0, -24.0)),
8850 )?;
8851
8852 let after = runtime.render(window_id)?;
8853 let after_child = semantic_bounds(&after, SemanticsRole::Text, "Floating tree child");
8854
8855 assert!(
8856 (before_child.y() - after_child.y() - 24.0).abs() < 0.5,
8857 "custom tree child should move with scroll: before={before_child:?}, after={after_child:?}"
8858 );
8859 Ok(())
8860 }
8861
8862 #[test]
8863 fn tree_view_keyboard_expands_and_selects_child() -> Result<()> {
8864 let changes = Rc::new(RefCell::new(Vec::new()));
8865 let on_change = Rc::clone(&changes);
8866 let (mut runtime, window_id) = build_runtime(
8867 TreeView::new("Scene")
8868 .item(
8869 TreeItem::new("Root")
8870 .with_child(TreeItem::new("Child A"))
8871 .with_child(TreeItem::new("Child B")),
8872 )
8873 .on_change(move |path, label| on_change.borrow_mut().push((path, label))),
8874 );
8875
8876 let _ = runtime.render(window_id)?;
8877 runtime.handle_event(
8878 window_id,
8879 primary_pointer(PointerEventKind::Down, Point::new(48.0, 26.0), true),
8880 )?;
8881 runtime.handle_event(
8882 window_id,
8883 primary_pointer(PointerEventKind::Up, Point::new(48.0, 26.0), false),
8884 )?;
8885 runtime.handle_event(
8886 window_id,
8887 Event::Keyboard(KeyboardEvent::new("ArrowRight", KeyState::Pressed)),
8888 )?;
8889 runtime.handle_event(
8890 window_id,
8891 Event::Keyboard(KeyboardEvent::new("ArrowDown", KeyState::Pressed)),
8892 )?;
8893
8894 assert!(changes.borrow().iter().any(|(_, label)| label == "Child A"));
8895
8896 let output = runtime.render(window_id)?;
8897 let tree = output
8898 .semantics
8899 .iter()
8900 .find(|node| node.role == SemanticsRole::Tree)
8901 .expect("tree semantics present");
8902 assert_eq!(
8903 tree.value,
8904 Some(SemanticsValue::Text("Child A".to_string()))
8905 );
8906 Ok(())
8907 }
8908
8909 #[test]
8910 fn tree_view_keyed_rows_support_accessible_expansion_and_activation() -> Result<()> {
8911 let changes = Rc::new(RefCell::new(Vec::new()));
8912 let on_change = Rc::clone(&changes);
8913 let (mut runtime, window_id) = build_runtime(
8914 SizedBox::new().width(320.0).height(140.0).with_child(
8915 TreeView::new("Scene")
8916 .item(
8917 TreeItem::new("Root")
8918 .key(42)
8919 .with_child(TreeItem::new("Child").key(7)),
8920 )
8921 .on_change(move |path, label| on_change.borrow_mut().push((path, label))),
8922 ),
8923 );
8924 let before = runtime.render(window_id)?;
8925 let root = before
8926 .semantics
8927 .iter()
8928 .find(|node| {
8929 node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Root")
8930 })
8931 .expect("root tree item");
8932 let root_id = root.id;
8933 assert!(root.actions.contains(&SemanticsAction::Expand));
8934
8935 assert!(runtime.handle_semantics_action(
8936 window_id,
8937 root_id,
8938 SemanticsActionRequest::Expand,
8939 )?);
8940 let expanded = runtime.render(window_id)?;
8941 let expanded_root = expanded
8942 .semantics
8943 .iter()
8944 .find(|node| node.name.as_deref() == Some("Root"))
8945 .expect("expanded root");
8946 assert_eq!(expanded_root.id, root_id);
8947 let child = expanded
8948 .semantics
8949 .iter()
8950 .find(|node| node.name.as_deref() == Some("Child"))
8951 .expect("child tree item");
8952
8953 assert!(runtime.handle_semantics_action(
8954 window_id,
8955 child.id,
8956 SemanticsActionRequest::Activate,
8957 )?);
8958 assert!(changes.borrow().iter().any(|(_, label)| label == "Child"));
8959 Ok(())
8960 }
8961
8962 #[test]
8963 fn table_keyboard_selects_next_row() -> Result<()> {
8964 let changes = Rc::new(RefCell::new(Vec::new()));
8965 let on_change = Rc::clone(&changes);
8966 let (mut runtime, window_id) = build_runtime(
8967 Table::new("Materials")
8968 .columns([TableColumn::new("Name"), TableColumn::new("Passes")])
8969 .rows([TableRow::new(["Glass", "3"]), TableRow::new(["Water", "4"])])
8970 .on_change(move |index| on_change.borrow_mut().push(index)),
8971 );
8972
8973 let _ = runtime.render(window_id)?;
8974 runtime.handle_event(
8975 window_id,
8976 primary_pointer(PointerEventKind::Down, Point::new(60.0, 72.0), true),
8977 )?;
8978 runtime.handle_event(
8979 window_id,
8980 primary_pointer(PointerEventKind::Up, Point::new(60.0, 72.0), false),
8981 )?;
8982 runtime.handle_event(
8983 window_id,
8984 Event::Keyboard(KeyboardEvent::new("ArrowDown", KeyState::Pressed)),
8985 )?;
8986
8987 assert!(changes.borrow().contains(&1));
8988
8989 let output = runtime.render(window_id)?;
8990 let table = output
8991 .semantics
8992 .iter()
8993 .find(|node| node.role == SemanticsRole::Table)
8994 .expect("table semantics present");
8995 assert_eq!(table.value, Some(SemanticsValue::Text("Water".to_string())));
8996 Ok(())
8997 }
8998
8999 #[test]
9000 fn virtual_table_semantics_include_columns_and_visible_rows() {
9001 let output = render(
9002 SizedBox::new().width(360.0).height(120.0).with_child(
9003 VirtualTable::new("Files")
9004 .columns([
9005 VirtualTableColumn::new("Name").min_width(160.0),
9006 VirtualTableColumn::new("Kind").width(80.0),
9007 ])
9008 .row_count(100)
9009 .row_height(20.0)
9010 .header_height(24.0)
9011 .row_name(|index| format!("Row {index}"))
9012 .row_description(|index| format!("File row {index}")),
9013 ),
9014 );
9015
9016 let table = output
9017 .semantics
9018 .iter()
9019 .find(|node| node.role == SemanticsRole::Table)
9020 .expect("virtual table semantics present");
9021 assert_eq!(table.name.as_deref(), Some("Files"));
9022 assert_eq!(
9023 table.value,
9024 Some(SemanticsValue::Text("100 rows".to_string()))
9025 );
9026 assert!(table.description.as_deref().is_some_and(|description| {
9027 description.contains("Columns: Name, Kind") && description.contains("of 100")
9028 }));
9029
9030 let rows = output
9031 .semantics
9032 .iter()
9033 .filter(|node| node.role == SemanticsRole::ListItem)
9034 .collect::<Vec<_>>();
9035 assert!(!rows.is_empty());
9036 assert!(
9037 rows.len() < 100,
9038 "virtual table should expose only visible rows, got {}",
9039 rows.len()
9040 );
9041 assert_eq!(rows[0].name.as_deref(), Some("Row 0"));
9042 assert_eq!(
9043 rows[0].description.as_deref(),
9044 Some("File row 0; row 1 of 100")
9045 );
9046 }
9047
9048 #[test]
9049 fn virtual_table_supports_variable_row_heights() {
9050 let output = render(
9051 SizedBox::new().width(360.0).height(180.0).with_child(
9052 VirtualTable::new("Variable rows")
9053 .columns([VirtualTableColumn::new("Name")])
9054 .row_count(3)
9055 .row_heights([20.0, 44.0, 28.0])
9056 .row_name(|index| format!("Row {index}")),
9057 ),
9058 );
9059 let rows = output
9060 .semantics
9061 .iter()
9062 .filter(|node| node.role == SemanticsRole::ListItem)
9063 .collect::<Vec<_>>();
9064 assert_eq!(rows.len(), 3);
9065 assert_eq!(rows[0].bounds.height(), 20.0);
9066 assert_eq!(rows[1].bounds.height(), 44.0);
9067 assert_eq!(rows[2].bounds.height(), 28.0);
9068 assert_eq!(rows[1].bounds.y(), rows[0].bounds.max_y());
9069 }
9070
9071 #[test]
9072 fn virtual_table_row_keys_stabilize_semantics_across_reordering() -> Result<()> {
9073 let keys = Rc::new(RefCell::new(vec![42_u64, 7]));
9074 let key_reader = Rc::clone(&keys);
9075 let name_reader = Rc::clone(&keys);
9076 let (mut runtime, window_id) = build_runtime(
9077 SizedBox::new().width(360.0).height(140.0).with_child(
9078 VirtualTable::new("Keyed rows")
9079 .columns([VirtualTableColumn::new("Name")])
9080 .row_count(2)
9081 .row_key(move |index| key_reader.borrow()[index])
9082 .row_name(move |index| format!("Row {}", name_reader.borrow()[index])),
9083 ),
9084 );
9085 let before = runtime.render(window_id)?;
9086 let before_id = before
9087 .semantics
9088 .iter()
9089 .find(|node| node.name.as_deref() == Some("Row 42"))
9090 .expect("row 42 semantics")
9091 .id;
9092
9093 keys.borrow_mut().swap(0, 1);
9094 runtime.handle_event(
9095 window_id,
9096 Event::Pointer(PointerEvent::new(
9097 PointerEventKind::Move,
9098 Point::new(20.0, 80.0),
9099 )),
9100 )?;
9101 let after = runtime.render(window_id)?;
9102 let after_id = after
9103 .semantics
9104 .iter()
9105 .find(|node| node.name.as_deref() == Some("Row 42"))
9106 .expect("reordered row 42 semantics")
9107 .id;
9108 assert_eq!(before_id, after_id);
9109 Ok(())
9110 }
9111
9112 #[test]
9113 fn virtual_table_state_retains_keyed_selection_across_reordering() -> Result<()> {
9114 let keys = Rc::new(RefCell::new(vec![42_u64, 7]));
9115 let key_reader = Rc::clone(&keys);
9116 let name_reader = Rc::clone(&keys);
9117 let state = VirtualTableState::new();
9118 state.select_key(Some(42));
9119 let (mut runtime, window_id) = build_runtime(
9120 SizedBox::new().width(360.0).height(140.0).with_child(
9121 VirtualTable::new("Retained keyed rows")
9122 .state(state.clone())
9123 .columns([VirtualTableColumn::new("Name")])
9124 .row_count(2)
9125 .row_key(move |index| key_reader.borrow()[index])
9126 .row_name(move |index| format!("Row {}", name_reader.borrow()[index])),
9127 ),
9128 );
9129
9130 let before = runtime.render(window_id)?;
9131 assert!(
9132 before
9133 .semantics
9134 .iter()
9135 .find(|node| node.name.as_deref() == Some("Row 42"))
9136 .is_some_and(|node| node.state.selected)
9137 );
9138
9139 keys.borrow_mut().swap(0, 1);
9140 runtime.handle_event(
9141 window_id,
9142 Event::Pointer(PointerEvent::new(
9143 PointerEventKind::Move,
9144 Point::new(20.0, 80.0),
9145 )),
9146 )?;
9147 let after = runtime.render(window_id)?;
9148 assert!(
9149 after
9150 .semantics
9151 .iter()
9152 .find(|node| node.name.as_deref() == Some("Row 42"))
9153 .is_some_and(|node| node.state.selected)
9154 );
9155 assert_eq!(state.selected_key(), Some(42));
9156
9157 state.select_key(None);
9158 let cleared = runtime.render(window_id)?;
9159 assert!(
9160 cleared
9161 .semantics
9162 .iter()
9163 .filter(|node| node.role == SemanticsRole::ListItem)
9164 .all(|node| !node.state.selected)
9165 );
9166 Ok(())
9167 }
9168
9169 #[test]
9170 fn paged_virtual_table_reports_global_range_and_supports_keyed_scroll() -> Result<()> {
9171 let state = VirtualTableState::new();
9172 state.scroll_to(900, ScrollAlignment::Start);
9173 let (mut runtime, window_id) = build_runtime(
9174 SizedBox::new().width(360.0).height(140.0).with_child(
9175 VirtualTable::new("Files")
9176 .state(state.clone())
9177 .columns([VirtualTableColumn::new("Name")])
9178 .collection_window(CollectionWindow::loaded(
9179 500..1_012,
9180 Some(5_000),
9181 true,
9182 true,
9183 ))
9184 .row_count(512)
9185 .row_height(20.0)
9186 .row_key(|index| 500 + index as u64)
9187 .row_name(|index| format!("File {}", 500 + index)),
9188 ),
9189 );
9190
9191 let output = runtime.render(window_id)?;
9192 let viewport = state.viewport();
9193 assert_eq!(viewport.loaded_range, 500..1_012);
9194 assert_eq!(viewport.visible_range.start, 900);
9195 assert_eq!(viewport.total_count, Some(5_000));
9196 assert_eq!(viewport.anchor.as_ref().map(|anchor| anchor.key), Some(900));
9197
9198 let table = output
9199 .semantics
9200 .iter()
9201 .find(|node| node.role == SemanticsRole::Table)
9202 .expect("table semantics");
9203 assert_eq!(
9204 table.value,
9205 Some(SemanticsValue::Text("5000 rows".to_string()))
9206 );
9207 assert!(
9208 table
9209 .description
9210 .as_deref()
9211 .is_some_and(|description| description.contains("of 5000"))
9212 );
9213 let first_visible = output
9214 .semantics
9215 .iter()
9216 .find(|node| node.role == SemanticsRole::ListItem)
9217 .expect("visible table row");
9218 assert!(
9219 first_visible
9220 .description
9221 .as_deref()
9222 .is_some_and(|description| description.contains("901 of 5000"))
9223 );
9224 Ok(())
9225 }
9226
9227 #[test]
9228 fn virtual_table_state_retains_width_by_column_key() {
9229 let state = VirtualTableState::new();
9230 state.set_column_width(11, 184.0);
9231 let painted_width = Rc::new(RefCell::new(0.0));
9232 let width = Rc::clone(&painted_width);
9233 let _ = render(
9234 SizedBox::new().width(360.0).height(140.0).with_child(
9235 VirtualTable::new("Retained widths")
9236 .state(state.clone())
9237 .columns([
9238 VirtualTableColumn::new("Name").key(11),
9239 VirtualTableColumn::new("Kind").key(12).width(80.0),
9240 ])
9241 .row_count(1)
9242 .row_painter(move |_ctx, row| {
9243 *width.borrow_mut() = row.column_rects[0].width();
9244 }),
9245 ),
9246 );
9247 assert_eq!(*painted_width.borrow(), 184.0);
9248 assert_eq!(state.column_width(11), Some(184.0));
9249 }
9250
9251 #[test]
9252 fn virtual_table_column_separator_drag_resizes_column() -> Result<()> {
9253 let resized = Rc::new(RefCell::new(Vec::new()));
9254 let resize_events = Rc::clone(&resized);
9255 let theme = DefaultTheme::default();
9256 let width = 360.0;
9257 let padding = theme.metrics.data_viewport_padding;
9258 let available = width - padding.left - padding.right;
9259 let separator_x = padding.left + available - 80.0;
9260 let header_y = padding.top + theme.metrics.table_header_height * 0.5;
9261 let (mut runtime, window_id) = build_runtime(
9262 SizedBox::new().width(width).height(140.0).with_child(
9263 VirtualTable::new("Resizable")
9264 .theme(theme)
9265 .columns([
9266 VirtualTableColumn::new("Name").min_width(120.0),
9267 VirtualTableColumn::new("Kind").width(80.0).resizable(false),
9268 ])
9269 .row_count(2)
9270 .on_column_resize(move |index, width| {
9271 resize_events.borrow_mut().push((index, width));
9272 }),
9273 ),
9274 );
9275 runtime.render(window_id)?;
9276 runtime.handle_event(
9277 window_id,
9278 primary_pointer(
9279 PointerEventKind::Down,
9280 Point::new(separator_x, header_y),
9281 true,
9282 ),
9283 )?;
9284 runtime.handle_event(
9285 window_id,
9286 primary_pointer(
9287 PointerEventKind::Move,
9288 Point::new(separator_x + 32.0, header_y),
9289 true,
9290 ),
9291 )?;
9292 runtime.handle_event(
9293 window_id,
9294 primary_pointer(
9295 PointerEventKind::Up,
9296 Point::new(separator_x + 32.0, header_y),
9297 false,
9298 ),
9299 )?;
9300
9301 let events = resized.borrow();
9302 assert!(!events.is_empty());
9303 assert_eq!(events.last().map(|event| event.0), Some(0));
9304 assert!(
9305 events
9306 .last()
9307 .is_some_and(|event| event.1 > available - 80.0)
9308 );
9309 Ok(())
9310 }
9311
9312 #[test]
9313 fn virtual_table_pinned_columns_hold_position_during_horizontal_scroll() -> Result<()> {
9314 let painted = Rc::new(RefCell::new(Vec::<Vec<Rect>>::new()));
9315 let row_rects = Rc::clone(&painted);
9316 let (mut runtime, window_id) = build_runtime(
9317 SizedBox::new().width(220.0).height(140.0).with_child(
9318 VirtualTable::new("Pinned")
9319 .columns([
9320 VirtualTableColumn::new("Name").width(100.0).pinned(true),
9321 VirtualTableColumn::new("Kind").width(100.0),
9322 VirtualTableColumn::new("Status").width(100.0),
9323 ])
9324 .row_count(2)
9325 .row_painter(move |_ctx, row| {
9326 if row.row_index == 0 {
9327 row_rects.borrow_mut().push(row.column_rects.to_vec());
9328 }
9329 }),
9330 ),
9331 );
9332 runtime.render(window_id)?;
9333 let before = painted.borrow().last().cloned().expect("first row painted");
9334
9335 runtime.handle_event(
9336 window_id,
9337 wheel_scroll(Point::new(120.0, 80.0), Vector::new(-80.0, 0.0)),
9338 )?;
9339 runtime.render(window_id)?;
9340 let after = painted
9341 .borrow()
9342 .last()
9343 .cloned()
9344 .expect("scrolled row painted");
9345
9346 assert_eq!(before[0].x(), after[0].x());
9347 assert!(after[1].width() < before[1].width());
9348 assert!(after[2].x() < before[2].x());
9349 Ok(())
9350 }
9351
9352 #[test]
9353 fn table_numeric_column_uses_tabular_figures_and_shared_right_edge() {
9354 let output = render(
9355 SizedBox::new().width(360.0).height(140.0).with_child(
9356 Table::new("Materials")
9357 .columns([
9358 TableColumn::new("Name"),
9359 TableColumn::new("Passes").numeric(),
9360 ])
9361 .rows([
9362 TableRow::new(["Glass", "3"]),
9363 TableRow::new(["Water", "128"]),
9364 ]),
9365 ),
9366 );
9367 let short = text_runs_for(&output, "3")
9368 .into_iter()
9369 .find(|run| {
9370 run.style
9371 .features
9372 .iter()
9373 .any(|feature| feature.tag == FontFeature::TABULAR_FIGURES)
9374 })
9375 .expect("short numeric cell should be tabular");
9376 let long = text_runs_for(&output, "128")
9377 .into_iter()
9378 .next()
9379 .expect("long numeric cell should render");
9380
9381 assert!(
9382 long.style
9383 .features
9384 .iter()
9385 .any(|feature| feature.tag == FontFeature::TABULAR_FIGURES && feature.value == 1)
9386 );
9387 assert!((short.rect.max_x() - long.rect.max_x()).abs() < 0.75);
9388 }
9389
9390 #[test]
9391 fn selected_table_cells_preserve_body_metrics_and_numeric_alignment() {
9392 let mut theme = DefaultTheme::default();
9393 theme.typography.body_font_size = 13.0;
9394 theme.typography.body_line_height = 21.0;
9395 let output = render(
9396 SizedBox::new().width(360.0).height(140.0).with_child(
9397 Table::new("Materials")
9398 .theme(theme)
9399 .columns([
9400 TableColumn::new("Name"),
9401 TableColumn::new("Passes").numeric(),
9402 ])
9403 .rows([
9404 TableRow::new(["Glass", "8642"]),
9405 TableRow::new(["Water", "7"]),
9406 ])
9407 .selected(0),
9408 ),
9409 );
9410 let selected_label = text_runs_for(&output, "Glass")
9411 .into_iter()
9412 .next()
9413 .expect("selected text cell should render");
9414 let selected_number = text_runs_for(&output, "8642")
9415 .into_iter()
9416 .next()
9417 .expect("selected numeric cell should render");
9418 let unselected_number = text_runs_for(&output, "7")
9419 .into_iter()
9420 .next()
9421 .expect("unselected numeric cell should render");
9422
9423 assert_eq!(selected_label.style.color, theme.palette.text);
9424 assert_eq!(
9425 selected_label.style.font_size,
9426 theme.typography.body_font_size
9427 );
9428 assert_eq!(
9429 selected_label.style.line_height,
9430 theme.typography.body_line_height
9431 );
9432 assert_eq!(selected_number.style.color, theme.palette.text);
9433 assert_eq!(
9434 selected_number.style.font_size,
9435 theme.typography.body_font_size
9436 );
9437 assert_eq!(
9438 selected_number.style.line_height,
9439 theme.typography.body_line_height
9440 );
9441 assert!(
9442 selected_number
9443 .style
9444 .features
9445 .iter()
9446 .any(|feature| feature.tag == FontFeature::TABULAR_FIGURES && feature.value == 1)
9447 );
9448 assert!((selected_number.rect.max_x() - unselected_number.rect.max_x()).abs() < 0.75);
9449 }
9450
9451 #[test]
9452 fn collection_and_path_widgets_theme_when_paints_dark_tokens() {
9453 let theme = DefaultTheme::dark();
9454 let list = render(
9455 SizedBox::new().width(320.0).height(120.0).with_child(
9456 ListView::new("Assets")
9457 .theme_when(move || theme)
9458 .item(ListItem::new("Hero texture").detail("2048 x 2048 RGBA")),
9459 ),
9460 );
9461 assert_eq!(
9462 text_runs_for(&list, "Hero texture")[0].style.color,
9463 theme.palette.text
9464 );
9465 assert!(solid_fill_colors(&list).contains(&theme.palette.surface));
9466
9467 let theme = DefaultTheme::dark();
9468 let tree = render(
9469 SizedBox::new().width(320.0).height(120.0).with_child(
9470 TreeView::new("Scene")
9471 .theme_when(move || theme)
9472 .item(TreeItem::new("Environment").detail("Visible")),
9473 ),
9474 );
9475 assert_eq!(
9476 text_runs_for(&tree, "Environment")[0].style.color,
9477 theme.palette.text
9478 );
9479 assert!(solid_fill_colors(&tree).contains(&theme.palette.surface));
9480
9481 let theme = DefaultTheme::dark();
9482 let table = render(
9483 SizedBox::new().width(320.0).height(140.0).with_child(
9484 Table::new("Materials")
9485 .theme_when(move || theme)
9486 .columns([TableColumn::new("Name")])
9487 .rows([TableRow::new(["Glass"])]),
9488 ),
9489 );
9490 let table_fills = solid_fill_colors(&table);
9491 assert!(table_fills.contains(&theme.palette.surface));
9492 assert!(table_fills.contains(&theme.palette.control));
9493 assert!(
9494 !table_fills.contains(&Color::rgba(0.95, 0.965, 0.985, 1.0)),
9495 "dark table header should not use the old hardcoded light fill"
9496 );
9497
9498 let theme = DefaultTheme::dark();
9499 let breadcrumb = render(Breadcrumb::new("Path").theme_when(move || theme).items([
9500 BreadcrumbItem::new("Workspace"),
9501 BreadcrumbItem::new("Project"),
9502 ]));
9503 assert_eq!(
9504 text_runs_for(&breadcrumb, "Workspace")[0].style.color,
9505 theme.palette.text
9506 );
9507 assert!(solid_fill_colors(&breadcrumb).contains(&theme.palette.surface));
9508 }
9509
9510 #[test]
9511 fn table_chrome_uses_theme_metrics() {
9512 let mut theme = DefaultTheme::default();
9513 theme.metrics.table_header_separator_inset = 7.0;
9514 theme.metrics.table_separator_width = 2.75;
9515 theme.metrics.table_row_border_opacity = 0.29;
9516 theme.metrics.data_scroll_thumb_width = 5.5;
9517 theme.metrics.data_scroll_thumb_inset = 9.0;
9518 theme.metrics.data_scroll_thumb_radius = 2.75;
9519 theme.metrics.data_scroll_thumb_min_length = 35.0;
9520 theme.metrics.data_scroll_thumb_opacity = 0.41;
9521 let rows = (0..10).map(|index| TableRow::new([format!("Row {index}"), format!("{index}")]));
9522
9523 let output = render(
9524 SizedBox::new().width(320.0).height(120.0).with_child(
9525 Table::new("Materials")
9526 .theme(theme)
9527 .columns([
9528 TableColumn::new("Name").width(160.0),
9529 TableColumn::new("Passes").width(80.0),
9530 ])
9531 .rows(rows),
9532 ),
9533 );
9534
9535 let expected_separator_height =
9536 theme.metrics.table_header_height - (theme.metrics.table_header_separator_inset * 2.0);
9537 assert!(solid_stroke_rects(&output).iter().any(|rect| {
9538 (rect.width() - theme.metrics.table_separator_width).abs() < 0.01
9539 && (rect.height() - expected_separator_height).abs() < 0.01
9540 }));
9541 assert!(
9542 solid_stroke_widths(&output)
9543 .iter()
9544 .any(|width| { (*width - theme.metrics.table_separator_width).abs() < 0.01 })
9545 );
9546 assert!(
9547 solid_stroke_colors(&output).contains(
9548 &theme
9549 .palette
9550 .border
9551 .with_alpha(theme.metrics.table_row_border_opacity)
9552 )
9553 );
9554 assert!(
9555 solid_fill_colors(&output).contains(
9556 &theme
9557 .palette
9558 .border_hover
9559 .with_alpha(theme.metrics.data_scroll_thumb_opacity)
9560 )
9561 );
9562 let thumb_color = theme
9563 .palette
9564 .border_hover
9565 .with_alpha(theme.metrics.data_scroll_thumb_opacity);
9566 let thumbs = solid_fill_bounds_for_color(&output, thumb_color);
9567 let header = solid_fill_bounds_for_color(&output, theme.palette.control)
9568 .into_iter()
9569 .find(|rect| (rect.height() - theme.metrics.table_header_height).abs() < 0.01)
9570 .expect("table header");
9571 assert!(!thumbs.is_empty());
9572 for thumb in thumbs {
9573 assert!(
9574 header.max_x() <= thumb.x(),
9575 "table columns must end before the scrollbar gutter"
9576 );
9577 assert!(thumb.max_x() <= 320.0 - theme.metrics.data_viewport_padding.right);
9578 }
9579 }
9580
9581 #[test]
9582 fn list_view_detail_text_does_not_overlap_primary_label() {
9583 let output = render(SizedBox::new().width(320.0).height(120.0).with_child(
9584 ListView::new("Assets").item(ListItem::new("Hero texture").detail("2048 x 2048 RGBA")),
9585 ));
9586
9587 let label = text_rects_for(&output, "Hero texture")[0];
9588 let detail = text_rects_for(&output, "2048 x 2048 RGBA")[0];
9589
9590 assert!(label.max_y() <= detail.y());
9591 }
9592
9593 #[test]
9594 fn list_view_label_and_detail_visual_centers_match_row_slots() {
9595 let theme = DefaultTheme::default();
9596 let output = render(SizedBox::new().width(320.0).height(72.0).with_child(
9597 ListView::new("Assets").item(ListItem::new("Hero texture").detail("2048 x 2048 RGBA")),
9598 ));
9599 let label = text_runs_for(&output, "Hero texture")
9600 .into_iter()
9601 .next()
9602 .expect("list row label draw command present");
9603 let detail = text_runs_for(&output, "2048 x 2048 RGBA")
9604 .into_iter()
9605 .next()
9606 .expect("list row detail draw command present");
9607 let viewport_padding = theme.metrics.data_viewport_padding;
9608 let row_height = theme
9609 .metrics
9610 .list_row_height
9611 .max(super::two_line_row_height(
9612 label.style.line_height,
9613 detail.style.line_height,
9614 ));
9615 let row = Rect::new(
9616 viewport_padding.left,
9617 viewport_padding.top,
9618 (output.frame.viewport.width - viewport_padding.left - viewport_padding.right).max(0.0),
9619 row_height,
9620 );
9621
9622 assert_two_line_row_text_matches_slots(&output, "Hero texture", "2048 x 2048 RGBA", row);
9623 }
9624
9625 #[test]
9626 fn data_detail_text_styles_follow_theme_xs_token() {
9627 let mut theme = DefaultTheme::default();
9628 theme.text.xs = ThemeTextToken {
9629 size: 10.5,
9630 line_height: 17.5,
9631 };
9632 theme.sync_derived_fields();
9633
9634 let list = render(
9635 SizedBox::new().width(320.0).height(72.0).with_child(
9636 ListView::new("Assets")
9637 .theme(theme)
9638 .item(ListItem::new("Hero texture").detail("2048 x 2048 RGBA")),
9639 ),
9640 );
9641 assert_text_run_uses_token(
9642 &text_runs_for(&list, "2048 x 2048 RGBA")
9643 .into_iter()
9644 .next()
9645 .expect("list detail should render"),
9646 theme.text.xs,
9647 );
9648
9649 let layer = render(
9650 SizedBox::new().width(280.0).height(72.0).with_child(
9651 LayerList::new("Layers").theme(theme).layer(
9652 LayerListItem::new("Paint")
9653 .detail("Normal / 100%")
9654 .thumbnail(Color::rgba(0.16, 0.31, 0.88, 1.0)),
9655 ),
9656 ),
9657 );
9658 assert_text_run_uses_token(
9659 &text_runs_for(&layer, "Normal / 100%")
9660 .into_iter()
9661 .next()
9662 .expect("layer detail should render"),
9663 theme.text.xs,
9664 );
9665
9666 let tree = render(
9667 SizedBox::new().width(320.0).height(72.0).with_child(
9668 TreeView::new("Scene")
9669 .theme(theme)
9670 .item(TreeItem::new("Environment").detail("Visible")),
9671 ),
9672 );
9673 assert_text_run_uses_token(
9674 &text_runs_for(&tree, "Visible")
9675 .into_iter()
9676 .next()
9677 .expect("tree detail should render"),
9678 theme.text.xs,
9679 );
9680 }
9681
9682 #[test]
9683 fn list_view_long_label_clips_to_single_line() {
9684 let title = "What tools are available to you when the session title is very long";
9685 let output = render(
9686 SizedBox::new()
9687 .width(170.0)
9688 .height(56.0)
9689 .with_child(ListView::new("Sessions").item(ListItem::new(title))),
9690 );
9691
9692 let run = text_runs_for(&output, title)
9693 .into_iter()
9694 .next()
9695 .expect("long title should be drawn");
9696 let clips = draw_clip_rects_for(&output, title);
9697
9698 assert_eq!(clips.len(), 1);
9699 assert!(
9700 clips[0].height() <= run.style.line_height + 0.5,
9701 "long single-line labels should clip wrapped overflow to one line; clip={:?}, line_height={}",
9702 clips[0],
9703 run.style.line_height
9704 );
9705 }
9706
9707 #[test]
9708 fn tree_view_detail_text_does_not_overlap_primary_label() {
9709 let output = render(SizedBox::new().width(320.0).height(120.0).with_child(
9710 TreeView::new("Scene").item(TreeItem::new("Environment").detail("Visible")),
9711 ));
9712
9713 let label = text_rects_for(&output, "Environment")[0];
9714 let detail = text_rects_for(&output, "Visible")[0];
9715
9716 assert!(label.max_y() <= detail.y());
9717 }
9718
9719 #[test]
9720 fn list_and_tree_detail_text_stays_grouped_with_primary_label() {
9721 let list = render(SizedBox::new().width(320.0).height(120.0).with_child(
9722 ListView::new("Assets").item(ListItem::new("Hero texture").detail("2048 x 2048 RGBA")),
9723 ));
9724 let tree = render(SizedBox::new().width(320.0).height(120.0).with_child(
9725 TreeView::new("Scene").item(TreeItem::new("Environment").detail("Visible")),
9726 ));
9727
9728 for (output, label_text, detail_text) in [
9729 (&list, "Hero texture", "2048 x 2048 RGBA"),
9730 (&tree, "Environment", "Visible"),
9731 ] {
9732 let label = text_rects_for(output, label_text)[0];
9733 let detail = text_rects_for(output, detail_text)[0];
9734 let gap = detail.y() - label.max_y();
9735
9736 assert!(
9737 (0.0..=2.5).contains(&gap),
9738 "expected {label_text:?} and {detail_text:?} to read as one row; gap was {gap}"
9739 );
9740 }
9741 }
9742
9743 #[test]
9744 fn tree_view_label_and_detail_visual_centers_match_row_slots() {
9745 let theme = DefaultTheme::default();
9746 let output = render(SizedBox::new().width(320.0).height(72.0).with_child(
9747 TreeView::new("Scene").item(TreeItem::new("Environment").detail("Visible")),
9748 ));
9749 let label = text_runs_for(&output, "Environment")
9750 .into_iter()
9751 .next()
9752 .expect("tree row label draw command present");
9753 let detail = text_runs_for(&output, "Visible")
9754 .into_iter()
9755 .next()
9756 .expect("tree row detail draw command present");
9757 let viewport_padding = theme.metrics.data_viewport_padding;
9758 let row_height = theme
9759 .metrics
9760 .tree_row_height
9761 .max(super::two_line_row_height(
9762 label.style.line_height,
9763 detail.style.line_height,
9764 ));
9765 let row = Rect::new(
9766 viewport_padding.left,
9767 viewport_padding.top,
9768 (output.frame.viewport.width - viewport_padding.left - viewport_padding.right).max(0.0),
9769 row_height,
9770 );
9771
9772 assert_two_line_row_text_matches_slots(&output, "Environment", "Visible", row);
9773 }
9774
9775 #[test]
9776 fn list_view_does_not_paint_internal_scroll_thumb() {
9777 let output = render(
9778 SizedBox::new().width(320.0).height(100.0).with_child(
9779 ListView::new("Assets")
9780 .items([
9781 ListItem::new("Hero texture").detail("2048 x 2048 RGBA"),
9782 ListItem::new("UI icon sheet").detail("Tagged for export"),
9783 ListItem::new("Archive cache").detail("Read only"),
9784 ListItem::new("Normals atlas").detail("Streaming mip chain"),
9785 ])
9786 .selected(1),
9787 ),
9788 );
9789
9790 assert!(vertical_scroll_thumb_rects(&output).is_empty());
9791 }
9792
9793 #[test]
9794 fn list_view_scrolls_overflowing_rows_without_thumb() -> Result<()> {
9795 let (mut runtime, window_id) =
9796 build_runtime(SizedBox::new().width(320.0).height(100.0).with_child(
9797 ListView::new("Assets").items([
9798 ListItem::new("Hero texture").detail("2048 x 2048 RGBA"),
9799 ListItem::new("UI icon sheet").detail("Tagged for export"),
9800 ListItem::new("Archive cache").detail("Read only"),
9801 ListItem::new("Normals atlas").detail("Streaming mip chain"),
9802 ]),
9803 ));
9804
9805 let before = runtime.render(window_id)?;
9806 let before_y = text_rects_for(&before, "Hero texture")[0].y();
9807
9808 runtime.handle_event(
9809 window_id,
9810 wheel_scroll(Point::new(60.0, 60.0), Vector::new(0.0, -24.0)),
9811 )?;
9812 let after = runtime.render(window_id)?;
9813 let after_y = text_rects_for(&after, "Hero texture")[0].y();
9814
9815 assert!(after_y < before_y);
9816 assert!(vertical_scroll_thumb_rects(&after).is_empty());
9817 Ok(())
9818 }
9819
9820 #[test]
9821 fn list_view_clips_scrolled_selection_highlight_to_viewport() -> Result<()> {
9822 let theme = DefaultTheme::default();
9823 let (mut runtime, window_id) = build_runtime(
9824 SizedBox::new().width(320.0).height(100.0).with_child(
9825 ListView::new("Assets")
9826 .theme(theme)
9827 .items([
9828 ListItem::new("Hero texture").detail("2048 x 2048 RGBA"),
9829 ListItem::new("UI icon sheet").detail("Tagged for export"),
9830 ListItem::new("Archive cache").detail("Read only"),
9831 ListItem::new("Normals atlas").detail("Streaming mip chain"),
9832 ])
9833 .selected(0),
9834 ),
9835 );
9836
9837 let _ = runtime.render(window_id)?;
9838 runtime.handle_event(
9839 window_id,
9840 wheel_scroll(Point::new(60.0, 60.0), Vector::new(0.0, -24.0)),
9841 )?;
9842 let output = runtime.render(window_id)?;
9843 let highlight = selected_highlight_rects(&output)
9844 .first()
9845 .copied()
9846 .expect("selected list row highlight should be painted");
9847
9848 assert!(highlight.y() >= theme.metrics.data_viewport_padding.top);
9849 assert!(highlight.max_y() <= 100.0 - theme.metrics.data_viewport_padding.bottom);
9850 Ok(())
9851 }
9852
9853 #[test]
9854 fn tree_view_does_not_paint_internal_scroll_thumb() {
9855 let output = render(
9856 SizedBox::new().width(320.0).height(120.0).with_child(
9857 TreeView::new("Scene").item(
9858 TreeItem::new("Environment")
9859 .with_child(TreeItem::new("Sky dome").detail("Visible"))
9860 .with_child(TreeItem::new("Fog volume").detail("Animated"))
9861 .with_child(TreeItem::new("Characters").detail("Selected")),
9862 ),
9863 ),
9864 );
9865
9866 assert!(vertical_scroll_thumb_rects(&output).is_empty());
9867 }
9868
9869 #[test]
9870 fn tree_view_scrolls_overflowing_rows_without_thumb() -> Result<()> {
9871 let (mut runtime, window_id) = build_runtime(
9872 SizedBox::new().width(320.0).height(120.0).with_child(
9873 TreeView::new("Scene").item(
9874 TreeItem::new("Scene")
9875 .expanded(true)
9876 .with_child(TreeItem::new("Environment").detail("Visible"))
9877 .with_child(TreeItem::new("Sky dome").detail("Visible"))
9878 .with_child(TreeItem::new("Fog volume").detail("Animated"))
9879 .with_child(TreeItem::new("Pilot").detail("Selected")),
9880 ),
9881 ),
9882 );
9883
9884 let before = runtime.render(window_id)?;
9885 let before_y = text_rects_for(&before, "Scene")[0].y();
9886
9887 runtime.handle_event(
9888 window_id,
9889 wheel_scroll(Point::new(60.0, 60.0), Vector::new(0.0, -24.0)),
9890 )?;
9891 let after = runtime.render(window_id)?;
9892 let after_y = text_rects_for(&after, "Scene")[0].y();
9893
9894 assert!(after_y < before_y);
9895 assert!(vertical_scroll_thumb_rects(&after).is_empty());
9896 Ok(())
9897 }
9898
9899 #[test]
9900 fn tree_view_clips_scrolled_selection_highlight_to_viewport() -> Result<()> {
9901 let theme = DefaultTheme::default();
9902 let (mut runtime, window_id) = build_runtime(
9903 SizedBox::new().width(320.0).height(120.0).with_child(
9904 TreeView::new("Scene").item(
9905 TreeItem::new("Scene")
9906 .expanded(true)
9907 .with_child(TreeItem::new("Environment").detail("Visible"))
9908 .with_child(TreeItem::new("Sky dome").detail("Visible"))
9909 .with_child(TreeItem::new("Fog volume").detail("Animated"))
9910 .with_child(TreeItem::new("Pilot").detail("Selected")),
9911 ),
9912 ),
9913 );
9914
9915 let _ = runtime.render(window_id)?;
9916 runtime.handle_event(
9917 window_id,
9918 primary_pointer(PointerEventKind::Down, Point::new(60.0, 24.0), true),
9919 )?;
9920 runtime.handle_event(
9921 window_id,
9922 primary_pointer(PointerEventKind::Up, Point::new(60.0, 24.0), false),
9923 )?;
9924 runtime.handle_event(
9925 window_id,
9926 wheel_scroll(Point::new(60.0, 60.0), Vector::new(0.0, -24.0)),
9927 )?;
9928 let output = runtime.render(window_id)?;
9929 let highlight = selected_highlight_rects(&output)
9930 .first()
9931 .copied()
9932 .expect("selected tree row highlight should be painted");
9933
9934 assert!(highlight.y() >= theme.metrics.data_viewport_padding.top);
9935 assert!(highlight.max_y() <= 120.0 - theme.metrics.data_viewport_padding.bottom);
9936 Ok(())
9937 }
9938
9939 #[test]
9940 fn tree_view_disclosure_does_not_overlap_primary_label() {
9941 let output = render(
9942 SizedBox::new().width(320.0).height(120.0).with_child(
9943 TreeView::new("Scene").item(
9944 TreeItem::new("Environment")
9945 .with_child(TreeItem::new("Sky dome").detail("Visible")),
9946 ),
9947 ),
9948 );
9949
9950 let label = text_rects_for(&output, "Environment")[0];
9951 let mut disclosure_bounds = Vec::new();
9952 output.frame.scene.visit_commands(&mut |command| {
9953 if let SceneCommand::FillPath { path, .. } = command {
9954 let bounds = path.bounds();
9955 if bounds.width() <= 12.0 && bounds.height() <= 12.0 {
9956 disclosure_bounds.push(bounds);
9957 }
9958 }
9959 });
9960
9961 let disclosure = disclosure_bounds
9962 .first()
9963 .expect("tree disclosure should be painted");
9964 assert!(
9965 disclosure.max_x() + DefaultTheme::default().metrics.tree_disclosure_gap <= label.x()
9966 );
9967 }
9968
9969 #[test]
9970 fn table_text_rect_uses_full_line_height() {
9971 let output = render(
9972 SizedBox::new().width(320.0).height(140.0).with_child(
9973 Table::new("Materials")
9974 .columns([TableColumn::new("Name")])
9975 .rows([TableRow::new(["Glass"])]),
9976 ),
9977 );
9978
9979 let header = text_rects_for(&output, "Name")[0];
9980 let cell = text_rects_for(&output, "Glass")[0];
9981 let line_height = DefaultTheme::default().body_text_style().line_height;
9982
9983 assert!(header.height() >= line_height);
9984 assert!(cell.height() >= line_height);
9985 }
9986
9987 #[test]
9988 fn table_aligned_text_preserves_tall_measurements_and_cell_alignment() {
9989 let mut theme = DefaultTheme::default();
9990 theme.typography.body_font_size = 28.0;
9991 theme.typography.body_line_height = 12.0;
9992 theme.metrics.table_header_height = 44.0;
9993 theme.metrics.table_row_height = 48.0;
9994
9995 let output = render(
9996 SizedBox::new().width(360.0).height(136.0).with_child(
9997 Table::new("Materials")
9998 .theme(theme)
9999 .columns([
10000 TableColumn::new("Name")
10001 .width(180.0)
10002 .alignment(TableColumnAlignment::Center),
10003 TableColumn::new("Passes").width(120.0).numeric(),
10004 ])
10005 .rows([TableRow::new(["Glass", "128"])]),
10006 ),
10007 );
10008 let header = text_runs_for(&output, "Name")
10009 .into_iter()
10010 .next()
10011 .expect("centered table header should render");
10012 let header_clip = draw_clip_rects_for(&output, "Name")
10013 .into_iter()
10014 .next()
10015 .expect("centered table header should be clipped to its cell");
10016 let cell = text_runs_for(&output, "Glass")
10017 .into_iter()
10018 .next()
10019 .expect("table cell should render");
10020 let cell_clip = draw_clip_rects_for(&output, "Glass")
10021 .into_iter()
10022 .next()
10023 .expect("table cell should be clipped to its cell");
10024 let numeric = text_runs_for(&output, "128")
10025 .into_iter()
10026 .next()
10027 .expect("numeric table cell should render");
10028 let numeric_clip = draw_clip_rects_for(&output, "128")
10029 .into_iter()
10030 .next()
10031 .expect("numeric table cell should be clipped to its cell");
10032 let measured_height = |run: &sui_text::TextRun| {
10033 TextSystem::new()
10034 .shape_text_run(run, &FontRegistry::new())
10035 .expect("table text should shape")
10036 .measurement()
10037 .height
10038 };
10039
10040 assert!(header.rect.height() >= measured_height(&header) - 0.01);
10041 assert!(cell.rect.height() >= measured_height(&cell) - 0.01);
10042 assert!(numeric.rect.height() >= measured_height(&numeric) - 0.01);
10043 assert!(
10044 (rect_center(header.rect).x - rect_center(header_clip).x).abs() < 0.75,
10045 "centered table header should align to cell center: text={:?}, cell={:?}",
10046 header.rect,
10047 header_clip
10048 );
10049 assert!(
10050 (numeric.rect.max_x() - numeric_clip.max_x()).abs() < 0.75,
10051 "numeric table cell should align to trailing edge: text={:?}, cell={:?}",
10052 numeric.rect,
10053 numeric_clip
10054 );
10055 assert!(
10056 (text_visual_center_for(&output, "Name") - rect_center(header_clip).y).abs() < 0.75,
10057 "centered table header should be optically centered in its cell"
10058 );
10059 assert!(
10060 (text_visual_center_for(&output, "Glass") - rect_center(cell_clip).y).abs() < 0.75,
10061 "table body cell should be optically centered in its cell"
10062 );
10063 assert!(
10064 (text_visual_center_for(&output, "128") - rect_center(numeric_clip).y).abs() < 0.75,
10065 "numeric table body cell should be optically centered in its cell"
10066 );
10067 }
10068
10069 #[test]
10070 fn non_scrollable_table_allows_wheel_to_bubble_to_parent_scroll_view() -> Result<()> {
10071 let (mut runtime, window_id) = build_runtime(
10072 SizedBox::new()
10073 .size(Size::new(220.0, 120.0))
10074 .with_child(ScrollView::vertical(
10075 Stack::vertical()
10076 .with_child(SizedBox::new().width(220.0).height(80.0))
10077 .with_child(
10078 SizedBox::new().width(220.0).height(120.0).with_child(
10079 Table::new("Materials")
10080 .columns([
10081 TableColumn::new("Name"),
10082 TableColumn::new("Passes").width(80.0),
10083 ])
10084 .rows([
10085 TableRow::new(["Glass", "3"]),
10086 TableRow::new(["Water", "4"]),
10087 ]),
10088 ),
10089 )
10090 .with_child(SizedBox::new().width(220.0).height(160.0)),
10091 )),
10092 );
10093
10094 let _ = runtime.render(window_id)?;
10095
10096 let mut scroll = PointerEvent::new(PointerEventKind::Scroll, Point::new(60.0, 90.0));
10097 scroll.scroll_delta = Some(ScrollDelta::Pixels(Vector::new(0.0, -24.0)));
10098 runtime.handle_event(window_id, Event::Pointer(scroll))?;
10099 let _ = runtime.render(window_id)?;
10100
10101 let graph = runtime.widget_graph(window_id)?;
10102 let outer_content = graph
10103 .nodes
10104 .iter()
10105 .find(|node| {
10106 node.bounds.width() == 220.0 - DefaultTheme::default().metrics.scroll_bar_thickness
10107 && node.bounds.height() == 360.0
10108 })
10109 .expect("outer scroll content present");
10110
10111 assert_eq!(outer_content.bounds.y(), -24.0);
10112 Ok(())
10113 }
10114
10115 #[test]
10116 fn breadcrumb_keyboard_activates_last_segment() -> Result<()> {
10117 let changes = Rc::new(RefCell::new(Vec::new()));
10118 let on_activate = Rc::clone(&changes);
10119 let (mut runtime, window_id) = build_runtime(
10120 Breadcrumb::new("Path")
10121 .items([
10122 BreadcrumbItem::new("Workspace"),
10123 BreadcrumbItem::new("Project"),
10124 BreadcrumbItem::new("Scene"),
10125 ])
10126 .current(0)
10127 .on_activate(move |index, label| on_activate.borrow_mut().push((index, label))),
10128 );
10129
10130 let _ = runtime.render(window_id)?;
10131 runtime.handle_event(
10132 window_id,
10133 primary_pointer(PointerEventKind::Down, Point::new(28.0, 20.0), true),
10134 )?;
10135 runtime.handle_event(
10136 window_id,
10137 primary_pointer(PointerEventKind::Up, Point::new(28.0, 20.0), false),
10138 )?;
10139 runtime.handle_event(
10140 window_id,
10141 Event::Keyboard(KeyboardEvent::new("End", KeyState::Pressed)),
10142 )?;
10143 runtime.handle_event(
10144 window_id,
10145 Event::Keyboard(KeyboardEvent::new("Enter", KeyState::Pressed)),
10146 )?;
10147
10148 assert_eq!(changes.borrow().last(), Some(&(2, "Scene".to_string())));
10149
10150 let output = runtime.render(window_id)?;
10151 let breadcrumb = output
10152 .semantics
10153 .iter()
10154 .find(|node| node.role == SemanticsRole::Breadcrumb)
10155 .expect("breadcrumb semantics present");
10156 assert_eq!(
10157 breadcrumb.value,
10158 Some(SemanticsValue::Text("Scene".to_string()))
10159 );
10160 Ok(())
10161 }
10162
10163 #[test]
10164 fn breadcrumb_paints_segment_labels_with_line_height() {
10165 let output = render(Breadcrumb::new("Path").items([
10166 BreadcrumbItem::new("Workspace"),
10167 BreadcrumbItem::new("Project"),
10168 BreadcrumbItem::new("Scene"),
10169 ]));
10170
10171 let run = text_runs_for(&output, "Workspace")
10172 .into_iter()
10173 .next()
10174 .expect("breadcrumb label draw command present");
10175 let theme = DefaultTheme::default();
10176 let line_height = theme.body_text_style().line_height;
10177 let available_height = (theme.metrics.breadcrumb_height
10178 - theme.metrics.breadcrumb_item_padding.top
10179 - theme.metrics.breadcrumb_item_padding.bottom)
10180 .max(0.0);
10181 let layout = TextSystem::new()
10182 .shape_text_run(&run, &FontRegistry::new())
10183 .expect("breadcrumb label should shape");
10184 let line = layout.lines().first().expect("breadcrumb line present");
10185 let actual_visual_center =
10186 run.rect.y() + line.baseline + optical_visual_center(layout.measurement());
10187 let slot_center = theme.metrics.breadcrumb_item_padding.top + (available_height * 0.5);
10188
10189 assert!((run.rect.height() - line_height.min(available_height)).abs() < 0.001);
10190 assert!(run.rect.width() > 0.0);
10191 assert!(
10192 (actual_visual_center - slot_center).abs() < 0.75,
10193 "breadcrumb label visual center {actual_visual_center} did not match slot center {slot_center}; text rect {:?}",
10194 run.rect
10195 );
10196 }
10197
10198 #[test]
10199 fn breadcrumb_label_stays_within_vertical_item_bounds() {
10200 let output = render(Breadcrumb::new("Path").items([BreadcrumbItem::new("Workspace")]));
10201 let label = text_rects_for(&output, "Workspace")[0];
10202
10203 assert!(label.y() >= -0.01);
10204 assert!(label.max_y() <= output.frame.viewport.height + 0.01);
10205 }
10206
10207 #[test]
10208 fn list_row_label_visual_center_matches_row_center() {
10209 let output = render(ListView::new("Assets").item(ListItem::new("Hero texture")));
10210 let run = text_runs_for(&output, "Hero texture")
10211 .into_iter()
10212 .next()
10213 .expect("list row label draw command present");
10214 let layout = TextSystem::new()
10215 .shape_text_run(&run, &FontRegistry::new())
10216 .expect("list row label should shape");
10217 let line = layout.lines().first().expect("list row line present");
10218 let actual_visual_center =
10219 run.rect.y() + line.baseline + optical_visual_center(layout.measurement());
10220 let row_center = output.frame.viewport.height * 0.5;
10221
10222 assert!((actual_visual_center - row_center).abs() < 0.75);
10223 }
10224
10225 struct LeadingLabelCellFixture {
10226 theme: DefaultTheme,
10227 }
10228
10229 impl Widget for LeadingLabelCellFixture {
10230 fn measure(
10231 &mut self,
10232 _ctx: &mut sui_runtime::MeasureCtx,
10233 constraints: Constraints,
10234 ) -> Size {
10235 constraints.clamp(Size::new(132.0, 32.0))
10236 }
10237
10238 fn paint(&self, ctx: &mut PaintCtx) {
10239 super::paint_leading_label_cell(
10240 ctx,
10241 &self.theme,
10242 ctx.bounds(),
10243 "artifact.txt",
10244 LeadingLabelCellPaint::new()
10245 .icon(crate::IconGlyph::File)
10246 .icon_color(self.theme.palette.text_muted)
10247 .label_color(self.theme.palette.text)
10248 .label_weight(FontWeight::MEDIUM)
10249 .icon_slot_side(20.0)
10250 .icon_inset(2.0)
10251 .gap(8.0)
10252 .padding(6.0, 8.0),
10253 );
10254 }
10255 }
10256
10257 #[test]
10258 fn leading_label_cell_uses_compact_token_and_clips_to_cell() {
10259 let theme = DefaultTheme::default();
10260 let output = render(LeadingLabelCellFixture { theme });
10261 let label = text_runs_for(&output, "artifact.txt")
10262 .into_iter()
10263 .next()
10264 .expect("leading-label cell text should paint");
10265
10266 assert_text_run_uses_token(&label, theme.text.sm);
10267 assert_eq!(label.style.weight, FontWeight::MEDIUM);
10268 assert!(label.rect.x() >= 34.0);
10269 assert!(
10270 label.rect.max_x() <= output.frame.viewport.width + 0.75,
10271 "label should stay within the cell bounds: {:?}",
10272 label.rect
10273 );
10274 let layout = TextSystem::new()
10275 .shape_text_run(&label, &FontRegistry::new())
10276 .expect("leading-label cell text should shape");
10277 let line = layout.lines().first().expect("leading-label line present");
10278 let visual_center =
10279 label.rect.y() + line.baseline + optical_visual_center(layout.measurement());
10280 assert!(
10281 (visual_center - (output.frame.viewport.height * 0.5)).abs() < 0.75,
10282 "leading-label visual center {visual_center} did not match cell center; text rect {:?}",
10283 label.rect
10284 );
10285 }
10286
10287 struct TextCellFixture {
10288 theme: DefaultTheme,
10289 }
10290
10291 impl Widget for TextCellFixture {
10292 fn measure(
10293 &mut self,
10294 _ctx: &mut sui_runtime::MeasureCtx,
10295 constraints: Constraints,
10296 ) -> Size {
10297 constraints.clamp(Size::new(160.0, 32.0))
10298 }
10299
10300 fn paint(&self, ctx: &mut PaintCtx) {
10301 super::paint_text_cell(
10302 ctx,
10303 &self.theme,
10304 ctx.bounds(),
10305 "128",
10306 TextCellPaint::new()
10307 .text_token(self.theme.text.xs)
10308 .color(self.theme.palette.text_muted)
10309 .weight(FontWeight::MEDIUM)
10310 .padding(10.0, 18.0)
10311 .alignment(TableColumnAlignment::End)
10312 .numeric(),
10313 );
10314 }
10315 }
10316
10317 #[test]
10318 fn text_cell_paint_uses_alignment_numeric_token_and_clipping() {
10319 let mut theme = DefaultTheme::default();
10320 theme.text.xs = ThemeTextToken {
10321 size: 10.5,
10322 line_height: 17.5,
10323 };
10324 theme.sync_derived_fields();
10325 let output = render(TextCellFixture { theme });
10326 let run = text_runs_for(&output, "128")
10327 .into_iter()
10328 .next()
10329 .expect("text-cell text should paint");
10330 let clip = draw_clip_rects_for(&output, "128")
10331 .into_iter()
10332 .next()
10333 .expect("text-cell text should clip to padded content");
10334 let content_right = output.frame.viewport.width - 18.0;
10335
10336 assert_text_run_uses_token(&run, theme.text.xs);
10337 assert_eq!(run.style.color, theme.palette.text_muted);
10338 assert_eq!(run.style.weight, FontWeight::MEDIUM);
10339 assert!(
10340 run.style
10341 .features
10342 .iter()
10343 .any(|feature| feature.tag == FontFeature::TABULAR_FIGURES && feature.value == 1),
10344 "numeric text cells should opt into tabular figures"
10345 );
10346 assert!((run.rect.max_x() - content_right).abs() < 0.75);
10347 assert!((clip.x() - 10.0).abs() < 0.01);
10348 assert!((clip.max_x() - content_right).abs() < 0.01);
10349 let layout = TextSystem::new()
10350 .shape_text_run(&run, &FontRegistry::new())
10351 .expect("text-cell text should shape");
10352 let line = layout.lines().first().expect("text-cell line present");
10353 let visual_center =
10354 run.rect.y() + line.baseline + optical_visual_center(layout.measurement());
10355 assert!(
10356 (visual_center - (output.frame.viewport.height * 0.5)).abs() < 0.75,
10357 "text-cell visual center {visual_center} did not match cell center; text rect {:?}",
10358 run.rect
10359 );
10360 }
10361
10362 struct TextBlockFixture {
10363 theme: DefaultTheme,
10364 text: String,
10365 }
10366
10367 impl Widget for TextBlockFixture {
10368 fn measure(
10369 &mut self,
10370 _ctx: &mut sui_runtime::MeasureCtx,
10371 constraints: Constraints,
10372 ) -> Size {
10373 constraints.clamp(Size::new(178.0, 76.0))
10374 }
10375
10376 fn paint(&self, ctx: &mut PaintCtx) {
10377 super::paint_text_block(
10378 ctx,
10379 &self.theme,
10380 ctx.bounds(),
10381 &self.text,
10382 TextBlockPaint::new()
10383 .text_token(self.theme.text.sm)
10384 .color(self.theme.palette.text_muted)
10385 .weight(FontWeight::MEDIUM)
10386 .padding(Insets {
10387 left: 12.0,
10388 top: 7.0,
10389 right: 16.0,
10390 bottom: 9.0,
10391 }),
10392 );
10393 }
10394 }
10395
10396 #[test]
10397 fn text_block_paint_wraps_top_aligns_and_clips_to_padding() {
10398 let mut theme = DefaultTheme::default();
10399 theme.text.sm = ThemeTextToken {
10400 size: 12.0,
10401 line_height: 18.0,
10402 };
10403 theme.sync_derived_fields();
10404 let text =
10405 "This preview line wraps through SUI text layout.\nSecond paragraph stays compact."
10406 .to_string();
10407 let output = render(TextBlockFixture {
10408 theme,
10409 text: text.clone(),
10410 });
10411 let (origin, layout, color) = output
10412 .frame
10413 .scene
10414 .commands()
10415 .iter()
10416 .find_map(|command| {
10417 let SceneCommand::DrawShapedText(run) = command else {
10418 return None;
10419 };
10420 let layout = run.resolve(output.frame.text_layout_registry.as_ref())?;
10421 (layout.text() == text).then_some((run.origin, layout.clone(), run.color_override))
10422 })
10423 .expect("text block should paint as a shaped text layout");
10424 let clip = draw_clip_rects_for(&output, &text)
10425 .into_iter()
10426 .next()
10427 .expect("text block should clip to padded content");
10428
10429 assert_eq!(color, Some(theme.palette.text_muted));
10430 assert!((origin.x - 12.0).abs() < 0.01);
10431 assert!((origin.y - 7.0).abs() < 0.01);
10432 assert!((layout.box_size().width - 150.0).abs() < 0.01);
10433 assert!((layout.box_size().height - 60.0).abs() < 0.01);
10434 assert!(layout.lines().len() >= 2, "text block should wrap");
10435 assert_text_run_uses_token(
10436 &sui_text::TextRun {
10437 rect: Rect::ZERO,
10438 text,
10439 style: layout.style().clone(),
10440 },
10441 theme.text.sm,
10442 );
10443 assert_eq!(layout.style().weight, FontWeight::MEDIUM);
10444 assert!((clip.x() - 12.0).abs() < 0.01);
10445 assert!((clip.y() - 7.0).abs() < 0.01);
10446 assert!((clip.width() - 150.0).abs() < 0.01);
10447 assert!((clip.height() - 60.0).abs() < 0.01);
10448 }
10449
10450 #[test]
10451 fn list_row_text_preserves_tall_measurement_in_compact_line_box() {
10452 let mut theme = DefaultTheme::default();
10453 theme.typography.body_font_size = 28.0;
10454 theme.typography.body_line_height = 12.0;
10455 theme.metrics.list_row_height = 52.0;
10456
10457 let output = render(
10458 SizedBox::new().width(320.0).height(72.0).with_child(
10459 ListView::new("Assets")
10460 .theme(theme)
10461 .item(ListItem::new("Glass")),
10462 ),
10463 );
10464 let run = text_runs_for(&output, "Glass")
10465 .into_iter()
10466 .next()
10467 .expect("list row label draw command present");
10468 let layout = TextSystem::new()
10469 .shape_text_run(&run, &FontRegistry::new())
10470 .expect("list row label should shape");
10471 let row_center =
10472 theme.metrics.data_viewport_padding.top + theme.metrics.list_row_height * 0.5;
10473
10474 assert!(
10475 run.rect.height() >= layout.measurement().height - 0.01,
10476 "list row text rect should preserve measured glyph height: rect={:?}, measurement={:?}",
10477 run.rect,
10478 layout.measurement()
10479 );
10480 assert!(
10481 run.rect.height() > run.style.line_height,
10482 "test theme should exercise measured-height preservation"
10483 );
10484 assert!(
10485 (text_run_visual_center(&run) - row_center).abs() < 0.75,
10486 "list row label visual center should remain row-centered"
10487 );
10488 }
10489
10490 #[test]
10491 fn list_row_leading_and_trailing_text_align_to_row_center_and_edge() {
10492 let theme = DefaultTheme::default();
10493 let output = render(
10494 SizedBox::new().width(260.0).with_child(
10495 ListView::new("Assets").item(
10496 ListItem::new("Hero texture")
10497 .leading_text("A")
10498 .trailing("42"),
10499 ),
10500 ),
10501 );
10502 let leading = text_runs_for(&output, "A")
10503 .into_iter()
10504 .next()
10505 .expect("leading text draw command present");
10506 let trailing = text_runs_for(&output, "42")
10507 .into_iter()
10508 .next()
10509 .expect("trailing text draw command present");
10510 let text_system = TextSystem::new();
10511 let leading_layout = text_system
10512 .shape_text_run(&leading, &FontRegistry::new())
10513 .expect("leading text should shape");
10514 let trailing_layout = text_system
10515 .shape_text_run(&trailing, &FontRegistry::new())
10516 .expect("trailing text should shape");
10517 let leading_line = leading_layout
10518 .lines()
10519 .first()
10520 .expect("leading line present");
10521 let trailing_line = trailing_layout
10522 .lines()
10523 .first()
10524 .expect("trailing line present");
10525 let leading_visual_center = leading.rect.y()
10526 + leading_line.baseline
10527 + optical_visual_center(leading_layout.measurement());
10528 let trailing_visual_center = trailing.rect.y()
10529 + trailing_line.baseline
10530 + optical_visual_center(trailing_layout.measurement());
10531 let row_center = output.frame.viewport.height * 0.5;
10532 let trailing_edge = output.frame.viewport.width
10533 - theme.metrics.data_viewport_padding.right
10534 - theme.metrics.data_row_padding.right;
10535
10536 assert!((leading_visual_center - row_center).abs() < 0.75);
10537 assert!((trailing_visual_center - row_center).abs() < 0.75);
10538 assert!(
10539 (trailing.rect.max_x() - trailing_edge).abs() < 0.75,
10540 "trailing text max_x {} did not align to content edge {trailing_edge}",
10541 trailing.rect.max_x()
10542 );
10543 }
10544
10545 #[test]
10546 fn list_row_leading_and_trailing_text_preserve_tall_measurements() {
10547 let mut theme = DefaultTheme::default();
10548 theme.typography.body_font_size = 28.0;
10549 theme.typography.body_line_height = 12.0;
10550 theme.text.xs = ThemeTextToken {
10551 size: 26.0,
10552 line_height: 10.0,
10553 };
10554 theme.metrics.list_row_height = 64.0;
10555
10556 let output = render(
10557 SizedBox::new().width(320.0).height(88.0).with_child(
10558 ListView::new("Assets").theme(theme).item(
10559 ListItem::new("Hero texture")
10560 .leading_text("A")
10561 .trailing("42"),
10562 ),
10563 ),
10564 );
10565 let row = output
10566 .semantics
10567 .iter()
10568 .find(|node| node.role == SemanticsRole::ListItem)
10569 .expect("list row semantics present")
10570 .bounds;
10571 let leading = text_runs_for(&output, "A")
10572 .into_iter()
10573 .next()
10574 .expect("leading text draw command present");
10575 let trailing = text_runs_for(&output, "42")
10576 .into_iter()
10577 .next()
10578 .expect("trailing text draw command present");
10579 let leading_layout = TextSystem::new()
10580 .shape_text_run(&leading, &FontRegistry::new())
10581 .expect("leading text should shape");
10582 let trailing_layout = TextSystem::new()
10583 .shape_text_run(&trailing, &FontRegistry::new())
10584 .expect("trailing text should shape");
10585 let trailing_clip = draw_clip_rects_for(&output, "42")
10586 .into_iter()
10587 .next()
10588 .expect("trailing text should be clipped to reserved slot");
10589 let row_center = row.y() + (row.height() * 0.5);
10590 let trailing_edge = row.max_x() - theme.metrics.data_row_padding.right;
10591
10592 assert_eq!(leading.style.font_size, 28.0);
10593 assert_eq!(leading.style.line_height, 12.0);
10594 assert_text_run_uses_token(&trailing, theme.text.xs);
10595 assert!(leading.rect.height() >= leading_layout.measurement().height - 0.01);
10596 assert!(trailing.rect.height() >= trailing_layout.measurement().height - 0.01);
10597 assert!(leading.rect.height() > leading.style.line_height);
10598 assert!(trailing.rect.height() > trailing.style.line_height);
10599 assert!((text_run_visual_center(&leading) - row_center).abs() < 0.75);
10600 assert!((text_run_visual_center(&trailing) - row_center).abs() < 0.75);
10601 assert!((trailing.rect.max_x() - trailing_edge).abs() < 0.75);
10602 assert!((trailing_clip.max_x() - trailing_edge).abs() < 0.75);
10603 }
10604
10605 #[test]
10606 fn selected_list_row_trailing_text_preserves_caption_metrics() {
10607 let mut theme = DefaultTheme::default();
10608 theme.text.xs = ThemeTextToken {
10609 size: 10.5,
10610 line_height: 17.5,
10611 };
10612 theme.sync_derived_fields();
10613 let output = render(
10614 SizedBox::new().width(260.0).with_child(
10615 ListView::new("Assets")
10616 .theme(theme)
10617 .selected(0)
10618 .item(ListItem::new("Hero texture").trailing("42")),
10619 ),
10620 );
10621 let trailing = text_runs_for(&output, "42")
10622 .into_iter()
10623 .next()
10624 .expect("selected trailing text draw command present");
10625 let trailing_layout = TextSystem::new()
10626 .shape_text_run(&trailing, &FontRegistry::new())
10627 .expect("selected trailing text should shape");
10628 let trailing_line = trailing_layout
10629 .lines()
10630 .first()
10631 .expect("selected trailing line present");
10632 let trailing_visual_center = trailing.rect.y()
10633 + trailing_line.baseline
10634 + optical_visual_center(trailing_layout.measurement());
10635 let row_center = output.frame.viewport.height * 0.5;
10636 let trailing_edge = output.frame.viewport.width
10637 - theme.metrics.data_viewport_padding.right
10638 - theme.metrics.data_row_padding.right;
10639
10640 assert_text_run_uses_token(&trailing, theme.text.xs);
10641 assert_eq!(trailing.style.color, theme.palette.placeholder);
10642 assert!((trailing_visual_center - row_center).abs() < 0.75);
10643 assert!(
10644 (trailing.rect.max_x() - trailing_edge).abs() < 0.75,
10645 "selected trailing text max_x {} did not align to content edge {trailing_edge}",
10646 trailing.rect.max_x()
10647 );
10648 }
10649}