Skip to main content

sui_widgets/
data.rs

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