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