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