Skip to main content

sui_widgets/
data.rs

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