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