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        Rect::new(
3308            bounds.x() + padding.left,
3309            bounds.y() + padding.top + self.resolved_header_height() + gap,
3310            (bounds.width() - padding.left - padding.right).max(0.0),
3311            (bounds.height() - padding.top - padding.bottom - self.resolved_header_height() - gap)
3312                .max(0.0),
3313        )
3314    }
3315
3316    fn content_height(&self) -> f32 {
3317        self.rows.len() as f32 * self.resolved_row_height()
3318    }
3319
3320    fn current_selected(&self) -> Option<usize> {
3321        self.selected_reader
3322            .as_ref()
3323            .map(|selected| selected())
3324            .unwrap_or(self.selected)
3325            .filter(|index| *index < self.rows.len())
3326    }
3327
3328    fn clamp_scroll(&self, viewport_height: f32, scroll_y: f32) -> f32 {
3329        let max_scroll = (self.content_height() - viewport_height).max(0.0);
3330        scroll_y.clamp(0.0, max_scroll)
3331    }
3332
3333    fn row_at_position(&self, bounds: Rect, position: Point) -> Option<usize> {
3334        let body = self.body_rect(bounds);
3335        if !body.contains(position) {
3336            return None;
3337        }
3338        let y = position.y - body.y() + self.scroll_y;
3339        let index = (y / self.resolved_row_height()).floor() as usize;
3340        (index < self.rows.len()).then_some(index)
3341    }
3342
3343    fn resolve_column_widths(&mut self, ctx: &mut MeasureCtx, available_width: f32) {
3344        let theme = self.resolved_theme();
3345        let header_style = theme.text_style(theme.palette.placeholder);
3346        let body_style = theme.body_text_style();
3347        let numeric_style = numeric_text_style(body_style.clone());
3348        self.column_widths = self
3349            .columns
3350            .iter()
3351            .enumerate()
3352            .map(|(index, column)| {
3353                let measured_title = measure_text(ctx, &column.title, &header_style).width;
3354                let cell_style = if column.numeric {
3355                    &numeric_style
3356                } else {
3357                    &body_style
3358                };
3359                let measured_cells = self
3360                    .rows
3361                    .iter()
3362                    .filter_map(|row| row.cells.get(index))
3363                    .map(|cell| measure_text(ctx, cell, cell_style).width)
3364                    .fold(0.0, f32::max);
3365                column.width.unwrap_or(
3366                    (measured_title.max(measured_cells) + (theme.metrics.table_cell_padding * 2.0))
3367                        .max(column.min_width),
3368                )
3369            })
3370            .collect();
3371
3372        if available_width <= 0.0 || self.column_widths.is_empty() {
3373            return;
3374        }
3375
3376        let total = self.column_widths.iter().sum::<f32>();
3377        if total < available_width {
3378            let extra = (available_width - total) / self.column_widths.len() as f32;
3379            for width in &mut self.column_widths {
3380                *width += extra;
3381            }
3382        }
3383    }
3384
3385    fn activate(&mut self, index: usize) {
3386        if index >= self.rows.len() {
3387            return;
3388        }
3389        self.selected = Some(index);
3390        if let Some(on_change) = &mut self.on_change {
3391            on_change(index);
3392        }
3393    }
3394
3395    fn set_hovered(&mut self, hovered: Option<usize>, ctx: &mut EventCtx) {
3396        if self.hovered == hovered {
3397            return;
3398        }
3399
3400        self.hovered = hovered;
3401        let theme = self.resolved_theme();
3402        self.hover_motion.set_hover_target(hovered, &theme, ctx);
3403        ctx.request_paint();
3404        ctx.request_semantics();
3405    }
3406
3407    fn set_pressed(&mut self, pressed: Option<usize>, ctx: &mut EventCtx) {
3408        if self.pressed == pressed {
3409            return;
3410        }
3411
3412        self.pressed = pressed;
3413        let theme = self.resolved_theme();
3414        self.press_motion.set_press_target(pressed, &theme, ctx);
3415        ctx.request_paint();
3416        ctx.request_semantics();
3417    }
3418
3419    fn advance_animations(&mut self, time: f64, ctx: &mut EventCtx) {
3420        let (hover_changed, hover_active) = self.hover_motion.advance(time);
3421        let (press_changed, press_active) = self.press_motion.advance(time);
3422        let (focus_changed, focus_active) = advance_scalar(&mut self.focus_animation, time);
3423
3424        if hover_changed || press_changed || focus_changed {
3425            ctx.request_paint();
3426        }
3427        if hover_active || press_active || focus_active {
3428            ctx.request_animation_frame();
3429        }
3430    }
3431}
3432
3433impl Widget for Table {
3434    fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
3435        let body = self.body_rect(ctx.bounds());
3436
3437        match event {
3438            Event::Pointer(pointer) if pointer.kind == PointerEventKind::Move => {
3439                let hovered = self.row_at_position(ctx.bounds(), pointer.position);
3440                self.set_hovered(hovered, ctx);
3441            }
3442            Event::Pointer(pointer)
3443                if pointer.kind == PointerEventKind::Scroll && body.contains(pointer.position) =>
3444            {
3445                let delta = pointer
3446                    .scroll_delta
3447                    .map(scroll_delta_to_offset)
3448                    .unwrap_or(pointer.delta);
3449                let next = self.clamp_scroll(body.height(), self.scroll_y - delta.y);
3450                if (next - self.scroll_y).abs() > f32::EPSILON {
3451                    self.scroll_y = next;
3452                    ctx.request_paint();
3453                    ctx.request_semantics();
3454                    ctx.set_handled();
3455                }
3456            }
3457            Event::Pointer(pointer)
3458                if pointer.kind == PointerEventKind::Down
3459                    && pointer.button == Some(PointerButton::Primary)
3460                    && body.contains(pointer.position) =>
3461            {
3462                let pressed = self.row_at_position(ctx.bounds(), pointer.position);
3463                self.set_hovered(pressed, ctx);
3464                self.set_pressed(pressed, ctx);
3465                ctx.request_focus();
3466                ctx.request_pointer_capture(pointer.pointer_id);
3467                ctx.set_handled();
3468            }
3469            Event::Pointer(pointer)
3470                if pointer.kind == PointerEventKind::Up
3471                    && pointer.button == Some(PointerButton::Primary) =>
3472            {
3473                let hovered = self.row_at_position(ctx.bounds(), pointer.position);
3474                if let Some(index) = self
3475                    .pressed
3476                    .zip(hovered)
3477                    .filter(|(pressed, hovered)| pressed == hovered)
3478                    .map(|(index, _)| index)
3479                {
3480                    self.activate(index);
3481                }
3482                self.set_hovered(hovered, ctx);
3483                self.set_pressed(None, ctx);
3484                ctx.release_pointer_capture(pointer.pointer_id);
3485                ctx.set_handled();
3486            }
3487            Event::Pointer(pointer) if pointer.kind == PointerEventKind::Leave => {
3488                self.set_hovered(None, ctx);
3489            }
3490            Event::Pointer(pointer) if pointer.kind == PointerEventKind::Cancel => {
3491                if self.pressed.is_some() {
3492                    self.set_pressed(None, ctx);
3493                    self.set_hovered(None, ctx);
3494                    ctx.release_pointer_capture(pointer.pointer_id);
3495                    ctx.set_handled();
3496                }
3497            }
3498            Event::Wake(WakeEvent::AnimationFrame { time, .. }) => {
3499                self.advance_animations(*time, ctx);
3500            }
3501            Event::Keyboard(key) if ctx.is_focused() && key.state == KeyState::Pressed => {
3502                if self.rows.is_empty() {
3503                    return;
3504                }
3505
3506                let current = self.current_selected().unwrap_or(0);
3507                match key.key.as_str() {
3508                    "ArrowUp" => self.activate(current.saturating_sub(1)),
3509                    "ArrowDown" => self.activate((current + 1).min(self.rows.len() - 1)),
3510                    "Home" => self.activate(0),
3511                    "End" => self.activate(self.rows.len() - 1),
3512                    _ => return,
3513                }
3514                ctx.request_paint();
3515                ctx.request_semantics();
3516                ctx.set_handled();
3517            }
3518            _ => {}
3519        }
3520    }
3521
3522    fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
3523        let desired_width = if constraints.max.width.is_finite() {
3524            constraints.max.width
3525        } else {
3526            540.0
3527        };
3528        let theme = self.resolved_theme();
3529        let padding = theme.metrics.data_viewport_padding;
3530        self.resolve_column_widths(ctx, (desired_width - padding.left - padding.right).max(0.0));
3531        let desired_height = padding.top
3532            + self.resolved_header_height()
3533            + theme.metrics.select_menu_gap
3534            + self.content_height()
3535            + padding.bottom;
3536        let size = constraints.clamp(Size::new(desired_width, desired_height));
3537        self.scroll_y = self.clamp_scroll(
3538            self.body_rect(Rect::from_origin_size(Point::ZERO, size))
3539                .height(),
3540            self.scroll_y,
3541        );
3542        size
3543    }
3544
3545    fn paint(&self, ctx: &mut PaintCtx) {
3546        let theme = self.resolved_theme();
3547        let palette = theme.palette;
3548        let metrics = theme.metrics;
3549        let header_style = theme.text_style(palette.placeholder);
3550        let body_style = theme.body_text_style();
3551        let numeric_body_style = numeric_text_style(body_style.clone());
3552        let body = self.body_rect(ctx.bounds());
3553        let padding = metrics.data_viewport_padding;
3554        let header = Rect::new(
3555            ctx.bounds().x() + padding.left,
3556            ctx.bounds().y() + padding.top,
3557            (ctx.bounds().width() - padding.left - padding.right).max(0.0),
3558            self.resolved_header_height(),
3559        );
3560        let row_height = self.resolved_row_height();
3561
3562        draw_surface(ctx, ctx.bounds(), &theme, self.focus_animation.value);
3563        ctx.fill(
3564            rounded_rect_path(header, metrics.corner_radius),
3565            palette.control,
3566        );
3567
3568        let mut x = header.x();
3569        for (index, column) in self.columns.iter().enumerate() {
3570            let width = *self.column_widths.get(index).unwrap_or(&column.min_width);
3571            let cell = Rect::new(x, header.y(), width, header.height());
3572            if index > 0 {
3573                let separator_inset = metrics
3574                    .table_header_separator_inset
3575                    .min(cell.height() * 0.5);
3576                ctx.stroke_rect(
3577                    Rect::new(
3578                        cell.x(),
3579                        cell.y() + separator_inset,
3580                        metrics.table_separator_width,
3581                        (cell.height() - (separator_inset * 2.0)).max(0.0),
3582                    ),
3583                    palette.border,
3584                    sui_scene::StrokeStyle::new(metrics.table_separator_width.max(1.0)),
3585                );
3586            }
3587            draw_aligned_text(
3588                ctx,
3589                horizontal_inset_rect(cell, metrics.table_cell_padding),
3590                &column.title,
3591                &header_style,
3592                column.alignment,
3593            );
3594            x += width;
3595        }
3596
3597        ctx.push_clip_rect(body);
3598        let start = (self.scroll_y / row_height).floor().max(0.0) as usize;
3599        let end = (((self.scroll_y + body.height()) / row_height).ceil() as usize + 1)
3600            .min(self.rows.len());
3601
3602        for row_index in start..end {
3603            let row_y = body.y() + (row_index as f32 * row_height) - self.scroll_y;
3604            let row_rect = Rect::new(body.x(), row_y, body.width(), row_height);
3605            let selected = self.current_selected() == Some(row_index);
3606            let hover_amount = self.hover_motion.amount_for(&row_index);
3607            let press_amount = self.press_motion.amount_for(&row_index);
3608            let background = if row_index % 2 == 0 {
3609                palette.surface.with_alpha(0.88)
3610            } else {
3611                palette.surface_raised
3612            };
3613            ctx.fill_rect(row_rect, background);
3614            paint_data_row_state(
3615                ctx,
3616                row_rect,
3617                body,
3618                &theme,
3619                selected,
3620                hover_amount,
3621                press_amount,
3622            );
3623            ctx.stroke_rect(
3624                row_rect,
3625                palette.border.with_alpha(metrics.table_row_border_opacity),
3626                sui_scene::StrokeStyle::new(metrics.table_separator_width.max(1.0)),
3627            );
3628
3629            let mut cell_x = row_rect.x();
3630            for (column_index, column) in self.columns.iter().enumerate() {
3631                let width = *self
3632                    .column_widths
3633                    .get(column_index)
3634                    .unwrap_or(&column.min_width);
3635                let cell_rect = Rect::new(cell_x, row_rect.y(), width, row_rect.height());
3636                if let Some(value) = self.rows[row_index].cells.get(column_index) {
3637                    let style = if column.numeric {
3638                        numeric_body_style.clone()
3639                    } else {
3640                        body_style.clone()
3641                    };
3642                    draw_aligned_text(
3643                        ctx,
3644                        horizontal_inset_rect(cell_rect, metrics.table_cell_padding),
3645                        value,
3646                        &style,
3647                        column.alignment,
3648                    );
3649                }
3650                cell_x += width;
3651            }
3652        }
3653
3654        ctx.pop_clip();
3655        draw_vertical_scroll_thumb(
3656            ctx,
3657            &theme,
3658            body,
3659            self.content_height(),
3660            self.scroll_y,
3661            palette.border_hover,
3662        );
3663    }
3664
3665    fn semantics(&self, ctx: &mut SemanticsCtx) {
3666        let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::Table, ctx.bounds());
3667        node.name = Some(self.name());
3668        node.state.focused = ctx.is_focused();
3669        node.value = self
3670            .current_selected()
3671            .and_then(|row| self.rows.get(row))
3672            .and_then(|row| row.cells.first())
3673            .cloned()
3674            .map(SemanticsValue::Text);
3675        node.actions = vec![SemanticsAction::Focus, SemanticsAction::SetValue];
3676        ctx.push(node);
3677    }
3678
3679    fn accepts_focus(&self) -> bool {
3680        true
3681    }
3682
3683    fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
3684        let theme = self.resolved_theme();
3685        set_focus_animation_target(&mut self.focus_animation, focused as u8 as f32, &theme, ctx);
3686        ctx.request_paint();
3687        ctx.request_semantics();
3688    }
3689}
3690
3691#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3692pub enum VirtualTableSortDirection {
3693    Ascending,
3694    Descending,
3695}
3696
3697/// Retained interaction state shared by rebuilt [`VirtualTable`] instances.
3698///
3699/// Row selection and pending scroll requests use stable row keys, while column
3700/// widths use the explicit key assigned to each [`VirtualTableColumn`].
3701#[derive(Clone)]
3702pub struct VirtualTableState {
3703    inner: Rc<RefCell<VirtualTableStateInner>>,
3704    revision: Signal<u64>,
3705    viewport: Signal<VirtualViewportSnapshot<u64>>,
3706    scroll: ScrollState,
3707}
3708
3709#[derive(Default)]
3710struct VirtualTableStateInner {
3711    selected_key: Option<u64>,
3712    pending_scroll: Option<(u64, ScrollAlignment)>,
3713    column_widths: HashMap<u64, f32>,
3714}
3715
3716impl VirtualTableState {
3717    pub fn new() -> Self {
3718        let scroll = ScrollState::new();
3719        scroll.sync_unmeasured_axes(ScrollAxes::Both);
3720        Self {
3721            inner: Rc::new(RefCell::new(VirtualTableStateInner::default())),
3722            revision: Signal::named("VirtualTableState", 0),
3723            viewport: Signal::named("VirtualTableViewport", VirtualViewportSnapshot::default()),
3724            scroll,
3725        }
3726    }
3727
3728    pub fn selected_key(&self) -> Option<u64> {
3729        self.inner.borrow().selected_key
3730    }
3731
3732    pub fn select_key(&self, key: Option<u64>) -> bool {
3733        let changed = {
3734            let mut inner = self.inner.borrow_mut();
3735            if inner.selected_key == key {
3736                false
3737            } else {
3738                inner.selected_key = key;
3739                true
3740            }
3741        };
3742        if changed {
3743            self.bump();
3744        }
3745        changed
3746    }
3747
3748    pub fn scroll_to(&self, key: u64, alignment: ScrollAlignment) {
3749        self.inner.borrow_mut().pending_scroll = Some((key, alignment));
3750        self.bump();
3751    }
3752
3753    pub fn column_width(&self, key: u64) -> Option<f32> {
3754        self.inner.borrow().column_widths.get(&key).copied()
3755    }
3756
3757    pub fn set_column_width(&self, key: u64, width: f32) -> bool {
3758        let width = width.max(32.0);
3759        let changed = {
3760            let mut inner = self.inner.borrow_mut();
3761            if inner
3762                .column_widths
3763                .get(&key)
3764                .is_some_and(|current| (*current - width).abs() <= f32::EPSILON)
3765            {
3766                false
3767            } else {
3768                inner.column_widths.insert(key, width);
3769                true
3770            }
3771        };
3772        if changed {
3773            self.bump();
3774        }
3775        changed
3776    }
3777
3778    pub fn scroll_state(&self) -> ScrollState {
3779        self.scroll.clone()
3780    }
3781
3782    pub fn viewport(&self) -> VirtualViewportSnapshot<u64> {
3783        self.viewport.get()
3784    }
3785
3786    pub fn viewport_signal(&self) -> Signal<VirtualViewportSnapshot<u64>> {
3787        self.viewport.clone()
3788    }
3789
3790    fn bump(&self) {
3791        let _ = self.revision.update(|revision| {
3792            *revision = revision.wrapping_add(1);
3793        });
3794    }
3795
3796    fn take_pending_scroll(&self) -> Option<(u64, ScrollAlignment)> {
3797        self.inner.borrow_mut().pending_scroll.take()
3798    }
3799
3800    fn publish_viewport(&self, viewport: VirtualViewportSnapshot<u64>) {
3801        let _ = self.viewport.set(viewport);
3802    }
3803}
3804
3805impl Default for VirtualTableState {
3806    fn default() -> Self {
3807        Self::new()
3808    }
3809}
3810
3811#[derive(Debug, Clone, PartialEq)]
3812pub struct VirtualTableColumn {
3813    key: Option<u64>,
3814    title: String,
3815    width: Option<f32>,
3816    min_width: f32,
3817    max_width: Option<f32>,
3818    resizable: bool,
3819    pinned: bool,
3820    alignment: TableColumnAlignment,
3821    sort_direction: Option<VirtualTableSortDirection>,
3822}
3823
3824impl VirtualTableColumn {
3825    pub fn new(title: impl Into<String>) -> Self {
3826        Self {
3827            key: None,
3828            title: title.into(),
3829            width: None,
3830            min_width: 96.0,
3831            max_width: None,
3832            resizable: true,
3833            pinned: false,
3834            alignment: TableColumnAlignment::Start,
3835            sort_direction: None,
3836        }
3837    }
3838
3839    /// Assign a stable identity used to retain resized width across rebuilds.
3840    pub fn key(mut self, key: u64) -> Self {
3841        self.key = Some(key);
3842        self
3843    }
3844
3845    pub fn width(mut self, width: f32) -> Self {
3846        self.width = Some(width.max(32.0));
3847        self
3848    }
3849
3850    pub fn min_width(mut self, min_width: f32) -> Self {
3851        self.min_width = min_width.max(32.0);
3852        self
3853    }
3854
3855    pub fn max_width(mut self, max_width: f32) -> Self {
3856        self.max_width = Some(max_width.max(self.min_width));
3857        self
3858    }
3859
3860    pub fn resizable(mut self, resizable: bool) -> Self {
3861        self.resizable = resizable;
3862        self
3863    }
3864
3865    pub fn pinned(mut self, pinned: bool) -> Self {
3866        self.pinned = pinned;
3867        self
3868    }
3869
3870    pub fn alignment(mut self, alignment: TableColumnAlignment) -> Self {
3871        self.alignment = alignment;
3872        self
3873    }
3874
3875    pub fn sort_direction(mut self, direction: Option<VirtualTableSortDirection>) -> Self {
3876        self.sort_direction = direction;
3877        self
3878    }
3879}
3880
3881#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3882pub enum VirtualTableRowActivationKind {
3883    Single,
3884    Double,
3885}
3886
3887pub struct VirtualTableRowContext<'a> {
3888    pub row_index: usize,
3889    pub row_key: u64,
3890    pub row_rect: Rect,
3891    pub column_rects: &'a [Rect],
3892    pub selected: bool,
3893    pub hovered: bool,
3894    pub pressed: bool,
3895}
3896
3897type ListViewChange = Box<dyn FnMut(usize, String)>;
3898type ListViewContextChange = Box<dyn FnMut(usize, String, &mut EventCtx)>;
3899type VirtualTableRowPainter = Box<dyn for<'a> Fn(&mut PaintCtx, &VirtualTableRowContext<'a>)>;
3900type VirtualTableRowName = Box<dyn Fn(usize) -> String>;
3901type VirtualTableRowDescription = Box<dyn Fn(usize) -> String>;
3902type VirtualTableCellActivation =
3903    Box<dyn FnMut(usize, usize, VirtualTableRowActivationKind) -> bool>;
3904
3905#[derive(Clone, Copy)]
3906struct VirtualTableColumnResize {
3907    column_index: usize,
3908    pointer_id: u64,
3909    start_x: f32,
3910    start_width: f32,
3911}
3912
3913pub struct VirtualTable {
3914    theme: Box<DefaultTheme>,
3915    theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
3916    name: String,
3917    columns: Vec<VirtualTableColumn>,
3918    state: Option<VirtualTableState>,
3919    window: CollectionWindow,
3920    window_explicit: bool,
3921    row_count: usize,
3922    selected: Option<usize>,
3923    selected_reader: Option<Box<dyn Fn() -> Option<usize>>>,
3924    hovered_row: Option<usize>,
3925    pressed_row: Option<usize>,
3926    pressed_header: Option<usize>,
3927    row_height: Option<f32>,
3928    row_heights: Option<Vec<f32>>,
3929    row_extents: CollectionExtentIndex,
3930    row_extents_default_height: f32,
3931    row_key: Option<Box<dyn Fn(usize) -> u64>>,
3932    header_height: Option<f32>,
3933    scroll_y: f32,
3934    scroll_x: f32,
3935    column_widths: Vec<f32>,
3936    focus_animation: AnimatedScalar,
3937    row_painter: Option<VirtualTableRowPainter>,
3938    row_name: Option<VirtualTableRowName>,
3939    row_description: Option<VirtualTableRowDescription>,
3940    on_row_activate: Option<Box<dyn FnMut(usize, VirtualTableRowActivationKind)>>,
3941    on_cell_activate: Option<VirtualTableCellActivation>,
3942    on_header_activate: Option<Box<dyn FnMut(usize)>>,
3943    on_column_resize: Option<Box<dyn FnMut(usize, f32)>>,
3944    on_near_end: Option<Box<dyn FnMut()>>,
3945    last_click: Option<(usize, Instant)>,
3946    column_resize: Option<VirtualTableColumnResize>,
3947}
3948
3949impl VirtualTable {
3950    const DOUBLE_CLICK_WINDOW: Duration = Duration::from_millis(450);
3951
3952    pub fn new(name: impl Into<String>) -> Self {
3953        Self {
3954            theme: Box::new(DefaultTheme::default()),
3955            theme_reader: None,
3956            name: name.into(),
3957            columns: Vec::new(),
3958            state: None,
3959            window: CollectionWindow::complete(0),
3960            window_explicit: false,
3961            row_count: 0,
3962            selected: None,
3963            selected_reader: None,
3964            hovered_row: None,
3965            pressed_row: None,
3966            pressed_header: None,
3967            row_height: None,
3968            row_heights: None,
3969            row_extents: CollectionExtentIndex::new(),
3970            row_extents_default_height: 0.0,
3971            row_key: None,
3972            header_height: None,
3973            scroll_y: 0.0,
3974            scroll_x: 0.0,
3975            column_widths: Vec::new(),
3976            focus_animation: AnimatedScalar::new(0.0),
3977            row_painter: None,
3978            row_name: None,
3979            row_description: None,
3980            on_row_activate: None,
3981            on_cell_activate: None,
3982            on_header_activate: None,
3983            on_column_resize: None,
3984            on_near_end: None,
3985            last_click: None,
3986            column_resize: None,
3987        }
3988    }
3989
3990    pub fn theme(mut self, theme: DefaultTheme) -> Self {
3991        self.theme = Box::new(theme);
3992        self.theme_reader = None;
3993        self
3994    }
3995
3996    pub fn theme_when<F>(mut self, theme: F) -> Self
3997    where
3998        F: Fn() -> DefaultTheme + 'static,
3999    {
4000        self.theme_reader = Some(Box::new(theme));
4001        self
4002    }
4003
4004    pub fn columns<I>(mut self, columns: I) -> Self
4005    where
4006        I: IntoIterator<Item = VirtualTableColumn>,
4007    {
4008        self.columns.extend(columns);
4009        self
4010    }
4011
4012    /// Attach retained keyed interaction and viewport state.
4013    pub fn state(mut self, state: VirtualTableState) -> Self {
4014        self.state = Some(state);
4015        self
4016    }
4017
4018    /// Describe where the currently loaded rows sit in the full dataset.
4019    pub fn collection_window(mut self, window: CollectionWindow) -> Self {
4020        self.window = window;
4021        self.window_explicit = true;
4022        self
4023    }
4024
4025    pub fn row_count(mut self, row_count: usize) -> Self {
4026        self.row_count = row_count;
4027        if !self.window_explicit {
4028            self.window = CollectionWindow::complete(row_count);
4029        }
4030        self.row_extents.clear();
4031        self
4032    }
4033
4034    pub fn row_height(mut self, row_height: f32) -> Self {
4035        self.row_height = Some(row_height.max(1.0));
4036        self.row_heights = None;
4037        self.row_extents.clear();
4038        self
4039    }
4040
4041    pub fn row_heights<I>(mut self, row_heights: I) -> Self
4042    where
4043        I: IntoIterator<Item = f32>,
4044    {
4045        self.row_heights = Some(
4046            row_heights
4047                .into_iter()
4048                .map(|height| height.max(1.0))
4049                .collect(),
4050        );
4051        self.row_extents.clear();
4052        self
4053    }
4054
4055    /// Provide a stable row identity independent of the current sorted index.
4056    ///
4057    /// The key is used for accessibility identity and remains stable when the
4058    /// application reorders its row source.
4059    pub fn row_key<F>(mut self, row_key: F) -> Self
4060    where
4061        F: Fn(usize) -> u64 + 'static,
4062    {
4063        self.row_key = Some(Box::new(row_key));
4064        self
4065    }
4066
4067    pub fn header_height(mut self, header_height: f32) -> Self {
4068        self.header_height = Some(header_height.max(1.0));
4069        self
4070    }
4071
4072    pub fn selected(mut self, selected: usize) -> Self {
4073        self.selected = Some(selected);
4074        self
4075    }
4076
4077    pub fn selected_when<F>(mut self, selected: F) -> Self
4078    where
4079        F: Fn() -> Option<usize> + 'static,
4080    {
4081        self.selected_reader = Some(Box::new(selected));
4082        self
4083    }
4084
4085    pub fn row_painter<F>(mut self, painter: F) -> Self
4086    where
4087        F: for<'a> Fn(&mut PaintCtx, &VirtualTableRowContext<'a>) + 'static,
4088    {
4089        self.row_painter = Some(Box::new(painter));
4090        self
4091    }
4092
4093    pub fn row_name<F>(mut self, name: F) -> Self
4094    where
4095        F: Fn(usize) -> String + 'static,
4096    {
4097        self.row_name = Some(Box::new(name));
4098        self
4099    }
4100
4101    pub fn row_description<F>(mut self, description: F) -> Self
4102    where
4103        F: Fn(usize) -> String + 'static,
4104    {
4105        self.row_description = Some(Box::new(description));
4106        self
4107    }
4108
4109    pub fn on_row_activate<F>(mut self, on_activate: F) -> Self
4110    where
4111        F: FnMut(usize, VirtualTableRowActivationKind) + 'static,
4112    {
4113        self.on_row_activate = Some(Box::new(on_activate));
4114        self
4115    }
4116
4117    pub fn on_cell_activate<F>(mut self, on_activate: F) -> Self
4118    where
4119        F: FnMut(usize, usize, VirtualTableRowActivationKind) -> bool + 'static,
4120    {
4121        self.on_cell_activate = Some(Box::new(on_activate));
4122        self
4123    }
4124
4125    pub fn on_header_activate<F>(mut self, on_activate: F) -> Self
4126    where
4127        F: FnMut(usize) + 'static,
4128    {
4129        self.on_header_activate = Some(Box::new(on_activate));
4130        self
4131    }
4132
4133    pub fn on_column_resize<F>(mut self, on_resize: F) -> Self
4134    where
4135        F: FnMut(usize, f32) + 'static,
4136    {
4137        self.on_column_resize = Some(Box::new(on_resize));
4138        self
4139    }
4140
4141    pub fn on_near_end<F>(mut self, on_near_end: F) -> Self
4142    where
4143        F: FnMut() + 'static,
4144    {
4145        self.on_near_end = Some(Box::new(on_near_end));
4146        self
4147    }
4148
4149    fn resolved_theme(&self) -> DefaultTheme {
4150        self.theme_reader
4151            .as_ref()
4152            .map(|theme| theme())
4153            .unwrap_or(*self.theme)
4154    }
4155
4156    fn resolved_selected(&self) -> Option<usize> {
4157        let selected = if let Some(selected_reader) = &self.selected_reader {
4158            selected_reader()
4159        } else if let Some(state) = &self.state {
4160            state.selected_key().and_then(|selected_key| {
4161                (0..self.row_count).find(|index| self.resolved_row_key(*index) == selected_key)
4162            })
4163        } else {
4164            self.selected
4165        };
4166        selected.filter(|index| *index < self.row_count)
4167    }
4168
4169    fn normalized_window(&self) -> CollectionWindow {
4170        self.window
4171            .clone()
4172            .normalized_for_loaded_count(self.row_count)
4173    }
4174
4175    fn resolved_row_height(&self) -> f32 {
4176        self.row_height
4177            .unwrap_or(self.resolved_theme().metrics.table_row_height)
4178    }
4179
4180    fn row_height_at(&self, index: usize) -> f32 {
4181        self.row_heights
4182            .as_ref()
4183            .and_then(|heights| heights.get(index).copied())
4184            .unwrap_or_else(|| self.resolved_row_height())
4185            .max(1.0)
4186    }
4187
4188    fn sync_row_extents(&mut self) {
4189        let default_height = self.resolved_row_height();
4190        let needs_rebuild = self.row_extents.len() != self.row_count
4191            || (self.row_heights.is_none()
4192                && (self.row_extents_default_height - default_height).abs() > f32::EPSILON);
4193        if needs_rebuild {
4194            let heights = (0..self.row_count)
4195                .map(|index| self.row_height_at(index))
4196                .collect::<Vec<_>>();
4197            self.row_extents.rebuild(heights);
4198            self.row_extents_default_height = default_height;
4199        }
4200    }
4201
4202    fn resolved_row_key(&self, index: usize) -> u64 {
4203        self.row_key
4204            .as_ref()
4205            .map(|row_key| row_key(index))
4206            .unwrap_or(index as u64)
4207    }
4208
4209    fn resolved_column_key(&self, index: usize) -> u64 {
4210        self.columns
4211            .get(index)
4212            .and_then(|column| column.key)
4213            .unwrap_or(index as u64)
4214    }
4215
4216    fn resolved_header_height(&self) -> f32 {
4217        self.header_height
4218            .unwrap_or(self.resolved_theme().metrics.table_header_height)
4219    }
4220
4221    fn body_rect(&self, bounds: Rect) -> Rect {
4222        let theme = self.resolved_theme();
4223        let padding = theme.metrics.data_viewport_padding;
4224        let gap = theme.metrics.select_menu_gap;
4225        Rect::new(
4226            bounds.x() + padding.left,
4227            bounds.y() + padding.top + self.resolved_header_height() + gap,
4228            (bounds.width() - padding.left - padding.right).max(0.0),
4229            (bounds.height() - padding.top - padding.bottom - self.resolved_header_height() - gap)
4230                .max(0.0),
4231        )
4232    }
4233
4234    fn header_rect(&self, bounds: Rect) -> Rect {
4235        let theme = self.resolved_theme();
4236        let padding = theme.metrics.data_viewport_padding;
4237        Rect::new(
4238            bounds.x() + padding.left,
4239            bounds.y() + padding.top,
4240            (bounds.width() - padding.left - padding.right).max(0.0),
4241            self.resolved_header_height(),
4242        )
4243    }
4244
4245    fn content_height(&self) -> f32 {
4246        if self.row_extents.len() == self.row_count {
4247            self.row_extents.total()
4248        } else {
4249            self.row_count as f32 * self.resolved_row_height()
4250        }
4251    }
4252
4253    fn clamp_scroll(&self, viewport_height: f32, scroll_y: f32) -> f32 {
4254        let max_scroll = (self.content_height() - viewport_height).max(0.0);
4255        scroll_y.clamp(0.0, max_scroll)
4256    }
4257
4258    fn pinned_width(&self) -> f32 {
4259        self.columns
4260            .iter()
4261            .enumerate()
4262            .filter(|(_, column)| column.pinned)
4263            .map(|(index, column)| *self.column_widths.get(index).unwrap_or(&column.min_width))
4264            .sum()
4265    }
4266
4267    fn unpinned_content_width(&self) -> f32 {
4268        self.columns
4269            .iter()
4270            .enumerate()
4271            .filter(|(_, column)| !column.pinned)
4272            .map(|(index, column)| *self.column_widths.get(index).unwrap_or(&column.min_width))
4273            .sum()
4274    }
4275
4276    fn clamp_horizontal_scroll(&self, viewport_width: f32, scroll_x: f32) -> f32 {
4277        let unpinned_viewport = (viewport_width - self.pinned_width()).max(0.0);
4278        let max_scroll = (self.unpinned_content_width() - unpinned_viewport).max(0.0);
4279        scroll_x.clamp(0.0, max_scroll)
4280    }
4281
4282    fn row_at_position(&self, bounds: Rect, position: Point) -> Option<usize> {
4283        let body = self.body_rect(bounds);
4284        if !body.contains(position) {
4285            return None;
4286        }
4287        let y = position.y - body.y() + self.scroll_y;
4288        self.row_extents
4289            .index_at_offset(y)
4290            .filter(|index| *index < self.row_count)
4291    }
4292
4293    fn body_column_at_position(&self, bounds: Rect, position: Point) -> Option<usize> {
4294        let body = self.body_rect(bounds);
4295        if !body.contains(position) {
4296            return None;
4297        }
4298        self.column_rects(body)
4299            .iter()
4300            .position(|rect| rect.contains(position))
4301    }
4302
4303    fn header_at_position(&self, bounds: Rect, position: Point) -> Option<usize> {
4304        let header = self.header_rect(bounds);
4305        if !header.contains(position) {
4306            return None;
4307        }
4308        self.column_rects(header)
4309            .iter()
4310            .position(|rect| rect.contains(position))
4311    }
4312
4313    fn resolve_column_widths(&mut self, ctx: &mut MeasureCtx, available_width: f32) {
4314        let theme = self.resolved_theme();
4315        let header_style = theme.text_style(theme.palette.placeholder);
4316        self.column_widths = self
4317            .columns
4318            .iter()
4319            .enumerate()
4320            .map(|(index, column)| {
4321                let retained_width = self
4322                    .state
4323                    .as_ref()
4324                    .and_then(|state| state.column_width(self.resolved_column_key(index)));
4325                let width = retained_width.or(column.width).unwrap_or_else(|| {
4326                    (measure_text(ctx, &column.title, &header_style).width
4327                        + (theme.metrics.table_cell_padding * 2.0))
4328                        .max(column.min_width)
4329                });
4330                width
4331                    .max(32.0)
4332                    .min(column.max_width.unwrap_or(f32::INFINITY))
4333            })
4334            .collect();
4335
4336        if available_width <= 0.0 || self.column_widths.is_empty() {
4337            return;
4338        }
4339
4340        let total = self.column_widths.iter().sum::<f32>();
4341        let flexible = self
4342            .columns
4343            .iter()
4344            .enumerate()
4345            .filter_map(|(index, column)| {
4346                let retained = self
4347                    .state
4348                    .as_ref()
4349                    .and_then(|state| state.column_width(self.resolved_column_key(index)));
4350                (column.width.is_none() && retained.is_none()).then_some(index)
4351            })
4352            .collect::<Vec<_>>();
4353        if total < available_width && !flexible.is_empty() {
4354            let extra = (available_width - total) / flexible.len() as f32;
4355            for index in flexible {
4356                self.column_widths[index] += extra;
4357            }
4358        }
4359    }
4360
4361    fn column_rects(&self, row_rect: Rect) -> Vec<Rect> {
4362        let pinned_width = self.pinned_width().min(row_rect.width());
4363        let unpinned_clip = Rect::new(
4364            row_rect.x() + pinned_width,
4365            row_rect.y(),
4366            (row_rect.width() - pinned_width).max(0.0),
4367            row_rect.height(),
4368        );
4369        let mut pinned_x = row_rect.x();
4370        let mut unpinned_x = row_rect.x() + pinned_width - self.scroll_x;
4371        self.columns
4372            .iter()
4373            .enumerate()
4374            .map(|(index, column)| {
4375                let width = *self.column_widths.get(index).unwrap_or(&column.min_width);
4376                if column.pinned {
4377                    let rect = Rect::new(pinned_x, row_rect.y(), width, row_rect.height());
4378                    pinned_x += width;
4379                    rect.intersection(row_rect).unwrap_or(Rect::ZERO)
4380                } else {
4381                    let rect = Rect::new(unpinned_x, row_rect.y(), width, row_rect.height());
4382                    unpinned_x += width;
4383                    rect.intersection(unpinned_clip).unwrap_or(Rect::ZERO)
4384                }
4385            })
4386            .collect()
4387    }
4388
4389    fn row_activation_kind(&mut self, row_index: usize) -> VirtualTableRowActivationKind {
4390        let now = Instant::now();
4391        let double_click = self.last_click.take().is_some_and(|(index, instant)| {
4392            index == row_index && now.duration_since(instant) <= Self::DOUBLE_CLICK_WINDOW
4393        });
4394        if double_click {
4395            VirtualTableRowActivationKind::Double
4396        } else {
4397            self.last_click = Some((row_index, now));
4398            VirtualTableRowActivationKind::Single
4399        }
4400    }
4401
4402    fn row_rect(&self, body: Rect, row_index: usize) -> Rect {
4403        let row_y = body.y() + self.row_extents.offset_of(row_index) - self.scroll_y;
4404        Rect::new(
4405            body.x(),
4406            row_y,
4407            body.width(),
4408            self.row_extents
4409                .extent(row_index)
4410                .unwrap_or_else(|| self.row_height_at(row_index)),
4411        )
4412    }
4413
4414    fn visible_row_range(&self, body: Rect) -> Range<usize> {
4415        if self.row_count == 0 {
4416            return 0..0;
4417        }
4418        let start = self.row_extents.index_at_offset(self.scroll_y).unwrap_or(0);
4419        let end = self
4420            .row_extents
4421            .index_at_offset(self.scroll_y + body.height())
4422            .map_or(self.row_count, |index| index + 2)
4423            .min(self.row_count);
4424        start..end
4425    }
4426
4427    fn viewport_row_range(&self, body: Rect) -> Range<usize> {
4428        if self.row_count == 0 || body.height() <= 0.0 {
4429            return 0..0;
4430        }
4431        let start = self.row_extents.index_at_offset(self.scroll_y).unwrap_or(0);
4432        let end = self
4433            .row_extents
4434            .index_at_offset(self.scroll_y + body.height())
4435            .map_or(self.row_count, |index| index + 1)
4436            .min(self.row_count);
4437        start..end
4438    }
4439
4440    fn offset_for_row_alignment(
4441        &self,
4442        row_index: usize,
4443        viewport_height: f32,
4444        alignment: ScrollAlignment,
4445    ) -> f32 {
4446        let top = self.row_extents.offset_of(row_index);
4447        let height = self
4448            .row_extents
4449            .extent(row_index)
4450            .unwrap_or_else(|| self.row_height_at(row_index));
4451        let bottom = top + height;
4452        let offset = match alignment {
4453            ScrollAlignment::Nearest if top < self.scroll_y => top,
4454            ScrollAlignment::Nearest if bottom > self.scroll_y + viewport_height => {
4455                bottom - viewport_height
4456            }
4457            ScrollAlignment::Nearest => self.scroll_y,
4458            ScrollAlignment::Start => top,
4459            ScrollAlignment::Center => top - (viewport_height - height) * 0.5,
4460            ScrollAlignment::End => bottom - viewport_height,
4461        };
4462        self.clamp_scroll(viewport_height, offset)
4463    }
4464
4465    fn apply_pending_keyed_scroll(&mut self, body_height: f32) {
4466        let Some((key, alignment)) = self
4467            .state
4468            .as_ref()
4469            .and_then(VirtualTableState::take_pending_scroll)
4470        else {
4471            return;
4472        };
4473        let Some(index) = (0..self.row_count).find(|index| self.resolved_row_key(*index) == key)
4474        else {
4475            return;
4476        };
4477        self.scroll_y = self.offset_for_row_alignment(index, body_height, alignment);
4478    }
4479
4480    fn sync_retained_scroll_state<C>(&mut self, ctx: &mut C, body: Rect)
4481    where
4482        C: crate::containers::ScrollInvalidationCtx + crate::containers::ScrollWidgetCtx,
4483    {
4484        let Some(state) = self.state.as_ref() else {
4485            return;
4486        };
4487        state
4488            .scroll
4489            .bind_scroll_view(ctx.widget_id(), ctx.widget_id());
4490        let content_width = self.column_widths.iter().sum::<f32>();
4491        let changed = state.scroll.sync_metrics(
4492            ScrollAxes::Both,
4493            body.size,
4494            Size::new(content_width, self.content_height()),
4495        );
4496        if changed {
4497            for scroll_bar_id in state.scroll.subscribers().scroll_bar_ids {
4498                crate::containers::request_scroll_bar_refresh(ctx, scroll_bar_id);
4499            }
4500        }
4501    }
4502
4503    fn sync_retained_offset(&self) {
4504        if let Some(state) = &self.state {
4505            let _ = state
4506                .scroll
4507                .set_offset(Vector::new(self.scroll_x, self.scroll_y));
4508        }
4509    }
4510
4511    fn publish_retained_viewport(&self, body: Rect) {
4512        let Some(state) = &self.state else {
4513            return;
4514        };
4515        let window = self.normalized_window();
4516        let local_visible = self.viewport_row_range(body);
4517        let visible_range = window
4518            .loaded_range
4519            .start
4520            .saturating_add(local_visible.start)
4521            ..window.loaded_range.start.saturating_add(local_visible.end);
4522        let visible_keys = local_visible
4523            .clone()
4524            .map(|index| self.resolved_row_key(index))
4525            .collect::<Vec<_>>();
4526        let anchor = (local_visible.start < self.row_count).then(|| {
4527            let index = local_visible.start;
4528            CollectionAnchor {
4529                key: self.resolved_row_key(index),
4530                offset_within_item: self.scroll_y - self.row_extents.offset_of(index),
4531                gravity: CollectionAnchorGravity::Start,
4532            }
4533        });
4534        let max_offset = (self.content_height() - body.height()).max(0.0);
4535        state.publish_viewport(VirtualViewportSnapshot {
4536            loaded_range: window.loaded_range,
4537            visible_range,
4538            visible_keys,
4539            total_count: window.total_count,
4540            has_before: window.has_before,
4541            has_after: window.has_after,
4542            anchor,
4543            offset: self.scroll_y,
4544            max_offset,
4545            at_loaded_start: self.scroll_y <= f32::EPSILON,
4546            at_loaded_end: max_offset - self.scroll_y <= f32::EPSILON,
4547            following_end: false,
4548        });
4549    }
4550
4551    fn ensure_row_visible(&mut self, body_height: f32, row_index: usize) {
4552        if row_index >= self.row_count {
4553            return;
4554        }
4555        let top = self.row_extents.offset_of(row_index);
4556        let bottom = top
4557            + self
4558                .row_extents
4559                .extent(row_index)
4560                .unwrap_or_else(|| self.row_height_at(row_index));
4561        if top < self.scroll_y {
4562            self.scroll_y = top;
4563        } else if bottom > self.scroll_y + body_height {
4564            self.scroll_y = bottom - body_height;
4565        }
4566        self.scroll_y = self.clamp_scroll(body_height, self.scroll_y);
4567    }
4568
4569    fn column_separator_at_position(&self, bounds: Rect, position: Point) -> Option<usize> {
4570        let header = self.header_rect(bounds);
4571        if !header.contains(position) {
4572            return None;
4573        }
4574        for (index, (column, rect)) in self
4575            .columns
4576            .iter()
4577            .zip(self.column_rects(header))
4578            .enumerate()
4579        {
4580            if !rect.is_empty() && column.resizable && (position.x - rect.max_x()).abs() <= 5.0 {
4581                return Some(index);
4582            }
4583        }
4584        None
4585    }
4586
4587    fn resize_column(&mut self, resize: VirtualTableColumnResize, position_x: f32) -> bool {
4588        let Some(column) = self.columns.get_mut(resize.column_index) else {
4589            return false;
4590        };
4591        let maximum = column.max_width.unwrap_or(f32::INFINITY);
4592        let width =
4593            (resize.start_width + position_x - resize.start_x).clamp(column.min_width, maximum);
4594        if (column.width.unwrap_or(resize.start_width) - width).abs() <= f32::EPSILON {
4595            return false;
4596        }
4597        column.width = Some(width);
4598        if let Some(current) = self.column_widths.get_mut(resize.column_index) {
4599            *current = width;
4600        }
4601        if let Some(state) = &self.state {
4602            let _ = state.set_column_width(self.resolved_column_key(resize.column_index), width);
4603        }
4604        if let Some(on_resize) = &mut self.on_column_resize {
4605            on_resize(resize.column_index, width);
4606        }
4607        true
4608    }
4609
4610    fn activate_row(&mut self, row_index: usize, column_index: Option<usize>) {
4611        if row_index >= self.row_count {
4612            return;
4613        }
4614        self.selected = Some(row_index);
4615        if let Some(state) = &self.state {
4616            let _ = state.select_key(Some(self.resolved_row_key(row_index)));
4617        }
4618        let kind = self.row_activation_kind(row_index);
4619        if let Some(column_index) = column_index
4620            && let Some(on_activate) = &mut self.on_cell_activate
4621            && on_activate(row_index, column_index, kind)
4622        {
4623            return;
4624        }
4625        if let Some(on_activate) = &mut self.on_row_activate {
4626            on_activate(row_index, kind);
4627        }
4628    }
4629
4630    fn maybe_notify_near_end(&mut self, viewport_height: f32) {
4631        let remaining = (self.content_height() - viewport_height - self.scroll_y).max(0.0);
4632        if remaining <= self.resolved_row_height() * 12.0
4633            && let Some(on_near_end) = &mut self.on_near_end
4634        {
4635            on_near_end();
4636        }
4637    }
4638
4639    fn advance_animations(&mut self, time: f64, ctx: &mut EventCtx) {
4640        let (focus_changed, focus_active) = advance_scalar(&mut self.focus_animation, time);
4641        if focus_changed {
4642            ctx.request_paint();
4643        }
4644        if focus_active {
4645            ctx.request_animation_frame();
4646        }
4647    }
4648}
4649
4650impl Widget for VirtualTable {
4651    fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
4652        let bounds = ctx.bounds();
4653        let body = self.body_rect(bounds);
4654
4655        match event {
4656            Event::Pointer(pointer)
4657                if pointer.kind == PointerEventKind::Move
4658                    && self
4659                        .column_resize
4660                        .is_some_and(|resize| resize.pointer_id == pointer.pointer_id) =>
4661            {
4662                let resize = self.column_resize.expect("checked resize gesture");
4663                if self.resize_column(resize, pointer.position.x) {
4664                    ctx.request_measure();
4665                    ctx.request_paint();
4666                    ctx.request_semantics();
4667                }
4668                ctx.set_handled();
4669            }
4670            Event::Pointer(pointer) if pointer.kind == PointerEventKind::Move => {
4671                let hovered = self.row_at_position(bounds, pointer.position);
4672                if self.hovered_row != hovered {
4673                    self.hovered_row = hovered;
4674                    ctx.request_paint();
4675                    ctx.request_semantics();
4676                }
4677            }
4678            Event::Pointer(pointer)
4679                if pointer.kind == PointerEventKind::Scroll && body.contains(pointer.position) =>
4680            {
4681                let delta = pointer
4682                    .scroll_delta
4683                    .map(scroll_delta_to_offset)
4684                    .unwrap_or(pointer.delta);
4685                let next_y = self.clamp_scroll(body.height(), self.scroll_y - delta.y);
4686                let next_x = self.clamp_horizontal_scroll(body.width(), self.scroll_x - delta.x);
4687                if (next_y - self.scroll_y).abs() > f32::EPSILON
4688                    || (next_x - self.scroll_x).abs() > f32::EPSILON
4689                {
4690                    self.scroll_y = next_y;
4691                    self.scroll_x = next_x;
4692                    self.sync_retained_offset();
4693                    self.publish_retained_viewport(body);
4694                    self.maybe_notify_near_end(body.height());
4695                    ctx.request_paint();
4696                    ctx.request_semantics();
4697                    ctx.set_handled();
4698                }
4699            }
4700            Event::Pointer(pointer)
4701                if pointer.kind == PointerEventKind::Down
4702                    && pointer.button == Some(PointerButton::Primary) =>
4703            {
4704                if let Some(column_index) =
4705                    self.column_separator_at_position(bounds, pointer.position)
4706                {
4707                    let start_width = self.column_widths[column_index];
4708                    self.column_resize = Some(VirtualTableColumnResize {
4709                        column_index,
4710                        pointer_id: pointer.pointer_id,
4711                        start_x: pointer.position.x,
4712                        start_width,
4713                    });
4714                    ctx.request_focus();
4715                    ctx.request_pointer_capture(pointer.pointer_id);
4716                    ctx.request_paint();
4717                    ctx.set_handled();
4718                } else if let Some(header) = self.header_at_position(bounds, pointer.position) {
4719                    self.pressed_header = Some(header);
4720                    ctx.request_focus();
4721                    ctx.request_pointer_capture(pointer.pointer_id);
4722                    ctx.request_paint();
4723                    ctx.set_handled();
4724                } else if let Some(row) = self.row_at_position(bounds, pointer.position) {
4725                    self.pressed_row = Some(row);
4726                    self.hovered_row = Some(row);
4727                    ctx.request_focus();
4728                    ctx.request_pointer_capture(pointer.pointer_id);
4729                    ctx.request_paint();
4730                    ctx.request_semantics();
4731                    ctx.set_handled();
4732                }
4733            }
4734            Event::Pointer(pointer)
4735                if pointer.kind == PointerEventKind::Up
4736                    && pointer.button == Some(PointerButton::Primary) =>
4737            {
4738                if self
4739                    .column_resize
4740                    .take()
4741                    .is_some_and(|resize| resize.pointer_id == pointer.pointer_id)
4742                {
4743                    ctx.release_pointer_capture(pointer.pointer_id);
4744                    ctx.request_paint();
4745                    ctx.request_semantics();
4746                    ctx.set_handled();
4747                    return;
4748                }
4749                let header = self.header_at_position(bounds, pointer.position);
4750                if let Some(index) = self
4751                    .pressed_header
4752                    .zip(header)
4753                    .filter(|(pressed, hovered)| pressed == hovered)
4754                    .map(|(index, _)| index)
4755                {
4756                    if let Some(on_activate) = &mut self.on_header_activate {
4757                        on_activate(index);
4758                    }
4759                } else {
4760                    let hovered = self.row_at_position(bounds, pointer.position);
4761                    if let Some(index) = self
4762                        .pressed_row
4763                        .zip(hovered)
4764                        .filter(|(pressed, hovered)| pressed == hovered)
4765                        .map(|(index, _)| index)
4766                    {
4767                        let column = self.body_column_at_position(bounds, pointer.position);
4768                        self.activate_row(index, column);
4769                    }
4770                    self.hovered_row = hovered;
4771                }
4772                self.pressed_row = None;
4773                self.pressed_header = None;
4774                ctx.release_pointer_capture(pointer.pointer_id);
4775                ctx.request_paint();
4776                ctx.request_semantics();
4777                ctx.set_handled();
4778            }
4779            Event::Pointer(pointer) if pointer.kind == PointerEventKind::Leave => {
4780                if self.hovered_row.take().is_some() {
4781                    ctx.request_paint();
4782                    ctx.request_semantics();
4783                }
4784            }
4785            Event::Pointer(pointer) if pointer.kind == PointerEventKind::Cancel => {
4786                if self.column_resize.take().is_some()
4787                    || self.pressed_row.take().is_some()
4788                    || self.pressed_header.take().is_some()
4789                {
4790                    ctx.release_pointer_capture(pointer.pointer_id);
4791                    ctx.request_paint();
4792                    ctx.set_handled();
4793                }
4794                if self.hovered_row.take().is_some() {
4795                    ctx.request_paint();
4796                    ctx.request_semantics();
4797                }
4798            }
4799            Event::Keyboard(key) if ctx.is_focused() && key.state == KeyState::Pressed => {
4800                if self.row_count == 0 {
4801                    return;
4802                }
4803                let current = self.resolved_selected().unwrap_or(0);
4804                match key.key.as_str() {
4805                    "ArrowUp" => {
4806                        let next = current.saturating_sub(1);
4807                        self.activate_row(next, None);
4808                        self.ensure_row_visible(body.height(), next);
4809                    }
4810                    "ArrowDown" => {
4811                        let next = (current + 1).min(self.row_count - 1);
4812                        self.activate_row(next, None);
4813                        self.ensure_row_visible(body.height(), next);
4814                    }
4815                    "Home" => {
4816                        self.activate_row(0, None);
4817                        self.ensure_row_visible(body.height(), 0);
4818                    }
4819                    "End" => {
4820                        let last = self.row_count - 1;
4821                        self.activate_row(last, None);
4822                        self.ensure_row_visible(body.height(), last);
4823                    }
4824                    "PageUp" => {
4825                        self.scroll_y =
4826                            self.clamp_scroll(body.height(), self.scroll_y - body.height() * 0.85);
4827                    }
4828                    "PageDown" => {
4829                        self.scroll_y =
4830                            self.clamp_scroll(body.height(), self.scroll_y + body.height() * 0.85);
4831                    }
4832                    _ => return,
4833                }
4834                self.sync_retained_offset();
4835                self.publish_retained_viewport(body);
4836                ctx.request_paint();
4837                ctx.request_semantics();
4838                ctx.set_handled();
4839            }
4840            Event::Semantics(semantics) if semantics.target == ctx.widget_id() => {
4841                let delta = match semantics.action {
4842                    sui_core::SemanticsActionRequest::Increment => Some(body.height() * 0.85),
4843                    sui_core::SemanticsActionRequest::Decrement => Some(-body.height() * 0.85),
4844                    _ => None,
4845                };
4846                if let Some(delta) = delta {
4847                    let next = self.clamp_scroll(body.height(), self.scroll_y + delta);
4848                    if (next - self.scroll_y).abs() > f32::EPSILON {
4849                        self.scroll_y = next;
4850                        self.sync_retained_offset();
4851                        self.publish_retained_viewport(body);
4852                        ctx.request_paint();
4853                        ctx.request_semantics();
4854                    }
4855                    ctx.set_handled();
4856                }
4857            }
4858            Event::Wake(WakeEvent::AnimationFrame { time, .. }) => {
4859                self.advance_animations(*time, ctx);
4860            }
4861            _ => {}
4862        }
4863    }
4864
4865    fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
4866        if let Some(state) = &self.state {
4867            let _ = ctx.observe(&state.revision);
4868        }
4869        self.sync_row_extents();
4870        let desired_width = if constraints.max.width.is_finite() {
4871            constraints.max.width
4872        } else {
4873            540.0
4874        };
4875        let desired_height = if constraints.max.height.is_finite() {
4876            constraints.max.height
4877        } else {
4878            let theme = self.resolved_theme();
4879            let padding = theme.metrics.data_viewport_padding;
4880            (padding.top
4881                + self.resolved_header_height()
4882                + theme.metrics.select_menu_gap
4883                + self.content_height()
4884                + padding.bottom)
4885                .min(420.0)
4886        };
4887        let theme = self.resolved_theme();
4888        let padding = theme.metrics.data_viewport_padding;
4889        self.resolve_column_widths(ctx, (desired_width - padding.left - padding.right).max(0.0));
4890        let size = constraints.clamp(Size::new(desired_width, desired_height));
4891        let body = self.body_rect(Rect::from_origin_size(Point::ZERO, size));
4892        self.sync_retained_scroll_state(ctx, body);
4893        if let Some(state) = &self.state {
4894            let offset = state.scroll.current_offset();
4895            self.scroll_y = offset.y;
4896            self.scroll_x = offset.x;
4897        }
4898        self.apply_pending_keyed_scroll(body.height());
4899        self.scroll_y = self.clamp_scroll(body.height(), self.scroll_y);
4900        self.scroll_x = self.clamp_horizontal_scroll(body.width(), self.scroll_x);
4901        self.sync_retained_offset();
4902        self.publish_retained_viewport(body);
4903        size
4904    }
4905
4906    fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
4907        let body = self.body_rect(bounds);
4908        let previous = Vector::new(self.scroll_x, self.scroll_y);
4909        self.sync_retained_scroll_state(ctx, body);
4910        if let Some(state) = &self.state {
4911            let offset = state.scroll.current_offset();
4912            self.scroll_y = self.clamp_scroll(body.height(), offset.y);
4913            self.scroll_x = self.clamp_horizontal_scroll(body.width(), offset.x);
4914        }
4915        self.apply_pending_keyed_scroll(body.height());
4916        self.sync_retained_offset();
4917        self.publish_retained_viewport(body);
4918        if previous != Vector::new(self.scroll_x, self.scroll_y) {
4919            ctx.request_paint();
4920            ctx.request_semantics();
4921        }
4922    }
4923
4924    fn paint(&self, ctx: &mut PaintCtx) {
4925        let theme = self.resolved_theme();
4926        let palette = theme.palette;
4927        let metrics = theme.metrics;
4928        let header_style = theme.text_style(palette.placeholder);
4929        let bounds = ctx.bounds();
4930        let body = self.body_rect(bounds);
4931        let header = self.header_rect(bounds);
4932        let selected = self.resolved_selected();
4933
4934        draw_surface(ctx, bounds, &theme, self.focus_animation.value);
4935        ctx.fill(
4936            rounded_rect_path(header, metrics.corner_radius),
4937            palette.control,
4938        );
4939
4940        let header_cells = self.column_rects(header);
4941        let paint_order = self
4942            .columns
4943            .iter()
4944            .enumerate()
4945            .filter_map(|(index, column)| (!column.pinned).then_some(index))
4946            .chain(
4947                self.columns
4948                    .iter()
4949                    .enumerate()
4950                    .filter_map(|(index, column)| column.pinned.then_some(index)),
4951            )
4952            .collect::<Vec<_>>();
4953        ctx.push_clip_rect(header);
4954        for index in paint_order {
4955            let column = &self.columns[index];
4956            let cell = header_cells[index];
4957            if cell.is_empty() {
4958                continue;
4959            }
4960            if index > 0 {
4961                let separator_inset = metrics
4962                    .table_header_separator_inset
4963                    .min(cell.height() * 0.5);
4964                ctx.stroke_rect(
4965                    Rect::new(
4966                        cell.x(),
4967                        cell.y() + separator_inset,
4968                        metrics.table_separator_width,
4969                        (cell.height() - (separator_inset * 2.0)).max(0.0),
4970                    ),
4971                    palette.border,
4972                    sui_scene::StrokeStyle::new(metrics.table_separator_width.max(1.0)),
4973                );
4974            }
4975            let title = match column.sort_direction {
4976                Some(VirtualTableSortDirection::Ascending) => format!("{} ^", column.title),
4977                Some(VirtualTableSortDirection::Descending) => format!("{} v", column.title),
4978                None => column.title.clone(),
4979            };
4980            draw_aligned_text(
4981                ctx,
4982                horizontal_inset_rect(cell, metrics.table_cell_padding),
4983                &title,
4984                &header_style,
4985                column.alignment,
4986            );
4987        }
4988        ctx.pop_clip();
4989
4990        ctx.push_clip_rect(body);
4991        for row_index in self.visible_row_range(body) {
4992            let row_rect = self.row_rect(body, row_index);
4993            let row_selected = selected == Some(row_index);
4994            let row_hovered = self.hovered_row == Some(row_index);
4995            let row_pressed = self.pressed_row == Some(row_index);
4996            paint_data_row_state(
4997                ctx,
4998                row_rect,
4999                body,
5000                &theme,
5001                row_selected,
5002                row_hovered as u8 as f32,
5003                row_pressed as u8 as f32,
5004            );
5005            let columns = self.column_rects(row_rect);
5006            if let Some(painter) = &self.row_painter {
5007                let row = VirtualTableRowContext {
5008                    row_index,
5009                    row_key: self.resolved_row_key(row_index),
5010                    row_rect,
5011                    column_rects: &columns,
5012                    selected: row_selected,
5013                    hovered: row_hovered,
5014                    pressed: row_pressed,
5015                };
5016                painter(ctx, &row);
5017            }
5018        }
5019        ctx.pop_clip();
5020
5021        draw_vertical_scroll_thumb(
5022            ctx,
5023            &theme,
5024            body,
5025            self.content_height(),
5026            self.scroll_y,
5027            palette.placeholder,
5028        );
5029    }
5030
5031    fn semantics(&self, ctx: &mut SemanticsCtx) {
5032        let window = self.normalized_window();
5033        let total_count = window.total_count;
5034        let described_count = total_count.unwrap_or(window.loaded_range.end);
5035        let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::Table, ctx.bounds());
5036        node.name = Some(self.name.clone());
5037        node.state.focused = ctx.is_focused();
5038        node.value = Some(SemanticsValue::Text(match total_count {
5039            Some(total_count) => format!("{total_count} rows"),
5040            None => format!("{} loaded rows", self.row_count),
5041        }));
5042        let columns = self
5043            .columns
5044            .iter()
5045            .filter_map(|column| {
5046                let title = column.title.trim();
5047                (!title.is_empty()).then(|| title.to_string())
5048            })
5049            .collect::<Vec<_>>();
5050        if !columns.is_empty() {
5051            let visible = self.viewport_row_range(self.body_rect(ctx.bounds()));
5052            let visible_start = window
5053                .loaded_range
5054                .start
5055                .saturating_add(visible.start)
5056                .saturating_add(1)
5057                .min(described_count);
5058            let visible_end = window
5059                .loaded_range
5060                .start
5061                .saturating_add(visible.end)
5062                .min(described_count);
5063            node.description = Some(match total_count {
5064                Some(total_count) => format!(
5065                    "Columns: {}; showing rows {} through {} of {}",
5066                    columns.join(", "),
5067                    visible_start,
5068                    visible_end,
5069                    total_count,
5070                ),
5071                None => format!(
5072                    "Columns: {}; showing loaded rows {} through {}",
5073                    columns.join(", "),
5074                    visible_start,
5075                    visible_end,
5076                ),
5077            });
5078        }
5079        node.actions = vec![
5080            SemanticsAction::Focus,
5081            SemanticsAction::Increment,
5082            SemanticsAction::Decrement,
5083            SemanticsAction::SetValue,
5084        ];
5085        ctx.push(node);
5086
5087        let body = self.body_rect(ctx.bounds());
5088        let selected = self.resolved_selected();
5089        for row_index in self.visible_row_range(body) {
5090            let row_rect = self.row_rect(body, row_index);
5091            let row_key = self.resolved_row_key(row_index);
5092            let dataset_index = window.loaded_range.start.saturating_add(row_index);
5093            let mut row = SemanticsNode::new(
5094                virtual_table_row_id(ctx.widget_id(), row_key),
5095                SemanticsRole::ListItem,
5096                row_rect,
5097            );
5098            row.parent = Some(ctx.widget_id());
5099            row.name = self.row_name.as_ref().map(|name| name(row_index));
5100            row.description = self
5101                .row_description
5102                .as_ref()
5103                .map(|description| {
5104                    let position = match total_count {
5105                        Some(total_count) => {
5106                            format!("row {} of {}", dataset_index + 1, total_count)
5107                        }
5108                        None => format!("loaded row {}", dataset_index + 1),
5109                    };
5110                    format!("{}; {}", description(row_index), position)
5111                })
5112                .or_else(|| {
5113                    Some(match total_count {
5114                        Some(total_count) => {
5115                            format!("Row {} of {}", dataset_index + 1, total_count)
5116                        }
5117                        None => format!("Loaded row {}", dataset_index + 1),
5118                    })
5119                });
5120            row.state.selected = selected == Some(row_index);
5121            row.state.hovered = self.hovered_row == Some(row_index);
5122            row.actions = vec![SemanticsAction::Activate];
5123            ctx.push(row);
5124        }
5125    }
5126
5127    fn accepts_focus(&self) -> bool {
5128        true
5129    }
5130
5131    fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
5132        let theme = self.resolved_theme();
5133        set_focus_animation_target(&mut self.focus_animation, focused as u8 as f32, &theme, ctx);
5134        ctx.request_paint();
5135        ctx.request_semantics();
5136    }
5137}
5138
5139#[derive(Debug, Clone, PartialEq)]
5140pub struct BreadcrumbItem {
5141    label: String,
5142}
5143
5144impl BreadcrumbItem {
5145    pub fn new(label: impl Into<String>) -> Self {
5146        Self {
5147            label: label.into(),
5148        }
5149    }
5150}
5151
5152pub type PathBar = Breadcrumb;
5153
5154pub struct Breadcrumb {
5155    theme: Box<DefaultTheme>,
5156    theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
5157    name: String,
5158    name_reader: Option<Box<dyn Fn() -> String>>,
5159    items: Vec<BreadcrumbItem>,
5160    current: usize,
5161    current_reader: Option<Box<dyn Fn() -> Option<usize>>>,
5162    focused_index: usize,
5163    hovered: Option<usize>,
5164    pressed: Option<usize>,
5165    hover_motion: IndexedInteractionMotion<usize>,
5166    press_motion: IndexedInteractionMotion<usize>,
5167    focus_animation: AnimatedScalar,
5168    measured_widths: Vec<f32>,
5169    content_width: f32,
5170    scroll_x: f32,
5171    auto_scroll_to_end: bool,
5172    drag_anchor: Option<(Point, f32)>,
5173    drag_moved: bool,
5174    on_activate: Option<Box<dyn FnMut(usize, String)>>,
5175}
5176
5177impl Breadcrumb {
5178    pub fn new(name: impl Into<String>) -> Self {
5179        Self {
5180            theme: Box::new(DefaultTheme::default()),
5181            theme_reader: None,
5182            name: name.into(),
5183            name_reader: None,
5184            items: Vec::new(),
5185            current: 0,
5186            current_reader: None,
5187            focused_index: 0,
5188            hovered: None,
5189            pressed: None,
5190            hover_motion: IndexedInteractionMotion::new(),
5191            press_motion: IndexedInteractionMotion::new(),
5192            focus_animation: AnimatedScalar::new(0.0),
5193            measured_widths: Vec::new(),
5194            content_width: 0.0,
5195            scroll_x: 0.0,
5196            auto_scroll_to_end: true,
5197            drag_anchor: None,
5198            drag_moved: false,
5199            on_activate: None,
5200        }
5201    }
5202
5203    pub fn theme(mut self, theme: DefaultTheme) -> Self {
5204        self.theme = Box::new(theme);
5205        self.theme_reader = None;
5206        self
5207    }
5208
5209    pub fn theme_when<F>(mut self, theme: F) -> Self
5210    where
5211        F: Fn() -> DefaultTheme + 'static,
5212    {
5213        self.theme_reader = Some(Box::new(theme));
5214        self
5215    }
5216
5217    pub fn item(mut self, item: BreadcrumbItem) -> Self {
5218        self.items.push(item);
5219        self
5220    }
5221
5222    pub fn items<I>(mut self, items: I) -> Self
5223    where
5224        I: IntoIterator<Item = BreadcrumbItem>,
5225    {
5226        self.items.extend(items);
5227        self
5228    }
5229
5230    pub fn current(mut self, current: usize) -> Self {
5231        self.current = current;
5232        self.current_reader = None;
5233        self.focused_index = current;
5234        self
5235    }
5236
5237    pub fn name_when<F>(mut self, name: F) -> Self
5238    where
5239        F: Fn() -> String + 'static,
5240    {
5241        self.name_reader = Some(Box::new(name));
5242        self
5243    }
5244
5245    pub fn current_when<F>(mut self, current: F) -> Self
5246    where
5247        F: Fn() -> Option<usize> + 'static,
5248    {
5249        self.current_reader = Some(Box::new(current));
5250        self
5251    }
5252
5253    pub fn on_activate<F>(mut self, on_activate: F) -> Self
5254    where
5255        F: FnMut(usize, String) + 'static,
5256    {
5257        self.on_activate = Some(Box::new(on_activate));
5258        self
5259    }
5260
5261    fn normalized_current(&self) -> usize {
5262        let current = self
5263            .current_reader
5264            .as_ref()
5265            .and_then(|reader| reader())
5266            .unwrap_or(self.current);
5267        if self.items.is_empty() {
5268            0
5269        } else {
5270            current.min(self.items.len() - 1)
5271        }
5272    }
5273
5274    fn name(&self) -> String {
5275        self.name_reader
5276            .as_ref()
5277            .map(|reader| reader())
5278            .unwrap_or_else(|| self.name.clone())
5279    }
5280
5281    fn resolved_theme(&self) -> DefaultTheme {
5282        self.theme_reader
5283            .as_ref()
5284            .map(|theme| theme())
5285            .unwrap_or(*self.theme)
5286    }
5287
5288    fn activate(&mut self, index: usize) {
5289        if index >= self.items.len() {
5290            return;
5291        }
5292        self.current = index;
5293        self.focused_index = index;
5294        if let Some(on_activate) = &mut self.on_activate {
5295            on_activate(index, self.items[index].label.clone());
5296        }
5297    }
5298
5299    fn max_scroll_x(&self, bounds: Rect) -> f32 {
5300        (self.content_width - bounds.width()).max(0.0)
5301    }
5302
5303    fn content_overflows(&self, bounds: Rect) -> bool {
5304        self.max_scroll_x(bounds) > 0.5
5305    }
5306
5307    fn sync_scroll_to_bounds(&mut self, bounds: Rect) {
5308        let max_scroll = self.max_scroll_x(bounds);
5309        self.scroll_x = if self.auto_scroll_to_end {
5310            max_scroll
5311        } else {
5312            self.scroll_x.clamp(0.0, max_scroll)
5313        };
5314    }
5315
5316    fn set_scroll_x(&mut self, bounds: Rect, next_scroll_x: f32) -> bool {
5317        let max_scroll = self.max_scroll_x(bounds);
5318        let next_scroll_x = next_scroll_x.clamp(0.0, max_scroll);
5319        if (self.scroll_x - next_scroll_x).abs() <= 0.5 {
5320            return false;
5321        }
5322
5323        self.scroll_x = next_scroll_x;
5324        self.auto_scroll_to_end = false;
5325        true
5326    }
5327
5328    fn wheel_scroll_delta(delta: Vector) -> f32 {
5329        if delta.x.abs() > 0.0 {
5330            -delta.x
5331        } else {
5332            -delta.y
5333        }
5334    }
5335
5336    fn item_rect(&self, bounds: Rect, index: usize) -> Option<Rect> {
5337        let widths = &self.measured_widths;
5338        if index >= widths.len() {
5339            return None;
5340        }
5341        let theme = self.resolved_theme();
5342        let padding = theme.metrics.breadcrumb_item_padding;
5343        let gap = theme.metrics.breadcrumb_gap;
5344        let mut x = bounds.x() + padding.left - self.scroll_x;
5345        for (current, width) in widths.iter().enumerate() {
5346            let rect = Rect::new(
5347                x,
5348                bounds.y() + padding.top,
5349                *width,
5350                (bounds.height() - padding.top - padding.bottom).max(0.0),
5351            );
5352            if current == index {
5353                return Some(rect);
5354            }
5355            x += *width + gap;
5356        }
5357        None
5358    }
5359
5360    fn item_at(&self, bounds: Rect, position: Point) -> Option<usize> {
5361        if !bounds.contains(position) {
5362            return None;
5363        }
5364
5365        (0..self.items.len()).find(|index| {
5366            self.item_rect(bounds, *index)
5367                .is_some_and(|rect| rect.contains(position))
5368        })
5369    }
5370
5371    fn set_hovered(&mut self, hovered: Option<usize>, ctx: &mut EventCtx) {
5372        if self.hovered == hovered {
5373            return;
5374        }
5375
5376        self.hovered = hovered;
5377        let theme = self.resolved_theme();
5378        self.hover_motion.set_hover_target(hovered, &theme, ctx);
5379        ctx.request_paint();
5380        ctx.request_semantics();
5381    }
5382
5383    fn set_pressed(&mut self, pressed: Option<usize>, ctx: &mut EventCtx) {
5384        if self.pressed == pressed {
5385            return;
5386        }
5387
5388        self.pressed = pressed;
5389        let theme = self.resolved_theme();
5390        self.press_motion.set_press_target(pressed, &theme, ctx);
5391        ctx.request_paint();
5392        ctx.request_semantics();
5393    }
5394
5395    fn advance_animations(&mut self, time: f64, ctx: &mut EventCtx) {
5396        let (hover_changed, hover_active) = self.hover_motion.advance(time);
5397        let (press_changed, press_active) = self.press_motion.advance(time);
5398        let (focus_changed, focus_active) = advance_scalar(&mut self.focus_animation, time);
5399
5400        if hover_changed || press_changed || focus_changed {
5401            ctx.request_paint();
5402        }
5403        if hover_active || press_active || focus_active {
5404            ctx.request_animation_frame();
5405        }
5406    }
5407}
5408
5409impl Widget for Breadcrumb {
5410    fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
5411        match event {
5412            Event::Pointer(pointer) if pointer.kind == PointerEventKind::Move => {
5413                if pointer.buttons.contains(PointerButton::Primary)
5414                    && let Some((anchor_position, anchor_scroll_x)) = self.drag_anchor
5415                {
5416                    let bounds = ctx.bounds();
5417                    if self.content_overflows(bounds) {
5418                        let next_scroll_x =
5419                            anchor_scroll_x - (pointer.position.x - anchor_position.x);
5420                        if self.set_scroll_x(bounds, next_scroll_x) {
5421                            self.drag_moved = true;
5422                            self.set_pressed(None, ctx);
5423                            ctx.request_paint();
5424                            ctx.request_semantics();
5425                            ctx.set_handled();
5426                        }
5427
5428                        if (pointer.position.x - anchor_position.x).abs() > 3.0 {
5429                            self.drag_moved = true;
5430                        }
5431                    }
5432                }
5433
5434                let hovered = self.item_at(ctx.bounds(), pointer.position);
5435                self.set_hovered(hovered, ctx);
5436            }
5437            Event::Pointer(pointer) if pointer.kind == PointerEventKind::Scroll => {
5438                let bounds = ctx.bounds();
5439                if bounds.contains(pointer.position) && self.content_overflows(bounds) {
5440                    let delta = pointer
5441                        .scroll_delta
5442                        .map(scroll_delta_to_offset)
5443                        .unwrap_or(pointer.delta);
5444                    if self.set_scroll_x(bounds, self.scroll_x + Self::wheel_scroll_delta(delta)) {
5445                        let hovered = self.item_at(bounds, pointer.position);
5446                        self.set_hovered(hovered, ctx);
5447                        ctx.request_paint();
5448                        ctx.request_semantics();
5449                        ctx.set_handled();
5450                    }
5451                }
5452            }
5453            Event::Pointer(pointer)
5454                if pointer.kind == PointerEventKind::Down
5455                    && pointer.button == Some(PointerButton::Primary) =>
5456            {
5457                let pressed = self.item_at(ctx.bounds(), pointer.position);
5458                self.drag_anchor = Some((pointer.position, self.scroll_x));
5459                self.drag_moved = false;
5460                self.set_hovered(pressed, ctx);
5461                self.set_pressed(pressed, ctx);
5462                ctx.request_focus();
5463                ctx.request_pointer_capture(pointer.pointer_id);
5464                ctx.set_handled();
5465            }
5466            Event::Pointer(pointer)
5467                if pointer.kind == PointerEventKind::Up
5468                    && pointer.button == Some(PointerButton::Primary) =>
5469            {
5470                let hovered = self.item_at(ctx.bounds(), pointer.position);
5471                if !self.drag_moved
5472                    && let Some(index) = self
5473                        .pressed
5474                        .zip(hovered)
5475                        .filter(|(pressed, hovered)| pressed == hovered)
5476                        .map(|(index, _)| index)
5477                {
5478                    self.activate(index);
5479                }
5480                self.set_hovered(hovered, ctx);
5481                self.set_pressed(None, ctx);
5482                self.drag_anchor = None;
5483                self.drag_moved = false;
5484                ctx.release_pointer_capture(pointer.pointer_id);
5485                ctx.set_handled();
5486            }
5487            Event::Pointer(pointer) if pointer.kind == PointerEventKind::Leave => {
5488                if self.drag_anchor.is_none() {
5489                    self.set_hovered(None, ctx);
5490                }
5491            }
5492            Event::Pointer(pointer) if pointer.kind == PointerEventKind::Cancel => {
5493                if self.pressed.is_some() || self.drag_anchor.is_some() {
5494                    self.set_pressed(None, ctx);
5495                    self.set_hovered(None, ctx);
5496                    self.drag_anchor = None;
5497                    self.drag_moved = false;
5498                    ctx.release_pointer_capture(pointer.pointer_id);
5499                    ctx.set_handled();
5500                }
5501            }
5502            Event::Wake(WakeEvent::AnimationFrame { time, .. }) => {
5503                self.advance_animations(*time, ctx);
5504            }
5505            Event::Keyboard(key) if ctx.is_focused() && key.state == KeyState::Pressed => {
5506                if self.items.is_empty() {
5507                    return;
5508                }
5509                match key.key.as_str() {
5510                    "ArrowLeft" => {
5511                        self.focused_index = self.focused_index.saturating_sub(1);
5512                    }
5513                    "ArrowRight" => {
5514                        self.focused_index = (self.focused_index + 1).min(self.items.len() - 1);
5515                    }
5516                    "Enter" | " " => self.activate(self.focused_index),
5517                    "Home" => self.focused_index = 0,
5518                    "End" => self.focused_index = self.items.len() - 1,
5519                    _ => return,
5520                }
5521                ctx.request_paint();
5522                ctx.request_semantics();
5523                ctx.set_handled();
5524            }
5525            _ => {}
5526        }
5527    }
5528
5529    fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
5530        let theme = self.resolved_theme();
5531        let text_style = theme.body_text_style();
5532        self.measured_widths = self
5533            .items
5534            .iter()
5535            .map(|item| {
5536                measure_text(ctx, &item.label, &text_style).width
5537                    + theme.metrics.breadcrumb_item_padding.left
5538                    + theme.metrics.breadcrumb_item_padding.right
5539            })
5540            .collect();
5541        let desired_width = self.measured_widths.iter().sum::<f32>()
5542            + (self.items.len().saturating_sub(1) as f32 * theme.metrics.breadcrumb_gap)
5543            + theme.metrics.breadcrumb_item_padding.left
5544            + theme.metrics.breadcrumb_item_padding.right;
5545        if (self.content_width - desired_width).abs() > 0.5 {
5546            self.content_width = desired_width;
5547            self.auto_scroll_to_end = true;
5548        }
5549        constraints.clamp(Size::new(
5550            desired_width.max(180.0),
5551            theme.metrics.breadcrumb_height,
5552        ))
5553    }
5554
5555    fn arrange(&mut self, _ctx: &mut ArrangeCtx, bounds: Rect) {
5556        self.sync_scroll_to_bounds(bounds);
5557    }
5558
5559    fn paint(&self, ctx: &mut PaintCtx) {
5560        let theme = self.resolved_theme();
5561        let palette = theme.palette;
5562        let bounds = ctx.bounds();
5563        draw_surface(ctx, bounds, &theme, self.focus_animation.value);
5564
5565        ctx.push_clip_rect(bounds);
5566        for (index, item) in self.items.iter().enumerate() {
5567            let Some(rect) = self.item_rect(bounds, index) else {
5568                continue;
5569            };
5570            if rect.max_x() < bounds.x() || rect.x() > bounds.max_x() {
5571                continue;
5572            }
5573
5574            let current = self.normalized_current() == index;
5575            let focused = ctx.is_focused() && self.focused_index == index;
5576            let hover_amount = self.hover_motion.amount_for(&index);
5577            let press_amount = self.press_motion.amount_for(&index);
5578
5579            if current
5580                || focused
5581                || hover_amount > AnimatedScalar::EPSILON
5582                || press_amount > AnimatedScalar::EPSILON
5583            {
5584                ctx.fill(
5585                    rounded_rect_path(rect, theme.metrics.corner_radius),
5586                    data_row_state_fill(&theme, current || focused, hover_amount, press_amount),
5587                );
5588            }
5589
5590            let style = theme.body_text_style();
5591            draw_aligned_text(
5592                ctx,
5593                horizontal_inset_rect(rect, 8.0),
5594                &item.label,
5595                &style,
5596                TableColumnAlignment::Start,
5597            );
5598
5599            if index + 1 < self.items.len() {
5600                let separator = chevron_path(Rect::new(
5601                    rect.max_x()
5602                        + ((theme.metrics.breadcrumb_gap
5603                            - theme.metrics.breadcrumb_separator_size)
5604                            * 0.5)
5605                            .max(0.0),
5606                    rect.y() + ((rect.height() - theme.metrics.breadcrumb_separator_size) * 0.5),
5607                    theme.metrics.breadcrumb_separator_size,
5608                    theme.metrics.breadcrumb_separator_size,
5609                ));
5610                ctx.stroke(
5611                    separator,
5612                    palette.placeholder.with_alpha(0.9),
5613                    sui_scene::StrokeStyle::new(1.5),
5614                );
5615            }
5616        }
5617        ctx.pop_clip();
5618    }
5619
5620    fn semantics(&self, ctx: &mut SemanticsCtx) {
5621        let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::Breadcrumb, ctx.bounds());
5622        node.name = Some(self.name());
5623        node.state.focused = ctx.is_focused();
5624        node.value = self
5625            .items
5626            .get(self.normalized_current())
5627            .map(|item| SemanticsValue::Text(item.label.clone()));
5628        node.actions = vec![SemanticsAction::Focus, SemanticsAction::SetValue];
5629        ctx.push(node);
5630    }
5631
5632    fn accepts_focus(&self) -> bool {
5633        true
5634    }
5635
5636    fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
5637        let theme = self.resolved_theme();
5638        set_focus_animation_target(&mut self.focus_animation, focused as u8 as f32, &theme, ctx);
5639        ctx.request_paint();
5640        ctx.request_semantics();
5641    }
5642}
5643
5644#[derive(Debug, Clone, PartialEq)]
5645struct TreeRow {
5646    key: u64,
5647    path: Vec<usize>,
5648    depth: usize,
5649    label: String,
5650    detail: Option<String>,
5651    has_children: bool,
5652    expanded: bool,
5653    disabled: bool,
5654}
5655
5656fn flatten_tree(items: &[TreeItem], depth: usize, path: &mut Vec<usize>, rows: &mut Vec<TreeRow>) {
5657    for (index, item) in items.iter().enumerate() {
5658        path.push(index);
5659        rows.push(TreeRow {
5660            key: item.key.unwrap_or_else(|| tree_path_key(path.as_slice())),
5661            path: path.clone(),
5662            depth,
5663            label: item.label.clone(),
5664            detail: item.detail.clone(),
5665            has_children: !item.children.is_empty(),
5666            expanded: item.expanded,
5667            disabled: item.disabled,
5668        });
5669        if item.expanded {
5670            flatten_tree(&item.children, depth + 1, path, rows);
5671        }
5672        path.pop();
5673    }
5674}
5675
5676fn tree_path_key(path: &[usize]) -> u64 {
5677    path.iter().fold(0xcbf2_9ce4_8422_2325, |hash, index| {
5678        (hash ^ (*index as u64).wrapping_add(1)).wrapping_mul(0x1000_0000_01b3)
5679    })
5680}
5681
5682fn tree_view_row_id(parent: WidgetId, key: u64) -> WidgetId {
5683    const TAG: u64 = 8_u64 << 50;
5684    const LOW_MASK: u64 = (1_u64 << 50) - 1;
5685    let mixed = key
5686        .wrapping_add(parent.get().rotate_left(23))
5687        .wrapping_mul(0x9e37_79b9_7f4a_7c15);
5688    WidgetId::new(TAG | ((mixed ^ (mixed >> 29)) & LOW_MASK))
5689}
5690
5691fn tree_item<'a>(items: &'a [TreeItem], path: &[usize]) -> Option<&'a TreeItem> {
5692    let (first, rest) = path.split_first()?;
5693    let item = items.get(*first)?;
5694    if rest.is_empty() {
5695        Some(item)
5696    } else {
5697        tree_item(&item.children, rest)
5698    }
5699}
5700
5701fn tree_item_mut<'a>(items: &'a mut [TreeItem], path: &[usize]) -> Option<&'a mut TreeItem> {
5702    let (first, rest) = path.split_first()?;
5703    let item = items.get_mut(*first)?;
5704    if rest.is_empty() {
5705        Some(item)
5706    } else {
5707        tree_item_mut(&mut item.children, rest)
5708    }
5709}
5710
5711fn disclosure_rect(theme: &DefaultTheme, row: Rect, depth: usize) -> Rect {
5712    let metrics = theme.metrics;
5713    Rect::new(
5714        row.x() + metrics.data_row_padding.left + depth as f32 * metrics.tree_indent,
5715        row.y() + ((row.height() - metrics.tree_disclosure_size) * 0.5),
5716        metrics.tree_disclosure_size,
5717        metrics.tree_disclosure_size,
5718    )
5719}
5720
5721fn tree_label_offset(theme: &DefaultTheme, depth: usize) -> f32 {
5722    theme.metrics.data_row_padding.left
5723        + depth as f32 * theme.metrics.tree_indent
5724        + theme.metrics.tree_disclosure_size
5725        + theme.metrics.tree_disclosure_gap
5726}
5727
5728fn disclosure_path(rect: Rect, expanded: bool) -> Path {
5729    let mut builder = PathBuilder::new();
5730    if expanded {
5731        builder
5732            .move_to(Point::new(rect.x(), rect.y() + 2.0))
5733            .line_to(Point::new(rect.max_x(), rect.y() + 2.0))
5734            .line_to(Point::new(
5735                rect.x() + (rect.width() * 0.5),
5736                rect.max_y() - 2.0,
5737            ))
5738            .close();
5739    } else {
5740        builder
5741            .move_to(Point::new(rect.x() + 2.0, rect.y()))
5742            .line_to(Point::new(
5743                rect.max_x() - 2.0,
5744                rect.y() + (rect.height() * 0.5),
5745            ))
5746            .line_to(Point::new(rect.x() + 2.0, rect.max_y()))
5747            .close();
5748    }
5749    builder.build()
5750}
5751
5752fn chevron_path(rect: Rect) -> Path {
5753    let mut builder = PathBuilder::new();
5754    builder
5755        .move_to(Point::new(rect.x(), rect.y()))
5756        .line_to(Point::new(rect.max_x(), rect.y() + (rect.height() * 0.5)))
5757        .line_to(Point::new(rect.x(), rect.max_y()));
5758    builder.build()
5759}
5760
5761pub(crate) fn draw_surface(
5762    ctx: &mut PaintCtx,
5763    rect: Rect,
5764    theme: &DefaultTheme,
5765    _focus_progress: f32,
5766) {
5767    let palette = theme.palette;
5768    let metrics = theme.metrics;
5769    ctx.fill(
5770        rounded_rect_path(rect, metrics.corner_radius),
5771        palette.surface,
5772    );
5773    ctx.stroke(
5774        rounded_rect_path(rect, metrics.corner_radius),
5775        palette.border,
5776        sui_scene::StrokeStyle::new(metrics.border_width.max(1.0)),
5777    );
5778}
5779
5780fn draw_vertical_scroll_thumb(
5781    ctx: &mut PaintCtx,
5782    theme: &DefaultTheme,
5783    viewport: Rect,
5784    content_height: f32,
5785    scroll_y: f32,
5786    color: Color,
5787) {
5788    if content_height <= viewport.height() || viewport.height() <= 0.0 {
5789        return;
5790    }
5791
5792    let ratio = (viewport.height() / content_height).clamp(0.08, 1.0);
5793    let metrics = theme.metrics;
5794    let thumb_height = (viewport.height() * ratio).max(metrics.data_scroll_thumb_min_length);
5795    let max_scroll = (content_height - viewport.height()).max(1.0);
5796    let thumb_y = viewport.y() + ((viewport.height() - thumb_height) * (scroll_y / max_scroll));
5797    let thumb_width = metrics
5798        .data_scroll_thumb_width
5799        .min(viewport.width())
5800        .max(0.0);
5801    let thumb_inset = metrics
5802        .data_scroll_thumb_inset
5803        .min((viewport.width() - thumb_width).max(0.0));
5804    ctx.fill(
5805        rounded_rect_path(
5806            Rect::new(
5807                viewport.max_x() - thumb_inset - thumb_width,
5808                thumb_y,
5809                thumb_width,
5810                thumb_height,
5811            ),
5812            metrics.data_scroll_thumb_radius,
5813        ),
5814        color.with_alpha(metrics.data_scroll_thumb_opacity),
5815    );
5816}
5817
5818fn draw_aligned_text(
5819    ctx: &mut PaintCtx,
5820    rect: Rect,
5821    text: &str,
5822    style: &TextStyle,
5823    alignment: TableColumnAlignment,
5824) {
5825    let horizontal_alignment = match alignment {
5826        TableColumnAlignment::Start => 0.0,
5827        TableColumnAlignment::Center => 0.5,
5828        TableColumnAlignment::End => 1.0,
5829    };
5830    ctx.push_clip_rect(rect);
5831    paint_aligned_text(
5832        ctx,
5833        rect,
5834        text,
5835        style,
5836        style.line_height,
5837        horizontal_alignment,
5838    );
5839    ctx.pop_clip();
5840}
5841
5842const TWO_LINE_ROW_TEXT_GAP: f32 = 2.0;
5843
5844fn row_text_rects(
5845    ctx: &PaintCtx,
5846    rect: Rect,
5847    primary_measurement: TextMeasurement,
5848    primary_line_height: f32,
5849    secondary_measurement: Option<TextMeasurement>,
5850    secondary_line_height: Option<f32>,
5851) -> (Rect, Option<Rect>) {
5852    match secondary_line_height {
5853        Some(secondary_line_height) => {
5854            let secondary_measurement = secondary_measurement.unwrap_or(primary_measurement);
5855            let primary_height = primary_line_height.max(primary_measurement.height);
5856            let secondary_height = secondary_line_height.max(secondary_measurement.height);
5857            let total_height = primary_height + secondary_height + TWO_LINE_ROW_TEXT_GAP;
5858            let top = rect.y() + ((rect.height() - total_height) * 0.5).max(0.0);
5859            let primary_rect = Rect::new(rect.x(), top, rect.width(), primary_height);
5860            let secondary_rect = Rect::new(
5861                rect.x(),
5862                top + primary_height + TWO_LINE_ROW_TEXT_GAP,
5863                rect.width(),
5864                secondary_height,
5865            );
5866            (
5867                Rect::new(
5868                    primary_rect.x(),
5869                    vertically_centered_text_rect_y(
5870                        ctx,
5871                        primary_rect,
5872                        primary_measurement,
5873                        primary_height,
5874                    ),
5875                    primary_rect.width(),
5876                    primary_rect.height(),
5877                ),
5878                Some(Rect::new(
5879                    secondary_rect.x(),
5880                    vertically_centered_text_rect_y(
5881                        ctx,
5882                        secondary_rect,
5883                        secondary_measurement,
5884                        secondary_height,
5885                    ),
5886                    secondary_rect.width(),
5887                    secondary_rect.height(),
5888                )),
5889            )
5890        }
5891        None => {
5892            let height = primary_line_height
5893                .max(primary_measurement.height)
5894                .min(rect.height());
5895            let y = vertically_centered_text_rect_y(ctx, rect, primary_measurement, height);
5896            (Rect::new(rect.x(), y, rect.width(), height), None)
5897        }
5898    }
5899}
5900
5901fn two_line_row_height(primary_line_height: f32, secondary_line_height: f32) -> f32 {
5902    primary_line_height + secondary_line_height + TWO_LINE_ROW_TEXT_GAP
5903}
5904
5905fn horizontal_inset_rect(rect: Rect, inset: f32) -> Rect {
5906    Rect::new(
5907        rect.x() + inset,
5908        rect.y(),
5909        (rect.width() - (inset * 2.0)).max(0.0),
5910        rect.height(),
5911    )
5912}
5913
5914fn estimate_text_width(text: &str, style: &TextStyle) -> f32 {
5915    text.chars().count() as f32 * style.font_size * 0.56
5916}
5917
5918fn numeric_text_style(mut style: TextStyle) -> TextStyle {
5919    style.features.enable(FontFeature::TABULAR_FIGURES);
5920    style
5921}
5922
5923#[derive(Clone, Copy, Debug, PartialEq)]
5924pub struct LeadingLabelCellPaint {
5925    pub icon: Option<IconGlyph>,
5926    pub icon_color: Option<Color>,
5927    pub label_color: Option<Color>,
5928    pub label_weight: FontWeight,
5929    pub padding_left: f32,
5930    pub padding_right: f32,
5931    pub icon_slot_side: Option<f32>,
5932    pub icon_inset: f32,
5933    pub gap: Option<f32>,
5934}
5935
5936impl LeadingLabelCellPaint {
5937    pub const fn new() -> Self {
5938        Self {
5939            icon: None,
5940            icon_color: None,
5941            label_color: None,
5942            label_weight: FontWeight::NORMAL,
5943            padding_left: 6.0,
5944            padding_right: 8.0,
5945            icon_slot_side: None,
5946            icon_inset: 2.0,
5947            gap: None,
5948        }
5949    }
5950
5951    pub const fn icon(mut self, icon: IconGlyph) -> Self {
5952        self.icon = Some(icon);
5953        self
5954    }
5955
5956    pub const fn icon_color(mut self, color: Color) -> Self {
5957        self.icon_color = Some(color);
5958        self
5959    }
5960
5961    pub const fn label_color(mut self, color: Color) -> Self {
5962        self.label_color = Some(color);
5963        self
5964    }
5965
5966    pub const fn label_weight(mut self, weight: FontWeight) -> Self {
5967        self.label_weight = weight;
5968        self
5969    }
5970
5971    pub const fn padding(mut self, left: f32, right: f32) -> Self {
5972        self.padding_left = left;
5973        self.padding_right = right;
5974        self
5975    }
5976
5977    pub const fn icon_slot_side(mut self, side: f32) -> Self {
5978        self.icon_slot_side = Some(side);
5979        self
5980    }
5981
5982    pub const fn icon_inset(mut self, inset: f32) -> Self {
5983        self.icon_inset = inset;
5984        self
5985    }
5986
5987    pub const fn gap(mut self, gap: f32) -> Self {
5988        self.gap = Some(gap);
5989        self
5990    }
5991}
5992
5993impl Default for LeadingLabelCellPaint {
5994    fn default() -> Self {
5995        Self::new()
5996    }
5997}
5998
5999#[derive(Clone, Copy, Debug, PartialEq)]
6000pub struct TextCellPaint {
6001    pub color: Option<Color>,
6002    pub weight: FontWeight,
6003    pub padding_left: f32,
6004    pub padding_right: f32,
6005    pub alignment: TableColumnAlignment,
6006    pub numeric: bool,
6007    pub text_token: Option<ThemeTextToken>,
6008}
6009
6010impl TextCellPaint {
6011    pub const fn new() -> Self {
6012        Self {
6013            color: None,
6014            weight: FontWeight::NORMAL,
6015            padding_left: 8.0,
6016            padding_right: 8.0,
6017            alignment: TableColumnAlignment::Start,
6018            numeric: false,
6019            text_token: None,
6020        }
6021    }
6022
6023    pub const fn color(mut self, color: Color) -> Self {
6024        self.color = Some(color);
6025        self
6026    }
6027
6028    pub const fn weight(mut self, weight: FontWeight) -> Self {
6029        self.weight = weight;
6030        self
6031    }
6032
6033    pub const fn padding(mut self, left: f32, right: f32) -> Self {
6034        self.padding_left = left;
6035        self.padding_right = right;
6036        self
6037    }
6038
6039    pub const fn alignment(mut self, alignment: TableColumnAlignment) -> Self {
6040        self.alignment = alignment;
6041        self
6042    }
6043
6044    pub const fn numeric(mut self) -> Self {
6045        self.numeric = true;
6046        self
6047    }
6048
6049    pub const fn text_token(mut self, token: ThemeTextToken) -> Self {
6050        self.text_token = Some(token);
6051        self
6052    }
6053}
6054
6055impl Default for TextCellPaint {
6056    fn default() -> Self {
6057        Self::new()
6058    }
6059}
6060
6061#[derive(Clone, Copy, Debug, PartialEq)]
6062pub struct TextBlockPaint {
6063    pub color: Option<Color>,
6064    pub weight: FontWeight,
6065    pub padding: Insets,
6066    pub text_token: Option<ThemeTextToken>,
6067    pub wrap: TextWrap,
6068    pub alignment: TextAlign,
6069}
6070
6071impl TextBlockPaint {
6072    pub const fn new() -> Self {
6073        Self {
6074            color: None,
6075            weight: FontWeight::NORMAL,
6076            padding: Insets::ZERO,
6077            text_token: None,
6078            wrap: TextWrap::Word,
6079            alignment: TextAlign::Start,
6080        }
6081    }
6082
6083    pub const fn color(mut self, color: Color) -> Self {
6084        self.color = Some(color);
6085        self
6086    }
6087
6088    pub const fn weight(mut self, weight: FontWeight) -> Self {
6089        self.weight = weight;
6090        self
6091    }
6092
6093    pub const fn padding(mut self, padding: Insets) -> Self {
6094        self.padding = padding;
6095        self
6096    }
6097
6098    pub const fn text_token(mut self, token: ThemeTextToken) -> Self {
6099        self.text_token = Some(token);
6100        self
6101    }
6102
6103    pub const fn wrap(mut self, wrap: TextWrap) -> Self {
6104        self.wrap = wrap;
6105        self
6106    }
6107
6108    pub const fn alignment(mut self, alignment: TextAlign) -> Self {
6109        self.alignment = alignment;
6110        self
6111    }
6112}
6113
6114impl Default for TextBlockPaint {
6115    fn default() -> Self {
6116        Self::new()
6117    }
6118}
6119
6120pub fn paint_leading_label_cell(
6121    ctx: &mut PaintCtx,
6122    theme: &DefaultTheme,
6123    rect: Rect,
6124    label: &str,
6125    style: LeadingLabelCellPaint,
6126) {
6127    if rect.width() <= 0.0 || rect.height() <= 0.0 {
6128        return;
6129    }
6130
6131    let mut text_x = rect.x() + style.padding_left.max(0.0);
6132    if let Some(icon) = style.icon {
6133        let slot_side = style
6134            .icon_slot_side
6135            .unwrap_or(theme.metrics.data_row_icon_size)
6136            .min((rect.height() - 6.0).max(0.0))
6137            .max(0.0);
6138        let icon_rect = Rect::new(
6139            text_x,
6140            rect.y() + ((rect.height() - slot_side) * 0.5).max(0.0),
6141            slot_side,
6142            slot_side,
6143        );
6144        let icon_inset = style.icon_inset.max(0.0).min(slot_side * 0.45);
6145        draw_icon_glyph(
6146            ctx,
6147            icon,
6148            icon_rect.inflate(-icon_inset, -icon_inset),
6149            style.icon_color.unwrap_or(theme.palette.text_muted),
6150        );
6151        text_x = icon_rect.max_x()
6152            + style
6153                .gap
6154                .unwrap_or(theme.metrics.data_row_icon_gap)
6155                .max(0.0);
6156    }
6157
6158    let label_rect = Rect::new(
6159        text_x,
6160        rect.y(),
6161        (rect.max_x() - text_x - style.padding_right.max(0.0)).max(0.0),
6162        rect.height(),
6163    );
6164    if label_rect.width() <= 0.0 {
6165        return;
6166    }
6167
6168    let mut label_style = TextStyle {
6169        font_size: theme.text.sm.size.max(1.0),
6170        line_height: theme.text.sm.line_height.max(1.0),
6171        color: style.label_color.unwrap_or(theme.palette.text),
6172        ..theme.body_text_style()
6173    };
6174    label_style.weight = style.label_weight;
6175
6176    ctx.push_clip_rect(label_rect);
6177    paint_aligned_text(
6178        ctx,
6179        label_rect,
6180        label,
6181        &label_style,
6182        label_style.line_height,
6183        0.0,
6184    );
6185    ctx.pop_clip();
6186}
6187
6188pub fn paint_text_block(
6189    ctx: &mut PaintCtx,
6190    theme: &DefaultTheme,
6191    rect: Rect,
6192    text: &str,
6193    style: TextBlockPaint,
6194) {
6195    if rect.width() <= 0.0 || rect.height() <= 0.0 {
6196        return;
6197    }
6198
6199    let content = Rect::new(
6200        rect.x() + style.padding.left.max(0.0),
6201        rect.y() + style.padding.top.max(0.0),
6202        (rect.width() - style.padding.left.max(0.0) - style.padding.right.max(0.0)).max(0.0),
6203        (rect.height() - style.padding.top.max(0.0) - style.padding.bottom.max(0.0)).max(0.0),
6204    );
6205    if content.width() <= 0.0 || content.height() <= 0.0 {
6206        return;
6207    }
6208
6209    let token = style.text_token.unwrap_or(theme.text.sm);
6210    let mut text_style = TextStyle {
6211        font_size: token.size.max(1.0),
6212        line_height: token.line_height.max(1.0),
6213        color: style.color.unwrap_or(theme.palette.text),
6214        ..theme.body_text_style()
6215    };
6216    text_style.weight = style.weight;
6217
6218    let color = text_style.color;
6219    let mut layout_style = text_style.clone();
6220    layout_style.color = Color::WHITE;
6221    let mut document = TextDocument::from_plain_text(text.to_string(), layout_style);
6222    for paragraph in &mut document.paragraphs {
6223        paragraph.style.align = style.alignment;
6224        paragraph.style.wrap = style.wrap;
6225    }
6226
6227    ctx.push_clip_rect(content);
6228    if let Ok(layout) = ctx.layout_text_document(TextLayoutRequest::new(document).with_box_size(
6229        Size::new(content.width().max(1.0), content.height().max(1.0)),
6230    )) {
6231        ctx.draw_text_layout_with_color(content.origin, &layout, color);
6232    } else {
6233        ctx.draw_text(content, text.to_string(), text_style);
6234    }
6235    ctx.pop_clip();
6236}
6237
6238pub fn paint_text_cell(
6239    ctx: &mut PaintCtx,
6240    theme: &DefaultTheme,
6241    rect: Rect,
6242    text: &str,
6243    style: TextCellPaint,
6244) {
6245    if rect.width() <= 0.0 || rect.height() <= 0.0 {
6246        return;
6247    }
6248
6249    let left = style.padding_left.max(0.0);
6250    let right = style.padding_right.max(0.0);
6251    let content = Rect::new(
6252        rect.x() + left,
6253        rect.y(),
6254        (rect.width() - left - right).max(0.0),
6255        rect.height(),
6256    );
6257    if content.width() <= 0.0 {
6258        return;
6259    }
6260
6261    let token = style.text_token.unwrap_or(theme.text.sm);
6262    let mut text_style = TextStyle {
6263        font_size: token.size.max(1.0),
6264        line_height: token.line_height.max(1.0),
6265        color: style.color.unwrap_or(theme.palette.text),
6266        ..theme.body_text_style()
6267    };
6268    text_style.weight = style.weight;
6269    if style.numeric {
6270        text_style = numeric_text_style(text_style);
6271    }
6272
6273    ctx.push_clip_rect(content);
6274    paint_aligned_text(
6275        ctx,
6276        content,
6277        text,
6278        &text_style,
6279        text_style.line_height,
6280        match style.alignment {
6281            TableColumnAlignment::Start => 0.0,
6282            TableColumnAlignment::Center => 0.5,
6283            TableColumnAlignment::End => 1.0,
6284        },
6285    );
6286    ctx.pop_clip();
6287}
6288
6289fn measure_list_item_leading_width(
6290    ctx: &mut MeasureCtx,
6291    item: &ListItem,
6292    style: &TextStyle,
6293    theme: &DefaultTheme,
6294) -> f32 {
6295    if item.leading_icon.is_some() {
6296        return theme.metrics.data_row_icon_size + theme.metrics.data_row_icon_gap;
6297    }
6298    item.leading_text
6299        .as_deref()
6300        .map(|text| measure_text(ctx, text, style).width + theme.metrics.data_row_icon_gap)
6301        .unwrap_or(0.0)
6302}
6303
6304fn measure_text(ctx: &mut MeasureCtx, text: &str, style: &TextStyle) -> TextMeasurement {
6305    ctx.layout()
6306        .measure_text(text.to_string(), style.clone())
6307        .unwrap_or(TextMeasurement {
6308            width: estimate_text_width(text, style),
6309            height: style.line_height,
6310            bounds: Rect::ZERO,
6311            ascent: style.font_size,
6312            descent: 0.0,
6313            cap_height: Some(style.font_size),
6314        })
6315}
6316
6317fn paint_text_measurement(ctx: &PaintCtx, text: &str, style: &TextStyle) -> TextMeasurement {
6318    ctx.measure_text(text.to_string(), style.clone())
6319        .unwrap_or(TextMeasurement {
6320            width: estimate_text_width(text, style),
6321            height: style.line_height,
6322            bounds: Rect::ZERO,
6323            ascent: style.font_size,
6324            descent: 0.0,
6325            cap_height: Some(style.font_size),
6326        })
6327}
6328
6329fn caption_style(theme: &DefaultTheme) -> TextStyle {
6330    TextStyle {
6331        font_size: theme.text.xs.size.max(1.0),
6332        line_height: theme.text.xs.line_height.max(1.0),
6333        color: theme.palette.placeholder,
6334        ..theme.body_text_style()
6335    }
6336}
6337
6338fn rounded_rect_path(rect: Rect, radius: f32) -> Path {
6339    let mut builder = PathBuilder::new();
6340    builder.push_rounded_rect(rect, radius);
6341    builder.build()
6342}
6343
6344fn row_highlight_rect(row: Rect, viewport: Rect) -> Option<Rect> {
6345    row.intersection(viewport)
6346        .map(|visible| inset_rect(visible, Insets::all(1.0)))
6347        .filter(|rect| !rect.is_empty())
6348}
6349
6350type AnimatedScalar = MotionScalar;
6351
6352fn set_animation_target(
6353    animation: &mut AnimatedScalar,
6354    target: f32,
6355    duration: f64,
6356    easing: crate::Easing,
6357    ctx: &mut EventCtx,
6358) -> bool {
6359    animation.set_target_event(target, duration, easing, ctx)
6360}
6361
6362fn set_hover_animation_target(
6363    animation: &mut AnimatedScalar,
6364    target: f32,
6365    theme: &DefaultTheme,
6366    ctx: &mut EventCtx,
6367) -> bool {
6368    set_animation_target(
6369        animation,
6370        target,
6371        theme.motion.hover_duration(),
6372        theme.motion.hover_easing(),
6373        ctx,
6374    )
6375}
6376
6377fn set_press_animation_target(
6378    animation: &mut AnimatedScalar,
6379    target: f32,
6380    theme: &DefaultTheme,
6381    ctx: &mut EventCtx,
6382) -> bool {
6383    set_animation_target(
6384        animation,
6385        target,
6386        theme.motion.press_duration(),
6387        theme.motion.press_easing(),
6388        ctx,
6389    )
6390}
6391
6392fn set_focus_animation_target(
6393    animation: &mut AnimatedScalar,
6394    target: f32,
6395    theme: &DefaultTheme,
6396    ctx: &mut EventCtx,
6397) -> bool {
6398    set_animation_target(
6399        animation,
6400        target,
6401        theme.motion.focus_duration(),
6402        theme.motion.focus_easing(),
6403        ctx,
6404    )
6405}
6406
6407fn advance_scalar(animation: &mut AnimatedScalar, time: f64) -> (bool, bool) {
6408    let previous = animation.value;
6409    let active = animation.advance(time);
6410    (animation.changed_since(previous), active)
6411}
6412
6413#[derive(Debug, Clone, PartialEq)]
6414struct IndexedInteractionMotion<T>
6415where
6416    T: Clone + PartialEq,
6417{
6418    visual: Option<T>,
6419    animation: AnimatedScalar,
6420}
6421
6422impl<T> IndexedInteractionMotion<T>
6423where
6424    T: Clone + PartialEq,
6425{
6426    const fn new() -> Self {
6427        Self {
6428            visual: None,
6429            animation: AnimatedScalar::new(0.0),
6430        }
6431    }
6432
6433    fn set_hover_target(
6434        &mut self,
6435        target: Option<T>,
6436        theme: &DefaultTheme,
6437        ctx: &mut EventCtx,
6438    ) -> bool {
6439        self.set_target(target, theme, ctx, |animation, target, theme, ctx| {
6440            set_hover_animation_target(animation, target, theme, ctx)
6441        })
6442    }
6443
6444    fn set_press_target(
6445        &mut self,
6446        target: Option<T>,
6447        theme: &DefaultTheme,
6448        ctx: &mut EventCtx,
6449    ) -> bool {
6450        self.set_target(target, theme, ctx, |animation, target, theme, ctx| {
6451            set_press_animation_target(animation, target, theme, ctx)
6452        })
6453    }
6454
6455    fn set_target(
6456        &mut self,
6457        target: Option<T>,
6458        theme: &DefaultTheme,
6459        ctx: &mut EventCtx,
6460        set_animation: impl FnOnce(&mut AnimatedScalar, f32, &DefaultTheme, &mut EventCtx) -> bool,
6461    ) -> bool {
6462        match target {
6463            Some(target) => {
6464                if self.visual.as_ref() != Some(&target) {
6465                    self.visual = Some(target);
6466                    self.animation = AnimatedScalar::new(0.0);
6467                }
6468                set_animation(&mut self.animation, 1.0, theme, ctx)
6469            }
6470            None => {
6471                let changed = set_animation(&mut self.animation, 0.0, theme, ctx);
6472                if !changed && !self.animation.is_presented() {
6473                    self.visual = None;
6474                }
6475                changed
6476            }
6477        }
6478    }
6479
6480    fn amount_for(&self, key: &T) -> f32 {
6481        self.amount_for_by(|visual| visual == key)
6482    }
6483
6484    fn amount_for_by(&self, matches: impl FnOnce(&T) -> bool) -> f32 {
6485        self.visual
6486            .as_ref()
6487            .filter(|visual| matches(visual))
6488            .map(|_| self.animation.value)
6489            .unwrap_or(0.0)
6490    }
6491
6492    fn advance(&mut self, time: f64) -> (bool, bool) {
6493        let previous = self.animation.value;
6494        let active = self.animation.advance(time);
6495        let changed = self.animation.changed_since(previous);
6496        if !self.animation.is_presented() {
6497            self.visual = None;
6498        }
6499        (changed, active)
6500    }
6501}
6502
6503fn data_row_state_fill(
6504    theme: &DefaultTheme,
6505    selected: bool,
6506    hover_amount: f32,
6507    press_amount: f32,
6508) -> Color {
6509    let palette = theme.palette;
6510    let interaction = theme.interaction;
6511    if selected {
6512        // `selection` is already a translucent semantic accent token. Keeping
6513        // it intact avoids turning selected rows into opaque accent slabs.
6514        palette.selection
6515    } else {
6516        let overlay = theme.surfaces.hover;
6517        let hover_alpha = overlay.alpha * interaction.hover_blend * hover_amount.clamp(0.0, 1.0);
6518        let press_alpha =
6519            overlay.alpha * 1.75 * interaction.pressed_blend * press_amount.clamp(0.0, 1.0);
6520        let alpha = hover_alpha.max(press_alpha).min(0.18);
6521        if alpha > AnimatedScalar::EPSILON {
6522            overlay.with_alpha(alpha)
6523        } else {
6524            Color::TRANSPARENT
6525        }
6526    }
6527}
6528
6529pub(crate) fn paint_data_row_state(
6530    ctx: &mut PaintCtx,
6531    row: Rect,
6532    viewport: Rect,
6533    theme: &DefaultTheme,
6534    selected: bool,
6535    hover_amount: f32,
6536    press_amount: f32,
6537) {
6538    if !selected
6539        && hover_amount <= AnimatedScalar::EPSILON
6540        && press_amount <= AnimatedScalar::EPSILON
6541    {
6542        return;
6543    }
6544
6545    let Some(highlight) = row_highlight_rect(row, viewport) else {
6546        return;
6547    };
6548    ctx.fill_rect(
6549        highlight,
6550        data_row_state_fill(theme, selected, hover_amount, press_amount),
6551    );
6552
6553    if selected {
6554        let indicator_width = 2.0_f32.min(highlight.width());
6555        let indicator_inset = (highlight.height() * 0.18).min(5.0);
6556        let indicator = Rect::new(
6557            highlight.x(),
6558            highlight.y() + indicator_inset,
6559            indicator_width,
6560            (highlight.height() - indicator_inset * 2.0).max(0.0),
6561        );
6562        if !indicator.is_empty() {
6563            ctx.fill(
6564                rounded_rect_path(indicator, indicator_width * 0.5),
6565                theme.palette.accent,
6566            );
6567        }
6568    }
6569}
6570
6571fn list_view_row_id(parent: WidgetId, index: usize) -> WidgetId {
6572    const TAG: u64 = 5_u64 << 50;
6573    const LOW_MASK: u64 = (1_u64 << 50) - 1;
6574
6575    WidgetId::new(
6576        TAG | (parent
6577            .get()
6578            .wrapping_mul(359)
6579            .wrapping_add(index as u64 + 1)
6580            & LOW_MASK),
6581    )
6582}
6583
6584fn virtual_table_row_id(parent: WidgetId, row_key: u64) -> WidgetId {
6585    const TAG: u64 = 7_u64 << 50;
6586    const LOW_MASK: u64 = (1_u64 << 50) - 1;
6587
6588    let mixed = row_key
6589        .wrapping_add(0x9e37_79b9_7f4a_7c15)
6590        .wrapping_add(parent.get().rotate_left(17));
6591    let mixed = (mixed ^ (mixed >> 30)).wrapping_mul(0xbf58_476d_1ce4_e5b9);
6592    let mixed = (mixed ^ (mixed >> 27)).wrapping_mul(0x94d0_49bb_1331_11eb);
6593    WidgetId::new(TAG | ((mixed ^ (mixed >> 31)) & LOW_MASK))
6594}
6595
6596fn layer_list_row_id(parent: WidgetId, index: usize) -> WidgetId {
6597    const TAG: u64 = 6_u64 << 50;
6598    const LOW_MASK: u64 = (1_u64 << 50) - 1;
6599
6600    WidgetId::new(
6601        TAG | (parent
6602            .get()
6603            .wrapping_mul(383)
6604            .wrapping_add(index as u64 + 1)
6605            & LOW_MASK),
6606    )
6607}
6608
6609fn layer_list_visibility_id(parent: WidgetId, index: usize) -> WidgetId {
6610    const TAG: u64 = 7_u64 << 50;
6611    const LOW_MASK: u64 = (1_u64 << 50) - 1;
6612
6613    WidgetId::new(
6614        TAG | (parent
6615            .get()
6616            .wrapping_mul(389)
6617            .wrapping_add(index as u64 + 1)
6618            & LOW_MASK),
6619    )
6620}
6621
6622fn layer_list_lock_id(parent: WidgetId, index: usize) -> WidgetId {
6623    const TAG: u64 = 4_u64 << 50;
6624    const LOW_MASK: u64 = (1_u64 << 50) - 1;
6625
6626    WidgetId::new(
6627        TAG | (parent
6628            .get()
6629            .wrapping_mul(397)
6630            .wrapping_add(index as u64 + 1)
6631            & LOW_MASK),
6632    )
6633}
6634
6635fn paint_layer_visibility_button(
6636    ctx: &mut PaintCtx,
6637    rect: Rect,
6638    theme: &DefaultTheme,
6639    visible: bool,
6640    hover_amount: f32,
6641    press_amount: f32,
6642) {
6643    let palette = theme.palette;
6644    if hover_amount > AnimatedScalar::EPSILON || press_amount > AnimatedScalar::EPSILON {
6645        ctx.fill(
6646            rounded_rect_path(rect, theme.metrics.corner_radius.min(rect.height() * 0.35)),
6647            data_row_state_fill(theme, false, hover_amount, press_amount),
6648        );
6649    }
6650
6651    let metrics = theme.metrics;
6652    let icon = inset_rect(rect, Insets::all(metrics.layer_action_icon_inset));
6653    let color = if visible {
6654        palette.accent
6655    } else {
6656        palette.placeholder
6657    };
6658    ctx.stroke(
6659        layer_visibility_eye_path(icon),
6660        color,
6661        sui_scene::StrokeStyle::new(metrics.layer_visibility_stroke_width),
6662    );
6663    if visible {
6664        ctx.fill(
6665            Path::circle(
6666                Point::new(
6667                    icon.x() + icon.width() * 0.5,
6668                    icon.y() + icon.height() * 0.5,
6669                ),
6670                icon.width().min(icon.height()) * 0.17,
6671            ),
6672            color,
6673        );
6674    } else {
6675        ctx.stroke(
6676            line_path(
6677                Point::new(
6678                    icon.x() + icon.width() * 0.1,
6679                    icon.max_y() - icon.height() * 0.05,
6680                ),
6681                Point::new(
6682                    icon.max_x() - icon.width() * 0.1,
6683                    icon.y() + icon.height() * 0.05,
6684                ),
6685            ),
6686            color,
6687            sui_scene::StrokeStyle::new(metrics.layer_visibility_slash_stroke_width),
6688        );
6689    }
6690}
6691
6692fn paint_layer_lock_button(
6693    ctx: &mut PaintCtx,
6694    rect: Rect,
6695    theme: &DefaultTheme,
6696    locked: bool,
6697    hover_amount: f32,
6698    press_amount: f32,
6699) {
6700    let palette = theme.palette;
6701    if hover_amount > AnimatedScalar::EPSILON || press_amount > AnimatedScalar::EPSILON {
6702        ctx.fill(
6703            rounded_rect_path(rect, theme.metrics.corner_radius.min(rect.height() * 0.35)),
6704            data_row_state_fill(theme, false, hover_amount, press_amount),
6705        );
6706    }
6707
6708    let metrics = theme.metrics;
6709    draw_icon_glyph(
6710        ctx,
6711        if locked {
6712            IconGlyph::Lock
6713        } else {
6714            IconGlyph::Unlock
6715        },
6716        inset_rect(rect, Insets::all(metrics.layer_lock_icon_inset)),
6717        if locked {
6718            palette.accent
6719        } else {
6720            palette.placeholder
6721        },
6722    );
6723}
6724
6725fn paint_layer_thumbnail(
6726    ctx: &mut PaintCtx,
6727    rect: Rect,
6728    theme: &DefaultTheme,
6729    color: Color,
6730    visible: bool,
6731) {
6732    let palette = theme.palette;
6733    let metrics = theme.metrics;
6734    let radius = metrics.layer_thumbnail_radius;
6735    ctx.fill(rounded_rect_path(rect, radius), palette.control_hover);
6736    let fill = inset_rect(rect, Insets::all(metrics.layer_thumbnail_inset));
6737    ctx.fill(
6738        rounded_rect_path(
6739            fill,
6740            (radius - metrics.layer_thumbnail_inset * 0.5).max(0.0),
6741        ),
6742        if visible {
6743            color
6744        } else {
6745            color.with_alpha(color.alpha * metrics.layer_thumbnail_disabled_opacity)
6746        },
6747    );
6748    ctx.stroke(
6749        rounded_rect_path(rect, radius),
6750        palette.border.with_alpha(if visible {
6751            1.0
6752        } else {
6753            metrics.layer_thumbnail_disabled_border_opacity
6754        }),
6755        sui_scene::StrokeStyle::new(metrics.border_width.max(1.0)),
6756    );
6757}
6758
6759fn layer_visibility_eye_path(rect: Rect) -> Path {
6760    let mut builder = PathBuilder::new();
6761    let cx = rect.x() + rect.width() * 0.5;
6762    let cy = rect.y() + rect.height() * 0.5;
6763    builder
6764        .move_to(Point::new(rect.x(), cy))
6765        .cubic_to(
6766            Point::new(rect.x() + rect.width() * 0.22, rect.y()),
6767            Point::new(rect.x() + rect.width() * 0.78, rect.y()),
6768            Point::new(rect.max_x(), cy),
6769        )
6770        .cubic_to(
6771            Point::new(rect.x() + rect.width() * 0.78, rect.max_y()),
6772            Point::new(rect.x() + rect.width() * 0.22, rect.max_y()),
6773            Point::new(rect.x(), cy),
6774        )
6775        .close();
6776    let _ = (cx, cy);
6777    builder.build()
6778}
6779
6780fn line_path(from: Point, to: Point) -> Path {
6781    let mut builder = PathBuilder::new();
6782    builder.move_to(from).line_to(to);
6783    builder.build()
6784}
6785
6786fn inset_rect(rect: Rect, padding: Insets) -> Rect {
6787    Rect::new(
6788        rect.x() + padding.left,
6789        rect.y() + padding.top,
6790        (rect.width() - padding.left - padding.right).max(0.0),
6791        (rect.height() - padding.top - padding.bottom).max(0.0),
6792    )
6793}
6794
6795fn scroll_delta_to_offset(delta: sui_core::ScrollDelta) -> Vector {
6796    match delta {
6797        sui_core::ScrollDelta::Lines(delta) => Vector::new(delta.x * 40.0, delta.y * 40.0),
6798        sui_core::ScrollDelta::Pixels(delta) => delta,
6799    }
6800}
6801
6802#[cfg(test)]
6803mod tests {
6804    use std::{cell::RefCell, rc::Rc};
6805
6806    use super::{
6807        Breadcrumb, BreadcrumbItem, DefaultTheme, LayerList, LayerListItem, LayerListReorderChange,
6808        LeadingLabelCellPaint, ListItem, ListView, Table, TableColumn, TableColumnAlignment,
6809        TableRow, TextBlockPaint, TextCellPaint, TreeItem, TreeView, VirtualTable,
6810        VirtualTableColumn, VirtualTableState,
6811    };
6812    use crate::{
6813        Button, CollectionWindow, Label, ScrollAlignment, ScrollView, SizedBox, Stack,
6814        ThemeTextToken,
6815    };
6816    use sui_core::{
6817        Color, Event, KeyState, KeyboardEvent, Modifiers, Point, PointerButton, PointerButtons,
6818        PointerEvent, PointerEventKind, PointerKind, Rect, Result, ScrollDelta, SemanticsAction,
6819        SemanticsActionRequest, SemanticsRole, SemanticsValue, Size, ToggleState, Vector, WidgetId,
6820        WindowEvent,
6821    };
6822    use sui_layout::{Constraints, Padding as Insets};
6823    use sui_runtime::{Application, PaintCtx, RenderOutput, Runtime, Widget, WindowBuilder};
6824    use sui_scene::{Brush, SceneCommand};
6825    use sui_text::{FontFeature, FontRegistry, FontWeight, TextSystem};
6826
6827    fn build_runtime<W>(root: W) -> (Runtime, sui_core::WindowId)
6828    where
6829        W: Widget + 'static,
6830    {
6831        let runtime = Application::new()
6832            .window(WindowBuilder::new().title("Data widgets").root(root))
6833            .build()
6834            .unwrap();
6835        let window_id = runtime.window_ids()[0];
6836        (runtime, window_id)
6837    }
6838
6839    fn render<W>(root: W) -> RenderOutput
6840    where
6841        W: Widget + 'static,
6842    {
6843        let (mut runtime, window_id) = build_runtime(root);
6844        runtime.render(window_id).expect("render should succeed")
6845    }
6846
6847    #[test]
6848    fn density_modes_resize_data_widgets() {
6849        let compact = DefaultTheme::compact();
6850        let touch = DefaultTheme::touch();
6851
6852        assert!(
6853            render(
6854                ListView::new("Layers")
6855                    .theme(compact)
6856                    .items([ListItem::new("Paint"), ListItem::new("Ink")])
6857            )
6858            .frame
6859            .viewport
6860            .height
6861                < render(
6862                    ListView::new("Layers")
6863                        .theme(touch)
6864                        .items([ListItem::new("Paint"), ListItem::new("Ink")])
6865                )
6866                .frame
6867                .viewport
6868                .height
6869        );
6870        assert!(
6871            render(
6872                LayerList::new("Layers")
6873                    .theme(compact)
6874                    .layers([LayerListItem::new("Paint"), LayerListItem::new("Ink")])
6875            )
6876            .frame
6877            .viewport
6878            .height
6879                < render(
6880                    LayerList::new("Layers")
6881                        .theme(touch)
6882                        .layers([LayerListItem::new("Paint"), LayerListItem::new("Ink")])
6883                )
6884                .frame
6885                .viewport
6886                .height
6887        );
6888        assert!(
6889            render(
6890                TreeView::new("Scene")
6891                    .theme(compact)
6892                    .items([TreeItem::new("Canvas"), TreeItem::new("Lighting")])
6893            )
6894            .frame
6895            .viewport
6896            .height
6897                < render(
6898                    TreeView::new("Scene")
6899                        .theme(touch)
6900                        .items([TreeItem::new("Canvas"), TreeItem::new("Lighting")])
6901                )
6902                .frame
6903                .viewport
6904                .height
6905        );
6906        assert!(
6907            render(
6908                Table::new("Objects")
6909                    .theme(compact)
6910                    .columns([TableColumn::new("Name")])
6911                    .rows([TableRow::new(["Canvas"]), TableRow::new(["Lighting"])])
6912            )
6913            .frame
6914            .viewport
6915            .height
6916                < render(
6917                    Table::new("Objects")
6918                        .theme(touch)
6919                        .columns([TableColumn::new("Name")])
6920                        .rows([TableRow::new(["Canvas"]), TableRow::new(["Lighting"])])
6921                )
6922                .frame
6923                .viewport
6924                .height
6925        );
6926        assert!(
6927            render(
6928                Breadcrumb::new("Path")
6929                    .theme(compact)
6930                    .items([BreadcrumbItem::new("Scene"), BreadcrumbItem::new("Layers")])
6931            )
6932            .frame
6933            .viewport
6934            .height
6935                < render(
6936                    Breadcrumb::new("Path")
6937                        .theme(touch)
6938                        .items([BreadcrumbItem::new("Scene"), BreadcrumbItem::new("Layers")])
6939                )
6940                .frame
6941                .viewport
6942                .height
6943        );
6944    }
6945
6946    fn text_rects_for(output: &RenderOutput, text: &str) -> Vec<Rect> {
6947        let mut rects = Vec::new();
6948        output
6949            .frame
6950            .scene
6951            .visit_commands(&mut |command| match command {
6952                SceneCommand::DrawText(run) if run.text == text => rects.push(run.rect),
6953                SceneCommand::DrawShapedText(run) => {
6954                    if let Some(layout) = run
6955                        .resolve(output.frame.text_layout_registry.as_ref())
6956                        .filter(|layout| layout.text() == text)
6957                    {
6958                        rects.push(shaped_text_run_rect(run.origin, layout));
6959                    }
6960                }
6961                _ => {}
6962            });
6963
6964        rects
6965    }
6966
6967    fn shaped_text_run_rect(origin: Point, layout: &sui_text::TextLayout) -> Rect {
6968        let measurement = layout.measurement();
6969        let bounds = measurement.bounds;
6970        let width = if bounds.width().is_finite() && bounds.width() > 0.0 {
6971            bounds.width()
6972        } else {
6973            measurement.width
6974        };
6975        Rect::new(
6976            origin.x + bounds.x(),
6977            origin.y + ((layout.box_size().height - measurement.height).max(0.0) * 0.5),
6978            width,
6979            layout.style().line_height.max(measurement.height),
6980        )
6981    }
6982
6983    fn text_runs_for(output: &RenderOutput, text: &str) -> Vec<sui_text::TextRun> {
6984        let mut runs = Vec::new();
6985        output
6986            .frame
6987            .scene
6988            .visit_commands(&mut |command| match command {
6989                SceneCommand::DrawText(run) if run.text == text => runs.push(run.clone()),
6990                SceneCommand::DrawShapedText(run) => {
6991                    if let Some(layout) = run
6992                        .resolve(output.frame.text_layout_registry.as_ref())
6993                        .filter(|layout| layout.text() == text)
6994                    {
6995                        let mut style = layout.style().clone();
6996                        if let Some(color) = run.color_override {
6997                            style.color = color;
6998                        }
6999                        runs.push(sui_text::TextRun {
7000                            rect: shaped_text_run_rect(run.origin, layout),
7001                            text: layout.text().to_string(),
7002                            style,
7003                        });
7004                    }
7005                }
7006                _ => {}
7007            });
7008
7009        runs
7010    }
7011
7012    fn draw_clip_rects_for(output: &RenderOutput, text: &str) -> Vec<Rect> {
7013        let mut clips = Vec::new();
7014        let mut stack = Vec::new();
7015        output
7016            .frame
7017            .scene
7018            .visit_commands(&mut |command| match command {
7019                SceneCommand::PushClip { rect } => stack.push(*rect),
7020                SceneCommand::PopClip => {
7021                    stack.pop();
7022                }
7023                SceneCommand::DrawText(run) if run.text == text => {
7024                    if let Some(rect) = stack.last() {
7025                        clips.push(*rect);
7026                    }
7027                }
7028                SceneCommand::DrawShapedText(run)
7029                    if run
7030                        .resolve(output.frame.text_layout_registry.as_ref())
7031                        .filter(|layout| layout.text() == text)
7032                        .is_some_and(|layout| !layout.text().is_empty())
7033                        && let Some(rect) = stack.last() =>
7034                {
7035                    clips.push(*rect);
7036                }
7037                _ => {}
7038            });
7039
7040        clips
7041    }
7042
7043    fn selected_highlight_rects(output: &RenderOutput) -> Vec<Rect> {
7044        let theme = DefaultTheme::default();
7045        let selected_brush = Brush::Solid(super::data_row_state_fill(&theme, true, 0.0, 0.0));
7046        let mut rects = Vec::new();
7047        output
7048            .frame
7049            .scene
7050            .visit_commands(&mut |command| match command {
7051                SceneCommand::FillPath { path, brush } if *brush == selected_brush => {
7052                    rects.push(path.bounds());
7053                }
7054                SceneCommand::FillRect { rect, brush } if *brush == selected_brush => {
7055                    rects.push(*rect);
7056                }
7057                _ => {}
7058            });
7059        rects
7060    }
7061
7062    fn solid_fill_colors(output: &RenderOutput) -> Vec<Color> {
7063        let mut colors = Vec::new();
7064        output
7065            .frame
7066            .scene
7067            .visit_commands(&mut |command| match command {
7068                SceneCommand::FillRect {
7069                    brush: Brush::Solid(color),
7070                    ..
7071                }
7072                | SceneCommand::FillPath {
7073                    brush: Brush::Solid(color),
7074                    ..
7075                } => colors.push(*color),
7076                _ => {}
7077            });
7078        colors
7079    }
7080
7081    fn solid_fill_bounds_for_color(output: &RenderOutput, expected: Color) -> Vec<Rect> {
7082        let mut rects = Vec::new();
7083        output
7084            .frame
7085            .scene
7086            .visit_commands(&mut |command| match command {
7087                SceneCommand::FillRect {
7088                    rect,
7089                    brush: Brush::Solid(color),
7090                } if *color == expected => rects.push(*rect),
7091                SceneCommand::FillPath {
7092                    path,
7093                    brush: Brush::Solid(color),
7094                } if *color == expected => rects.push(path.bounds()),
7095                _ => {}
7096            });
7097        rects
7098    }
7099
7100    fn solid_stroke_widths(output: &RenderOutput) -> Vec<f32> {
7101        let mut widths = Vec::new();
7102        output
7103            .frame
7104            .scene
7105            .visit_commands(&mut |command| match command {
7106                SceneCommand::StrokeRect { stroke, .. }
7107                | SceneCommand::StrokePath { stroke, .. } => {
7108                    widths.push(stroke.width);
7109                }
7110                _ => {}
7111            });
7112        widths
7113    }
7114
7115    fn solid_stroke_colors(output: &RenderOutput) -> Vec<Color> {
7116        let mut colors = Vec::new();
7117        output
7118            .frame
7119            .scene
7120            .visit_commands(&mut |command| match command {
7121                SceneCommand::StrokeRect {
7122                    brush: Brush::Solid(color),
7123                    ..
7124                }
7125                | SceneCommand::StrokePath {
7126                    brush: Brush::Solid(color),
7127                    ..
7128                } => colors.push(*color),
7129                _ => {}
7130            });
7131        colors
7132    }
7133
7134    fn solid_stroke_rects(output: &RenderOutput) -> Vec<Rect> {
7135        let mut rects = Vec::new();
7136        output.frame.scene.visit_commands(&mut |command| {
7137            if let SceneCommand::StrokeRect { rect, .. } = command {
7138                rects.push(*rect);
7139            }
7140        });
7141        rects
7142    }
7143
7144    fn optical_visual_center(measurement: sui_text::TextMeasurement) -> f32 {
7145        let top = -measurement.cap_height.unwrap_or(measurement.ascent);
7146        let bottom = measurement.descent * 0.5;
7147        (top + bottom) * 0.5
7148    }
7149
7150    fn rect_center(rect: Rect) -> Point {
7151        Point::new(
7152            rect.x() + rect.width() * 0.5,
7153            rect.y() + rect.height() * 0.5,
7154        )
7155    }
7156
7157    fn text_run_visual_center(run: &sui_text::TextRun) -> f32 {
7158        let layout = TextSystem::new()
7159            .shape_text(
7160                run.text.clone(),
7161                Size::new(f32::INFINITY, run.rect.height().max(1.0)),
7162                run.style.clone(),
7163                &FontRegistry::new(),
7164            )
7165            .expect("text run should shape");
7166        let line = layout.lines().first().expect("text run should have a line");
7167        run.rect.y() + line.baseline + optical_visual_center(layout.measurement())
7168    }
7169
7170    fn text_visual_center_for(output: &RenderOutput, text: &str) -> f32 {
7171        output
7172            .frame
7173            .scene
7174            .commands()
7175            .iter()
7176            .find_map(|command| match command {
7177                SceneCommand::DrawText(run) if run.text == text => {
7178                    Some(text_run_visual_center(run))
7179                }
7180                SceneCommand::DrawShapedText(run) => {
7181                    let layout = run.resolve(output.frame.text_layout_registry.as_ref())?;
7182                    if layout.text() != text {
7183                        return None;
7184                    }
7185                    let line = layout.lines().first().expect("text run should have a line");
7186                    Some(run.origin.y + line.baseline + optical_visual_center(layout.measurement()))
7187                }
7188                _ => None,
7189            })
7190            .expect("text draw command present")
7191    }
7192
7193    fn assert_two_line_row_text_matches_slots(
7194        output: &RenderOutput,
7195        label: &str,
7196        detail: &str,
7197        row: Rect,
7198    ) {
7199        let label = text_runs_for(output, label)
7200            .into_iter()
7201            .next()
7202            .expect("row label draw command present");
7203        let detail = text_runs_for(output, detail)
7204            .into_iter()
7205            .next()
7206            .expect("row detail draw command present");
7207        let total_height =
7208            label.style.line_height + detail.style.line_height + super::TWO_LINE_ROW_TEXT_GAP;
7209        let top = row.y() + ((row.height() - total_height) * 0.5).max(0.0);
7210        let label_slot_center = top + (label.style.line_height * 0.5);
7211        let detail_slot_center = top
7212            + label.style.line_height
7213            + super::TWO_LINE_ROW_TEXT_GAP
7214            + (detail.style.line_height * 0.5);
7215
7216        assert!((text_run_visual_center(&label) - label_slot_center).abs() < 0.75);
7217        assert!((text_run_visual_center(&detail) - detail_slot_center).abs() < 0.75);
7218    }
7219
7220    fn assert_text_run_uses_token(run: &sui_text::TextRun, token: ThemeTextToken) {
7221        assert!(
7222            (run.style.font_size - token.size).abs() < 0.001,
7223            "text '{}' used font size {}, expected token size {}",
7224            run.text,
7225            run.style.font_size,
7226            token.size
7227        );
7228        assert!(
7229            (run.style.line_height - token.line_height).abs() < 0.001,
7230            "text '{}' used line height {}, expected token line height {}",
7231            run.text,
7232            run.style.line_height,
7233            token.line_height
7234        );
7235    }
7236
7237    fn vertical_scroll_thumb_rects(output: &RenderOutput) -> Vec<Rect> {
7238        let mut rects = Vec::new();
7239        output.frame.scene.visit_commands(&mut |command| {
7240            if let SceneCommand::FillPath { path, .. } = command {
7241                let bounds = path.bounds();
7242                if (bounds.width() - 4.0).abs() <= f32::EPSILON && bounds.height() >= 28.0 {
7243                    rects.push(bounds);
7244                }
7245            }
7246        });
7247        rects
7248    }
7249
7250    fn primary_pointer(kind: PointerEventKind, position: Point, pressed: bool) -> Event {
7251        let mut buttons = PointerButtons::NONE;
7252        if pressed {
7253            buttons.insert(PointerButton::Primary);
7254        }
7255
7256        Event::Pointer(PointerEvent {
7257            pointer_id: 1,
7258            kind,
7259            position,
7260            delta: Vector::ZERO,
7261            scroll_delta: None,
7262            button: Some(PointerButton::Primary),
7263            buttons,
7264            modifiers: Modifiers::NONE,
7265            pointer_kind: PointerKind::Mouse,
7266            is_primary: true,
7267        })
7268    }
7269
7270    fn wheel_scroll(position: Point, delta: Vector) -> Event {
7271        let mut scroll = PointerEvent::new(PointerEventKind::Scroll, position);
7272        scroll.scroll_delta = Some(ScrollDelta::Pixels(delta));
7273        Event::Pointer(scroll)
7274    }
7275
7276    fn semantic_bounds(output: &RenderOutput, role: SemanticsRole, name: &str) -> Rect {
7277        output
7278            .semantics
7279            .iter()
7280            .find(|node| node.role == role && node.name.as_deref() == Some(name))
7281            .map(|node| node.bounds)
7282            .unwrap_or_else(|| panic!("{role:?} semantics named {name:?} should be present"))
7283    }
7284
7285    fn handle_ready_events(runtime: &mut Runtime) -> Result<usize> {
7286        let ready = runtime.drain_ready_events();
7287        let count = ready.len();
7288        for (ready_window, event) in ready {
7289            runtime.handle_event(ready_window, event)?;
7290        }
7291        Ok(count)
7292    }
7293
7294    fn assert_focus_surface_keeps_chrome_neutral<W>(root: W, position: Point) -> Result<()>
7295    where
7296        W: Widget + 'static,
7297    {
7298        let theme = DefaultTheme::default();
7299        let (mut runtime, window_id) = build_runtime(root);
7300        let _ = runtime.render(window_id)?;
7301
7302        runtime.handle_event(
7303            window_id,
7304            primary_pointer(PointerEventKind::Down, position, true),
7305        )?;
7306
7307        let focused = runtime.render(window_id)?;
7308        let focused_strokes = solid_stroke_colors(&focused);
7309        assert!(
7310            !focused_strokes.contains(&theme.palette.focus_ring),
7311            "focused data containers should not paint a focus ring; strokes={focused_strokes:?}"
7312        );
7313        assert_eq!(
7314            focused_strokes.first().copied(),
7315            Some(theme.palette.border),
7316            "focused data containers should keep their surface border neutral; strokes={focused_strokes:?}"
7317        );
7318
7319        Ok(())
7320    }
7321
7322    fn assert_pointer_hover_and_press_use_theme_motion(
7323        runtime: &mut Runtime,
7324        window_id: sui_core::WindowId,
7325        position: Point,
7326        theme: &DefaultTheme,
7327    ) -> Result<()> {
7328        let hover_duration = theme.motion.hover_duration();
7329        let press_duration = theme.motion.press_duration();
7330        let expected_hover = super::data_row_state_fill(theme, false, 1.0, 0.0);
7331        let expected_press = super::data_row_state_fill(theme, false, 0.0, 1.0);
7332
7333        runtime.handle_event(
7334            window_id,
7335            primary_pointer(PointerEventKind::Move, position, false),
7336        )?;
7337        runtime.tick(hover_duration * 0.5);
7338        assert_eq!(handle_ready_events(runtime)?, 1);
7339        let mid_hover = runtime.render(window_id)?;
7340        assert!(
7341            !solid_fill_colors(&mid_hover).contains(&expected_hover),
7342            "hover fill should not snap to the settled hover color"
7343        );
7344
7345        runtime.tick(hover_duration);
7346        assert_eq!(handle_ready_events(runtime)?, 1);
7347        let settled_hover = runtime.render(window_id)?;
7348        assert!(
7349            solid_fill_colors(&settled_hover).contains(&expected_hover),
7350            "hover fill should settle to the theme interaction color"
7351        );
7352
7353        runtime.handle_event(
7354            window_id,
7355            primary_pointer(PointerEventKind::Down, position, true),
7356        )?;
7357        runtime.tick(hover_duration + press_duration * 0.5);
7358        assert_eq!(handle_ready_events(runtime)?, 1);
7359        let mid_press = runtime.render(window_id)?;
7360        assert!(
7361            !solid_fill_colors(&mid_press).contains(&expected_press),
7362            "press fill should not snap to the settled pressed color"
7363        );
7364
7365        runtime.tick(hover_duration + press_duration);
7366        assert_eq!(handle_ready_events(runtime)?, 1);
7367        let settled_press = runtime.render(window_id)?;
7368        assert!(
7369            solid_fill_colors(&settled_press).contains(&expected_press),
7370            "press fill should settle to the theme interaction color"
7371        );
7372
7373        Ok(())
7374    }
7375
7376    #[test]
7377    fn data_row_hover_and_press_fills_are_translucent_overlays() {
7378        let theme = DefaultTheme::default();
7379        let hover = super::data_row_state_fill(&theme, false, 1.0, 0.0);
7380        let press = super::data_row_state_fill(&theme, false, 0.0, 1.0);
7381
7382        assert_eq!(
7383            super::data_row_state_fill(&theme, false, 0.0, 0.0),
7384            Color::TRANSPARENT
7385        );
7386        assert!(hover.alpha > 0.0 && hover.alpha < 1.0);
7387        assert!(press.alpha > hover.alpha && press.alpha < 1.0);
7388        assert_ne!(hover, theme.palette.control);
7389        assert_ne!(hover, theme.palette.control_hover);
7390
7391        let dark_hover = super::data_row_state_fill(&DefaultTheme::dark(), false, 1.0, 0.0);
7392        assert!(dark_hover.alpha > 0.0 && dark_hover.alpha < 1.0);
7393    }
7394
7395    #[test]
7396    fn data_focus_surfaces_keep_chrome_neutral() -> Result<()> {
7397        assert_focus_surface_keeps_chrome_neutral(
7398            SizedBox::new().width(260.0).height(120.0).with_child(
7399                ListView::new("Assets").items([ListItem::new("First"), ListItem::new("Second")]),
7400            ),
7401            Point::new(24.0, 24.0),
7402        )?;
7403
7404        assert_focus_surface_keeps_chrome_neutral(
7405            SizedBox::new().width(280.0).height(120.0).with_child(
7406                LayerList::new("Layers")
7407                    .layers([LayerListItem::new("Paint"), LayerListItem::new("Ink")]),
7408            ),
7409            Point::new(24.0, 24.0),
7410        )?;
7411
7412        assert_focus_surface_keeps_chrome_neutral(
7413            SizedBox::new().width(260.0).height(120.0).with_child(
7414                TreeView::new("Scene").items([TreeItem::new("Canvas"), TreeItem::new("Lighting")]),
7415            ),
7416            Point::new(24.0, 24.0),
7417        )?;
7418
7419        assert_focus_surface_keeps_chrome_neutral(
7420            SizedBox::new().width(280.0).height(140.0).with_child(
7421                Table::new("Objects")
7422                    .columns([TableColumn::new("Name")])
7423                    .rows([TableRow::new(["Canvas"]), TableRow::new(["Lighting"])]),
7424            ),
7425            Point::new(24.0, 58.0),
7426        )?;
7427
7428        assert_focus_surface_keeps_chrome_neutral(
7429            Breadcrumb::new("Path").items([
7430                BreadcrumbItem::new("Scene"),
7431                BreadcrumbItem::new("Layers"),
7432                BreadcrumbItem::new("Ink"),
7433            ]),
7434            Point::new(24.0, 18.0),
7435        )
7436    }
7437
7438    #[test]
7439    fn list_view_row_hover_and_press_use_theme_motion() -> Result<()> {
7440        let theme = DefaultTheme::default();
7441        let (mut runtime, window_id) =
7442            build_runtime(SizedBox::new().width(260.0).height(140.0).with_child(
7443                ListView::new("Assets").theme(theme).items([
7444                    ListItem::new("First"),
7445                    ListItem::new("Second"),
7446                    ListItem::new("Third"),
7447                ]),
7448            ));
7449
7450        let output = runtime.render(window_id)?;
7451        let row = output
7452            .semantics
7453            .iter()
7454            .find(|node| {
7455                node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Second")
7456            })
7457            .expect("second row semantics present");
7458
7459        assert_pointer_hover_and_press_use_theme_motion(
7460            &mut runtime,
7461            window_id,
7462            rect_center(row.bounds),
7463            &theme,
7464        )
7465    }
7466
7467    #[test]
7468    fn layer_list_action_hover_and_press_use_theme_motion() -> Result<()> {
7469        let theme = DefaultTheme::default();
7470        let (mut runtime, window_id) = build_runtime(
7471            SizedBox::new().width(280.0).height(120.0).with_child(
7472                LayerList::new("Layers")
7473                    .theme(theme)
7474                    .layers([LayerListItem::new("Paint"), LayerListItem::new("Ink")]),
7475            ),
7476        );
7477
7478        let output = runtime.render(window_id)?;
7479        let visibility = output
7480            .semantics
7481            .iter()
7482            .find(|node| {
7483                node.role == SemanticsRole::Button
7484                    && node.name.as_deref() == Some("Hide Paint layer")
7485            })
7486            .expect("visibility button semantics present");
7487
7488        assert_pointer_hover_and_press_use_theme_motion(
7489            &mut runtime,
7490            window_id,
7491            rect_center(visibility.bounds),
7492            &theme,
7493        )
7494    }
7495
7496    #[test]
7497    fn layer_list_drag_reorders_rows_without_activating_buttons() -> Result<()> {
7498        let changes = Rc::new(RefCell::new(Vec::new()));
7499        let captured = Rc::clone(&changes);
7500        let (mut runtime, window_id) = build_runtime(
7501            SizedBox::new().width(280.0).height(168.0).with_child(
7502                LayerList::new("Layers")
7503                    .layers([
7504                        LayerListItem::new("Paint"),
7505                        LayerListItem::new("Paper"),
7506                        LayerListItem::new("Ink"),
7507                    ])
7508                    .on_reorder(move |change| captured.borrow_mut().push(change)),
7509            ),
7510        );
7511        let output = runtime.render(window_id)?;
7512        let paint = output
7513            .semantics
7514            .iter()
7515            .find(|node| {
7516                node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Paint")
7517            })
7518            .expect("paint layer semantics present");
7519        let paper = output
7520            .semantics
7521            .iter()
7522            .find(|node| {
7523                node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Paper")
7524            })
7525            .expect("paper layer semantics present");
7526
7527        let start = rect_center(paint.bounds);
7528        let end = Point::new(start.x, paper.bounds.max_y() + 4.0);
7529        runtime.handle_event(
7530            window_id,
7531            primary_pointer(PointerEventKind::Down, start, true),
7532        )?;
7533        runtime.handle_event(
7534            window_id,
7535            primary_pointer(PointerEventKind::Move, end, true),
7536        )?;
7537        runtime.handle_event(window_id, primary_pointer(PointerEventKind::Up, end, false))?;
7538
7539        assert_eq!(
7540            changes.borrow().as_slice(),
7541            &[LayerListReorderChange {
7542                item: 0,
7543                from: 0,
7544                to: 1
7545            }]
7546        );
7547
7548        let output = runtime.render(window_id)?;
7549        let paint = output
7550            .semantics
7551            .iter()
7552            .find(|node| {
7553                node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Paint")
7554            })
7555            .expect("paint layer semantics present after reorder");
7556        let paper = output
7557            .semantics
7558            .iter()
7559            .find(|node| {
7560                node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Paper")
7561            })
7562            .expect("paper layer semantics present after reorder");
7563        assert!(paper.bounds.y() < paint.bounds.y());
7564        assert!(
7565            output.semantics.iter().any(|node| {
7566                node.role == SemanticsRole::Button
7567                    && node.name.as_deref() == Some("Hide Paint layer")
7568                    && node.value == Some(SemanticsValue::Text("Visible".to_string()))
7569            }),
7570            "visibility button should remain a normal button after enabling row reorder"
7571        );
7572        Ok(())
7573    }
7574
7575    #[test]
7576    fn table_row_hover_and_press_use_theme_motion() -> Result<()> {
7577        let theme = DefaultTheme::default();
7578        let position = Point::new(
7579            theme.metrics.data_viewport_padding.left + 24.0,
7580            theme.metrics.data_viewport_padding.top
7581                + theme.metrics.table_header_height
7582                + theme.metrics.select_menu_gap
7583                + theme.metrics.table_row_height * 0.5,
7584        );
7585        let (mut runtime, window_id) = build_runtime(
7586            SizedBox::new().width(360.0).height(180.0).with_child(
7587                Table::new("Objects")
7588                    .theme(theme)
7589                    .columns([TableColumn::new("Name"), TableColumn::new("State")])
7590                    .rows([
7591                        TableRow::new(["Canvas", "Visible"]),
7592                        TableRow::new(["Lighting", "Locked"]),
7593                    ]),
7594            ),
7595        );
7596
7597        let _ = runtime.render(window_id)?;
7598        assert_pointer_hover_and_press_use_theme_motion(&mut runtime, window_id, position, &theme)
7599    }
7600
7601    #[test]
7602    fn table_row_hover_keeps_row_base_under_overlay() -> Result<()> {
7603        let theme = DefaultTheme::default();
7604        let position = Point::new(
7605            theme.metrics.data_viewport_padding.left + 24.0,
7606            theme.metrics.data_viewport_padding.top
7607                + theme.metrics.table_header_height
7608                + theme.metrics.select_menu_gap
7609                + theme.metrics.table_row_height * 0.5,
7610        );
7611        let (mut runtime, window_id) = build_runtime(
7612            SizedBox::new().width(360.0).height(180.0).with_child(
7613                Table::new("Objects")
7614                    .theme(theme)
7615                    .columns([TableColumn::new("Name"), TableColumn::new("State")])
7616                    .rows([
7617                        TableRow::new(["Canvas", "Visible"]),
7618                        TableRow::new(["Lighting", "Locked"]),
7619                    ]),
7620            ),
7621        );
7622
7623        let _ = runtime.render(window_id)?;
7624        runtime.handle_event(
7625            window_id,
7626            primary_pointer(PointerEventKind::Move, position, false),
7627        )?;
7628        runtime.tick(theme.motion.hover_duration());
7629        assert_eq!(handle_ready_events(&mut runtime)?, 1);
7630        let hovered = runtime.render(window_id)?;
7631        let fills = solid_fill_colors(&hovered);
7632
7633        assert!(fills.contains(&theme.palette.surface.with_alpha(0.88)));
7634        assert!(fills.contains(&super::data_row_state_fill(&theme, false, 1.0, 0.0)));
7635        assert!(
7636            !fills.contains(&theme.palette.control_hover),
7637            "hovered table rows should paint a translucent overlay, not an opaque control fill"
7638        );
7639        Ok(())
7640    }
7641
7642    #[test]
7643    fn selected_data_rows_share_soft_fill_and_leading_indicator() {
7644        let theme = DefaultTheme::default();
7645        let outputs = [
7646            (
7647                "list view",
7648                render(
7649                    SizedBox::new().width(300.0).height(96.0).with_child(
7650                        ListView::new("Assets")
7651                            .theme(theme)
7652                            .items([ListItem::new("Canvas"), ListItem::new("Lighting")])
7653                            .selected(0),
7654                    ),
7655                ),
7656            ),
7657            (
7658                "layer list",
7659                render(
7660                    SizedBox::new().width(300.0).height(96.0).with_child(
7661                        LayerList::new("Layers")
7662                            .theme(theme)
7663                            .layers([LayerListItem::new("Canvas"), LayerListItem::new("Lighting")])
7664                            .selected(0),
7665                    ),
7666                ),
7667            ),
7668            (
7669                "tree view",
7670                render(
7671                    SizedBox::new().width(300.0).height(96.0).with_child(
7672                        TreeView::new("Scene")
7673                            .theme(theme)
7674                            .items([TreeItem::new("Canvas"), TreeItem::new("Lighting")])
7675                            .selected(0),
7676                    ),
7677                ),
7678            ),
7679            (
7680                "table",
7681                render(
7682                    SizedBox::new().width(300.0).height(128.0).with_child(
7683                        Table::new("Objects")
7684                            .theme(theme)
7685                            .columns([TableColumn::new("Name")])
7686                            .rows([TableRow::new(["Canvas"]), TableRow::new(["Lighting"])])
7687                            .selected(0),
7688                    ),
7689                ),
7690            ),
7691            (
7692                "virtual table",
7693                render(
7694                    SizedBox::new().width(300.0).height(128.0).with_child(
7695                        VirtualTable::new("Virtual objects")
7696                            .theme(theme)
7697                            .columns([VirtualTableColumn::new("Name")])
7698                            .row_count(2)
7699                            .selected(0),
7700                    ),
7701                ),
7702            ),
7703        ];
7704
7705        for (name, output) in outputs {
7706            assert!(
7707                solid_fill_colors(&output).contains(&theme.palette.selection),
7708                "{name} should use the semantic soft selection fill"
7709            );
7710            let indicators = solid_fill_bounds_for_color(&output, theme.palette.accent)
7711                .into_iter()
7712                .filter(|rect| (rect.width() - 2.0).abs() < 0.01 && rect.height() > rect.width())
7713                .collect::<Vec<_>>();
7714            assert_eq!(
7715                indicators.len(),
7716                1,
7717                "{name} should paint one slim leading selection indicator; indicators={indicators:?}"
7718            );
7719        }
7720    }
7721
7722    #[test]
7723    fn breadcrumb_item_hover_and_press_use_theme_motion() -> Result<()> {
7724        let theme = DefaultTheme::default();
7725        let (mut runtime, window_id) = build_runtime(Breadcrumb::new("Path").theme(theme).items([
7726            BreadcrumbItem::new("Workspace"),
7727            BreadcrumbItem::new("Project"),
7728            BreadcrumbItem::new("Scene"),
7729        ]));
7730
7731        let output = runtime.render(window_id)?;
7732        let project_label = text_rects_for(&output, "Project")
7733            .into_iter()
7734            .next()
7735            .expect("project label should render");
7736
7737        assert_pointer_hover_and_press_use_theme_motion(
7738            &mut runtime,
7739            window_id,
7740            rect_center(project_label),
7741            &theme,
7742        )
7743    }
7744
7745    #[test]
7746    fn breadcrumb_overflow_clips_and_defaults_to_trailing_items() {
7747        let output = render(SizedBox::new().width(180.0).with_child(
7748            Breadcrumb::new("Path").items([
7749                BreadcrumbItem::new("SIFS"),
7750                BreadcrumbItem::new("sinomo"),
7751                BreadcrumbItem::new("nodes"),
7752                BreadcrumbItem::new("node 01kvbbd...3fsrx"),
7753                BreadcrumbItem::new("attachments"),
7754            ]),
7755        ));
7756
7757        assert!(
7758            output.frame.scene.commands().iter().any(|command| matches!(
7759                command,
7760                SceneCommand::PushClip { rect }
7761                    if (rect.width() - 180.0).abs() < 0.01
7762                        && (rect.height() - output.frame.viewport.height).abs() < 0.01
7763            )),
7764            "overflowing breadcrumb content should be clipped to the widget bounds"
7765        );
7766
7767        let trailing_label = text_rects_for(&output, "attachments")
7768            .into_iter()
7769            .next()
7770            .expect("trailing breadcrumb item should render");
7771        assert!(
7772            trailing_label.x() >= -0.01 && trailing_label.max_x() <= 180.01,
7773            "default overflow position should keep the last item visible: {trailing_label:?}"
7774        );
7775    }
7776
7777    #[test]
7778    fn breadcrumb_wheel_scrolls_overflowing_content_leftward() -> Result<()> {
7779        let (mut runtime, window_id) = build_runtime(SizedBox::new().width(180.0).with_child(
7780            Breadcrumb::new("Path").items([
7781                BreadcrumbItem::new("SIFS"),
7782                BreadcrumbItem::new("sinomo"),
7783                BreadcrumbItem::new("nodes"),
7784                BreadcrumbItem::new("node 01kvbbd...3fsrx"),
7785                BreadcrumbItem::new("attachments"),
7786            ]),
7787        ));
7788
7789        let before = runtime.render(window_id)?;
7790        let before_x = text_rects_for(&before, "attachments")[0].x();
7791
7792        runtime.handle_event(
7793            window_id,
7794            wheel_scroll(Point::new(90.0, 18.0), Vector::new(0.0, 24.0)),
7795        )?;
7796
7797        let after = runtime.render(window_id)?;
7798        let after_x = text_rects_for(&after, "attachments")[0].x();
7799        assert!(
7800            after_x > before_x,
7801            "wheel scrolling upward should reveal earlier breadcrumb items by moving content right"
7802        );
7803        Ok(())
7804    }
7805
7806    #[test]
7807    fn breadcrumb_drag_scrolls_overflowing_content_leftward() -> Result<()> {
7808        let (mut runtime, window_id) = build_runtime(SizedBox::new().width(180.0).with_child(
7809            Breadcrumb::new("Path").items([
7810                BreadcrumbItem::new("SIFS"),
7811                BreadcrumbItem::new("sinomo"),
7812                BreadcrumbItem::new("nodes"),
7813                BreadcrumbItem::new("node 01kvbbd...3fsrx"),
7814                BreadcrumbItem::new("attachments"),
7815            ]),
7816        ));
7817
7818        let before = runtime.render(window_id)?;
7819        let before_x = text_rects_for(&before, "attachments")[0].x();
7820
7821        runtime.handle_event(
7822            window_id,
7823            primary_pointer(PointerEventKind::Down, Point::new(90.0, 18.0), true),
7824        )?;
7825        runtime.handle_event(
7826            window_id,
7827            primary_pointer(PointerEventKind::Move, Point::new(126.0, 18.0), true),
7828        )?;
7829        runtime.handle_event(
7830            window_id,
7831            primary_pointer(PointerEventKind::Up, Point::new(126.0, 18.0), false),
7832        )?;
7833
7834        let after = runtime.render(window_id)?;
7835        let after_x = text_rects_for(&after, "attachments")[0].x();
7836        assert!(
7837            after_x > before_x,
7838            "dragging right should reveal earlier breadcrumb items by moving content right"
7839        );
7840        Ok(())
7841    }
7842
7843    #[test]
7844    fn list_view_click_selects_row_and_updates_semantics() -> Result<()> {
7845        let changes = Rc::new(RefCell::new(Vec::new()));
7846        let on_change = Rc::clone(&changes);
7847        let (mut runtime, window_id) = build_runtime(
7848            ListView::new("Assets")
7849                .items([
7850                    ListItem::new("First"),
7851                    ListItem::new("Second"),
7852                    ListItem::new("Third"),
7853                ])
7854                .on_change(move |index, label| on_change.borrow_mut().push((index, label))),
7855        );
7856
7857        let _ = runtime.render(window_id)?;
7858        runtime.handle_event(
7859            window_id,
7860            primary_pointer(PointerEventKind::Down, Point::new(44.0, 44.0), true),
7861        )?;
7862        runtime.handle_event(
7863            window_id,
7864            primary_pointer(PointerEventKind::Up, Point::new(44.0, 44.0), false),
7865        )?;
7866
7867        assert_eq!(changes.borrow().as_slice(), &[(1, "Second".to_string())]);
7868
7869        let output = runtime.render(window_id)?;
7870        let list = output
7871            .semantics
7872            .iter()
7873            .find(|node| node.role == SemanticsRole::List)
7874            .expect("list semantics present");
7875        assert_eq!(list.value, Some(SemanticsValue::Text("Second".to_string())));
7876        let row = output
7877            .semantics
7878            .iter()
7879            .find(|node| {
7880                node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Second")
7881            })
7882            .expect("selected row semantics present");
7883        assert_eq!(row.parent, Some(list.id));
7884        assert!(row.state.selected);
7885        assert!(row.actions.contains(&SemanticsAction::Activate));
7886        Ok(())
7887    }
7888
7889    #[test]
7890    fn list_view_change_callback_can_request_relayout() -> Result<()> {
7891        let changes = Rc::new(RefCell::new(Vec::new()));
7892        let requests = Rc::new(RefCell::new(0_usize));
7893        let on_change = Rc::clone(&changes);
7894        let requested = Rc::clone(&requests);
7895        let (mut runtime, window_id) = build_runtime(
7896            ListView::new("Assets")
7897                .items([ListItem::new("First"), ListItem::new("Second")])
7898                .on_change_with_ctx(move |index, label, ctx| {
7899                    on_change.borrow_mut().push((index, label));
7900                    *requested.borrow_mut() += 1;
7901                    ctx.request_measure();
7902                    ctx.request_arrange();
7903                    ctx.request_paint();
7904                    ctx.request_semantics();
7905                }),
7906        );
7907
7908        let _ = runtime.render(window_id)?;
7909        runtime.handle_event(
7910            window_id,
7911            primary_pointer(PointerEventKind::Down, Point::new(44.0, 44.0), true),
7912        )?;
7913        runtime.handle_event(
7914            window_id,
7915            primary_pointer(PointerEventKind::Up, Point::new(44.0, 44.0), false),
7916        )?;
7917
7918        assert_eq!(changes.borrow().as_slice(), &[(1, "Second".to_string())]);
7919        assert_eq!(*requests.borrow(), 1);
7920        Ok(())
7921    }
7922
7923    #[test]
7924    fn list_view_exposes_visible_row_semantics() -> Result<()> {
7925        let (mut runtime, window_id) = build_runtime(
7926            SizedBox::new().width(260.0).height(132.0).with_child(
7927                ListView::new("Layers")
7928                    .items([
7929                        ListItem::new("Paint").detail("Normal / 100%"),
7930                        ListItem::new("Paper").detail("Background"),
7931                        ListItem::new("Locked").detail("Read only").disabled(),
7932                    ])
7933                    .selected(0),
7934            ),
7935        );
7936
7937        let output = runtime.render(window_id)?;
7938        let list = output
7939            .semantics
7940            .iter()
7941            .find(|node| node.role == SemanticsRole::List)
7942            .expect("list semantics present");
7943        let rows = output
7944            .semantics
7945            .iter()
7946            .filter(|node| node.role == SemanticsRole::ListItem)
7947            .collect::<Vec<_>>();
7948
7949        assert_eq!(rows.len(), 3);
7950        let paint = rows
7951            .iter()
7952            .find(|node| node.name.as_deref() == Some("Paint"))
7953            .expect("paint row semantics present");
7954        assert_eq!(paint.parent, Some(list.id));
7955        assert_eq!(paint.description.as_deref(), Some("Normal / 100%"));
7956        assert_eq!(
7957            paint.value,
7958            Some(SemanticsValue::Text("Normal / 100%".to_string()))
7959        );
7960        assert!(paint.state.selected);
7961        assert!(!paint.state.disabled);
7962        assert!(paint.actions.contains(&SemanticsAction::Activate));
7963
7964        let paper = rows
7965            .iter()
7966            .find(|node| node.name.as_deref() == Some("Paper"))
7967            .expect("paper row semantics present");
7968        assert_eq!(paper.parent, Some(list.id));
7969        assert_eq!(paper.description.as_deref(), Some("Background"));
7970        assert_eq!(
7971            paper.value,
7972            Some(SemanticsValue::Text("Background".to_string()))
7973        );
7974        assert!(!paper.state.selected);
7975
7976        let locked = rows
7977            .iter()
7978            .find(|node| node.name.as_deref() == Some("Locked"))
7979            .expect("locked row semantics present");
7980        assert!(locked.state.disabled);
7981        assert!(locked.actions.is_empty());
7982        Ok(())
7983    }
7984
7985    #[test]
7986    fn list_view_selected_when_reads_external_selection() -> Result<()> {
7987        let selected = Rc::new(RefCell::new(0_usize));
7988        let selected_reader = Rc::clone(&selected);
7989        let (mut runtime, window_id) = build_runtime(
7990            SizedBox::new().width(260.0).height(132.0).with_child(
7991                ListView::new("Layers")
7992                    .items([
7993                        ListItem::new("Paint").detail("Normal / 100%"),
7994                        ListItem::new("Paper").detail("Background"),
7995                    ])
7996                    .selected_when(move || Some(*selected_reader.borrow())),
7997            ),
7998        );
7999
8000        let output = runtime.render(window_id)?;
8001        let paint = output
8002            .semantics
8003            .iter()
8004            .find(|node| {
8005                node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Paint")
8006            })
8007            .expect("paint row semantics present");
8008        assert!(paint.state.selected);
8009
8010        *selected.borrow_mut() = 1;
8011        runtime.handle_event(
8012            window_id,
8013            Event::Window(WindowEvent::Resized(Size::new(260.0, 132.0))),
8014        )?;
8015        let output = runtime.render(window_id)?;
8016        let list = output
8017            .semantics
8018            .iter()
8019            .find(|node| node.role == SemanticsRole::List)
8020            .expect("list semantics present");
8021        assert_eq!(list.value, Some(SemanticsValue::Text("Paper".to_string())));
8022        let paper = output
8023            .semantics
8024            .iter()
8025            .find(|node| {
8026                node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Paper")
8027            })
8028            .expect("paper row semantics present");
8029        assert!(paper.state.selected);
8030        Ok(())
8031    }
8032
8033    #[test]
8034    fn list_view_row_ids_are_javascript_safe_and_distinct() {
8035        let parent = WidgetId::new(402);
8036        let mut ids = (0..8)
8037            .map(|index| super::list_view_row_id(parent, index).get())
8038            .collect::<Vec<_>>();
8039
8040        assert!(ids.iter().all(|id| *id <= ((1_u64 << 53) - 1)));
8041        assert!(ids.iter().all(|id| *id != parent.get()));
8042        ids.sort_unstable();
8043        ids.dedup();
8044        assert_eq!(ids.len(), 8);
8045    }
8046
8047    #[test]
8048    fn layer_list_exposes_visibility_semantics() {
8049        let output = render(
8050            SizedBox::new().width(280.0).height(112.0).with_child(
8051                LayerList::new("Layers")
8052                    .layers([
8053                        LayerListItem::new("Paint")
8054                            .detail("Normal / 100%")
8055                            .thumbnail(Color::rgba(0.16, 0.31, 0.88, 1.0)),
8056                        LayerListItem::new("Paper")
8057                            .detail("Background")
8058                            .thumbnail(Color::rgba(0.89, 0.91, 0.94, 1.0)),
8059                    ])
8060                    .selected(0),
8061            ),
8062        );
8063
8064        let list = output
8065            .semantics
8066            .iter()
8067            .find(|node| node.role == SemanticsRole::List)
8068            .expect("layer list semantics present");
8069        assert_eq!(list.name.as_deref(), Some("Layers"));
8070        assert_eq!(list.value, Some(SemanticsValue::Text("Paint".to_string())));
8071
8072        let paint = output
8073            .semantics
8074            .iter()
8075            .find(|node| {
8076                node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Paint")
8077            })
8078            .expect("paint layer row semantics present");
8079        assert_eq!(paint.parent, Some(list.id));
8080        assert_eq!(paint.description.as_deref(), Some("Normal / 100%"));
8081        assert_eq!(
8082            paint.value,
8083            Some(SemanticsValue::Text(
8084                "Normal / 100%; Visible; Unlocked".to_string()
8085            ))
8086        );
8087        assert!(paint.state.selected);
8088
8089        let visibility = output
8090            .semantics
8091            .iter()
8092            .find(|node| {
8093                node.role == SemanticsRole::Button
8094                    && node.name.as_deref() == Some("Hide Paint layer")
8095            })
8096            .expect("paint layer visibility control semantics present");
8097        assert_eq!(visibility.parent, Some(paint.id));
8098        assert_eq!(
8099            visibility.value,
8100            Some(SemanticsValue::Text("Visible".to_string()))
8101        );
8102        assert_eq!(visibility.state.checked, Some(ToggleState::Checked));
8103        assert!(visibility.actions.contains(&SemanticsAction::Activate));
8104
8105        let lock = output
8106            .semantics
8107            .iter()
8108            .find(|node| {
8109                node.role == SemanticsRole::Button
8110                    && node.name.as_deref() == Some("Lock Paint layer")
8111            })
8112            .expect("paint layer lock control semantics present");
8113        assert_eq!(lock.parent, Some(paint.id));
8114        assert_eq!(
8115            lock.value,
8116            Some(SemanticsValue::Text("Unlocked".to_string()))
8117        );
8118        assert_eq!(lock.state.checked, Some(ToggleState::Unchecked));
8119        assert!(lock.actions.contains(&SemanticsAction::Activate));
8120    }
8121
8122    #[test]
8123    fn layer_list_chrome_uses_theme_metrics() {
8124        let mut theme = DefaultTheme::default();
8125        theme.metrics.layer_visibility_stroke_width = 2.75;
8126        theme.metrics.layer_visibility_slash_stroke_width = 3.25;
8127        theme.metrics.layer_thumbnail_disabled_opacity = 0.21;
8128        theme.metrics.layer_thumbnail_disabled_border_opacity = 0.33;
8129        let thumbnail = Color::rgba(0.30, 0.50, 0.70, 1.0);
8130
8131        let output = render(
8132            SizedBox::new().width(280.0).height(64.0).with_child(
8133                LayerList::new("Layers")
8134                    .theme(theme)
8135                    .layers([LayerListItem::new("Paper")
8136                        .thumbnail(thumbnail)
8137                        .visible(false)]),
8138            ),
8139        );
8140        let fills = solid_fill_colors(&output);
8141        let stroke_widths = solid_stroke_widths(&output);
8142        let stroke_colors = solid_stroke_colors(&output);
8143
8144        assert!(fills.contains(&thumbnail.with_alpha(0.21)));
8145        assert!(fills.contains(&theme.palette.control_hover));
8146        assert!(stroke_colors.contains(&theme.palette.border.with_alpha(0.33)));
8147        assert!(
8148            stroke_widths
8149                .iter()
8150                .any(|width| (*width - 2.75).abs() < f32::EPSILON)
8151        );
8152        assert!(
8153            stroke_widths
8154                .iter()
8155                .any(|width| (*width - 3.25).abs() < f32::EPSILON)
8156        );
8157    }
8158
8159    #[test]
8160    fn layer_list_label_and_detail_visual_centers_match_row_slots() {
8161        let output = render(
8162            SizedBox::new().width(280.0).height(64.0).with_child(
8163                LayerList::new("Layers").layer(
8164                    LayerListItem::new("Paint")
8165                        .detail("Normal / 100%")
8166                        .thumbnail(Color::rgba(0.16, 0.31, 0.88, 1.0)),
8167                ),
8168            ),
8169        );
8170        let row = output
8171            .semantics
8172            .iter()
8173            .find(|node| {
8174                node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Paint")
8175            })
8176            .expect("layer row semantics present")
8177            .bounds;
8178
8179        assert_two_line_row_text_matches_slots(&output, "Paint", "Normal / 100%", row);
8180    }
8181
8182    #[test]
8183    fn layer_list_item_dynamic_detail_and_visibility_update_semantics() -> Result<()> {
8184        let detail = Rc::new(RefCell::new("Normal / 100%".to_string()));
8185        let detail_reader = Rc::clone(&detail);
8186        let visible = Rc::new(RefCell::new(true));
8187        let visible_reader = Rc::clone(&visible);
8188        let (mut runtime, window_id) = build_runtime(
8189            SizedBox::new().width(280.0).height(112.0).with_child(
8190                LayerList::new("Layers")
8191                    .layers([
8192                        LayerListItem::new("Paint")
8193                            .detail_when(move || detail_reader.borrow().clone())
8194                            .thumbnail(Color::rgba(0.16, 0.31, 0.88, 1.0))
8195                            .visible_when(move || *visible_reader.borrow()),
8196                        LayerListItem::new("Paper")
8197                            .detail("Background")
8198                            .thumbnail(Color::rgba(0.89, 0.91, 0.94, 1.0)),
8199                    ])
8200                    .selected(0),
8201            ),
8202        );
8203
8204        let output = runtime.render(window_id)?;
8205        let paint = output
8206            .semantics
8207            .iter()
8208            .find(|node| {
8209                node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Paint")
8210            })
8211            .expect("paint layer row semantics present");
8212        assert_eq!(paint.description.as_deref(), Some("Normal / 100%"));
8213        assert_eq!(
8214            paint.value,
8215            Some(SemanticsValue::Text(
8216                "Normal / 100%; Visible; Unlocked".to_string()
8217            ))
8218        );
8219
8220        *detail.borrow_mut() = "Normal / 50%".to_string();
8221        *visible.borrow_mut() = false;
8222        runtime.handle_event(
8223            window_id,
8224            Event::Window(WindowEvent::Resized(Size::new(280.0, 112.0))),
8225        )?;
8226        let output = runtime.render(window_id)?;
8227        let paint = output
8228            .semantics
8229            .iter()
8230            .find(|node| {
8231                node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Paint")
8232            })
8233            .expect("paint layer row semantics present");
8234        assert_eq!(paint.description.as_deref(), Some("Normal / 50%"));
8235        assert_eq!(
8236            paint.value,
8237            Some(SemanticsValue::Text(
8238                "Normal / 50%; Hidden; Unlocked".to_string()
8239            ))
8240        );
8241
8242        let visibility = output
8243            .semantics
8244            .iter()
8245            .find(|node| {
8246                node.role == SemanticsRole::Button
8247                    && node.name.as_deref() == Some("Show Paint layer")
8248            })
8249            .expect("paint layer visibility control should update its label");
8250        assert_eq!(
8251            visibility.value,
8252            Some(SemanticsValue::Text("Hidden".to_string()))
8253        );
8254        assert_eq!(visibility.state.checked, Some(ToggleState::Unchecked));
8255        Ok(())
8256    }
8257
8258    #[test]
8259    fn layer_list_visibility_button_toggles_without_selecting_row() -> Result<()> {
8260        let selections = Rc::new(RefCell::new(Vec::new()));
8261        let on_select = Rc::clone(&selections);
8262        let visibility_changes = Rc::new(RefCell::new(Vec::new()));
8263        let on_visibility_change = Rc::clone(&visibility_changes);
8264        let (mut runtime, window_id) = build_runtime(
8265            SizedBox::new().width(280.0).height(112.0).with_child(
8266                LayerList::new("Layers")
8267                    .layers([
8268                        LayerListItem::new("Paint")
8269                            .detail("Normal / 100%")
8270                            .thumbnail(Color::rgba(0.16, 0.31, 0.88, 1.0)),
8271                        LayerListItem::new("Paper")
8272                            .detail("Background")
8273                            .thumbnail(Color::rgba(0.89, 0.91, 0.94, 1.0)),
8274                    ])
8275                    .selected(0)
8276                    .on_select(move |index, label| {
8277                        on_select.borrow_mut().push((index, label));
8278                    })
8279                    .on_visibility_change(move |index, visible| {
8280                        on_visibility_change.borrow_mut().push((index, visible));
8281                    }),
8282            ),
8283        );
8284
8285        let output = runtime.render(window_id)?;
8286        let visibility = output
8287            .semantics
8288            .iter()
8289            .find(|node| {
8290                node.role == SemanticsRole::Button
8291                    && node.name.as_deref() == Some("Hide Paper layer")
8292            })
8293            .expect("paper layer visibility control should exist");
8294        let position = Point::new(
8295            visibility.bounds.x() + (visibility.bounds.width() * 0.5),
8296            visibility.bounds.y() + (visibility.bounds.height() * 0.5),
8297        );
8298
8299        runtime.handle_event(
8300            window_id,
8301            primary_pointer(PointerEventKind::Down, position, true),
8302        )?;
8303        runtime.handle_event(
8304            window_id,
8305            primary_pointer(PointerEventKind::Up, position, false),
8306        )?;
8307
8308        assert!(selections.borrow().is_empty());
8309        assert_eq!(visibility_changes.borrow().as_slice(), &[(1, false)]);
8310
8311        let output = runtime.render(window_id)?;
8312        let paint = output
8313            .semantics
8314            .iter()
8315            .find(|node| {
8316                node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Paint")
8317            })
8318            .expect("paint layer row should still exist");
8319        assert!(paint.state.selected);
8320
8321        let paper = output
8322            .semantics
8323            .iter()
8324            .find(|node| {
8325                node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Paper")
8326            })
8327            .expect("paper layer row should still exist");
8328        assert!(!paper.state.selected);
8329        assert_eq!(
8330            paper.value,
8331            Some(SemanticsValue::Text(
8332                "Background; Hidden; Unlocked".to_string()
8333            ))
8334        );
8335
8336        let visibility = output
8337            .semantics
8338            .iter()
8339            .find(|node| {
8340                node.role == SemanticsRole::Button
8341                    && node.name.as_deref() == Some("Show Paper layer")
8342            })
8343            .expect("paper layer visibility control should update its label");
8344        assert_eq!(
8345            visibility.value,
8346            Some(SemanticsValue::Text("Hidden".to_string()))
8347        );
8348        assert_eq!(visibility.state.checked, Some(ToggleState::Unchecked));
8349        Ok(())
8350    }
8351
8352    #[test]
8353    fn layer_list_lock_button_toggles_without_selecting_row() -> Result<()> {
8354        let selections = Rc::new(RefCell::new(Vec::new()));
8355        let on_select = Rc::clone(&selections);
8356        let lock_changes = Rc::new(RefCell::new(Vec::new()));
8357        let on_lock_change = Rc::clone(&lock_changes);
8358        let (mut runtime, window_id) = build_runtime(
8359            SizedBox::new().width(280.0).height(112.0).with_child(
8360                LayerList::new("Layers")
8361                    .layers([
8362                        LayerListItem::new("Paint")
8363                            .detail("Normal / 100%")
8364                            .thumbnail(Color::rgba(0.16, 0.31, 0.88, 1.0)),
8365                        LayerListItem::new("Paper")
8366                            .detail("Background")
8367                            .thumbnail(Color::rgba(0.89, 0.91, 0.94, 1.0)),
8368                    ])
8369                    .selected(0)
8370                    .on_select(move |index, label| {
8371                        on_select.borrow_mut().push((index, label));
8372                    })
8373                    .on_lock_change(move |index, locked| {
8374                        on_lock_change.borrow_mut().push((index, locked));
8375                    }),
8376            ),
8377        );
8378
8379        let output = runtime.render(window_id)?;
8380        let lock = output
8381            .semantics
8382            .iter()
8383            .find(|node| {
8384                node.role == SemanticsRole::Button
8385                    && node.name.as_deref() == Some("Lock Paper layer")
8386            })
8387            .expect("paper layer lock control should exist");
8388        let position = Point::new(
8389            lock.bounds.x() + (lock.bounds.width() * 0.5),
8390            lock.bounds.y() + (lock.bounds.height() * 0.5),
8391        );
8392
8393        runtime.handle_event(
8394            window_id,
8395            primary_pointer(PointerEventKind::Down, position, true),
8396        )?;
8397        runtime.handle_event(
8398            window_id,
8399            primary_pointer(PointerEventKind::Up, position, false),
8400        )?;
8401
8402        assert!(selections.borrow().is_empty());
8403        assert_eq!(lock_changes.borrow().as_slice(), &[(1, true)]);
8404
8405        let output = runtime.render(window_id)?;
8406        let paint = output
8407            .semantics
8408            .iter()
8409            .find(|node| {
8410                node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Paint")
8411            })
8412            .expect("paint layer row should still exist");
8413        assert!(paint.state.selected);
8414
8415        let paper = output
8416            .semantics
8417            .iter()
8418            .find(|node| {
8419                node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Paper")
8420            })
8421            .expect("paper layer row should still exist");
8422        assert!(!paper.state.selected);
8423        assert_eq!(
8424            paper.value,
8425            Some(SemanticsValue::Text(
8426                "Background; Visible; Locked".to_string()
8427            ))
8428        );
8429
8430        let lock = output
8431            .semantics
8432            .iter()
8433            .find(|node| {
8434                node.role == SemanticsRole::Button
8435                    && node.name.as_deref() == Some("Unlock Paper layer")
8436            })
8437            .expect("paper layer lock control should update its label");
8438        assert_eq!(lock.value, Some(SemanticsValue::Text("Locked".to_string())));
8439        assert_eq!(lock.state.checked, Some(ToggleState::Checked));
8440        Ok(())
8441    }
8442
8443    #[test]
8444    fn layer_list_row_ids_are_javascript_safe_and_distinct() {
8445        let parent = WidgetId::new(402);
8446        let mut ids = (0..8)
8447            .flat_map(|index| {
8448                [
8449                    super::layer_list_row_id(parent, index).get(),
8450                    super::layer_list_visibility_id(parent, index).get(),
8451                    super::layer_list_lock_id(parent, index).get(),
8452                ]
8453            })
8454            .collect::<Vec<_>>();
8455
8456        assert!(ids.iter().all(|id| *id <= ((1_u64 << 53) - 1)));
8457        assert!(ids.iter().all(|id| *id != parent.get()));
8458        ids.sort_unstable();
8459        ids.dedup();
8460        assert_eq!(ids.len(), 24);
8461    }
8462
8463    #[test]
8464    fn list_item_child_widget_receives_pointer_events() -> Result<()> {
8465        let presses = Rc::new(RefCell::new(0));
8466        let on_press = Rc::clone(&presses);
8467        let row = Stack::horizontal()
8468            .spacing(8.0)
8469            .with_child(SizedBox::new().width(96.0).with_child(Label::new("Asset")))
8470            .with_child(Button::new("Open").on_press(move || *on_press.borrow_mut() += 1));
8471        let (mut runtime, window_id) =
8472            build_runtime(SizedBox::new().width(260.0).height(80.0).with_child(
8473                ListView::new("Actions").item(ListItem::new("Asset").with_content(row)),
8474            ));
8475
8476        let _ = runtime.render(window_id)?;
8477        runtime.handle_event(
8478            window_id,
8479            primary_pointer(PointerEventKind::Down, Point::new(136.0, 28.0), true),
8480        )?;
8481        runtime.handle_event(
8482            window_id,
8483            primary_pointer(PointerEventKind::Up, Point::new(136.0, 28.0), false),
8484        )?;
8485
8486        assert_eq!(*presses.borrow(), 1);
8487        let output = runtime.render(window_id)?;
8488        assert!(
8489            output
8490                .semantics
8491                .iter()
8492                .any(|node| node.role == SemanticsRole::Button
8493                    && node.name.as_deref() == Some("Open"))
8494        );
8495        Ok(())
8496    }
8497
8498    #[test]
8499    fn list_item_child_row_can_opt_into_row_activation() -> Result<()> {
8500        let row_changes = Rc::new(RefCell::new(Vec::new()));
8501        let button_presses = Rc::new(RefCell::new(0));
8502        let on_row = Rc::clone(&row_changes);
8503        let on_button = Rc::clone(&button_presses);
8504        let row = Stack::horizontal()
8505            .spacing(8.0)
8506            .with_child(SizedBox::new().width(96.0).with_child(Label::new("Asset")))
8507            .with_child(Button::new("Open").on_press(move || *on_button.borrow_mut() += 1));
8508        let item = ListItem::new("Asset")
8509            .semantic_name("Asset row")
8510            .description("Selectable asset row")
8511            .activate_with_content()
8512            .with_content(row);
8513        let (mut runtime, window_id) = build_runtime(
8514            SizedBox::new().width(260.0).height(80.0).with_child(
8515                ListView::new("Actions")
8516                    .item(item)
8517                    .on_change(move |index, label| {
8518                        on_row.borrow_mut().push((index, label));
8519                    }),
8520            ),
8521        );
8522
8523        let _ = runtime.render(window_id)?;
8524        runtime.handle_event(
8525            window_id,
8526            primary_pointer(PointerEventKind::Down, Point::new(36.0, 28.0), true),
8527        )?;
8528        runtime.handle_event(
8529            window_id,
8530            primary_pointer(PointerEventKind::Up, Point::new(36.0, 28.0), false),
8531        )?;
8532
8533        assert_eq!(row_changes.borrow().as_slice(), &[(0, "Asset".to_string())]);
8534        assert_eq!(*button_presses.borrow(), 0);
8535
8536        runtime.handle_event(
8537            window_id,
8538            primary_pointer(PointerEventKind::Down, Point::new(136.0, 28.0), true),
8539        )?;
8540        runtime.handle_event(
8541            window_id,
8542            primary_pointer(PointerEventKind::Up, Point::new(136.0, 28.0), false),
8543        )?;
8544
8545        assert_eq!(
8546            row_changes.borrow().as_slice(),
8547            &[(0, "Asset".to_string())],
8548            "nested button clicks should not also activate the row"
8549        );
8550        assert_eq!(*button_presses.borrow(), 1);
8551
8552        let output = runtime.render(window_id)?;
8553        let row = output
8554            .semantics
8555            .iter()
8556            .find(|node| {
8557                node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Asset row")
8558            })
8559            .expect("custom child row should expose list-item semantics");
8560        assert_eq!(row.description.as_deref(), Some("Selectable asset row"));
8561        assert!(row.actions.contains(&SemanticsAction::Activate));
8562        Ok(())
8563    }
8564
8565    #[test]
8566    fn list_item_child_respects_explicit_row_height() -> Result<()> {
8567        let row_changes = Rc::new(RefCell::new(Vec::new()));
8568        let on_row = Rc::clone(&row_changes);
8569        let item = ListItem::new("Tall asset")
8570            .activate_with_child()
8571            .with_child(
8572                SizedBox::new()
8573                    .height(180.0)
8574                    .with_child(Label::new("Tall custom row")),
8575            );
8576        let (mut runtime, window_id) = build_runtime(
8577            SizedBox::new().width(260.0).height(96.0).with_child(
8578                ListView::new("Assets")
8579                    .row_height(36.0)
8580                    .item(item)
8581                    .on_change(move |index, label| {
8582                        on_row.borrow_mut().push((index, label));
8583                    }),
8584            ),
8585        );
8586
8587        let output = runtime.render(window_id)?;
8588        let row = output
8589            .semantics
8590            .iter()
8591            .find(|node| {
8592                node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Tall asset")
8593            })
8594            .expect("fixed-height child row should expose list-item semantics");
8595        assert!(
8596            (row.bounds.height() - 36.0).abs() <= 0.5,
8597            "explicit row height should cap oversized child content, got {:?}",
8598            row.bounds
8599        );
8600
8601        let position = Point::new(
8602            row.bounds.x() + row.bounds.width() * 0.5,
8603            row.bounds.y() + row.bounds.height() * 0.5,
8604        );
8605        runtime.handle_event(
8606            window_id,
8607            primary_pointer(PointerEventKind::Down, position, true),
8608        )?;
8609        runtime.handle_event(
8610            window_id,
8611            primary_pointer(PointerEventKind::Up, position, false),
8612        )?;
8613
8614        assert_eq!(
8615            row_changes.borrow().as_slice(),
8616            &[(0, "Tall asset".to_string())]
8617        );
8618        Ok(())
8619    }
8620
8621    #[test]
8622    fn list_item_child_widget_rearranges_when_scrolled() -> Result<()> {
8623        let (mut runtime, window_id) = build_runtime(
8624            SizedBox::new().width(260.0).height(96.0).with_child(
8625                ListView::new("Assets")
8626                    .padding(Insets::ZERO)
8627                    .row_height(40.0)
8628                    .items([
8629                        ListItem::new("First"),
8630                        ListItem::new("Custom row").with_content(Label::new("Floating child")),
8631                        ListItem::new("Third"),
8632                        ListItem::new("Fourth"),
8633                    ]),
8634            ),
8635        );
8636
8637        let before = runtime.render(window_id)?;
8638        let before_child = semantic_bounds(&before, SemanticsRole::Text, "Floating child");
8639
8640        runtime.handle_event(
8641            window_id,
8642            wheel_scroll(Point::new(32.0, 32.0), Vector::new(0.0, -20.0)),
8643        )?;
8644
8645        let after = runtime.render(window_id)?;
8646        let after_child = semantic_bounds(&after, SemanticsRole::Text, "Floating child");
8647
8648        assert!(
8649            (before_child.y() - after_child.y() - 20.0).abs() < 0.5,
8650            "custom list child should move with scroll: before={before_child:?}, after={after_child:?}"
8651        );
8652        Ok(())
8653    }
8654
8655    #[test]
8656    fn list_and_tree_padding_overrides_inset_row_viewports() {
8657        let padding = Insets {
8658            left: 24.0,
8659            top: 16.0,
8660            right: 20.0,
8661            bottom: 12.0,
8662        };
8663        let list = render(
8664            SizedBox::new().width(320.0).height(120.0).with_child(
8665                ListView::new("Assets")
8666                    .padding(padding)
8667                    .item(ListItem::new("Asset")),
8668            ),
8669        );
8670        let list_row = list
8671            .semantics
8672            .iter()
8673            .find(|node| {
8674                node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Asset")
8675            })
8676            .expect("padded list row semantics");
8677        assert!((list_row.bounds.x() - padding.left).abs() < 0.01);
8678        assert!((list_row.bounds.y() - padding.top).abs() < 0.01);
8679        assert!((list_row.bounds.width() - (320.0 - padding.left - padding.right)).abs() < 0.01);
8680
8681        let tree = render(
8682            SizedBox::new().width(320.0).height(120.0).with_child(
8683                TreeView::new("Scene")
8684                    .padding(padding)
8685                    .item(TreeItem::new("Node")),
8686            ),
8687        );
8688        let tree_row = tree
8689            .semantics
8690            .iter()
8691            .find(|node| {
8692                node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Node")
8693            })
8694            .expect("padded tree row semantics");
8695        assert!((tree_row.bounds.x() - padding.left).abs() < 0.01);
8696        assert!((tree_row.bounds.y() - padding.top).abs() < 0.01);
8697        assert!((tree_row.bounds.width() - (320.0 - padding.left - padding.right)).abs() < 0.01);
8698    }
8699
8700    #[test]
8701    fn tree_item_content_widget_receives_pointer_events_and_drives_row_height() -> Result<()> {
8702        let presses = Rc::new(RefCell::new(0));
8703        let changes = Rc::new(RefCell::new(Vec::new()));
8704        let on_press = Rc::clone(&presses);
8705        let on_change = Rc::clone(&changes);
8706        let content = SizedBox::new().height(52.0).with_child(
8707            Stack::horizontal()
8708                .spacing(8.0)
8709                .with_child(SizedBox::new().width(96.0).with_child(Label::new("Asset")))
8710                .with_child(Button::new("Open").on_press(move || *on_press.borrow_mut() += 1)),
8711        );
8712        let padding = Insets::all(12.0);
8713        let (mut runtime, window_id) = build_runtime(
8714            SizedBox::new().width(320.0).height(120.0).with_child(
8715                TreeView::new("Scene")
8716                    .padding(padding)
8717                    .item(
8718                        TreeItem::new("Root")
8719                            .with_child(TreeItem::new("Asset row").with_content(content)),
8720                    )
8721                    .on_change(move |path, label| {
8722                        on_change.borrow_mut().push((path, label));
8723                    }),
8724            ),
8725        );
8726
8727        let collapsed = runtime.render(window_id)?;
8728        let root_id = collapsed
8729            .semantics
8730            .iter()
8731            .find(|node| {
8732                node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Root")
8733            })
8734            .expect("collapsed tree root semantics")
8735            .id;
8736        assert!(runtime.handle_semantics_action(
8737            window_id,
8738            root_id,
8739            SemanticsActionRequest::Expand,
8740        )?);
8741        let before = runtime.render(window_id)?;
8742        let row = before
8743            .semantics
8744            .iter()
8745            .find(|node| {
8746                node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Asset row")
8747            })
8748            .expect("custom tree row semantics");
8749        let button = before
8750            .semantics
8751            .iter()
8752            .find(|node| node.role == SemanticsRole::Button && node.name.as_deref() == Some("Open"))
8753            .expect("custom tree content button semantics");
8754        assert!(row.bounds.y() > padding.top);
8755        assert!(
8756            row.bounds.height() >= 52.0,
8757            "custom content should determine the tree row height"
8758        );
8759        assert!(
8760            !row.actions.contains(&SemanticsAction::Activate),
8761            "interactive custom content should own pointer activation by default"
8762        );
8763
8764        let position = Point::new(
8765            button.bounds.x() + button.bounds.width() * 0.5,
8766            button.bounds.y() + button.bounds.height() * 0.5,
8767        );
8768        runtime.handle_event(
8769            window_id,
8770            primary_pointer(PointerEventKind::Down, position, true),
8771        )?;
8772        runtime.handle_event(
8773            window_id,
8774            primary_pointer(PointerEventKind::Up, position, false),
8775        )?;
8776
8777        assert_eq!(*presses.borrow(), 1);
8778        assert!(changes.borrow().is_empty());
8779        Ok(())
8780    }
8781
8782    #[test]
8783    fn tree_item_child_widget_rearranges_when_scrolled() -> Result<()> {
8784        let (mut runtime, window_id) = build_runtime(
8785            SizedBox::new().width(320.0).height(104.0).with_child(
8786                TreeView::new("Scene")
8787                    .padding(Insets::ZERO)
8788                    .row_height(40.0)
8789                    .item(
8790                        TreeItem::new("Root")
8791                            .expanded(true)
8792                            .with_child(TreeItem::new("First child"))
8793                            .with_child(
8794                                TreeItem::new("Custom tree row")
8795                                    .with_content(Label::new("Floating tree child")),
8796                            )
8797                            .with_child(TreeItem::new("Third child")),
8798                    ),
8799            ),
8800        );
8801
8802        let before = runtime.render(window_id)?;
8803        let before_child = semantic_bounds(&before, SemanticsRole::Text, "Floating tree child");
8804
8805        runtime.handle_event(
8806            window_id,
8807            wheel_scroll(Point::new(32.0, 32.0), Vector::new(0.0, -24.0)),
8808        )?;
8809
8810        let after = runtime.render(window_id)?;
8811        let after_child = semantic_bounds(&after, SemanticsRole::Text, "Floating tree child");
8812
8813        assert!(
8814            (before_child.y() - after_child.y() - 24.0).abs() < 0.5,
8815            "custom tree child should move with scroll: before={before_child:?}, after={after_child:?}"
8816        );
8817        Ok(())
8818    }
8819
8820    #[test]
8821    fn tree_view_keyboard_expands_and_selects_child() -> Result<()> {
8822        let changes = Rc::new(RefCell::new(Vec::new()));
8823        let on_change = Rc::clone(&changes);
8824        let (mut runtime, window_id) = build_runtime(
8825            TreeView::new("Scene")
8826                .item(
8827                    TreeItem::new("Root")
8828                        .with_child(TreeItem::new("Child A"))
8829                        .with_child(TreeItem::new("Child B")),
8830                )
8831                .on_change(move |path, label| on_change.borrow_mut().push((path, label))),
8832        );
8833
8834        let _ = runtime.render(window_id)?;
8835        runtime.handle_event(
8836            window_id,
8837            primary_pointer(PointerEventKind::Down, Point::new(48.0, 26.0), true),
8838        )?;
8839        runtime.handle_event(
8840            window_id,
8841            primary_pointer(PointerEventKind::Up, Point::new(48.0, 26.0), false),
8842        )?;
8843        runtime.handle_event(
8844            window_id,
8845            Event::Keyboard(KeyboardEvent::new("ArrowRight", KeyState::Pressed)),
8846        )?;
8847        runtime.handle_event(
8848            window_id,
8849            Event::Keyboard(KeyboardEvent::new("ArrowDown", KeyState::Pressed)),
8850        )?;
8851
8852        assert!(changes.borrow().iter().any(|(_, label)| label == "Child A"));
8853
8854        let output = runtime.render(window_id)?;
8855        let tree = output
8856            .semantics
8857            .iter()
8858            .find(|node| node.role == SemanticsRole::Tree)
8859            .expect("tree semantics present");
8860        assert_eq!(
8861            tree.value,
8862            Some(SemanticsValue::Text("Child A".to_string()))
8863        );
8864        Ok(())
8865    }
8866
8867    #[test]
8868    fn tree_view_keyed_rows_support_accessible_expansion_and_activation() -> Result<()> {
8869        let changes = Rc::new(RefCell::new(Vec::new()));
8870        let on_change = Rc::clone(&changes);
8871        let (mut runtime, window_id) = build_runtime(
8872            SizedBox::new().width(320.0).height(140.0).with_child(
8873                TreeView::new("Scene")
8874                    .item(
8875                        TreeItem::new("Root")
8876                            .key(42)
8877                            .with_child(TreeItem::new("Child").key(7)),
8878                    )
8879                    .on_change(move |path, label| on_change.borrow_mut().push((path, label))),
8880            ),
8881        );
8882        let before = runtime.render(window_id)?;
8883        let root = before
8884            .semantics
8885            .iter()
8886            .find(|node| {
8887                node.role == SemanticsRole::ListItem && node.name.as_deref() == Some("Root")
8888            })
8889            .expect("root tree item");
8890        let root_id = root.id;
8891        assert!(root.actions.contains(&SemanticsAction::Expand));
8892
8893        assert!(runtime.handle_semantics_action(
8894            window_id,
8895            root_id,
8896            SemanticsActionRequest::Expand,
8897        )?);
8898        let expanded = runtime.render(window_id)?;
8899        let expanded_root = expanded
8900            .semantics
8901            .iter()
8902            .find(|node| node.name.as_deref() == Some("Root"))
8903            .expect("expanded root");
8904        assert_eq!(expanded_root.id, root_id);
8905        let child = expanded
8906            .semantics
8907            .iter()
8908            .find(|node| node.name.as_deref() == Some("Child"))
8909            .expect("child tree item");
8910
8911        assert!(runtime.handle_semantics_action(
8912            window_id,
8913            child.id,
8914            SemanticsActionRequest::Activate,
8915        )?);
8916        assert!(changes.borrow().iter().any(|(_, label)| label == "Child"));
8917        Ok(())
8918    }
8919
8920    #[test]
8921    fn table_keyboard_selects_next_row() -> Result<()> {
8922        let changes = Rc::new(RefCell::new(Vec::new()));
8923        let on_change = Rc::clone(&changes);
8924        let (mut runtime, window_id) = build_runtime(
8925            Table::new("Materials")
8926                .columns([TableColumn::new("Name"), TableColumn::new("Passes")])
8927                .rows([TableRow::new(["Glass", "3"]), TableRow::new(["Water", "4"])])
8928                .on_change(move |index| on_change.borrow_mut().push(index)),
8929        );
8930
8931        let _ = runtime.render(window_id)?;
8932        runtime.handle_event(
8933            window_id,
8934            primary_pointer(PointerEventKind::Down, Point::new(60.0, 72.0), true),
8935        )?;
8936        runtime.handle_event(
8937            window_id,
8938            primary_pointer(PointerEventKind::Up, Point::new(60.0, 72.0), false),
8939        )?;
8940        runtime.handle_event(
8941            window_id,
8942            Event::Keyboard(KeyboardEvent::new("ArrowDown", KeyState::Pressed)),
8943        )?;
8944
8945        assert!(changes.borrow().contains(&1));
8946
8947        let output = runtime.render(window_id)?;
8948        let table = output
8949            .semantics
8950            .iter()
8951            .find(|node| node.role == SemanticsRole::Table)
8952            .expect("table semantics present");
8953        assert_eq!(table.value, Some(SemanticsValue::Text("Water".to_string())));
8954        Ok(())
8955    }
8956
8957    #[test]
8958    fn virtual_table_semantics_include_columns_and_visible_rows() {
8959        let output = render(
8960            SizedBox::new().width(360.0).height(120.0).with_child(
8961                VirtualTable::new("Files")
8962                    .columns([
8963                        VirtualTableColumn::new("Name").min_width(160.0),
8964                        VirtualTableColumn::new("Kind").width(80.0),
8965                    ])
8966                    .row_count(100)
8967                    .row_height(20.0)
8968                    .header_height(24.0)
8969                    .row_name(|index| format!("Row {index}"))
8970                    .row_description(|index| format!("File row {index}")),
8971            ),
8972        );
8973
8974        let table = output
8975            .semantics
8976            .iter()
8977            .find(|node| node.role == SemanticsRole::Table)
8978            .expect("virtual table semantics present");
8979        assert_eq!(table.name.as_deref(), Some("Files"));
8980        assert_eq!(
8981            table.value,
8982            Some(SemanticsValue::Text("100 rows".to_string()))
8983        );
8984        assert!(table.description.as_deref().is_some_and(|description| {
8985            description.contains("Columns: Name, Kind") && description.contains("of 100")
8986        }));
8987
8988        let rows = output
8989            .semantics
8990            .iter()
8991            .filter(|node| node.role == SemanticsRole::ListItem)
8992            .collect::<Vec<_>>();
8993        assert!(!rows.is_empty());
8994        assert!(
8995            rows.len() < 100,
8996            "virtual table should expose only visible rows, got {}",
8997            rows.len()
8998        );
8999        assert_eq!(rows[0].name.as_deref(), Some("Row 0"));
9000        assert_eq!(
9001            rows[0].description.as_deref(),
9002            Some("File row 0; row 1 of 100")
9003        );
9004    }
9005
9006    #[test]
9007    fn virtual_table_supports_variable_row_heights() {
9008        let output = render(
9009            SizedBox::new().width(360.0).height(180.0).with_child(
9010                VirtualTable::new("Variable rows")
9011                    .columns([VirtualTableColumn::new("Name")])
9012                    .row_count(3)
9013                    .row_heights([20.0, 44.0, 28.0])
9014                    .row_name(|index| format!("Row {index}")),
9015            ),
9016        );
9017        let rows = output
9018            .semantics
9019            .iter()
9020            .filter(|node| node.role == SemanticsRole::ListItem)
9021            .collect::<Vec<_>>();
9022        assert_eq!(rows.len(), 3);
9023        assert_eq!(rows[0].bounds.height(), 20.0);
9024        assert_eq!(rows[1].bounds.height(), 44.0);
9025        assert_eq!(rows[2].bounds.height(), 28.0);
9026        assert_eq!(rows[1].bounds.y(), rows[0].bounds.max_y());
9027    }
9028
9029    #[test]
9030    fn virtual_table_row_keys_stabilize_semantics_across_reordering() -> Result<()> {
9031        let keys = Rc::new(RefCell::new(vec![42_u64, 7]));
9032        let key_reader = Rc::clone(&keys);
9033        let name_reader = Rc::clone(&keys);
9034        let (mut runtime, window_id) = build_runtime(
9035            SizedBox::new().width(360.0).height(140.0).with_child(
9036                VirtualTable::new("Keyed rows")
9037                    .columns([VirtualTableColumn::new("Name")])
9038                    .row_count(2)
9039                    .row_key(move |index| key_reader.borrow()[index])
9040                    .row_name(move |index| format!("Row {}", name_reader.borrow()[index])),
9041            ),
9042        );
9043        let before = runtime.render(window_id)?;
9044        let before_id = before
9045            .semantics
9046            .iter()
9047            .find(|node| node.name.as_deref() == Some("Row 42"))
9048            .expect("row 42 semantics")
9049            .id;
9050
9051        keys.borrow_mut().swap(0, 1);
9052        runtime.handle_event(
9053            window_id,
9054            Event::Pointer(PointerEvent::new(
9055                PointerEventKind::Move,
9056                Point::new(20.0, 80.0),
9057            )),
9058        )?;
9059        let after = runtime.render(window_id)?;
9060        let after_id = after
9061            .semantics
9062            .iter()
9063            .find(|node| node.name.as_deref() == Some("Row 42"))
9064            .expect("reordered row 42 semantics")
9065            .id;
9066        assert_eq!(before_id, after_id);
9067        Ok(())
9068    }
9069
9070    #[test]
9071    fn virtual_table_state_retains_keyed_selection_across_reordering() -> Result<()> {
9072        let keys = Rc::new(RefCell::new(vec![42_u64, 7]));
9073        let key_reader = Rc::clone(&keys);
9074        let name_reader = Rc::clone(&keys);
9075        let state = VirtualTableState::new();
9076        state.select_key(Some(42));
9077        let (mut runtime, window_id) = build_runtime(
9078            SizedBox::new().width(360.0).height(140.0).with_child(
9079                VirtualTable::new("Retained keyed rows")
9080                    .state(state.clone())
9081                    .columns([VirtualTableColumn::new("Name")])
9082                    .row_count(2)
9083                    .row_key(move |index| key_reader.borrow()[index])
9084                    .row_name(move |index| format!("Row {}", name_reader.borrow()[index])),
9085            ),
9086        );
9087
9088        let before = runtime.render(window_id)?;
9089        assert!(
9090            before
9091                .semantics
9092                .iter()
9093                .find(|node| node.name.as_deref() == Some("Row 42"))
9094                .is_some_and(|node| node.state.selected)
9095        );
9096
9097        keys.borrow_mut().swap(0, 1);
9098        runtime.handle_event(
9099            window_id,
9100            Event::Pointer(PointerEvent::new(
9101                PointerEventKind::Move,
9102                Point::new(20.0, 80.0),
9103            )),
9104        )?;
9105        let after = runtime.render(window_id)?;
9106        assert!(
9107            after
9108                .semantics
9109                .iter()
9110                .find(|node| node.name.as_deref() == Some("Row 42"))
9111                .is_some_and(|node| node.state.selected)
9112        );
9113        assert_eq!(state.selected_key(), Some(42));
9114
9115        state.select_key(None);
9116        let cleared = runtime.render(window_id)?;
9117        assert!(
9118            cleared
9119                .semantics
9120                .iter()
9121                .filter(|node| node.role == SemanticsRole::ListItem)
9122                .all(|node| !node.state.selected)
9123        );
9124        Ok(())
9125    }
9126
9127    #[test]
9128    fn paged_virtual_table_reports_global_range_and_supports_keyed_scroll() -> Result<()> {
9129        let state = VirtualTableState::new();
9130        state.scroll_to(900, ScrollAlignment::Start);
9131        let (mut runtime, window_id) = build_runtime(
9132            SizedBox::new().width(360.0).height(140.0).with_child(
9133                VirtualTable::new("Files")
9134                    .state(state.clone())
9135                    .columns([VirtualTableColumn::new("Name")])
9136                    .collection_window(CollectionWindow::loaded(
9137                        500..1_012,
9138                        Some(5_000),
9139                        true,
9140                        true,
9141                    ))
9142                    .row_count(512)
9143                    .row_height(20.0)
9144                    .row_key(|index| 500 + index as u64)
9145                    .row_name(|index| format!("File {}", 500 + index)),
9146            ),
9147        );
9148
9149        let output = runtime.render(window_id)?;
9150        let viewport = state.viewport();
9151        assert_eq!(viewport.loaded_range, 500..1_012);
9152        assert_eq!(viewport.visible_range.start, 900);
9153        assert_eq!(viewport.total_count, Some(5_000));
9154        assert_eq!(viewport.anchor.as_ref().map(|anchor| anchor.key), Some(900));
9155
9156        let table = output
9157            .semantics
9158            .iter()
9159            .find(|node| node.role == SemanticsRole::Table)
9160            .expect("table semantics");
9161        assert_eq!(
9162            table.value,
9163            Some(SemanticsValue::Text("5000 rows".to_string()))
9164        );
9165        assert!(
9166            table
9167                .description
9168                .as_deref()
9169                .is_some_and(|description| description.contains("of 5000"))
9170        );
9171        let first_visible = output
9172            .semantics
9173            .iter()
9174            .find(|node| node.role == SemanticsRole::ListItem)
9175            .expect("visible table row");
9176        assert!(
9177            first_visible
9178                .description
9179                .as_deref()
9180                .is_some_and(|description| description.contains("901 of 5000"))
9181        );
9182        Ok(())
9183    }
9184
9185    #[test]
9186    fn virtual_table_state_retains_width_by_column_key() {
9187        let state = VirtualTableState::new();
9188        state.set_column_width(11, 184.0);
9189        let painted_width = Rc::new(RefCell::new(0.0));
9190        let width = Rc::clone(&painted_width);
9191        let _ = render(
9192            SizedBox::new().width(360.0).height(140.0).with_child(
9193                VirtualTable::new("Retained widths")
9194                    .state(state.clone())
9195                    .columns([
9196                        VirtualTableColumn::new("Name").key(11),
9197                        VirtualTableColumn::new("Kind").key(12).width(80.0),
9198                    ])
9199                    .row_count(1)
9200                    .row_painter(move |_ctx, row| {
9201                        *width.borrow_mut() = row.column_rects[0].width();
9202                    }),
9203            ),
9204        );
9205        assert_eq!(*painted_width.borrow(), 184.0);
9206        assert_eq!(state.column_width(11), Some(184.0));
9207    }
9208
9209    #[test]
9210    fn virtual_table_column_separator_drag_resizes_column() -> Result<()> {
9211        let resized = Rc::new(RefCell::new(Vec::new()));
9212        let resize_events = Rc::clone(&resized);
9213        let theme = DefaultTheme::default();
9214        let width = 360.0;
9215        let padding = theme.metrics.data_viewport_padding;
9216        let available = width - padding.left - padding.right;
9217        let separator_x = padding.left + available - 80.0;
9218        let header_y = padding.top + theme.metrics.table_header_height * 0.5;
9219        let (mut runtime, window_id) = build_runtime(
9220            SizedBox::new().width(width).height(140.0).with_child(
9221                VirtualTable::new("Resizable")
9222                    .theme(theme)
9223                    .columns([
9224                        VirtualTableColumn::new("Name").min_width(120.0),
9225                        VirtualTableColumn::new("Kind").width(80.0).resizable(false),
9226                    ])
9227                    .row_count(2)
9228                    .on_column_resize(move |index, width| {
9229                        resize_events.borrow_mut().push((index, width));
9230                    }),
9231            ),
9232        );
9233        runtime.render(window_id)?;
9234        runtime.handle_event(
9235            window_id,
9236            primary_pointer(
9237                PointerEventKind::Down,
9238                Point::new(separator_x, header_y),
9239                true,
9240            ),
9241        )?;
9242        runtime.handle_event(
9243            window_id,
9244            primary_pointer(
9245                PointerEventKind::Move,
9246                Point::new(separator_x + 32.0, header_y),
9247                true,
9248            ),
9249        )?;
9250        runtime.handle_event(
9251            window_id,
9252            primary_pointer(
9253                PointerEventKind::Up,
9254                Point::new(separator_x + 32.0, header_y),
9255                false,
9256            ),
9257        )?;
9258
9259        let events = resized.borrow();
9260        assert!(!events.is_empty());
9261        assert_eq!(events.last().map(|event| event.0), Some(0));
9262        assert!(
9263            events
9264                .last()
9265                .is_some_and(|event| event.1 > available - 80.0)
9266        );
9267        Ok(())
9268    }
9269
9270    #[test]
9271    fn virtual_table_pinned_columns_hold_position_during_horizontal_scroll() -> Result<()> {
9272        let painted = Rc::new(RefCell::new(Vec::<Vec<Rect>>::new()));
9273        let row_rects = Rc::clone(&painted);
9274        let (mut runtime, window_id) = build_runtime(
9275            SizedBox::new().width(220.0).height(140.0).with_child(
9276                VirtualTable::new("Pinned")
9277                    .columns([
9278                        VirtualTableColumn::new("Name").width(100.0).pinned(true),
9279                        VirtualTableColumn::new("Kind").width(100.0),
9280                        VirtualTableColumn::new("Status").width(100.0),
9281                    ])
9282                    .row_count(2)
9283                    .row_painter(move |_ctx, row| {
9284                        if row.row_index == 0 {
9285                            row_rects.borrow_mut().push(row.column_rects.to_vec());
9286                        }
9287                    }),
9288            ),
9289        );
9290        runtime.render(window_id)?;
9291        let before = painted.borrow().last().cloned().expect("first row painted");
9292
9293        runtime.handle_event(
9294            window_id,
9295            wheel_scroll(Point::new(120.0, 80.0), Vector::new(-80.0, 0.0)),
9296        )?;
9297        runtime.render(window_id)?;
9298        let after = painted
9299            .borrow()
9300            .last()
9301            .cloned()
9302            .expect("scrolled row painted");
9303
9304        assert_eq!(before[0].x(), after[0].x());
9305        assert!(after[1].width() < before[1].width());
9306        assert!(after[2].x() < before[2].x());
9307        Ok(())
9308    }
9309
9310    #[test]
9311    fn table_numeric_column_uses_tabular_figures_and_shared_right_edge() {
9312        let output = render(
9313            SizedBox::new().width(360.0).height(140.0).with_child(
9314                Table::new("Materials")
9315                    .columns([
9316                        TableColumn::new("Name"),
9317                        TableColumn::new("Passes").numeric(),
9318                    ])
9319                    .rows([
9320                        TableRow::new(["Glass", "3"]),
9321                        TableRow::new(["Water", "128"]),
9322                    ]),
9323            ),
9324        );
9325        let short = text_runs_for(&output, "3")
9326            .into_iter()
9327            .find(|run| {
9328                run.style
9329                    .features
9330                    .iter()
9331                    .any(|feature| feature.tag == FontFeature::TABULAR_FIGURES)
9332            })
9333            .expect("short numeric cell should be tabular");
9334        let long = text_runs_for(&output, "128")
9335            .into_iter()
9336            .next()
9337            .expect("long numeric cell should render");
9338
9339        assert!(
9340            long.style
9341                .features
9342                .iter()
9343                .any(|feature| feature.tag == FontFeature::TABULAR_FIGURES && feature.value == 1)
9344        );
9345        assert!((short.rect.max_x() - long.rect.max_x()).abs() < 0.75);
9346    }
9347
9348    #[test]
9349    fn selected_table_cells_preserve_body_metrics_and_numeric_alignment() {
9350        let mut theme = DefaultTheme::default();
9351        theme.typography.body_font_size = 13.0;
9352        theme.typography.body_line_height = 21.0;
9353        let output = render(
9354            SizedBox::new().width(360.0).height(140.0).with_child(
9355                Table::new("Materials")
9356                    .theme(theme)
9357                    .columns([
9358                        TableColumn::new("Name"),
9359                        TableColumn::new("Passes").numeric(),
9360                    ])
9361                    .rows([
9362                        TableRow::new(["Glass", "8642"]),
9363                        TableRow::new(["Water", "7"]),
9364                    ])
9365                    .selected(0),
9366            ),
9367        );
9368        let selected_label = text_runs_for(&output, "Glass")
9369            .into_iter()
9370            .next()
9371            .expect("selected text cell should render");
9372        let selected_number = text_runs_for(&output, "8642")
9373            .into_iter()
9374            .next()
9375            .expect("selected numeric cell should render");
9376        let unselected_number = text_runs_for(&output, "7")
9377            .into_iter()
9378            .next()
9379            .expect("unselected numeric cell should render");
9380
9381        assert_eq!(selected_label.style.color, theme.palette.text);
9382        assert_eq!(
9383            selected_label.style.font_size,
9384            theme.typography.body_font_size
9385        );
9386        assert_eq!(
9387            selected_label.style.line_height,
9388            theme.typography.body_line_height
9389        );
9390        assert_eq!(selected_number.style.color, theme.palette.text);
9391        assert_eq!(
9392            selected_number.style.font_size,
9393            theme.typography.body_font_size
9394        );
9395        assert_eq!(
9396            selected_number.style.line_height,
9397            theme.typography.body_line_height
9398        );
9399        assert!(
9400            selected_number
9401                .style
9402                .features
9403                .iter()
9404                .any(|feature| feature.tag == FontFeature::TABULAR_FIGURES && feature.value == 1)
9405        );
9406        assert!((selected_number.rect.max_x() - unselected_number.rect.max_x()).abs() < 0.75);
9407    }
9408
9409    #[test]
9410    fn collection_and_path_widgets_theme_when_paints_dark_tokens() {
9411        let theme = DefaultTheme::dark();
9412        let list = render(
9413            SizedBox::new().width(320.0).height(120.0).with_child(
9414                ListView::new("Assets")
9415                    .theme_when(move || theme)
9416                    .item(ListItem::new("Hero texture").detail("2048 x 2048 RGBA")),
9417            ),
9418        );
9419        assert_eq!(
9420            text_runs_for(&list, "Hero texture")[0].style.color,
9421            theme.palette.text
9422        );
9423        assert!(solid_fill_colors(&list).contains(&theme.palette.surface));
9424
9425        let theme = DefaultTheme::dark();
9426        let tree = render(
9427            SizedBox::new().width(320.0).height(120.0).with_child(
9428                TreeView::new("Scene")
9429                    .theme_when(move || theme)
9430                    .item(TreeItem::new("Environment").detail("Visible")),
9431            ),
9432        );
9433        assert_eq!(
9434            text_runs_for(&tree, "Environment")[0].style.color,
9435            theme.palette.text
9436        );
9437        assert!(solid_fill_colors(&tree).contains(&theme.palette.surface));
9438
9439        let theme = DefaultTheme::dark();
9440        let table = render(
9441            SizedBox::new().width(320.0).height(140.0).with_child(
9442                Table::new("Materials")
9443                    .theme_when(move || theme)
9444                    .columns([TableColumn::new("Name")])
9445                    .rows([TableRow::new(["Glass"])]),
9446            ),
9447        );
9448        let table_fills = solid_fill_colors(&table);
9449        assert!(table_fills.contains(&theme.palette.surface));
9450        assert!(table_fills.contains(&theme.palette.control));
9451        assert!(
9452            !table_fills.contains(&Color::rgba(0.95, 0.965, 0.985, 1.0)),
9453            "dark table header should not use the old hardcoded light fill"
9454        );
9455
9456        let theme = DefaultTheme::dark();
9457        let breadcrumb = render(Breadcrumb::new("Path").theme_when(move || theme).items([
9458            BreadcrumbItem::new("Workspace"),
9459            BreadcrumbItem::new("Project"),
9460        ]));
9461        assert_eq!(
9462            text_runs_for(&breadcrumb, "Workspace")[0].style.color,
9463            theme.palette.text
9464        );
9465        assert!(solid_fill_colors(&breadcrumb).contains(&theme.palette.surface));
9466    }
9467
9468    #[test]
9469    fn table_chrome_uses_theme_metrics() {
9470        let mut theme = DefaultTheme::default();
9471        theme.metrics.table_header_separator_inset = 7.0;
9472        theme.metrics.table_separator_width = 2.75;
9473        theme.metrics.table_row_border_opacity = 0.29;
9474        theme.metrics.data_scroll_thumb_width = 5.5;
9475        theme.metrics.data_scroll_thumb_inset = 9.0;
9476        theme.metrics.data_scroll_thumb_radius = 2.75;
9477        theme.metrics.data_scroll_thumb_min_length = 35.0;
9478        theme.metrics.data_scroll_thumb_opacity = 0.41;
9479        let rows = (0..10).map(|index| TableRow::new([format!("Row {index}"), format!("{index}")]));
9480
9481        let output = render(
9482            SizedBox::new().width(320.0).height(120.0).with_child(
9483                Table::new("Materials")
9484                    .theme(theme)
9485                    .columns([
9486                        TableColumn::new("Name").width(160.0),
9487                        TableColumn::new("Passes").width(80.0),
9488                    ])
9489                    .rows(rows),
9490            ),
9491        );
9492
9493        let expected_separator_height =
9494            theme.metrics.table_header_height - (theme.metrics.table_header_separator_inset * 2.0);
9495        assert!(solid_stroke_rects(&output).iter().any(|rect| {
9496            (rect.width() - theme.metrics.table_separator_width).abs() < 0.01
9497                && (rect.height() - expected_separator_height).abs() < 0.01
9498        }));
9499        assert!(
9500            solid_stroke_widths(&output)
9501                .iter()
9502                .any(|width| { (*width - theme.metrics.table_separator_width).abs() < 0.01 })
9503        );
9504        assert!(
9505            solid_stroke_colors(&output).contains(
9506                &theme
9507                    .palette
9508                    .border
9509                    .with_alpha(theme.metrics.table_row_border_opacity)
9510            )
9511        );
9512        assert!(
9513            solid_fill_colors(&output).contains(
9514                &theme
9515                    .palette
9516                    .border_hover
9517                    .with_alpha(theme.metrics.data_scroll_thumb_opacity)
9518            )
9519        );
9520    }
9521
9522    #[test]
9523    fn list_view_detail_text_does_not_overlap_primary_label() {
9524        let output = render(SizedBox::new().width(320.0).height(120.0).with_child(
9525            ListView::new("Assets").item(ListItem::new("Hero texture").detail("2048 x 2048 RGBA")),
9526        ));
9527
9528        let label = text_rects_for(&output, "Hero texture")[0];
9529        let detail = text_rects_for(&output, "2048 x 2048 RGBA")[0];
9530
9531        assert!(label.max_y() <= detail.y());
9532    }
9533
9534    #[test]
9535    fn list_view_label_and_detail_visual_centers_match_row_slots() {
9536        let theme = DefaultTheme::default();
9537        let output = render(SizedBox::new().width(320.0).height(72.0).with_child(
9538            ListView::new("Assets").item(ListItem::new("Hero texture").detail("2048 x 2048 RGBA")),
9539        ));
9540        let label = text_runs_for(&output, "Hero texture")
9541            .into_iter()
9542            .next()
9543            .expect("list row label draw command present");
9544        let detail = text_runs_for(&output, "2048 x 2048 RGBA")
9545            .into_iter()
9546            .next()
9547            .expect("list row detail draw command present");
9548        let viewport_padding = theme.metrics.data_viewport_padding;
9549        let row_height = theme
9550            .metrics
9551            .list_row_height
9552            .max(super::two_line_row_height(
9553                label.style.line_height,
9554                detail.style.line_height,
9555            ));
9556        let row = Rect::new(
9557            viewport_padding.left,
9558            viewport_padding.top,
9559            (output.frame.viewport.width - viewport_padding.left - viewport_padding.right).max(0.0),
9560            row_height,
9561        );
9562
9563        assert_two_line_row_text_matches_slots(&output, "Hero texture", "2048 x 2048 RGBA", row);
9564    }
9565
9566    #[test]
9567    fn data_detail_text_styles_follow_theme_xs_token() {
9568        let mut theme = DefaultTheme::default();
9569        theme.text.xs = ThemeTextToken {
9570            size: 10.5,
9571            line_height: 17.5,
9572        };
9573        theme.sync_derived_fields();
9574
9575        let list = render(
9576            SizedBox::new().width(320.0).height(72.0).with_child(
9577                ListView::new("Assets")
9578                    .theme(theme)
9579                    .item(ListItem::new("Hero texture").detail("2048 x 2048 RGBA")),
9580            ),
9581        );
9582        assert_text_run_uses_token(
9583            &text_runs_for(&list, "2048 x 2048 RGBA")
9584                .into_iter()
9585                .next()
9586                .expect("list detail should render"),
9587            theme.text.xs,
9588        );
9589
9590        let layer = render(
9591            SizedBox::new().width(280.0).height(72.0).with_child(
9592                LayerList::new("Layers").theme(theme).layer(
9593                    LayerListItem::new("Paint")
9594                        .detail("Normal / 100%")
9595                        .thumbnail(Color::rgba(0.16, 0.31, 0.88, 1.0)),
9596                ),
9597            ),
9598        );
9599        assert_text_run_uses_token(
9600            &text_runs_for(&layer, "Normal / 100%")
9601                .into_iter()
9602                .next()
9603                .expect("layer detail should render"),
9604            theme.text.xs,
9605        );
9606
9607        let tree = render(
9608            SizedBox::new().width(320.0).height(72.0).with_child(
9609                TreeView::new("Scene")
9610                    .theme(theme)
9611                    .item(TreeItem::new("Environment").detail("Visible")),
9612            ),
9613        );
9614        assert_text_run_uses_token(
9615            &text_runs_for(&tree, "Visible")
9616                .into_iter()
9617                .next()
9618                .expect("tree detail should render"),
9619            theme.text.xs,
9620        );
9621    }
9622
9623    #[test]
9624    fn list_view_long_label_clips_to_single_line() {
9625        let title = "What tools are available to you when the session title is very long";
9626        let output = render(
9627            SizedBox::new()
9628                .width(170.0)
9629                .height(56.0)
9630                .with_child(ListView::new("Sessions").item(ListItem::new(title))),
9631        );
9632
9633        let run = text_runs_for(&output, title)
9634            .into_iter()
9635            .next()
9636            .expect("long title should be drawn");
9637        let clips = draw_clip_rects_for(&output, title);
9638
9639        assert_eq!(clips.len(), 1);
9640        assert!(
9641            clips[0].height() <= run.style.line_height + 0.5,
9642            "long single-line labels should clip wrapped overflow to one line; clip={:?}, line_height={}",
9643            clips[0],
9644            run.style.line_height
9645        );
9646    }
9647
9648    #[test]
9649    fn tree_view_detail_text_does_not_overlap_primary_label() {
9650        let output = render(SizedBox::new().width(320.0).height(120.0).with_child(
9651            TreeView::new("Scene").item(TreeItem::new("Environment").detail("Visible")),
9652        ));
9653
9654        let label = text_rects_for(&output, "Environment")[0];
9655        let detail = text_rects_for(&output, "Visible")[0];
9656
9657        assert!(label.max_y() <= detail.y());
9658    }
9659
9660    #[test]
9661    fn list_and_tree_detail_text_stays_grouped_with_primary_label() {
9662        let list = render(SizedBox::new().width(320.0).height(120.0).with_child(
9663            ListView::new("Assets").item(ListItem::new("Hero texture").detail("2048 x 2048 RGBA")),
9664        ));
9665        let tree = render(SizedBox::new().width(320.0).height(120.0).with_child(
9666            TreeView::new("Scene").item(TreeItem::new("Environment").detail("Visible")),
9667        ));
9668
9669        for (output, label_text, detail_text) in [
9670            (&list, "Hero texture", "2048 x 2048 RGBA"),
9671            (&tree, "Environment", "Visible"),
9672        ] {
9673            let label = text_rects_for(output, label_text)[0];
9674            let detail = text_rects_for(output, detail_text)[0];
9675            let gap = detail.y() - label.max_y();
9676
9677            assert!(
9678                (0.0..=2.5).contains(&gap),
9679                "expected {label_text:?} and {detail_text:?} to read as one row; gap was {gap}"
9680            );
9681        }
9682    }
9683
9684    #[test]
9685    fn tree_view_label_and_detail_visual_centers_match_row_slots() {
9686        let theme = DefaultTheme::default();
9687        let output = render(SizedBox::new().width(320.0).height(72.0).with_child(
9688            TreeView::new("Scene").item(TreeItem::new("Environment").detail("Visible")),
9689        ));
9690        let label = text_runs_for(&output, "Environment")
9691            .into_iter()
9692            .next()
9693            .expect("tree row label draw command present");
9694        let detail = text_runs_for(&output, "Visible")
9695            .into_iter()
9696            .next()
9697            .expect("tree row detail draw command present");
9698        let viewport_padding = theme.metrics.data_viewport_padding;
9699        let row_height = theme
9700            .metrics
9701            .tree_row_height
9702            .max(super::two_line_row_height(
9703                label.style.line_height,
9704                detail.style.line_height,
9705            ));
9706        let row = Rect::new(
9707            viewport_padding.left,
9708            viewport_padding.top,
9709            (output.frame.viewport.width - viewport_padding.left - viewport_padding.right).max(0.0),
9710            row_height,
9711        );
9712
9713        assert_two_line_row_text_matches_slots(&output, "Environment", "Visible", row);
9714    }
9715
9716    #[test]
9717    fn list_view_does_not_paint_internal_scroll_thumb() {
9718        let output = render(
9719            SizedBox::new().width(320.0).height(100.0).with_child(
9720                ListView::new("Assets")
9721                    .items([
9722                        ListItem::new("Hero texture").detail("2048 x 2048 RGBA"),
9723                        ListItem::new("UI icon sheet").detail("Tagged for export"),
9724                        ListItem::new("Archive cache").detail("Read only"),
9725                        ListItem::new("Normals atlas").detail("Streaming mip chain"),
9726                    ])
9727                    .selected(1),
9728            ),
9729        );
9730
9731        assert!(vertical_scroll_thumb_rects(&output).is_empty());
9732    }
9733
9734    #[test]
9735    fn list_view_scrolls_overflowing_rows_without_thumb() -> Result<()> {
9736        let (mut runtime, window_id) =
9737            build_runtime(SizedBox::new().width(320.0).height(100.0).with_child(
9738                ListView::new("Assets").items([
9739                    ListItem::new("Hero texture").detail("2048 x 2048 RGBA"),
9740                    ListItem::new("UI icon sheet").detail("Tagged for export"),
9741                    ListItem::new("Archive cache").detail("Read only"),
9742                    ListItem::new("Normals atlas").detail("Streaming mip chain"),
9743                ]),
9744            ));
9745
9746        let before = runtime.render(window_id)?;
9747        let before_y = text_rects_for(&before, "Hero texture")[0].y();
9748
9749        runtime.handle_event(
9750            window_id,
9751            wheel_scroll(Point::new(60.0, 60.0), Vector::new(0.0, -24.0)),
9752        )?;
9753        let after = runtime.render(window_id)?;
9754        let after_y = text_rects_for(&after, "Hero texture")[0].y();
9755
9756        assert!(after_y < before_y);
9757        assert!(vertical_scroll_thumb_rects(&after).is_empty());
9758        Ok(())
9759    }
9760
9761    #[test]
9762    fn list_view_clips_scrolled_selection_highlight_to_viewport() -> Result<()> {
9763        let theme = DefaultTheme::default();
9764        let (mut runtime, window_id) = build_runtime(
9765            SizedBox::new().width(320.0).height(100.0).with_child(
9766                ListView::new("Assets")
9767                    .theme(theme)
9768                    .items([
9769                        ListItem::new("Hero texture").detail("2048 x 2048 RGBA"),
9770                        ListItem::new("UI icon sheet").detail("Tagged for export"),
9771                        ListItem::new("Archive cache").detail("Read only"),
9772                        ListItem::new("Normals atlas").detail("Streaming mip chain"),
9773                    ])
9774                    .selected(0),
9775            ),
9776        );
9777
9778        let _ = runtime.render(window_id)?;
9779        runtime.handle_event(
9780            window_id,
9781            wheel_scroll(Point::new(60.0, 60.0), Vector::new(0.0, -24.0)),
9782        )?;
9783        let output = runtime.render(window_id)?;
9784        let highlight = selected_highlight_rects(&output)
9785            .first()
9786            .copied()
9787            .expect("selected list row highlight should be painted");
9788
9789        assert!(highlight.y() >= theme.metrics.data_viewport_padding.top);
9790        assert!(highlight.max_y() <= 100.0 - theme.metrics.data_viewport_padding.bottom);
9791        Ok(())
9792    }
9793
9794    #[test]
9795    fn tree_view_does_not_paint_internal_scroll_thumb() {
9796        let output = render(
9797            SizedBox::new().width(320.0).height(120.0).with_child(
9798                TreeView::new("Scene").item(
9799                    TreeItem::new("Environment")
9800                        .with_child(TreeItem::new("Sky dome").detail("Visible"))
9801                        .with_child(TreeItem::new("Fog volume").detail("Animated"))
9802                        .with_child(TreeItem::new("Characters").detail("Selected")),
9803                ),
9804            ),
9805        );
9806
9807        assert!(vertical_scroll_thumb_rects(&output).is_empty());
9808    }
9809
9810    #[test]
9811    fn tree_view_scrolls_overflowing_rows_without_thumb() -> Result<()> {
9812        let (mut runtime, window_id) = build_runtime(
9813            SizedBox::new().width(320.0).height(120.0).with_child(
9814                TreeView::new("Scene").item(
9815                    TreeItem::new("Scene")
9816                        .expanded(true)
9817                        .with_child(TreeItem::new("Environment").detail("Visible"))
9818                        .with_child(TreeItem::new("Sky dome").detail("Visible"))
9819                        .with_child(TreeItem::new("Fog volume").detail("Animated"))
9820                        .with_child(TreeItem::new("Pilot").detail("Selected")),
9821                ),
9822            ),
9823        );
9824
9825        let before = runtime.render(window_id)?;
9826        let before_y = text_rects_for(&before, "Scene")[0].y();
9827
9828        runtime.handle_event(
9829            window_id,
9830            wheel_scroll(Point::new(60.0, 60.0), Vector::new(0.0, -24.0)),
9831        )?;
9832        let after = runtime.render(window_id)?;
9833        let after_y = text_rects_for(&after, "Scene")[0].y();
9834
9835        assert!(after_y < before_y);
9836        assert!(vertical_scroll_thumb_rects(&after).is_empty());
9837        Ok(())
9838    }
9839
9840    #[test]
9841    fn tree_view_clips_scrolled_selection_highlight_to_viewport() -> Result<()> {
9842        let theme = DefaultTheme::default();
9843        let (mut runtime, window_id) = build_runtime(
9844            SizedBox::new().width(320.0).height(120.0).with_child(
9845                TreeView::new("Scene").item(
9846                    TreeItem::new("Scene")
9847                        .expanded(true)
9848                        .with_child(TreeItem::new("Environment").detail("Visible"))
9849                        .with_child(TreeItem::new("Sky dome").detail("Visible"))
9850                        .with_child(TreeItem::new("Fog volume").detail("Animated"))
9851                        .with_child(TreeItem::new("Pilot").detail("Selected")),
9852                ),
9853            ),
9854        );
9855
9856        let _ = runtime.render(window_id)?;
9857        runtime.handle_event(
9858            window_id,
9859            primary_pointer(PointerEventKind::Down, Point::new(60.0, 24.0), true),
9860        )?;
9861        runtime.handle_event(
9862            window_id,
9863            primary_pointer(PointerEventKind::Up, Point::new(60.0, 24.0), false),
9864        )?;
9865        runtime.handle_event(
9866            window_id,
9867            wheel_scroll(Point::new(60.0, 60.0), Vector::new(0.0, -24.0)),
9868        )?;
9869        let output = runtime.render(window_id)?;
9870        let highlight = selected_highlight_rects(&output)
9871            .first()
9872            .copied()
9873            .expect("selected tree row highlight should be painted");
9874
9875        assert!(highlight.y() >= theme.metrics.data_viewport_padding.top);
9876        assert!(highlight.max_y() <= 120.0 - theme.metrics.data_viewport_padding.bottom);
9877        Ok(())
9878    }
9879
9880    #[test]
9881    fn tree_view_disclosure_does_not_overlap_primary_label() {
9882        let output = render(
9883            SizedBox::new().width(320.0).height(120.0).with_child(
9884                TreeView::new("Scene").item(
9885                    TreeItem::new("Environment")
9886                        .with_child(TreeItem::new("Sky dome").detail("Visible")),
9887                ),
9888            ),
9889        );
9890
9891        let label = text_rects_for(&output, "Environment")[0];
9892        let mut disclosure_bounds = Vec::new();
9893        output.frame.scene.visit_commands(&mut |command| {
9894            if let SceneCommand::FillPath { path, .. } = command {
9895                let bounds = path.bounds();
9896                if bounds.width() <= 12.0 && bounds.height() <= 12.0 {
9897                    disclosure_bounds.push(bounds);
9898                }
9899            }
9900        });
9901
9902        let disclosure = disclosure_bounds
9903            .first()
9904            .expect("tree disclosure should be painted");
9905        assert!(
9906            disclosure.max_x() + DefaultTheme::default().metrics.tree_disclosure_gap <= label.x()
9907        );
9908    }
9909
9910    #[test]
9911    fn table_text_rect_uses_full_line_height() {
9912        let output = render(
9913            SizedBox::new().width(320.0).height(140.0).with_child(
9914                Table::new("Materials")
9915                    .columns([TableColumn::new("Name")])
9916                    .rows([TableRow::new(["Glass"])]),
9917            ),
9918        );
9919
9920        let header = text_rects_for(&output, "Name")[0];
9921        let cell = text_rects_for(&output, "Glass")[0];
9922        let line_height = DefaultTheme::default().body_text_style().line_height;
9923
9924        assert!(header.height() >= line_height);
9925        assert!(cell.height() >= line_height);
9926    }
9927
9928    #[test]
9929    fn table_aligned_text_preserves_tall_measurements_and_cell_alignment() {
9930        let mut theme = DefaultTheme::default();
9931        theme.typography.body_font_size = 28.0;
9932        theme.typography.body_line_height = 12.0;
9933        theme.metrics.table_header_height = 44.0;
9934        theme.metrics.table_row_height = 48.0;
9935
9936        let output = render(
9937            SizedBox::new().width(360.0).height(136.0).with_child(
9938                Table::new("Materials")
9939                    .theme(theme)
9940                    .columns([
9941                        TableColumn::new("Name")
9942                            .width(180.0)
9943                            .alignment(TableColumnAlignment::Center),
9944                        TableColumn::new("Passes").width(120.0).numeric(),
9945                    ])
9946                    .rows([TableRow::new(["Glass", "128"])]),
9947            ),
9948        );
9949        let header = text_runs_for(&output, "Name")
9950            .into_iter()
9951            .next()
9952            .expect("centered table header should render");
9953        let header_clip = draw_clip_rects_for(&output, "Name")
9954            .into_iter()
9955            .next()
9956            .expect("centered table header should be clipped to its cell");
9957        let cell = text_runs_for(&output, "Glass")
9958            .into_iter()
9959            .next()
9960            .expect("table cell should render");
9961        let cell_clip = draw_clip_rects_for(&output, "Glass")
9962            .into_iter()
9963            .next()
9964            .expect("table cell should be clipped to its cell");
9965        let numeric = text_runs_for(&output, "128")
9966            .into_iter()
9967            .next()
9968            .expect("numeric table cell should render");
9969        let numeric_clip = draw_clip_rects_for(&output, "128")
9970            .into_iter()
9971            .next()
9972            .expect("numeric table cell should be clipped to its cell");
9973        let measured_height = |run: &sui_text::TextRun| {
9974            TextSystem::new()
9975                .shape_text_run(run, &FontRegistry::new())
9976                .expect("table text should shape")
9977                .measurement()
9978                .height
9979        };
9980
9981        assert!(header.rect.height() >= measured_height(&header) - 0.01);
9982        assert!(cell.rect.height() >= measured_height(&cell) - 0.01);
9983        assert!(numeric.rect.height() >= measured_height(&numeric) - 0.01);
9984        assert!(
9985            (rect_center(header.rect).x - rect_center(header_clip).x).abs() < 0.75,
9986            "centered table header should align to cell center: text={:?}, cell={:?}",
9987            header.rect,
9988            header_clip
9989        );
9990        assert!(
9991            (numeric.rect.max_x() - numeric_clip.max_x()).abs() < 0.75,
9992            "numeric table cell should align to trailing edge: text={:?}, cell={:?}",
9993            numeric.rect,
9994            numeric_clip
9995        );
9996        assert!(
9997            (text_visual_center_for(&output, "Name") - rect_center(header_clip).y).abs() < 0.75,
9998            "centered table header should be optically centered in its cell"
9999        );
10000        assert!(
10001            (text_visual_center_for(&output, "Glass") - rect_center(cell_clip).y).abs() < 0.75,
10002            "table body cell should be optically centered in its cell"
10003        );
10004        assert!(
10005            (text_visual_center_for(&output, "128") - rect_center(numeric_clip).y).abs() < 0.75,
10006            "numeric table body cell should be optically centered in its cell"
10007        );
10008    }
10009
10010    #[test]
10011    fn non_scrollable_table_allows_wheel_to_bubble_to_parent_scroll_view() -> Result<()> {
10012        let (mut runtime, window_id) = build_runtime(
10013            SizedBox::new()
10014                .size(Size::new(220.0, 120.0))
10015                .with_child(ScrollView::vertical(
10016                    Stack::vertical()
10017                        .with_child(SizedBox::new().width(220.0).height(80.0))
10018                        .with_child(
10019                            SizedBox::new().width(220.0).height(120.0).with_child(
10020                                Table::new("Materials")
10021                                    .columns([
10022                                        TableColumn::new("Name"),
10023                                        TableColumn::new("Passes").width(80.0),
10024                                    ])
10025                                    .rows([
10026                                        TableRow::new(["Glass", "3"]),
10027                                        TableRow::new(["Water", "4"]),
10028                                    ]),
10029                            ),
10030                        )
10031                        .with_child(SizedBox::new().width(220.0).height(160.0)),
10032                )),
10033        );
10034
10035        let _ = runtime.render(window_id)?;
10036
10037        let mut scroll = PointerEvent::new(PointerEventKind::Scroll, Point::new(60.0, 90.0));
10038        scroll.scroll_delta = Some(ScrollDelta::Pixels(Vector::new(0.0, -24.0)));
10039        runtime.handle_event(window_id, Event::Pointer(scroll))?;
10040        let _ = runtime.render(window_id)?;
10041
10042        let graph = runtime.widget_graph(window_id)?;
10043        let outer_content = graph
10044            .nodes
10045            .iter()
10046            .find(|node| node.bounds.width() == 220.0 && node.bounds.height() == 360.0)
10047            .expect("outer scroll content present");
10048
10049        assert_eq!(outer_content.bounds.y(), -24.0);
10050        Ok(())
10051    }
10052
10053    #[test]
10054    fn breadcrumb_keyboard_activates_last_segment() -> Result<()> {
10055        let changes = Rc::new(RefCell::new(Vec::new()));
10056        let on_activate = Rc::clone(&changes);
10057        let (mut runtime, window_id) = build_runtime(
10058            Breadcrumb::new("Path")
10059                .items([
10060                    BreadcrumbItem::new("Workspace"),
10061                    BreadcrumbItem::new("Project"),
10062                    BreadcrumbItem::new("Scene"),
10063                ])
10064                .current(0)
10065                .on_activate(move |index, label| on_activate.borrow_mut().push((index, label))),
10066        );
10067
10068        let _ = runtime.render(window_id)?;
10069        runtime.handle_event(
10070            window_id,
10071            primary_pointer(PointerEventKind::Down, Point::new(28.0, 20.0), true),
10072        )?;
10073        runtime.handle_event(
10074            window_id,
10075            primary_pointer(PointerEventKind::Up, Point::new(28.0, 20.0), false),
10076        )?;
10077        runtime.handle_event(
10078            window_id,
10079            Event::Keyboard(KeyboardEvent::new("End", KeyState::Pressed)),
10080        )?;
10081        runtime.handle_event(
10082            window_id,
10083            Event::Keyboard(KeyboardEvent::new("Enter", KeyState::Pressed)),
10084        )?;
10085
10086        assert_eq!(changes.borrow().last(), Some(&(2, "Scene".to_string())));
10087
10088        let output = runtime.render(window_id)?;
10089        let breadcrumb = output
10090            .semantics
10091            .iter()
10092            .find(|node| node.role == SemanticsRole::Breadcrumb)
10093            .expect("breadcrumb semantics present");
10094        assert_eq!(
10095            breadcrumb.value,
10096            Some(SemanticsValue::Text("Scene".to_string()))
10097        );
10098        Ok(())
10099    }
10100
10101    #[test]
10102    fn breadcrumb_paints_segment_labels_with_line_height() {
10103        let output = render(Breadcrumb::new("Path").items([
10104            BreadcrumbItem::new("Workspace"),
10105            BreadcrumbItem::new("Project"),
10106            BreadcrumbItem::new("Scene"),
10107        ]));
10108
10109        let run = text_runs_for(&output, "Workspace")
10110            .into_iter()
10111            .next()
10112            .expect("breadcrumb label draw command present");
10113        let theme = DefaultTheme::default();
10114        let line_height = theme.body_text_style().line_height;
10115        let available_height = (theme.metrics.breadcrumb_height
10116            - theme.metrics.breadcrumb_item_padding.top
10117            - theme.metrics.breadcrumb_item_padding.bottom)
10118            .max(0.0);
10119        let layout = TextSystem::new()
10120            .shape_text_run(&run, &FontRegistry::new())
10121            .expect("breadcrumb label should shape");
10122        let line = layout.lines().first().expect("breadcrumb line present");
10123        let actual_visual_center =
10124            run.rect.y() + line.baseline + optical_visual_center(layout.measurement());
10125        let slot_center = theme.metrics.breadcrumb_item_padding.top + (available_height * 0.5);
10126
10127        assert!((run.rect.height() - line_height.min(available_height)).abs() < 0.001);
10128        assert!(run.rect.width() > 0.0);
10129        assert!(
10130            (actual_visual_center - slot_center).abs() < 0.75,
10131            "breadcrumb label visual center {actual_visual_center} did not match slot center {slot_center}; text rect {:?}",
10132            run.rect
10133        );
10134    }
10135
10136    #[test]
10137    fn breadcrumb_label_stays_within_vertical_item_bounds() {
10138        let output = render(Breadcrumb::new("Path").items([BreadcrumbItem::new("Workspace")]));
10139        let label = text_rects_for(&output, "Workspace")[0];
10140
10141        assert!(label.y() >= -0.01);
10142        assert!(label.max_y() <= output.frame.viewport.height + 0.01);
10143    }
10144
10145    #[test]
10146    fn list_row_label_visual_center_matches_row_center() {
10147        let output = render(ListView::new("Assets").item(ListItem::new("Hero texture")));
10148        let run = text_runs_for(&output, "Hero texture")
10149            .into_iter()
10150            .next()
10151            .expect("list row label draw command present");
10152        let layout = TextSystem::new()
10153            .shape_text_run(&run, &FontRegistry::new())
10154            .expect("list row label should shape");
10155        let line = layout.lines().first().expect("list row line present");
10156        let actual_visual_center =
10157            run.rect.y() + line.baseline + optical_visual_center(layout.measurement());
10158        let row_center = output.frame.viewport.height * 0.5;
10159
10160        assert!((actual_visual_center - row_center).abs() < 0.75);
10161    }
10162
10163    struct LeadingLabelCellFixture {
10164        theme: DefaultTheme,
10165    }
10166
10167    impl Widget for LeadingLabelCellFixture {
10168        fn measure(
10169            &mut self,
10170            _ctx: &mut sui_runtime::MeasureCtx,
10171            constraints: Constraints,
10172        ) -> Size {
10173            constraints.clamp(Size::new(132.0, 32.0))
10174        }
10175
10176        fn paint(&self, ctx: &mut PaintCtx) {
10177            super::paint_leading_label_cell(
10178                ctx,
10179                &self.theme,
10180                ctx.bounds(),
10181                "artifact.txt",
10182                LeadingLabelCellPaint::new()
10183                    .icon(crate::IconGlyph::File)
10184                    .icon_color(self.theme.palette.text_muted)
10185                    .label_color(self.theme.palette.text)
10186                    .label_weight(FontWeight::MEDIUM)
10187                    .icon_slot_side(20.0)
10188                    .icon_inset(2.0)
10189                    .gap(8.0)
10190                    .padding(6.0, 8.0),
10191            );
10192        }
10193    }
10194
10195    #[test]
10196    fn leading_label_cell_uses_compact_token_and_clips_to_cell() {
10197        let theme = DefaultTheme::default();
10198        let output = render(LeadingLabelCellFixture { theme });
10199        let label = text_runs_for(&output, "artifact.txt")
10200            .into_iter()
10201            .next()
10202            .expect("leading-label cell text should paint");
10203
10204        assert_text_run_uses_token(&label, theme.text.sm);
10205        assert_eq!(label.style.weight, FontWeight::MEDIUM);
10206        assert!(label.rect.x() >= 34.0);
10207        assert!(
10208            label.rect.max_x() <= output.frame.viewport.width + 0.75,
10209            "label should stay within the cell bounds: {:?}",
10210            label.rect
10211        );
10212        let layout = TextSystem::new()
10213            .shape_text_run(&label, &FontRegistry::new())
10214            .expect("leading-label cell text should shape");
10215        let line = layout.lines().first().expect("leading-label line present");
10216        let visual_center =
10217            label.rect.y() + line.baseline + optical_visual_center(layout.measurement());
10218        assert!(
10219            (visual_center - (output.frame.viewport.height * 0.5)).abs() < 0.75,
10220            "leading-label visual center {visual_center} did not match cell center; text rect {:?}",
10221            label.rect
10222        );
10223    }
10224
10225    struct TextCellFixture {
10226        theme: DefaultTheme,
10227    }
10228
10229    impl Widget for TextCellFixture {
10230        fn measure(
10231            &mut self,
10232            _ctx: &mut sui_runtime::MeasureCtx,
10233            constraints: Constraints,
10234        ) -> Size {
10235            constraints.clamp(Size::new(160.0, 32.0))
10236        }
10237
10238        fn paint(&self, ctx: &mut PaintCtx) {
10239            super::paint_text_cell(
10240                ctx,
10241                &self.theme,
10242                ctx.bounds(),
10243                "128",
10244                TextCellPaint::new()
10245                    .text_token(self.theme.text.xs)
10246                    .color(self.theme.palette.text_muted)
10247                    .weight(FontWeight::MEDIUM)
10248                    .padding(10.0, 18.0)
10249                    .alignment(TableColumnAlignment::End)
10250                    .numeric(),
10251            );
10252        }
10253    }
10254
10255    #[test]
10256    fn text_cell_paint_uses_alignment_numeric_token_and_clipping() {
10257        let mut theme = DefaultTheme::default();
10258        theme.text.xs = ThemeTextToken {
10259            size: 10.5,
10260            line_height: 17.5,
10261        };
10262        theme.sync_derived_fields();
10263        let output = render(TextCellFixture { theme });
10264        let run = text_runs_for(&output, "128")
10265            .into_iter()
10266            .next()
10267            .expect("text-cell text should paint");
10268        let clip = draw_clip_rects_for(&output, "128")
10269            .into_iter()
10270            .next()
10271            .expect("text-cell text should clip to padded content");
10272        let content_right = output.frame.viewport.width - 18.0;
10273
10274        assert_text_run_uses_token(&run, theme.text.xs);
10275        assert_eq!(run.style.color, theme.palette.text_muted);
10276        assert_eq!(run.style.weight, FontWeight::MEDIUM);
10277        assert!(
10278            run.style
10279                .features
10280                .iter()
10281                .any(|feature| feature.tag == FontFeature::TABULAR_FIGURES && feature.value == 1),
10282            "numeric text cells should opt into tabular figures"
10283        );
10284        assert!((run.rect.max_x() - content_right).abs() < 0.75);
10285        assert!((clip.x() - 10.0).abs() < 0.01);
10286        assert!((clip.max_x() - content_right).abs() < 0.01);
10287        let layout = TextSystem::new()
10288            .shape_text_run(&run, &FontRegistry::new())
10289            .expect("text-cell text should shape");
10290        let line = layout.lines().first().expect("text-cell line present");
10291        let visual_center =
10292            run.rect.y() + line.baseline + optical_visual_center(layout.measurement());
10293        assert!(
10294            (visual_center - (output.frame.viewport.height * 0.5)).abs() < 0.75,
10295            "text-cell visual center {visual_center} did not match cell center; text rect {:?}",
10296            run.rect
10297        );
10298    }
10299
10300    struct TextBlockFixture {
10301        theme: DefaultTheme,
10302        text: String,
10303    }
10304
10305    impl Widget for TextBlockFixture {
10306        fn measure(
10307            &mut self,
10308            _ctx: &mut sui_runtime::MeasureCtx,
10309            constraints: Constraints,
10310        ) -> Size {
10311            constraints.clamp(Size::new(178.0, 76.0))
10312        }
10313
10314        fn paint(&self, ctx: &mut PaintCtx) {
10315            super::paint_text_block(
10316                ctx,
10317                &self.theme,
10318                ctx.bounds(),
10319                &self.text,
10320                TextBlockPaint::new()
10321                    .text_token(self.theme.text.sm)
10322                    .color(self.theme.palette.text_muted)
10323                    .weight(FontWeight::MEDIUM)
10324                    .padding(Insets {
10325                        left: 12.0,
10326                        top: 7.0,
10327                        right: 16.0,
10328                        bottom: 9.0,
10329                    }),
10330            );
10331        }
10332    }
10333
10334    #[test]
10335    fn text_block_paint_wraps_top_aligns_and_clips_to_padding() {
10336        let mut theme = DefaultTheme::default();
10337        theme.text.sm = ThemeTextToken {
10338            size: 12.0,
10339            line_height: 18.0,
10340        };
10341        theme.sync_derived_fields();
10342        let text =
10343            "This preview line wraps through SUI text layout.\nSecond paragraph stays compact."
10344                .to_string();
10345        let output = render(TextBlockFixture {
10346            theme,
10347            text: text.clone(),
10348        });
10349        let (origin, layout, color) = output
10350            .frame
10351            .scene
10352            .commands()
10353            .iter()
10354            .find_map(|command| {
10355                let SceneCommand::DrawShapedText(run) = command else {
10356                    return None;
10357                };
10358                let layout = run.resolve(output.frame.text_layout_registry.as_ref())?;
10359                (layout.text() == text).then_some((run.origin, layout.clone(), run.color_override))
10360            })
10361            .expect("text block should paint as a shaped text layout");
10362        let clip = draw_clip_rects_for(&output, &text)
10363            .into_iter()
10364            .next()
10365            .expect("text block should clip to padded content");
10366
10367        assert_eq!(color, Some(theme.palette.text_muted));
10368        assert!((origin.x - 12.0).abs() < 0.01);
10369        assert!((origin.y - 7.0).abs() < 0.01);
10370        assert!((layout.box_size().width - 150.0).abs() < 0.01);
10371        assert!((layout.box_size().height - 60.0).abs() < 0.01);
10372        assert!(layout.lines().len() >= 2, "text block should wrap");
10373        assert_text_run_uses_token(
10374            &sui_text::TextRun {
10375                rect: Rect::ZERO,
10376                text,
10377                style: layout.style().clone(),
10378            },
10379            theme.text.sm,
10380        );
10381        assert_eq!(layout.style().weight, FontWeight::MEDIUM);
10382        assert!((clip.x() - 12.0).abs() < 0.01);
10383        assert!((clip.y() - 7.0).abs() < 0.01);
10384        assert!((clip.width() - 150.0).abs() < 0.01);
10385        assert!((clip.height() - 60.0).abs() < 0.01);
10386    }
10387
10388    #[test]
10389    fn list_row_text_preserves_tall_measurement_in_compact_line_box() {
10390        let mut theme = DefaultTheme::default();
10391        theme.typography.body_font_size = 28.0;
10392        theme.typography.body_line_height = 12.0;
10393        theme.metrics.list_row_height = 52.0;
10394
10395        let output = render(
10396            SizedBox::new().width(320.0).height(72.0).with_child(
10397                ListView::new("Assets")
10398                    .theme(theme)
10399                    .item(ListItem::new("Glass")),
10400            ),
10401        );
10402        let run = text_runs_for(&output, "Glass")
10403            .into_iter()
10404            .next()
10405            .expect("list row label draw command present");
10406        let layout = TextSystem::new()
10407            .shape_text_run(&run, &FontRegistry::new())
10408            .expect("list row label should shape");
10409        let row_center =
10410            theme.metrics.data_viewport_padding.top + theme.metrics.list_row_height * 0.5;
10411
10412        assert!(
10413            run.rect.height() >= layout.measurement().height - 0.01,
10414            "list row text rect should preserve measured glyph height: rect={:?}, measurement={:?}",
10415            run.rect,
10416            layout.measurement()
10417        );
10418        assert!(
10419            run.rect.height() > run.style.line_height,
10420            "test theme should exercise measured-height preservation"
10421        );
10422        assert!(
10423            (text_run_visual_center(&run) - row_center).abs() < 0.75,
10424            "list row label visual center should remain row-centered"
10425        );
10426    }
10427
10428    #[test]
10429    fn list_row_leading_and_trailing_text_align_to_row_center_and_edge() {
10430        let theme = DefaultTheme::default();
10431        let output = render(
10432            SizedBox::new().width(260.0).with_child(
10433                ListView::new("Assets").item(
10434                    ListItem::new("Hero texture")
10435                        .leading_text("A")
10436                        .trailing("42"),
10437                ),
10438            ),
10439        );
10440        let leading = text_runs_for(&output, "A")
10441            .into_iter()
10442            .next()
10443            .expect("leading text draw command present");
10444        let trailing = text_runs_for(&output, "42")
10445            .into_iter()
10446            .next()
10447            .expect("trailing text draw command present");
10448        let text_system = TextSystem::new();
10449        let leading_layout = text_system
10450            .shape_text_run(&leading, &FontRegistry::new())
10451            .expect("leading text should shape");
10452        let trailing_layout = text_system
10453            .shape_text_run(&trailing, &FontRegistry::new())
10454            .expect("trailing text should shape");
10455        let leading_line = leading_layout
10456            .lines()
10457            .first()
10458            .expect("leading line present");
10459        let trailing_line = trailing_layout
10460            .lines()
10461            .first()
10462            .expect("trailing line present");
10463        let leading_visual_center = leading.rect.y()
10464            + leading_line.baseline
10465            + optical_visual_center(leading_layout.measurement());
10466        let trailing_visual_center = trailing.rect.y()
10467            + trailing_line.baseline
10468            + optical_visual_center(trailing_layout.measurement());
10469        let row_center = output.frame.viewport.height * 0.5;
10470        let trailing_edge = output.frame.viewport.width
10471            - theme.metrics.data_viewport_padding.right
10472            - theme.metrics.data_row_padding.right;
10473
10474        assert!((leading_visual_center - row_center).abs() < 0.75);
10475        assert!((trailing_visual_center - row_center).abs() < 0.75);
10476        assert!(
10477            (trailing.rect.max_x() - trailing_edge).abs() < 0.75,
10478            "trailing text max_x {} did not align to content edge {trailing_edge}",
10479            trailing.rect.max_x()
10480        );
10481    }
10482
10483    #[test]
10484    fn list_row_leading_and_trailing_text_preserve_tall_measurements() {
10485        let mut theme = DefaultTheme::default();
10486        theme.typography.body_font_size = 28.0;
10487        theme.typography.body_line_height = 12.0;
10488        theme.text.xs = ThemeTextToken {
10489            size: 26.0,
10490            line_height: 10.0,
10491        };
10492        theme.metrics.list_row_height = 64.0;
10493
10494        let output = render(
10495            SizedBox::new().width(320.0).height(88.0).with_child(
10496                ListView::new("Assets").theme(theme).item(
10497                    ListItem::new("Hero texture")
10498                        .leading_text("A")
10499                        .trailing("42"),
10500                ),
10501            ),
10502        );
10503        let row = output
10504            .semantics
10505            .iter()
10506            .find(|node| node.role == SemanticsRole::ListItem)
10507            .expect("list row semantics present")
10508            .bounds;
10509        let leading = text_runs_for(&output, "A")
10510            .into_iter()
10511            .next()
10512            .expect("leading text draw command present");
10513        let trailing = text_runs_for(&output, "42")
10514            .into_iter()
10515            .next()
10516            .expect("trailing text draw command present");
10517        let leading_layout = TextSystem::new()
10518            .shape_text_run(&leading, &FontRegistry::new())
10519            .expect("leading text should shape");
10520        let trailing_layout = TextSystem::new()
10521            .shape_text_run(&trailing, &FontRegistry::new())
10522            .expect("trailing text should shape");
10523        let trailing_clip = draw_clip_rects_for(&output, "42")
10524            .into_iter()
10525            .next()
10526            .expect("trailing text should be clipped to reserved slot");
10527        let row_center = row.y() + (row.height() * 0.5);
10528        let trailing_edge = row.max_x() - theme.metrics.data_row_padding.right;
10529
10530        assert_eq!(leading.style.font_size, 28.0);
10531        assert_eq!(leading.style.line_height, 12.0);
10532        assert_text_run_uses_token(&trailing, theme.text.xs);
10533        assert!(leading.rect.height() >= leading_layout.measurement().height - 0.01);
10534        assert!(trailing.rect.height() >= trailing_layout.measurement().height - 0.01);
10535        assert!(leading.rect.height() > leading.style.line_height);
10536        assert!(trailing.rect.height() > trailing.style.line_height);
10537        assert!((text_run_visual_center(&leading) - row_center).abs() < 0.75);
10538        assert!((text_run_visual_center(&trailing) - row_center).abs() < 0.75);
10539        assert!((trailing.rect.max_x() - trailing_edge).abs() < 0.75);
10540        assert!((trailing_clip.max_x() - trailing_edge).abs() < 0.75);
10541    }
10542
10543    #[test]
10544    fn selected_list_row_trailing_text_preserves_caption_metrics() {
10545        let mut theme = DefaultTheme::default();
10546        theme.text.xs = ThemeTextToken {
10547            size: 10.5,
10548            line_height: 17.5,
10549        };
10550        theme.sync_derived_fields();
10551        let output = render(
10552            SizedBox::new().width(260.0).with_child(
10553                ListView::new("Assets")
10554                    .theme(theme)
10555                    .selected(0)
10556                    .item(ListItem::new("Hero texture").trailing("42")),
10557            ),
10558        );
10559        let trailing = text_runs_for(&output, "42")
10560            .into_iter()
10561            .next()
10562            .expect("selected trailing text draw command present");
10563        let trailing_layout = TextSystem::new()
10564            .shape_text_run(&trailing, &FontRegistry::new())
10565            .expect("selected trailing text should shape");
10566        let trailing_line = trailing_layout
10567            .lines()
10568            .first()
10569            .expect("selected trailing line present");
10570        let trailing_visual_center = trailing.rect.y()
10571            + trailing_line.baseline
10572            + optical_visual_center(trailing_layout.measurement());
10573        let row_center = output.frame.viewport.height * 0.5;
10574        let trailing_edge = output.frame.viewport.width
10575            - theme.metrics.data_viewport_padding.right
10576            - theme.metrics.data_row_padding.right;
10577
10578        assert_text_run_uses_token(&trailing, theme.text.xs);
10579        assert_eq!(trailing.style.color, theme.palette.placeholder);
10580        assert!((trailing_visual_center - row_center).abs() < 0.75);
10581        assert!(
10582            (trailing.rect.max_x() - trailing_edge).abs() < 0.75,
10583            "selected trailing text max_x {} did not align to content edge {trailing_edge}",
10584            trailing.rect.max_x()
10585        );
10586    }
10587}