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