Skip to main content

sui_widgets/
controls.rs

1use crate::{
2    Blink, ControlMetrics, DefaultTheme, HdrThemeMode, Interpolate, MotionScalar,
3    ResolvedEffectStyle, ResolvedHdrStyle, SemanticTone, ThemeColorScheme, WidgetColorRole,
4    WidgetLuminanceRole, WidgetMaterialRole,
5    editor::{EditorCommand, EditorCommandResult, EditorState, selection_range},
6    overlay::{OverlayPlacement, OverlayPlacementRequest, place_overlay},
7    paint_theme_shadow, resolve_luminance_role, resolve_widget_hdr_style,
8    selection::{SelectionChange, SelectionOwnerId, SelectionScope},
9    text_align::{
10        HorizontalTextAlignmentMode, aligned_text_rect_for_layout,
11        aligned_text_rect_for_layout_with_mode, aligned_text_rect_for_text, paint_aligned_text,
12        paint_single_line_aligned_text,
13    },
14    text_command::TextCommand,
15    text_surface::paste_command,
16};
17use std::{cell::RefCell, ops::Range, rc::Rc, sync::Arc};
18use sui_core::{
19    Color, EditableTextSemantics, Event, ImeEvent, InvalidationKind, InvalidationRequest,
20    InvalidationTarget, KeyState, Path, PathBuilder, Point, PointerButton, PointerEventKind, Rect,
21    SemanticsAction, SemanticsActionRequest, SemanticsNode, SemanticsPopupKind, SemanticsRole,
22    SemanticsTextRange, SemanticsValue, Size, TimerToken, ToggleState, Vector, WakeEvent, WidgetId,
23};
24use sui_layout::{Axis, Constraints, IntrinsicSize, Padding as Insets};
25use sui_lucide::LucideIcon;
26use sui_reactive::Observable;
27use sui_runtime::{
28    ArrangeCtx, Command, EventCtx, EventPhase, LayerOptions, MeasureCtx, OVERLAY_DISMISS_REQUEST,
29    OverlayDismissPolicy, OverlayFocusBehavior, OverlayKind, OverlayOptions, PaintBoundaryMode,
30    PaintCtx, SemanticsCtx, SingleChild, StackSurfaceOptions, Widget, WidgetPodMutVisitor,
31    WidgetPodVisitor,
32};
33use sui_scene::{LayerCompositionMode, LayerProperties, StrokeStyle};
34use sui_text::{
35    FontFeature, PersistentTextLayout, TextCursor, TextMeasurement, TextSelection, TextStyle,
36};
37use unicode_segmentation::UnicodeSegmentation;
38
39#[derive(Debug, Clone, Copy, PartialEq, Eq)]
40pub enum IconGlyph {
41    Add,
42    Remove,
43    Check,
44    ChevronDown,
45    ChevronUp,
46    ChevronLeft,
47    ChevronRight,
48    Close,
49    Maximize,
50    Restore,
51    FitView,
52    ActualSize,
53    MoreHorizontal,
54    MoreVertical,
55    Search,
56    Undo,
57    Redo,
58    Brush,
59    Eraser,
60    PaintBucket,
61    Hand,
62    Lock,
63    Unlock,
64    Trash,
65    Download,
66    // Content/object glyphs (used by application chrome: chat, file browser, etc.).
67    Sparkles,
68    Chat,
69    History,
70    Folder,
71    File,
72    FileText,
73    Link,
74    Send,
75    ArrowUp,
76    Stop,
77    Attach,
78    Hourglass,
79    Alert,
80    Storage,
81    // Media/device glyphs for realtime call and device surfaces.
82    AudioLines,
83    Mic,
84    MicOff,
85    Camera,
86    CameraOff,
87    Video,
88    VideoOff,
89    Phone,
90    PhoneOff,
91    Monitor,
92    ScreenShare,
93}
94
95impl IconGlyph {
96    pub const fn lucide_icon(self) -> LucideIcon {
97        match self {
98            Self::Add => LucideIcon::Plus,
99            Self::Remove => LucideIcon::Minus,
100            Self::Check => LucideIcon::Check,
101            Self::ChevronDown => LucideIcon::ChevronDown,
102            Self::ChevronUp => LucideIcon::ChevronUp,
103            Self::ChevronLeft => LucideIcon::ChevronLeft,
104            Self::ChevronRight => LucideIcon::ChevronRight,
105            Self::Close => LucideIcon::X,
106            Self::Maximize => LucideIcon::Maximize,
107            Self::Restore => LucideIcon::Copy,
108            Self::FitView => LucideIcon::ScanSearch,
109            Self::ActualSize => LucideIcon::Scan,
110            Self::MoreHorizontal => LucideIcon::Ellipsis,
111            Self::MoreVertical => LucideIcon::EllipsisVertical,
112            Self::Search => LucideIcon::Search,
113            Self::Undo => LucideIcon::Undo2,
114            Self::Redo => LucideIcon::Redo2,
115            Self::Brush => LucideIcon::Brush,
116            Self::Eraser => LucideIcon::Eraser,
117            Self::PaintBucket => LucideIcon::PaintBucket,
118            Self::Hand => LucideIcon::Hand,
119            Self::Lock => LucideIcon::Lock,
120            Self::Unlock => LucideIcon::LockOpen,
121            Self::Trash => LucideIcon::Trash2,
122            Self::Download => LucideIcon::Download,
123            Self::Sparkles => LucideIcon::Sparkles,
124            Self::Chat => LucideIcon::MessageSquare,
125            Self::History => LucideIcon::History,
126            Self::Folder => LucideIcon::Folder,
127            Self::File => LucideIcon::File,
128            Self::FileText => LucideIcon::FileText,
129            Self::Link => LucideIcon::Link,
130            Self::Send => LucideIcon::Send,
131            Self::ArrowUp => LucideIcon::ArrowUp,
132            Self::Stop => LucideIcon::Square,
133            Self::Attach => LucideIcon::Paperclip,
134            Self::Hourglass => LucideIcon::Hourglass,
135            Self::Alert => LucideIcon::TriangleAlert,
136            Self::Storage => LucideIcon::HardDrive,
137            Self::AudioLines => LucideIcon::AudioLines,
138            Self::Mic => LucideIcon::Mic,
139            Self::MicOff => LucideIcon::MicOff,
140            Self::Camera => LucideIcon::Camera,
141            Self::CameraOff => LucideIcon::CameraOff,
142            Self::Video => LucideIcon::Video,
143            Self::VideoOff => LucideIcon::VideoOff,
144            Self::Phone => LucideIcon::Phone,
145            Self::PhoneOff => LucideIcon::PhoneOff,
146            Self::Monitor => LucideIcon::Monitor,
147            Self::ScreenShare => LucideIcon::ScreenShare,
148        }
149    }
150}
151
152pub const BUILTIN_ICON_GLYPHS: &[IconGlyph] = &[
153    IconGlyph::Add,
154    IconGlyph::Remove,
155    IconGlyph::Check,
156    IconGlyph::ChevronDown,
157    IconGlyph::ChevronUp,
158    IconGlyph::ChevronLeft,
159    IconGlyph::ChevronRight,
160    IconGlyph::Close,
161    IconGlyph::Maximize,
162    IconGlyph::Restore,
163    IconGlyph::FitView,
164    IconGlyph::ActualSize,
165    IconGlyph::MoreHorizontal,
166    IconGlyph::MoreVertical,
167    IconGlyph::Search,
168    IconGlyph::Undo,
169    IconGlyph::Redo,
170    IconGlyph::Brush,
171    IconGlyph::Eraser,
172    IconGlyph::PaintBucket,
173    IconGlyph::Hand,
174    IconGlyph::Lock,
175    IconGlyph::Unlock,
176    IconGlyph::Trash,
177    IconGlyph::Download,
178    IconGlyph::Sparkles,
179    IconGlyph::Chat,
180    IconGlyph::History,
181    IconGlyph::Folder,
182    IconGlyph::File,
183    IconGlyph::FileText,
184    IconGlyph::Link,
185    IconGlyph::Send,
186    IconGlyph::ArrowUp,
187    IconGlyph::Stop,
188    IconGlyph::Attach,
189    IconGlyph::Hourglass,
190    IconGlyph::Alert,
191    IconGlyph::Storage,
192    IconGlyph::AudioLines,
193    IconGlyph::Mic,
194    IconGlyph::MicOff,
195    IconGlyph::Camera,
196    IconGlyph::CameraOff,
197    IconGlyph::Video,
198    IconGlyph::VideoOff,
199    IconGlyph::Phone,
200    IconGlyph::PhoneOff,
201    IconGlyph::Monitor,
202    IconGlyph::ScreenShare,
203];
204
205pub fn register_builtin_icon_resources(
206    _application: &mut sui_runtime::Application,
207) -> sui_core::Result<()> {
208    // Built-in widgets paint Lucide geometry directly. Keep this compatibility hook so
209    // applications do not need to change their startup path.
210    Ok(())
211}
212
213pub struct Separator {
214    theme: Box<DefaultTheme>,
215    theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
216    axis: Axis,
217    name: Option<String>,
218    inset: f32,
219    thickness: Option<f32>,
220    length: Option<f32>,
221}
222
223impl Separator {
224    pub fn new(axis: Axis) -> Self {
225        Self {
226            theme: Box::new(DefaultTheme::default()),
227            theme_reader: None,
228            axis,
229            name: None,
230            inset: 0.0,
231            thickness: None,
232            length: None,
233        }
234    }
235
236    pub fn horizontal() -> Self {
237        Self::new(Axis::Horizontal)
238    }
239
240    pub fn vertical() -> Self {
241        Self::new(Axis::Vertical)
242    }
243
244    pub fn theme(mut self, theme: DefaultTheme) -> Self {
245        self.theme = Box::new(theme);
246        self.theme_reader = None;
247        self
248    }
249
250    pub fn theme_when<F>(mut self, theme: F) -> Self
251    where
252        F: Fn() -> DefaultTheme + 'static,
253    {
254        self.theme_reader = Some(Box::new(theme));
255        self
256    }
257
258    pub fn name(mut self, name: impl Into<String>) -> Self {
259        self.name = Some(name.into());
260        self
261    }
262
263    pub fn inset(mut self, inset: f32) -> Self {
264        self.inset = inset.max(0.0);
265        self
266    }
267
268    pub fn thickness(mut self, thickness: f32) -> Self {
269        self.thickness = Some(thickness.max(0.0));
270        self
271    }
272
273    pub fn length(mut self, length: f32) -> Self {
274        self.length = Some(length.max(0.0));
275        self
276    }
277
278    fn resolved_thickness(&self) -> f32 {
279        self.thickness
280            .unwrap_or(self.resolved_theme().metrics.separator_thickness)
281            .max(1.0)
282    }
283
284    fn resolved_theme(&self) -> DefaultTheme {
285        self.theme_reader
286            .as_ref()
287            .map(|reader| reader())
288            .unwrap_or_else(|| *self.theme)
289    }
290}
291
292impl Widget for Separator {
293    fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
294        let thickness = self.resolved_thickness();
295        let length = self.length.unwrap_or(64.0);
296        let size = match self.axis {
297            Axis::Horizontal => Size::new(length, thickness + (self.inset * 2.0)),
298            Axis::Vertical => Size::new(thickness + (self.inset * 2.0), length),
299        };
300
301        constraints.clamp(Size::new(
302            if self.axis == Axis::Horizontal && constraints.max.width.is_finite() {
303                constraints.max.width
304            } else {
305                size.width
306            },
307            if self.axis == Axis::Vertical && constraints.max.height.is_finite() {
308                constraints.max.height
309            } else {
310                size.height
311            },
312        ))
313    }
314
315    fn paint(&self, ctx: &mut PaintCtx) {
316        let theme = self.resolved_theme();
317        let thickness = physical_pixels(ctx, self.resolved_thickness());
318        let line = match self.axis {
319            Axis::Horizontal => Rect::new(
320                ctx.bounds().x() + self.inset,
321                ctx.bounds().y() + ((ctx.bounds().height() - thickness) * 0.5),
322                (ctx.bounds().width() - (self.inset * 2.0)).max(0.0),
323                thickness,
324            ),
325            Axis::Vertical => Rect::new(
326                ctx.bounds().x() + ((ctx.bounds().width() - thickness) * 0.5),
327                ctx.bounds().y() + self.inset,
328                thickness,
329                (ctx.bounds().height() - (self.inset * 2.0)).max(0.0),
330            ),
331        };
332        ctx.fill(
333            rounded_rect_path(line, thickness * 0.5),
334            theme.palette.border,
335        );
336    }
337
338    fn semantics(&self, ctx: &mut SemanticsCtx) {
339        let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::Separator, ctx.bounds());
340        node.name = self.name.clone();
341        ctx.push(node);
342    }
343}
344
345pub struct Icon {
346    theme: Box<DefaultTheme>,
347    glyph: IconGlyph,
348    size: Option<f32>,
349    color: Option<Color>,
350    color_reader: Option<Box<dyn Fn() -> Color>>,
351    label: Option<String>,
352}
353
354impl Icon {
355    pub fn new(glyph: IconGlyph) -> Self {
356        Self {
357            theme: Box::new(DefaultTheme::default()),
358            glyph,
359            size: None,
360            color: None,
361            color_reader: None,
362            label: None,
363        }
364    }
365
366    pub fn theme(mut self, theme: DefaultTheme) -> Self {
367        self.theme = Box::new(theme);
368        self
369    }
370
371    pub fn size(mut self, size: f32) -> Self {
372        self.size = Some(size.max(0.0));
373        self
374    }
375
376    pub fn color(mut self, color: Color) -> Self {
377        self.color = Some(color);
378        self.color_reader = None;
379        self
380    }
381
382    pub fn color_when<F>(mut self, color: F) -> Self
383    where
384        F: Fn() -> Color + 'static,
385    {
386        self.color_reader = Some(Box::new(color));
387        self
388    }
389
390    pub fn label(mut self, label: impl Into<String>) -> Self {
391        self.label = Some(label.into());
392        self
393    }
394
395    fn resolved_color(&self) -> Color {
396        self.color_reader
397            .as_ref()
398            .map(|reader| reader())
399            .or(self.color)
400            .unwrap_or(self.theme.palette.text)
401    }
402
403    fn resolved_size(&self) -> f32 {
404        self.size.unwrap_or(self.theme.metrics.icon_size)
405    }
406}
407
408impl Widget for Icon {
409    fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
410        let side = self.resolved_size();
411        constraints.clamp(Size::new(side, side))
412    }
413
414    fn paint(&self, ctx: &mut PaintCtx) {
415        draw_icon_glyph(
416            ctx,
417            self.glyph,
418            center_square(ctx.bounds(), self.resolved_size()),
419            self.resolved_color(),
420        );
421    }
422
423    fn semantics(&self, ctx: &mut SemanticsCtx) {
424        if let Some(label) = &self.label {
425            let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::Image, ctx.bounds());
426            node.name = Some(label.clone());
427            ctx.push(node);
428        }
429    }
430}
431
432const CARET_BLINK_PERIOD_SECONDS: f64 = 1.0;
433const SELECT_CHEVRON_SLOT_WIDTH: f32 = 28.0;
434const SELECT_CHEVRON_ICON_SIZE: f32 = 20.0;
435#[cfg(test)]
436const SELECT_MENU_GAP: f32 = 6.0;
437
438#[derive(Debug, Clone, Copy, PartialEq, Eq)]
439enum SelectMenuPlacement {
440    Below,
441    Above,
442}
443
444type AnimatedScalar = MotionScalar;
445
446fn request_child_invalidation(ctx: &mut EventCtx, widget_id: WidgetId, kind: InvalidationKind) {
447    ctx.request(InvalidationRequest::new(
448        InvalidationTarget::Widget(widget_id),
449        kind,
450    ));
451}
452
453fn set_animation_target(
454    animation: &mut AnimatedScalar,
455    target: f32,
456    duration: f64,
457    easing: crate::Easing,
458    ctx: &mut EventCtx,
459) {
460    animation.set_target_event(target, duration, easing, ctx);
461}
462
463fn set_hover_animation_target(
464    animation: &mut AnimatedScalar,
465    target: f32,
466    theme: &DefaultTheme,
467    ctx: &mut EventCtx,
468) {
469    set_animation_target(
470        animation,
471        target,
472        theme.motion.hover_duration(),
473        theme.motion.hover_easing(),
474        ctx,
475    );
476}
477
478fn set_press_animation_target(
479    animation: &mut AnimatedScalar,
480    target: f32,
481    theme: &DefaultTheme,
482    ctx: &mut EventCtx,
483) {
484    set_animation_target(
485        animation,
486        target,
487        theme.motion.press_duration(),
488        theme.motion.press_easing(),
489        ctx,
490    );
491}
492
493fn set_toggle_animation_target(
494    animation: &mut AnimatedScalar,
495    target: f32,
496    theme: &DefaultTheme,
497    ctx: &mut EventCtx,
498) {
499    set_animation_target(
500        animation,
501        target,
502        theme.motion.toggle_duration(),
503        theme.motion.toggle_easing(),
504        ctx,
505    );
506}
507
508fn set_focus_animation_target(
509    animation: &mut AnimatedScalar,
510    target: f32,
511    theme: &DefaultTheme,
512    ctx: &mut EventCtx,
513) {
514    set_animation_target(
515        animation,
516        target,
517        theme.motion.focus_duration(),
518        theme.motion.focus_easing(),
519        ctx,
520    );
521}
522
523fn mix_color(from: Color, to: Color, t: f32) -> Color {
524    Color::interpolate(from, to, t)
525}
526
527/// The visual treatment used by pressable controls.
528///
529/// Appearance and semantic tone are deliberately independent: a destructive
530/// action can be rendered as a filled, tonal, outlined, or low-emphasis ghost
531/// control without remapping the application's theme palette.
532#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
533pub enum ButtonAppearance {
534    /// A solid semantic-color fill for primary and high-emphasis actions.
535    Filled,
536    /// A soft semantic-color wash with semantic ink.
537    #[default]
538    Tonal,
539    /// A transparent surface with a visible semantic outline.
540    Outline,
541    /// A borderless, transparent surface that reveals a wash on interaction.
542    Ghost,
543}
544
545/// Whether an editor paints its own field chrome.
546#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
547pub enum FieldAppearance {
548    /// Paint the standard field background, border, hover, and focus ring.
549    #[default]
550    Framed,
551    /// Paint only editor content. Intended for use inside [`crate::FramedField`].
552    Bare,
553}
554
555/// The whole-row visual treatment used by checkbox, switch, and radio controls.
556///
557/// This affects only the row surrounding the label and indicator. The checkbox,
558/// switch track, or radio indicator always keeps its own stateful chrome.
559#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
560pub enum ChoiceAppearance {
561    /// A quiet row that is transparent at rest and reveals a soft wash while
562    /// hovered, pressed, or focused.
563    #[default]
564    Plain,
565    /// A filled, bordered row suitable for inspectors and dense settings panes.
566    Framed,
567}
568
569#[derive(Clone, Copy, Debug, PartialEq)]
570struct ChoiceFrameVisuals {
571    background: Color,
572    border: Color,
573}
574
575fn choice_frame_visuals(
576    theme: &DefaultTheme,
577    appearance: ChoiceAppearance,
578    framed_background: Color,
579    framed_border: Color,
580    hover_progress: f32,
581    press_progress: f32,
582    focus_progress: f32,
583) -> ChoiceFrameVisuals {
584    if appearance == ChoiceAppearance::Framed {
585        return ChoiceFrameVisuals {
586            background: framed_background,
587            border: framed_border,
588        };
589    }
590
591    let hover_wash = theme.surfaces.hover;
592    let press_wash = theme
593        .palette
594        .text
595        .with_alpha(if theme.surfaces.dark { 0.10 } else { 0.07 });
596    let focus_wash = theme
597        .palette
598        .accent
599        .with_alpha(if theme.surfaces.dark { 0.12 } else { 0.08 });
600    let background = mix_color(
601        mix_color(
602            mix_color(
603                Color::TRANSPARENT,
604                hover_wash,
605                hover_progress.clamp(0.0, 1.0),
606            ),
607            focus_wash,
608            focus_progress.clamp(0.0, 1.0),
609        ),
610        press_wash,
611        press_progress.clamp(0.0, 1.0),
612    );
613
614    ChoiceFrameVisuals {
615        background,
616        border: Color::TRANSPARENT,
617    }
618}
619
620fn field_background(
621    theme: &DefaultTheme,
622    read_only: bool,
623    hover_progress: f32,
624    focus_progress: f32,
625) -> Color {
626    let palette = theme.palette;
627    let base = if read_only {
628        palette.surface
629    } else {
630        palette.field
631    };
632    let hover_target = if !read_only && theme.colors.scheme == ThemeColorScheme::Light {
633        palette.surface
634    } else {
635        base
636    };
637    let hovered = mix_color(
638        base,
639        hover_target,
640        hover_progress.clamp(0.0, 1.0) * theme.interaction.hover_blend,
641    );
642    mix_color(
643        hovered,
644        palette.surface_focus,
645        focus_progress.clamp(0.0, 1.0),
646    )
647}
648
649#[derive(Clone, Copy, Debug, PartialEq)]
650struct SemanticButtonVisuals {
651    background: Color,
652    border: Color,
653    content: Color,
654}
655
656fn semantic_button_visuals(
657    theme: &DefaultTheme,
658    appearance: ButtonAppearance,
659    tone: SemanticTone,
660    enabled: bool,
661    hover_progress: f32,
662    press_progress: f32,
663) -> SemanticButtonVisuals {
664    let palette = theme.palette;
665    let interaction = theme.interaction;
666    let hover = if enabled {
667        hover_progress.clamp(0.0, 1.0) * interaction.hover_blend
668    } else {
669        0.0
670    };
671    let press = if enabled {
672        press_progress.clamp(0.0, 1.0) * interaction.pressed_blend
673    } else {
674        0.0
675    };
676    let (solid, solid_text) = theme.semantic_tone_colors(tone);
677    let (soft, soft_text) = theme.semantic_tone_soft_colors(tone);
678    let ink = if tone == SemanticTone::Neutral {
679        palette.text
680    } else {
681        solid
682    };
683    let outline = if tone == SemanticTone::Neutral {
684        palette.border
685    } else {
686        solid.with_alpha(0.72)
687    };
688
689    let (base, hovered, pressed, border, content) = match appearance {
690        ButtonAppearance::Filled => {
691            let hovered = if tone == SemanticTone::Accent {
692                palette.accent_hover
693            } else {
694                mix_color(solid, solid_text, 0.10)
695            };
696            let pressed = if tone == SemanticTone::Accent {
697                palette.accent_pressed
698            } else {
699                mix_color(solid, palette.text, 0.16)
700            };
701            (solid, hovered, pressed, solid, solid_text)
702        }
703        ButtonAppearance::Tonal => (
704            soft,
705            mix_color(soft, solid, 0.12),
706            mix_color(soft, solid, 0.24),
707            if tone == SemanticTone::Neutral {
708                palette.border
709            } else {
710                solid.with_alpha(0.30)
711            },
712            soft_text,
713        ),
714        ButtonAppearance::Outline => (
715            Color::TRANSPARENT,
716            soft,
717            mix_color(soft, solid, 0.16),
718            outline,
719            ink,
720        ),
721        ButtonAppearance::Ghost => (
722            Color::TRANSPARENT,
723            soft,
724            mix_color(soft, solid, 0.16),
725            Color::TRANSPARENT,
726            ink,
727        ),
728    };
729    let background = mix_color(mix_color(base, hovered, hover), pressed, press);
730
731    if enabled {
732        SemanticButtonVisuals {
733            background,
734            border,
735            content,
736        }
737    } else {
738        let background = if matches!(
739            appearance,
740            ButtonAppearance::Outline | ButtonAppearance::Ghost
741        ) {
742            Color::TRANSPARENT
743        } else {
744            mix_color(background, palette.control, 0.72).with_alpha(interaction.disabled_opacity)
745        };
746        SemanticButtonVisuals {
747            background,
748            border: border.with_alpha(interaction.disabled_content_opacity),
749            content: palette
750                .text_muted
751                .with_alpha(interaction.disabled_content_opacity),
752        }
753    }
754}
755
756#[derive(Clone, Copy, Debug, PartialEq)]
757pub struct IconButtonPaint {
758    pub appearance: ButtonAppearance,
759    pub tone: SemanticTone,
760    pub selected: bool,
761    pub enabled: bool,
762    pub hover_progress: f32,
763    pub press_progress: f32,
764    pub focus_progress: f32,
765    pub icon_size: Option<f32>,
766}
767
768impl IconButtonPaint {
769    pub const fn new() -> Self {
770        Self {
771            appearance: ButtonAppearance::Tonal,
772            tone: SemanticTone::Neutral,
773            selected: false,
774            enabled: true,
775            hover_progress: 0.0,
776            press_progress: 0.0,
777            focus_progress: 0.0,
778            icon_size: None,
779        }
780    }
781
782    pub const fn appearance(mut self, appearance: ButtonAppearance) -> Self {
783        self.appearance = appearance;
784        self
785    }
786
787    pub const fn tone(mut self, tone: SemanticTone) -> Self {
788        self.tone = tone;
789        self
790    }
791
792    pub const fn selected(mut self, selected: bool) -> Self {
793        self.selected = selected;
794        self
795    }
796
797    pub const fn enabled(mut self, enabled: bool) -> Self {
798        self.enabled = enabled;
799        self
800    }
801
802    pub const fn hovered(mut self, hovered: bool) -> Self {
803        self.hover_progress = if hovered { 1.0 } else { 0.0 };
804        self
805    }
806
807    pub const fn pressed(mut self, pressed: bool) -> Self {
808        self.press_progress = if pressed { 1.0 } else { 0.0 };
809        self
810    }
811
812    pub const fn focused(mut self, focused: bool) -> Self {
813        self.focus_progress = if focused { 1.0 } else { 0.0 };
814        self
815    }
816
817    pub fn hover_progress(mut self, progress: f32) -> Self {
818        self.hover_progress = progress;
819        self
820    }
821
822    pub fn press_progress(mut self, progress: f32) -> Self {
823        self.press_progress = progress;
824        self
825    }
826
827    pub fn focus_progress(mut self, progress: f32) -> Self {
828        self.focus_progress = progress;
829        self
830    }
831
832    pub const fn icon_size(mut self, icon_size: f32) -> Self {
833        self.icon_size = Some(icon_size);
834        self
835    }
836}
837
838impl Default for IconButtonPaint {
839    fn default() -> Self {
840        Self::new()
841    }
842}
843
844pub fn paint_icon_button(
845    ctx: &mut PaintCtx,
846    theme: &DefaultTheme,
847    rect: Rect,
848    icon: IconGlyph,
849    style: IconButtonPaint,
850) {
851    if rect.width() <= 0.0 || rect.height() <= 0.0 {
852        return;
853    }
854
855    let palette = theme.palette;
856    let metrics = theme.metrics;
857    let interaction = theme.interaction;
858    let selected = style.selected;
859    let enabled = style.enabled;
860    let hover_progress = if enabled {
861        style.hover_progress.clamp(0.0, 1.0) * interaction.hover_blend
862    } else {
863        0.0
864    };
865    let press_progress = if enabled {
866        style.press_progress.clamp(0.0, 1.0) * interaction.pressed_blend
867    } else {
868        0.0
869    };
870    let focus_progress = if enabled {
871        style.focus_progress.clamp(0.0, 1.0)
872    } else {
873        0.0
874    };
875    let legacy_default =
876        style.appearance == ButtonAppearance::Tonal && style.tone == SemanticTone::Neutral;
877    let (background, border, icon_color) = if legacy_default {
878        let base_background = if selected {
879            mix_color(palette.control, palette.accent, interaction.selected_blend)
880        } else {
881            palette.control
882        };
883        let hover_background = if selected {
884            mix_color(base_background, palette.accent_hover, 0.18)
885        } else {
886            palette.control_hover
887        };
888        let press_background = if selected {
889            mix_color(base_background, palette.control_active, 0.45)
890        } else {
891            palette.control_active
892        };
893        let background = mix_color(
894            mix_color(base_background, hover_background, hover_progress),
895            press_background,
896            press_progress,
897        );
898        let border_base = if !enabled {
899            palette.border.with_alpha(0.55)
900        } else if selected {
901            mix_color(palette.accent_border, palette.border_hover, hover_progress)
902        } else {
903            mix_color(palette.border, palette.border_hover, hover_progress)
904        };
905        let border = if enabled {
906            mix_color(border_base, palette.border_focus, focus_progress)
907        } else {
908            border_base
909        };
910        let background = if enabled {
911            background
912        } else {
913            mix_color(background, palette.control, 0.72).with_alpha(interaction.disabled_opacity)
914        };
915        let icon_color = if !enabled {
916            palette
917                .text
918                .with_alpha(interaction.disabled_content_opacity)
919        } else if selected {
920            palette.accent
921        } else {
922            palette.text
923        };
924        (background, border, icon_color)
925    } else {
926        let mut visuals = semantic_button_visuals(
927            theme,
928            style.appearance,
929            style.tone,
930            enabled,
931            style.hover_progress,
932            style.press_progress,
933        );
934        if selected && enabled {
935            let selection = if style.tone == SemanticTone::Neutral {
936                palette.accent
937            } else {
938                theme.semantic_tone_color(style.tone)
939            };
940            visuals.background =
941                mix_color(visuals.background, selection, interaction.selected_blend);
942            visuals.border = mix_color(visuals.border, selection, 0.72);
943            visuals.content = selection;
944        }
945        visuals.border = if enabled {
946            mix_color(visuals.border, palette.border_focus, focus_progress)
947        } else {
948            visuals.border
949        };
950        (visuals.background, visuals.border, visuals.content)
951    };
952    let icon_size = style
953        .icon_size
954        .unwrap_or(metrics.icon_size)
955        .min(rect.width().min(rect.height()))
956        .max(0.0);
957
958    draw_control_frame(
959        ctx,
960        rect,
961        metrics.corner_radius,
962        metrics,
963        background,
964        border,
965        (focus_progress > 0.0).then_some(
966            palette
967                .focus_ring
968                .with_alpha(palette.focus_ring.alpha * focus_progress),
969        ),
970    );
971    draw_icon_glyph(ctx, icon, center_square(rect, icon_size), icon_color);
972}
973
974pub struct IconButton {
975    theme: Box<DefaultTheme>,
976    theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
977    icon: IconGlyph,
978    label: String,
979    semantic_description: Option<String>,
980    appearance: ButtonAppearance,
981    tone: SemanticTone,
982    size: Option<f32>,
983    icon_size: Option<f32>,
984    selected: bool,
985    selected_reader: Option<Box<dyn Fn() -> bool>>,
986    enabled: bool,
987    enabled_reader: Option<Box<dyn Fn() -> bool>>,
988    hovered: bool,
989    pressed: bool,
990    hover_animation: AnimatedScalar,
991    press_animation: AnimatedScalar,
992    focus_animation: AnimatedScalar,
993    on_press: Option<Box<dyn FnMut()>>,
994    on_press_with_ctx: Option<Box<dyn FnMut(&mut EventCtx)>>,
995}
996
997impl IconButton {
998    pub fn new(icon: IconGlyph, label: impl Into<String>) -> Self {
999        Self {
1000            theme: Box::new(DefaultTheme::default()),
1001            theme_reader: None,
1002            icon,
1003            label: label.into(),
1004            semantic_description: None,
1005            appearance: ButtonAppearance::Tonal,
1006            tone: SemanticTone::Neutral,
1007            size: None,
1008            icon_size: None,
1009            selected: false,
1010            selected_reader: None,
1011            enabled: true,
1012            enabled_reader: None,
1013            hovered: false,
1014            pressed: false,
1015            hover_animation: AnimatedScalar::new(0.0),
1016            press_animation: AnimatedScalar::new(0.0),
1017            focus_animation: AnimatedScalar::new(0.0),
1018            on_press: None,
1019            on_press_with_ctx: None,
1020        }
1021    }
1022
1023    pub fn theme(mut self, theme: DefaultTheme) -> Self {
1024        self.theme = Box::new(theme);
1025        self.theme_reader = None;
1026        self
1027    }
1028
1029    pub fn description(mut self, description: impl Into<String>) -> Self {
1030        self.semantic_description = Some(description.into());
1031        self
1032    }
1033
1034    pub fn appearance(mut self, appearance: ButtonAppearance) -> Self {
1035        self.appearance = appearance;
1036        self
1037    }
1038
1039    pub fn tone(mut self, tone: SemanticTone) -> Self {
1040        self.tone = tone;
1041        self
1042    }
1043
1044    pub fn theme_when<F>(mut self, theme: F) -> Self
1045    where
1046        F: Fn() -> DefaultTheme + 'static,
1047    {
1048        self.theme_reader = Some(Box::new(theme));
1049        self
1050    }
1051
1052    pub fn size(mut self, size: f32) -> Self {
1053        self.size = Some(size.max(0.0));
1054        self
1055    }
1056
1057    pub fn icon_size(mut self, icon_size: f32) -> Self {
1058        self.icon_size = Some(icon_size.max(0.0));
1059        self
1060    }
1061
1062    pub fn selected(mut self, selected: bool) -> Self {
1063        self.selected = selected;
1064        self.selected_reader = None;
1065        self
1066    }
1067
1068    pub fn selected_when<F>(mut self, selected: F) -> Self
1069    where
1070        F: Fn() -> bool + 'static,
1071    {
1072        self.selected_reader = Some(Box::new(selected));
1073        self
1074    }
1075
1076    pub fn enabled(mut self, enabled: bool) -> Self {
1077        self.enabled = enabled;
1078        self.enabled_reader = None;
1079        self
1080    }
1081
1082    pub fn enabled_when<F>(mut self, enabled: F) -> Self
1083    where
1084        F: Fn() -> bool + 'static,
1085    {
1086        self.enabled_reader = Some(Box::new(enabled));
1087        self
1088    }
1089
1090    pub fn on_press<F>(mut self, on_press: F) -> Self
1091    where
1092        F: FnMut() + 'static,
1093    {
1094        self.on_press = Some(Box::new(on_press));
1095        self
1096    }
1097
1098    pub fn on_press_with_ctx<F>(mut self, on_press: F) -> Self
1099    where
1100        F: FnMut(&mut EventCtx) + 'static,
1101    {
1102        self.on_press_with_ctx = Some(Box::new(on_press));
1103        self
1104    }
1105
1106    fn resolved_theme(&self) -> DefaultTheme {
1107        self.theme_reader
1108            .as_ref()
1109            .map(|theme| theme())
1110            .unwrap_or(*self.theme)
1111    }
1112
1113    fn resolved_size(&self) -> f32 {
1114        let theme = self.resolved_theme();
1115        self.size
1116            .unwrap_or(theme.metrics.icon_button_size)
1117            .max(theme.metrics.min_height)
1118    }
1119
1120    fn resolved_icon_size(&self) -> f32 {
1121        let theme = self.resolved_theme();
1122        self.icon_size
1123            .unwrap_or(theme.metrics.icon_size)
1124            .min(self.resolved_size())
1125            .max(0.0)
1126    }
1127
1128    fn is_selected(&self) -> bool {
1129        self.selected_reader
1130            .as_ref()
1131            .map(|selected| selected())
1132            .unwrap_or(self.selected)
1133    }
1134
1135    fn is_enabled(&self) -> bool {
1136        self.enabled_reader
1137            .as_ref()
1138            .map(|enabled| enabled())
1139            .unwrap_or(self.enabled)
1140    }
1141
1142    fn activate(&mut self, ctx: &mut EventCtx) {
1143        if !self.is_enabled() {
1144            return;
1145        }
1146        if let Some(on_press) = &mut self.on_press {
1147            on_press();
1148        }
1149        if let Some(on_press) = &mut self.on_press_with_ctx {
1150            on_press(ctx);
1151        }
1152    }
1153
1154    fn set_hovered(&mut self, hovered: bool, ctx: &mut EventCtx) {
1155        if self.hovered != hovered {
1156            let theme = self.resolved_theme();
1157            self.hovered = hovered;
1158            set_hover_animation_target(
1159                &mut self.hover_animation,
1160                hovered as u8 as f32,
1161                &theme,
1162                ctx,
1163            );
1164            ctx.request_paint();
1165            ctx.request_semantics();
1166        }
1167    }
1168
1169    fn advance_animations(&mut self, time: f64) -> bool {
1170        self.hover_animation.advance(time)
1171            | self.press_animation.advance(time)
1172            | self.focus_animation.advance(time)
1173    }
1174}
1175
1176impl Widget for IconButton {
1177    fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
1178        if !self.is_enabled() {
1179            if self.hovered || self.pressed {
1180                let theme = self.resolved_theme();
1181                self.hovered = false;
1182                self.pressed = false;
1183                set_hover_animation_target(&mut self.hover_animation, 0.0, &theme, ctx);
1184                set_press_animation_target(&mut self.press_animation, 0.0, &theme, ctx);
1185                ctx.request_paint();
1186                ctx.request_semantics();
1187            }
1188            return;
1189        }
1190
1191        match event {
1192            Event::Pointer(pointer) if pointer.kind == PointerEventKind::Move => {
1193                self.set_hovered(ctx.bounds().contains(pointer.position), ctx);
1194            }
1195            Event::Pointer(_pointer) if matches!(_pointer.kind, PointerEventKind::Enter) => {
1196                self.set_hovered(true, ctx);
1197            }
1198            Event::Pointer(_pointer) if matches!(_pointer.kind, PointerEventKind::Leave) => {
1199                self.set_hovered(false, ctx);
1200            }
1201            Event::Pointer(pointer)
1202                if pointer.kind == PointerEventKind::Down
1203                    && pointer.button == Some(PointerButton::Primary) =>
1204            {
1205                let theme = self.resolved_theme();
1206                self.pressed = true;
1207                self.hovered = true;
1208                set_hover_animation_target(&mut self.hover_animation, 1.0, &theme, ctx);
1209                set_press_animation_target(&mut self.press_animation, 1.0, &theme, ctx);
1210                ctx.request_pointer_capture(pointer.pointer_id);
1211                ctx.request_focus();
1212                ctx.request_paint();
1213                ctx.request_semantics();
1214                ctx.set_handled();
1215            }
1216            Event::Pointer(pointer)
1217                if pointer.kind == PointerEventKind::Up
1218                    && (pointer.button == Some(PointerButton::Primary) || self.pressed) =>
1219            {
1220                let theme = self.resolved_theme();
1221                let hovered = ctx.bounds().contains(pointer.position);
1222                let activate = self.pressed && hovered;
1223                self.pressed = false;
1224                self.hovered = hovered;
1225                set_hover_animation_target(
1226                    &mut self.hover_animation,
1227                    hovered as u8 as f32,
1228                    &theme,
1229                    ctx,
1230                );
1231                set_press_animation_target(&mut self.press_animation, 0.0, &theme, ctx);
1232                ctx.release_pointer_capture(pointer.pointer_id);
1233                if activate {
1234                    self.activate(ctx);
1235                }
1236                ctx.request_paint();
1237                ctx.request_semantics();
1238                ctx.set_handled();
1239            }
1240            Event::Pointer(pointer) if pointer.kind == PointerEventKind::Cancel => {
1241                if self.pressed {
1242                    let theme = self.resolved_theme();
1243                    self.pressed = false;
1244                    self.hovered = false;
1245                    set_hover_animation_target(&mut self.hover_animation, 0.0, &theme, ctx);
1246                    set_press_animation_target(&mut self.press_animation, 0.0, &theme, ctx);
1247                    ctx.release_pointer_capture(pointer.pointer_id);
1248                    ctx.request_paint();
1249                    ctx.request_semantics();
1250                    ctx.set_handled();
1251                }
1252            }
1253            Event::Keyboard(key)
1254                if key.state == KeyState::Pressed
1255                    && ctx.is_focused()
1256                    && matches!(key.key.as_str(), "Enter" | " ") =>
1257            {
1258                self.activate(ctx);
1259                ctx.request_paint();
1260                ctx.request_semantics();
1261                ctx.set_handled();
1262            }
1263            Event::Wake(sui_core::WakeEvent::AnimationFrame { time, .. }) => {
1264                if self.advance_animations(*time) {
1265                    ctx.request_animation_frame();
1266                }
1267                ctx.request_paint();
1268            }
1269            _ => {}
1270        }
1271    }
1272
1273    fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
1274        let side = self.resolved_size();
1275        constraints.clamp(Size::new(side, side))
1276    }
1277
1278    fn paint(&self, ctx: &mut PaintCtx) {
1279        let theme = self.resolved_theme();
1280        paint_icon_button(
1281            ctx,
1282            &theme,
1283            ctx.bounds(),
1284            self.icon,
1285            IconButtonPaint::new()
1286                .appearance(self.appearance)
1287                .tone(self.tone)
1288                .selected(self.is_selected())
1289                .enabled(self.is_enabled())
1290                .hover_progress(self.hover_animation.value)
1291                .press_progress(self.press_animation.value)
1292                .focus_progress(self.focus_animation.value)
1293                .icon_size(self.resolved_icon_size()),
1294        );
1295    }
1296
1297    fn semantics(&self, ctx: &mut SemanticsCtx) {
1298        let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::Button, ctx.bounds());
1299        node.name = Some(self.label.clone());
1300        node.description = self.semantic_description.clone();
1301        node.state.focused = ctx.is_focused();
1302        node.state.hovered = self.hovered && self.is_enabled();
1303        node.state.selected = self.is_selected();
1304        node.state.disabled = !self.is_enabled();
1305        node.actions = if self.is_enabled() {
1306            vec![SemanticsAction::Focus, SemanticsAction::Activate]
1307        } else {
1308            Vec::new()
1309        };
1310        ctx.push(node);
1311    }
1312
1313    fn accepts_focus(&self) -> bool {
1314        self.is_enabled()
1315    }
1316
1317    fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
1318        let theme = self.resolved_theme();
1319        set_focus_animation_target(&mut self.focus_animation, focused as u8 as f32, &theme, ctx);
1320        ctx.request_paint();
1321        ctx.request_semantics();
1322    }
1323}
1324
1325pub struct Label {
1326    text: String,
1327    text_reader: Option<Box<dyn Fn() -> String>>,
1328    text_source: Option<Arc<dyn Observable<String>>>,
1329    semantic_name: Option<String>,
1330    style: TextStyle,
1331    color_reader: Option<Box<dyn Fn() -> Color>>,
1332    measurement: Option<TextMeasurement>,
1333    layout: Option<PersistentTextLayout>,
1334    selection_scope: Option<SelectionScope>,
1335    selection: TextSelection,
1336    dragging_selection: Option<u64>,
1337}
1338
1339impl Label {
1340    pub fn new(text: impl Into<String>) -> Self {
1341        Self {
1342            text: text.into(),
1343            text_reader: None,
1344            text_source: None,
1345            semantic_name: None,
1346            style: DefaultTheme::default().body_text_style(),
1347            color_reader: None,
1348            measurement: None,
1349            layout: None,
1350            selection_scope: None,
1351            selection: TextSelection::new(TextCursor::new(0), TextCursor::new(0)),
1352            dragging_selection: None,
1353        }
1354    }
1355
1356    pub fn dynamic<F>(fallback: impl Into<String>, reader: F) -> Self
1357    where
1358        F: Fn() -> String + 'static,
1359    {
1360        Self::new(fallback).text_when(reader)
1361    }
1362
1363    pub fn text_when<F>(mut self, reader: F) -> Self
1364    where
1365        F: Fn() -> String + 'static,
1366    {
1367        self.text_reader = Some(Box::new(reader));
1368        self.text_source = None;
1369        self
1370    }
1371
1372    /// Bind label text to an observable value.
1373    ///
1374    /// Changes automatically invalidate text measurement, paint, and
1375    /// semantics for this retained label instance.
1376    pub fn text_from<O>(mut self, source: O) -> Self
1377    where
1378        O: Observable<String> + 'static,
1379    {
1380        self.text = source.get();
1381        self.text_reader = None;
1382        self.text_source = Some(Arc::new(source));
1383        self
1384    }
1385
1386    pub fn semantic_name(mut self, name: impl Into<String>) -> Self {
1387        self.semantic_name = Some(name.into());
1388        self
1389    }
1390
1391    pub fn selectable(mut self, selection_scope: SelectionScope) -> Self {
1392        self.selection_scope = Some(selection_scope);
1393        self
1394    }
1395
1396    pub fn selection_scope(&self) -> Option<&SelectionScope> {
1397        self.selection_scope.as_ref()
1398    }
1399
1400    pub fn theme(mut self, theme: DefaultTheme) -> Self {
1401        self.style = theme.body_text_style();
1402        self
1403    }
1404
1405    pub fn text(&self) -> &str {
1406        &self.text
1407    }
1408
1409    pub fn set_text(&mut self, text: impl Into<String>) {
1410        self.text = text.into();
1411        self.text_reader = None;
1412        self.text_source = None;
1413    }
1414
1415    pub fn color(mut self, color: Color) -> Self {
1416        self.style.color = color;
1417        self.color_reader = None;
1418        self
1419    }
1420
1421    pub fn color_when<F>(mut self, color: F) -> Self
1422    where
1423        F: Fn() -> Color + 'static,
1424    {
1425        self.color_reader = Some(Box::new(color));
1426        self
1427    }
1428
1429    pub fn font_size(mut self, font_size: f32) -> Self {
1430        self.style.font_size = font_size.max(1.0);
1431        self
1432    }
1433
1434    pub fn line_height(mut self, line_height: f32) -> Self {
1435        self.style.line_height = line_height.max(1.0);
1436        self
1437    }
1438
1439    pub fn style(mut self, style: TextStyle) -> Self {
1440        self.style = style;
1441        self
1442    }
1443
1444    fn current_text(&self) -> String {
1445        self.text_source
1446            .as_ref()
1447            .map(|source| source.get())
1448            .or_else(|| self.text_reader.as_ref().map(|reader| reader()))
1449            .unwrap_or_else(|| self.text.clone())
1450    }
1451
1452    fn observed_text(&self, ctx: &MeasureCtx) -> String {
1453        self.text_source
1454            .as_ref()
1455            .map(|source| ctx.observe_with(source.as_ref(), InvalidationKind::Text))
1456            .unwrap_or_else(|| self.current_text())
1457    }
1458
1459    fn resolved_style(&self) -> TextStyle {
1460        let mut style = self.style.clone();
1461        if let Some(color_reader) = &self.color_reader {
1462            style.color = color_reader();
1463        }
1464        style
1465    }
1466
1467    fn has_explicit_line_break(text: &str) -> bool {
1468        text.bytes().any(|byte| matches!(byte, b'\n' | b'\r'))
1469    }
1470
1471    fn owner_id(widget_id: WidgetId) -> SelectionOwnerId {
1472        SelectionOwnerId::from(widget_id)
1473    }
1474
1475    fn selected_range(&self, text_len: usize) -> std::ops::Range<usize> {
1476        selection_range(&self.selection, text_len)
1477    }
1478
1479    fn active_selection_range(
1480        &self,
1481        widget_id: WidgetId,
1482        text_len: usize,
1483    ) -> Option<std::ops::Range<usize>> {
1484        let owner = Self::owner_id(widget_id);
1485        let range = self.selected_range(text_len);
1486        self.selection_scope
1487            .as_ref()
1488            .is_some_and(|scope| scope.has_owner_selection(owner))
1489            .then_some(range)
1490            .filter(|range| !range.is_empty())
1491    }
1492
1493    fn sync_selection_scope(&self, ctx: &mut EventCtx, text: &str) {
1494        let Some(scope) = &self.selection_scope else {
1495            return;
1496        };
1497        let owner = Self::owner_id(ctx.widget_id());
1498        let range = self.selected_range(text.len());
1499        let selected = text.get(range.clone()).unwrap_or("").to_string();
1500        let change = scope.replace_text(owner, owner, range, text.len(), selected);
1501        request_selection_change(ctx, change);
1502    }
1503
1504    fn label_layout_origin_for_event(&self, bounds: Rect, layout: &PersistentTextLayout) -> Point {
1505        let measurement = layout.measurement();
1506        let height = self
1507            .resolved_style()
1508            .line_height
1509            .max(measurement.height)
1510            .min(bounds.height());
1511        Point::new(
1512            bounds.x() - measurement.bounds.x(),
1513            bounds.y() + ((bounds.height() - height).max(0.0) * 0.5),
1514        )
1515    }
1516
1517    fn hit_test_offset(&self, bounds: Rect, position: Point, text_len: usize) -> usize {
1518        self.layout
1519            .as_ref()
1520            .map(|layout| {
1521                let origin = self.label_layout_origin_for_event(bounds, layout);
1522                layout
1523                    .hit_test_point(Point::new(position.x - origin.x, position.y - origin.y))
1524                    .utf8_offset
1525                    .min(text_len)
1526            })
1527            .unwrap_or(text_len)
1528    }
1529
1530    fn set_selection(&mut self, anchor: usize, focus: usize, text_len: usize) {
1531        self.selection = TextSelection::new(
1532            TextCursor::new(anchor.min(text_len)),
1533            TextCursor::new(focus.min(text_len)),
1534        );
1535    }
1536
1537    fn copy_selection(&self, ctx: &mut EventCtx) -> bool {
1538        let text = self.current_text();
1539        let range = self.selected_range(text.len());
1540        let Some(selected) = text.get(range).filter(|selected| !selected.is_empty()) else {
1541            return false;
1542        };
1543        ctx.set_clipboard_text(selected);
1544        true
1545    }
1546}
1547
1548impl Widget for Label {
1549    fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
1550        if self.selection_scope.is_none() {
1551            return;
1552        }
1553
1554        match event {
1555            Event::Pointer(pointer)
1556                if pointer.kind == PointerEventKind::Down
1557                    && pointer.button == Some(PointerButton::Primary)
1558                    && ctx.phase() != sui_runtime::EventPhase::Capture
1559                    && ctx.bounds().contains(pointer.position) =>
1560            {
1561                let text = self.current_text();
1562                let offset = self.hit_test_offset(ctx.bounds(), pointer.position, text.len());
1563                let anchor = if pointer.modifiers.shift {
1564                    self.selection.anchor.utf8_offset
1565                } else {
1566                    offset
1567                };
1568                self.set_selection(anchor, offset, text.len());
1569                self.dragging_selection = Some(pointer.pointer_id);
1570                self.sync_selection_scope(ctx, &text);
1571                ctx.request_focus();
1572                ctx.request_pointer_capture(pointer.pointer_id);
1573                ctx.request_paint();
1574                ctx.request_semantics();
1575                ctx.set_handled();
1576            }
1577            Event::Pointer(pointer)
1578                if pointer.kind == PointerEventKind::Move
1579                    && self.dragging_selection == Some(pointer.pointer_id)
1580                    && pointer.buttons.contains(PointerButton::Primary) =>
1581            {
1582                let text = self.current_text();
1583                let anchor = self.selection.anchor.utf8_offset;
1584                let focus = self.hit_test_offset(ctx.bounds(), pointer.position, text.len());
1585                self.set_selection(anchor, focus, text.len());
1586                self.sync_selection_scope(ctx, &text);
1587                ctx.request_paint();
1588                ctx.request_semantics();
1589                ctx.set_handled();
1590            }
1591            Event::Pointer(pointer)
1592                if pointer.kind == PointerEventKind::Up
1593                    && self.dragging_selection == Some(pointer.pointer_id) =>
1594            {
1595                self.dragging_selection = None;
1596                ctx.release_pointer_capture(pointer.pointer_id);
1597                ctx.set_handled();
1598            }
1599            Event::Pointer(pointer)
1600                if pointer.kind == PointerEventKind::Cancel
1601                    && self.dragging_selection == Some(pointer.pointer_id) =>
1602            {
1603                self.dragging_selection = None;
1604                ctx.release_pointer_capture(pointer.pointer_id);
1605                ctx.set_handled();
1606            }
1607            Event::Pointer(pointer)
1608                if pointer.kind == PointerEventKind::Down
1609                    && pointer.button == Some(PointerButton::Secondary)
1610                    && ctx.phase() != EventPhase::Capture
1611                    && ctx.bounds().contains(pointer.position) =>
1612            {
1613                // Preserve the active selection while handing the same press
1614                // to a wrapping ContextMenu. Its activation can route a
1615                // TextCommand back to this label after focus moves to the menu.
1616                ctx.request_focus();
1617                ctx.request_paint();
1618                ctx.request_semantics();
1619            }
1620            Event::Keyboard(key)
1621                if key.state == KeyState::Pressed
1622                    && ctx.is_focused()
1623                    && (key.modifiers.control || key.modifiers.meta)
1624                    && matches!(key.key.as_str(), "a" | "A") =>
1625            {
1626                let text = self.current_text();
1627                self.set_selection(0, text.len(), text.len());
1628                self.sync_selection_scope(ctx, &text);
1629                ctx.request_paint();
1630                ctx.request_semantics();
1631                ctx.set_handled();
1632            }
1633            Event::Keyboard(key)
1634                if key.state == KeyState::Pressed
1635                    && ctx.is_focused()
1636                    && (key.modifiers.control || key.modifiers.meta)
1637                    && matches!(key.key.as_str(), "c" | "C") =>
1638            {
1639                if self.copy_selection(ctx) {
1640                    ctx.set_handled();
1641                }
1642            }
1643            Event::Keyboard(key)
1644                if key.state == KeyState::Pressed && ctx.is_focused() && key.key == "Escape" =>
1645            {
1646                if let Some(scope) = &self.selection_scope {
1647                    let change = scope.clear_owner(Self::owner_id(ctx.widget_id()));
1648                    request_selection_change(ctx, change);
1649                }
1650                self.set_selection(0, 0, 0);
1651                ctx.request_paint();
1652                ctx.request_semantics();
1653                ctx.set_handled();
1654            }
1655            Event::Semantics(semantics) if semantics.target == ctx.widget_id() => {
1656                match &semantics.action {
1657                    SemanticsActionRequest::SetSelection(selection) => {
1658                        let text = self.current_text();
1659                        self.set_selection(selection.start, selection.end, text.len());
1660                        self.sync_selection_scope(ctx, &text);
1661                        ctx.request_paint();
1662                        ctx.request_semantics();
1663                        ctx.set_handled();
1664                    }
1665                    SemanticsActionRequest::Copy if self.copy_selection(ctx) => {
1666                        ctx.set_handled();
1667                    }
1668                    _ => {}
1669                }
1670            }
1671            _ => {}
1672        }
1673    }
1674
1675    fn command(&mut self, ctx: &mut EventCtx, command: &Command<'_>) {
1676        let Some(command) = TextCommand::from_command(command) else {
1677            return;
1678        };
1679        match command {
1680            TextCommand::SelectAll => {
1681                let text = self.current_text();
1682                self.set_selection(0, text.len(), text.len());
1683                self.sync_selection_scope(ctx, &text);
1684                ctx.request_paint();
1685                ctx.request_semantics();
1686                ctx.set_handled();
1687            }
1688            TextCommand::Copy => {
1689                if self.copy_selection(ctx) {
1690                    ctx.set_handled();
1691                }
1692            }
1693            TextCommand::Cut | TextCommand::Paste => {}
1694        }
1695    }
1696
1697    fn intrinsic_size(
1698        &mut self,
1699        ctx: &mut MeasureCtx,
1700        axis: Axis,
1701        available_cross: f32,
1702    ) -> IntrinsicSize {
1703        if axis == Axis::Horizontal {
1704            let text = self.observed_text(ctx);
1705            let style = self.resolved_style();
1706            let natural = measure_text(ctx, &text, &style).width;
1707            let minimum = text
1708                .split_whitespace()
1709                .map(|segment| measure_text(ctx, segment, &style).width)
1710                .fold(0.0_f32, f32::max);
1711            return IntrinsicSize::new(minimum, natural);
1712        }
1713
1714        let width = if available_cross.is_finite() {
1715            available_cross.max(0.0)
1716        } else {
1717            f32::INFINITY
1718        };
1719        let size = self.measure(
1720            ctx,
1721            Constraints::new(Size::ZERO, Size::new(width, f32::INFINITY)),
1722        );
1723        IntrinsicSize::fixed(size.height)
1724    }
1725
1726    fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
1727        let text = self.observed_text(ctx);
1728        let style = self.resolved_style();
1729        let natural_measurement = measure_text(ctx, &text, &style);
1730        let max_width = constraints.max.width;
1731        let wraps_to_constraint = max_width.is_finite() && natural_measurement.width > max_width;
1732        let needs_layout = self.selection_scope.is_some()
1733            || wraps_to_constraint
1734            || Self::has_explicit_line_break(&text);
1735        let mut measured_width = if wraps_to_constraint {
1736            max_width.max(0.0)
1737        } else {
1738            natural_measurement.width
1739        };
1740        let mut measurement = natural_measurement;
1741
1742        if needs_layout {
1743            let layout_width = if max_width.is_finite() {
1744                measured_width.min(max_width).max(1.0)
1745            } else {
1746                measured_width.max(1.0)
1747            };
1748            measurement = ctx
1749                .layout()
1750                .shape_text(
1751                    text.clone(),
1752                    Size::new(layout_width, f32::INFINITY),
1753                    style.clone(),
1754                )
1755                .map(|layout| layout.measurement())
1756                .unwrap_or(measurement);
1757            if !wraps_to_constraint {
1758                measured_width = if max_width.is_finite() {
1759                    measurement.width.min(max_width).max(0.0)
1760                } else {
1761                    measurement.width.max(0.0)
1762                };
1763            }
1764            self.layout = ctx
1765                .layout()
1766                .shape_text_persistent(
1767                    self.layout.as_ref().map(|layout| layout.handle()),
1768                    text,
1769                    Size::new(
1770                        measured_width.max(1.0),
1771                        measurement.height.max(style.line_height).max(1.0),
1772                    ),
1773                    style.clone(),
1774                )
1775                .ok();
1776        } else {
1777            self.layout = None;
1778        }
1779        self.measurement = Some(measurement);
1780        constraints.clamp(Size::new(
1781            measured_width,
1782            measurement.height.max(style.line_height),
1783        ))
1784    }
1785
1786    fn paint(&self, ctx: &mut PaintCtx) {
1787        let text = self.current_text();
1788        let style = self.resolved_style();
1789        if let Some(layout) = &self.layout {
1790            let layout_bounds = layout.measurement().bounds;
1791            let mut layout_rect = aligned_text_rect_for_layout_with_mode(
1792                ctx,
1793                ctx.bounds(),
1794                layout.layout(),
1795                style.line_height,
1796                0.0,
1797                HorizontalTextAlignmentMode::Optical,
1798            );
1799            if layout.lines().len() > 1 {
1800                let block_height = style
1801                    .line_height
1802                    .max(layout.measurement().height)
1803                    .min(ctx.bounds().height());
1804                layout_rect = Rect::new(
1805                    layout_rect.x(),
1806                    ctx.bounds().y() + ((ctx.bounds().height() - block_height).max(0.0) * 0.5),
1807                    layout_rect.width(),
1808                    block_height,
1809                );
1810            }
1811            let origin = Point::new(layout_rect.x() - layout_bounds.x(), layout_rect.y());
1812            if let Some(range) = self.active_selection_range(ctx.widget_id(), text.len()) {
1813                let theme = DefaultTheme::default();
1814                for rect in layout.selection_rects(range) {
1815                    ctx.fill_rect(rect.translate(origin.to_vector()), theme.palette.selection);
1816                }
1817            }
1818            ctx.draw_persistent_text_layout(origin, layout);
1819        } else {
1820            paint_aligned_text(ctx, ctx.bounds(), &text, &style, style.line_height, 0.0);
1821        }
1822    }
1823
1824    fn semantics(&self, ctx: &mut SemanticsCtx) {
1825        let text = self.current_text();
1826        let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::Text, ctx.bounds());
1827        node.name = Some(self.semantic_name.clone().unwrap_or_else(|| text.clone()));
1828        if self.semantic_name.is_some() {
1829            node.value = Some(SemanticsValue::Text(text));
1830        }
1831        if self.selection_scope.is_some() {
1832            node.actions = vec![
1833                SemanticsAction::Focus,
1834                SemanticsAction::SetSelection,
1835                SemanticsAction::Copy,
1836            ];
1837            node.state.focused = ctx.is_focused();
1838        }
1839        ctx.push(node);
1840    }
1841
1842    fn accepts_focus(&self) -> bool {
1843        self.selection_scope.is_some()
1844    }
1845
1846    fn focus_changed(&mut self, ctx: &mut EventCtx, _focused: bool) {
1847        ctx.request_paint();
1848        ctx.request_semantics();
1849    }
1850}
1851
1852pub struct Link {
1853    theme: Box<DefaultTheme>,
1854    theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
1855    label: String,
1856    label_reader: Option<Box<dyn Fn() -> String>>,
1857    url: String,
1858    url_reader: Option<Box<dyn Fn() -> String>>,
1859    semantic_name: Option<String>,
1860    text_style: Option<TextStyle>,
1861    enabled: bool,
1862    enabled_reader: Option<Box<dyn Fn() -> bool>>,
1863    hovered: bool,
1864    pressed: bool,
1865    measurement: Option<TextMeasurement>,
1866    on_open: Option<Box<dyn FnMut(&str)>>,
1867    on_open_with_ctx: Option<Box<dyn FnMut(&mut EventCtx, &str)>>,
1868}
1869
1870impl Link {
1871    pub fn new(label: impl Into<String>, url: impl Into<String>) -> Self {
1872        Self {
1873            theme: Box::new(DefaultTheme::default()),
1874            theme_reader: None,
1875            label: label.into(),
1876            label_reader: None,
1877            url: url.into(),
1878            url_reader: None,
1879            semantic_name: None,
1880            text_style: None,
1881            enabled: true,
1882            enabled_reader: None,
1883            hovered: false,
1884            pressed: false,
1885            measurement: None,
1886            on_open: None,
1887            on_open_with_ctx: None,
1888        }
1889    }
1890
1891    pub fn url(url: impl Into<String>) -> Self {
1892        let url = url.into();
1893        Self::new(url.clone(), url)
1894    }
1895
1896    pub fn label_when<F>(mut self, reader: F) -> Self
1897    where
1898        F: Fn() -> String + 'static,
1899    {
1900        self.label_reader = Some(Box::new(reader));
1901        self
1902    }
1903
1904    pub fn url_when<F>(mut self, reader: F) -> Self
1905    where
1906        F: Fn() -> String + 'static,
1907    {
1908        self.url_reader = Some(Box::new(reader));
1909        self
1910    }
1911
1912    pub fn semantic_name(mut self, name: impl Into<String>) -> Self {
1913        self.semantic_name = Some(name.into());
1914        self
1915    }
1916
1917    pub fn theme(mut self, theme: DefaultTheme) -> Self {
1918        self.theme = Box::new(theme);
1919        self.theme_reader = None;
1920        self
1921    }
1922
1923    pub fn theme_when<F>(mut self, theme: F) -> Self
1924    where
1925        F: Fn() -> DefaultTheme + 'static,
1926    {
1927        self.theme_reader = Some(Box::new(theme));
1928        self
1929    }
1930
1931    pub fn text_style(mut self, text_style: TextStyle) -> Self {
1932        self.text_style = Some(text_style);
1933        self
1934    }
1935
1936    pub fn enabled(mut self, enabled: bool) -> Self {
1937        self.enabled = enabled;
1938        self.enabled_reader = None;
1939        self
1940    }
1941
1942    pub fn enabled_when<F>(mut self, enabled: F) -> Self
1943    where
1944        F: Fn() -> bool + 'static,
1945    {
1946        self.enabled_reader = Some(Box::new(enabled));
1947        self
1948    }
1949
1950    pub fn on_open<F>(mut self, on_open: F) -> Self
1951    where
1952        F: FnMut(&str) + 'static,
1953    {
1954        self.on_open = Some(Box::new(on_open));
1955        self
1956    }
1957
1958    pub fn on_open_with_ctx<F>(mut self, on_open: F) -> Self
1959    where
1960        F: FnMut(&mut EventCtx, &str) + 'static,
1961    {
1962        self.on_open_with_ctx = Some(Box::new(on_open));
1963        self
1964    }
1965
1966    fn current_label(&self) -> String {
1967        single_line_text(
1968            self.label_reader
1969                .as_ref()
1970                .map(|reader| reader())
1971                .unwrap_or_else(|| self.label.clone()),
1972        )
1973    }
1974
1975    fn current_url(&self) -> String {
1976        single_line_text(
1977            self.url_reader
1978                .as_ref()
1979                .map(|reader| reader())
1980                .unwrap_or_else(|| self.url.clone()),
1981        )
1982        .trim()
1983        .to_string()
1984    }
1985
1986    fn is_enabled(&self) -> bool {
1987        self.enabled_reader
1988            .as_ref()
1989            .map(|enabled| enabled())
1990            .unwrap_or(self.enabled)
1991    }
1992
1993    fn resolved_theme(&self) -> DefaultTheme {
1994        self.theme_reader
1995            .as_ref()
1996            .map(|theme| theme())
1997            .unwrap_or(*self.theme)
1998    }
1999
2000    fn resolved_text_style(&self, color: Color) -> TextStyle {
2001        let mut style = self
2002            .text_style
2003            .clone()
2004            .unwrap_or_else(|| self.resolved_theme().body_text_style());
2005        style.color = color;
2006        style
2007    }
2008
2009    fn resolved_color(&self, theme: &DefaultTheme) -> Color {
2010        if !self.is_enabled() {
2011            return theme
2012                .palette
2013                .placeholder
2014                .with_alpha(theme.interaction.disabled_content_opacity);
2015        }
2016        if self.pressed {
2017            theme.palette.accent_pressed
2018        } else if self.hovered {
2019            theme.palette.accent_hover
2020        } else {
2021            theme.palette.accent
2022        }
2023    }
2024
2025    fn is_visible_parts(label: &str, url: &str) -> bool {
2026        !label.trim().is_empty() && !url.trim().is_empty()
2027    }
2028
2029    fn is_visible(&self) -> bool {
2030        Self::is_visible_parts(&self.current_label(), &self.current_url())
2031    }
2032
2033    fn can_activate_parts(&self, label: &str, url: &str) -> bool {
2034        self.is_enabled() && Self::is_visible_parts(label, url)
2035    }
2036
2037    fn activate(&mut self, ctx: &mut EventCtx) {
2038        let label = self.current_label();
2039        let url = self.current_url();
2040        if !self.can_activate_parts(&label, &url) {
2041            return;
2042        }
2043        if let Some(on_open) = &mut self.on_open {
2044            on_open(&url);
2045        }
2046        if let Some(on_open) = &mut self.on_open_with_ctx {
2047            on_open(ctx, &url);
2048        }
2049    }
2050
2051    fn set_hovered(&mut self, hovered: bool, ctx: &mut EventCtx) {
2052        if self.hovered != hovered {
2053            self.hovered = hovered;
2054            ctx.request_paint();
2055            ctx.request_semantics();
2056        }
2057    }
2058
2059    fn reset_interaction(&mut self, ctx: &mut EventCtx) {
2060        if self.hovered || self.pressed {
2061            self.hovered = false;
2062            self.pressed = false;
2063            ctx.request_paint();
2064            ctx.request_semantics();
2065        }
2066    }
2067}
2068
2069impl Widget for Link {
2070    fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
2071        if !self.is_visible() || !self.is_enabled() {
2072            self.reset_interaction(ctx);
2073            return;
2074        }
2075
2076        match event {
2077            Event::Pointer(pointer) if pointer.kind == PointerEventKind::Move => {
2078                self.set_hovered(ctx.bounds().contains(pointer.position), ctx);
2079            }
2080            Event::Pointer(pointer) if pointer.kind == PointerEventKind::Enter => {
2081                self.set_hovered(ctx.bounds().contains(pointer.position), ctx);
2082            }
2083            Event::Pointer(_pointer) if _pointer.kind == PointerEventKind::Leave => {
2084                self.set_hovered(false, ctx);
2085            }
2086            Event::Pointer(pointer)
2087                if pointer.kind == PointerEventKind::Down
2088                    && pointer.button == Some(PointerButton::Primary) =>
2089            {
2090                self.pressed = true;
2091                self.hovered = true;
2092                ctx.request_pointer_capture(pointer.pointer_id);
2093                ctx.request_focus();
2094                ctx.request_paint();
2095                ctx.request_semantics();
2096                ctx.set_handled();
2097            }
2098            Event::Pointer(pointer)
2099                if pointer.kind == PointerEventKind::Up
2100                    && pointer.button == Some(PointerButton::Primary) =>
2101            {
2102                let hovered = ctx.bounds().contains(pointer.position);
2103                let activate = self.pressed && hovered;
2104                self.pressed = false;
2105                self.hovered = hovered;
2106                ctx.release_pointer_capture(pointer.pointer_id);
2107                if activate {
2108                    self.activate(ctx);
2109                }
2110                ctx.request_paint();
2111                ctx.request_semantics();
2112                ctx.set_handled();
2113            }
2114            Event::Pointer(pointer) if pointer.kind == PointerEventKind::Cancel => {
2115                if self.pressed {
2116                    self.pressed = false;
2117                    self.hovered = false;
2118                    ctx.release_pointer_capture(pointer.pointer_id);
2119                    ctx.request_paint();
2120                    ctx.request_semantics();
2121                    ctx.set_handled();
2122                }
2123            }
2124            Event::Keyboard(key)
2125                if key.state == KeyState::Pressed
2126                    && ctx.is_focused()
2127                    && matches!(key.key.as_str(), "Enter" | " ") =>
2128            {
2129                self.activate(ctx);
2130                ctx.request_paint();
2131                ctx.request_semantics();
2132                ctx.set_handled();
2133            }
2134            _ => {}
2135        }
2136    }
2137
2138    fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
2139        let label = self.current_label();
2140        let url = self.current_url();
2141        if !Self::is_visible_parts(&label, &url) {
2142            self.measurement = None;
2143            return constraints.clamp(Size::ZERO);
2144        }
2145
2146        let theme = self.resolved_theme();
2147        let style = self.resolved_text_style(self.resolved_color(&theme));
2148        let measurement = measure_text(ctx, &label, &style);
2149        self.measurement = Some(measurement);
2150        constraints.clamp(Size::new(
2151            measurement.width,
2152            measurement.height.max(style.line_height),
2153        ))
2154    }
2155
2156    fn paint(&self, ctx: &mut PaintCtx) {
2157        let label = self.current_label();
2158        let url = self.current_url();
2159        if !Self::is_visible_parts(&label, &url) {
2160            return;
2161        }
2162
2163        let theme = self.resolved_theme();
2164        let color = self.resolved_color(&theme);
2165        let style = self.resolved_text_style(color);
2166        let bounds = ctx.bounds();
2167        ctx.push_clip_rect(bounds);
2168        paint_single_line_aligned_text(ctx, bounds, &label, &style, style.line_height, 0.0);
2169        ctx.pop_clip();
2170
2171        let measured_width = self
2172            .measurement
2173            .map(|measurement| measurement.width)
2174            .unwrap_or(bounds.width())
2175            .min(bounds.width())
2176            .max(0.0);
2177        if measured_width > 0.0 {
2178            let underline_y = bounds.y() + bounds.height() - physical_pixels(ctx, 2.0);
2179            let mut underline = PathBuilder::new();
2180            underline
2181                .move_to(Point::new(bounds.x(), underline_y))
2182                .line_to(Point::new(bounds.x() + measured_width, underline_y));
2183            ctx.stroke(
2184                underline.build(),
2185                color,
2186                StrokeStyle::new(physical_pixels(ctx, 1.0)),
2187            );
2188        }
2189
2190        if ctx.is_focused() && self.is_enabled() {
2191            ctx.stroke_rect(
2192                bounds.inflate(physical_pixels(ctx, 2.0), physical_pixels(ctx, 1.0)),
2193                theme.palette.focus_ring,
2194                StrokeStyle::new(physical_pixels(ctx, 1.0)),
2195            );
2196        }
2197    }
2198
2199    fn semantics(&self, ctx: &mut SemanticsCtx) {
2200        let label = self.current_label();
2201        let url = self.current_url();
2202        if !Self::is_visible_parts(&label, &url) {
2203            return;
2204        }
2205
2206        let enabled = self.is_enabled();
2207        let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::Link, ctx.bounds());
2208        node.name = Some(self.semantic_name.clone().unwrap_or(label));
2209        node.value = Some(SemanticsValue::Text(url));
2210        node.state.focused = ctx.is_focused();
2211        node.state.hovered = self.hovered && enabled;
2212        node.state.disabled = !enabled;
2213        node.actions = if enabled {
2214            vec![SemanticsAction::Focus, SemanticsAction::Activate]
2215        } else {
2216            Vec::new()
2217        };
2218        ctx.push(node);
2219    }
2220
2221    fn accepts_focus(&self) -> bool {
2222        self.is_enabled() && self.is_visible()
2223    }
2224
2225    fn focus_changed(&mut self, ctx: &mut EventCtx, _focused: bool) {
2226        ctx.request_paint();
2227        ctx.request_semantics();
2228    }
2229}
2230
2231pub struct Button {
2232    theme: Box<DefaultTheme>,
2233    theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
2234    label: String,
2235    semantic_name: Option<String>,
2236    semantic_description: Option<String>,
2237    appearance: ButtonAppearance,
2238    tone: SemanticTone,
2239    text_style: Option<TextStyle>,
2240    icon: Option<IconGlyph>,
2241    icon_size: Option<f32>,
2242    icon_gap: Option<f32>,
2243    padding: Option<Insets>,
2244    min_width: Option<f32>,
2245    min_height: Option<f32>,
2246    hovered: bool,
2247    pressed: bool,
2248    hover_animation: AnimatedScalar,
2249    press_animation: AnimatedScalar,
2250    focus_animation: AnimatedScalar,
2251    label_measurement: Option<TextMeasurement>,
2252    label_layout: Option<PersistentTextLayout>,
2253    enabled: bool,
2254    enabled_reader: Option<Box<dyn Fn() -> bool>>,
2255    on_press: Option<Box<dyn FnMut()>>,
2256    on_press_with_ctx: Option<Box<dyn FnMut(&mut EventCtx)>>,
2257}
2258
2259#[derive(Debug, Clone, Copy, PartialEq)]
2260struct ButtonVisuals {
2261    background: Color,
2262    border: Color,
2263    focus_ring: Option<Color>,
2264    label_color: Color,
2265    label_peak_lift: f32,
2266    chrome_style: Option<ResolvedHdrStyle>,
2267}
2268
2269impl Button {
2270    /// Creates a neutral, tonal button for an ordinary action.
2271    pub fn new(label: impl Into<String>) -> Self {
2272        Self {
2273            theme: Box::new(DefaultTheme::default()),
2274            theme_reader: None,
2275            label: label.into(),
2276            semantic_name: None,
2277            semantic_description: None,
2278            appearance: ButtonAppearance::Tonal,
2279            tone: SemanticTone::Neutral,
2280            text_style: None,
2281            icon: None,
2282            icon_size: None,
2283            icon_gap: None,
2284            padding: None,
2285            min_width: None,
2286            min_height: None,
2287            hovered: false,
2288            pressed: false,
2289            hover_animation: AnimatedScalar::new(0.0),
2290            press_animation: AnimatedScalar::new(0.0),
2291            focus_animation: AnimatedScalar::new(0.0),
2292            label_measurement: None,
2293            label_layout: None,
2294            enabled: true,
2295            enabled_reader: None,
2296            on_press: None,
2297            on_press_with_ctx: None,
2298        }
2299    }
2300
2301    /// Creates a filled accent button for the primary action on a surface.
2302    pub fn primary(label: impl Into<String>) -> Self {
2303        Self::new(label).primary_action()
2304    }
2305
2306    /// Creates a filled danger button for a destructive or irreversible action.
2307    pub fn danger(label: impl Into<String>) -> Self {
2308        Self::new(label).danger_action()
2309    }
2310
2311    pub fn label(&self) -> &str {
2312        &self.label
2313    }
2314
2315    pub fn set_label(&mut self, label: impl Into<String>) {
2316        self.label = label.into();
2317    }
2318
2319    pub fn semantic_name(mut self, name: impl Into<String>) -> Self {
2320        self.semantic_name = Some(name.into());
2321        self
2322    }
2323
2324    pub fn description(mut self, description: impl Into<String>) -> Self {
2325        self.semantic_description = Some(description.into());
2326        self
2327    }
2328
2329    /// Selects the button's visual emphasis without changing its semantic
2330    /// meaning. The default is [`ButtonAppearance::Tonal`].
2331    pub fn appearance(mut self, appearance: ButtonAppearance) -> Self {
2332        self.appearance = appearance;
2333        self
2334    }
2335
2336    /// Selects the semantic color family used by this button. The default is
2337    /// [`SemanticTone::Neutral`].
2338    pub fn tone(mut self, tone: SemanticTone) -> Self {
2339        self.tone = tone;
2340        self
2341    }
2342
2343    /// Promotes this button to a filled accent primary action.
2344    pub fn primary_action(mut self) -> Self {
2345        self.appearance = ButtonAppearance::Filled;
2346        self.tone = SemanticTone::Accent;
2347        self
2348    }
2349
2350    /// Promotes this button to a filled danger action.
2351    pub fn danger_action(mut self) -> Self {
2352        self.appearance = ButtonAppearance::Filled;
2353        self.tone = SemanticTone::Danger;
2354        self
2355    }
2356
2357    pub fn theme(mut self, theme: DefaultTheme) -> Self {
2358        self.theme = Box::new(theme);
2359        self.theme_reader = None;
2360        self
2361    }
2362
2363    pub fn theme_when<F>(mut self, theme: F) -> Self
2364    where
2365        F: Fn() -> DefaultTheme + 'static,
2366    {
2367        self.theme_reader = Some(Box::new(theme));
2368        self
2369    }
2370
2371    pub fn text_style(mut self, text_style: TextStyle) -> Self {
2372        self.text_style = Some(text_style);
2373        self
2374    }
2375
2376    pub fn icon(mut self, icon: IconGlyph) -> Self {
2377        self.icon = Some(icon);
2378        self
2379    }
2380
2381    pub fn without_icon(mut self) -> Self {
2382        self.icon = None;
2383        self
2384    }
2385
2386    pub fn icon_size(mut self, icon_size: f32) -> Self {
2387        self.icon_size = Some(icon_size.max(0.0));
2388        self
2389    }
2390
2391    pub fn icon_gap(mut self, icon_gap: f32) -> Self {
2392        self.icon_gap = Some(icon_gap.max(0.0));
2393        self
2394    }
2395
2396    pub fn min_width(mut self, width: f32) -> Self {
2397        self.min_width = Some(width.max(0.0));
2398        self
2399    }
2400
2401    pub fn min_height(mut self, height: f32) -> Self {
2402        self.min_height = Some(height.max(0.0));
2403        self
2404    }
2405
2406    pub fn padding(mut self, padding: Insets) -> Self {
2407        self.padding = Some(padding);
2408        self
2409    }
2410
2411    pub fn enabled(mut self, enabled: bool) -> Self {
2412        self.enabled = enabled;
2413        self.enabled_reader = None;
2414        self
2415    }
2416
2417    pub fn enabled_when<F>(mut self, enabled: F) -> Self
2418    where
2419        F: Fn() -> bool + 'static,
2420    {
2421        self.enabled_reader = Some(Box::new(enabled));
2422        self
2423    }
2424
2425    pub fn on_press<F>(mut self, on_press: F) -> Self
2426    where
2427        F: FnMut() + 'static,
2428    {
2429        self.on_press = Some(Box::new(on_press));
2430        self
2431    }
2432
2433    pub fn on_press_with_ctx<F>(mut self, on_press: F) -> Self
2434    where
2435        F: FnMut(&mut EventCtx) + 'static,
2436    {
2437        self.on_press_with_ctx = Some(Box::new(on_press));
2438        self
2439    }
2440
2441    fn activate(&mut self, ctx: &mut EventCtx) {
2442        if !self.is_enabled() {
2443            return;
2444        }
2445        if let Some(on_press) = &mut self.on_press {
2446            on_press();
2447        }
2448        if let Some(on_press) = &mut self.on_press_with_ctx {
2449            on_press(ctx);
2450        }
2451    }
2452
2453    fn set_hovered(&mut self, hovered: bool, ctx: &mut EventCtx) {
2454        if self.hovered != hovered {
2455            let theme = self.resolved_theme();
2456            self.hovered = hovered;
2457            set_hover_animation_target(
2458                &mut self.hover_animation,
2459                hovered as u8 as f32,
2460                &theme,
2461                ctx,
2462            );
2463            ctx.request_paint();
2464            ctx.request_semantics();
2465        }
2466    }
2467
2468    fn advance_animations(&mut self, time: f64) -> bool {
2469        self.hover_animation.advance(time)
2470            | self.press_animation.advance(time)
2471            | self.focus_animation.advance(time)
2472    }
2473
2474    fn is_enabled(&self) -> bool {
2475        self.enabled_reader
2476            .as_ref()
2477            .map(|enabled| enabled())
2478            .unwrap_or(self.enabled)
2479    }
2480
2481    fn resolved_theme(&self) -> DefaultTheme {
2482        self.theme_reader
2483            .as_ref()
2484            .map(|theme| theme())
2485            .unwrap_or(*self.theme)
2486    }
2487
2488    fn resolved_text_style(&self) -> TextStyle {
2489        self.text_style
2490            .clone()
2491            .unwrap_or_else(|| self.resolved_theme().button_text_style())
2492    }
2493
2494    fn resolved_padding(&self) -> Insets {
2495        self.padding
2496            .unwrap_or(self.resolved_theme().metrics.button_padding)
2497    }
2498
2499    fn resolved_icon_size(&self) -> f32 {
2500        self.icon_size
2501            .unwrap_or(self.resolved_theme().metrics.icon_size)
2502            .max(0.0)
2503    }
2504
2505    fn resolved_icon_gap(&self) -> f32 {
2506        self.icon_gap
2507            .unwrap_or(self.resolved_theme().metrics.icon_label_gap)
2508            .max(0.0)
2509    }
2510
2511    fn icon_extent(&self) -> Option<(f32, f32)> {
2512        self.icon.map(|_| {
2513            let icon_size = self.resolved_icon_size();
2514            let gap = if self.label.is_empty() {
2515                0.0
2516            } else {
2517                self.resolved_icon_gap()
2518            };
2519            (icon_size, gap)
2520        })
2521    }
2522
2523    fn resolved_min_size(&self) -> Size {
2524        let theme = self.resolved_theme();
2525        Size::new(
2526            self.min_width.unwrap_or(theme.metrics.button_min_width),
2527            self.min_height.unwrap_or(theme.metrics.min_height),
2528        )
2529    }
2530
2531    #[cfg(test)]
2532    fn resolved_visuals(&self, focused: bool) -> ButtonVisuals {
2533        self.resolved_visuals_with_focus_progress(focused as u8 as f32)
2534    }
2535
2536    fn resolved_visuals_with_focus_progress(&self, focus_progress: f32) -> ButtonVisuals {
2537        let theme = self.resolved_theme();
2538        let palette = theme.palette;
2539        let interaction = theme.interaction;
2540        let enabled = self.is_enabled();
2541        let focus_progress = if enabled {
2542            focus_progress.clamp(0.0, 1.0)
2543        } else {
2544            0.0
2545        };
2546        let hover_progress = if enabled {
2547            self.hover_animation.value * interaction.hover_blend
2548        } else {
2549            0.0
2550        };
2551        let press_progress = if enabled {
2552            self.press_animation.value * interaction.pressed_blend
2553        } else {
2554            0.0
2555        };
2556        let legacy_default =
2557            self.appearance == ButtonAppearance::Filled && self.tone == SemanticTone::Accent;
2558        if !legacy_default {
2559            let semantic = semantic_button_visuals(
2560                &theme,
2561                self.appearance,
2562                self.tone,
2563                enabled,
2564                self.hover_animation.value,
2565                self.press_animation.value,
2566            );
2567            let label_peak_lift = resolve_luminance_role(&theme.hdr, WidgetLuminanceRole::Standard);
2568            let label_color = if enabled {
2569                apply_hdr_policy_cap(
2570                    self.text_style
2571                        .as_ref()
2572                        .map(|style| style.color)
2573                        .unwrap_or(semantic.content),
2574                    label_peak_lift,
2575                )
2576            } else {
2577                apply_hdr_policy_cap(semantic.content, label_peak_lift)
2578            };
2579            return ButtonVisuals {
2580                background: semantic.background,
2581                border: if enabled {
2582                    mix_color(semantic.border, palette.border_focus, focus_progress)
2583                } else {
2584                    semantic.border
2585                },
2586                focus_ring: (focus_progress > 0.0).then_some(
2587                    palette
2588                        .focus_ring
2589                        .with_alpha(palette.focus_ring.alpha * focus_progress),
2590                ),
2591                label_color,
2592                label_peak_lift,
2593                chrome_style: None,
2594            };
2595        }
2596        let background = if !enabled {
2597            mix_color(palette.control, palette.accent, 0.08)
2598                .with_alpha(interaction.disabled_opacity)
2599        } else {
2600            mix_color(
2601                mix_color(palette.accent, palette.accent_hover, hover_progress),
2602                palette.accent_pressed,
2603                press_progress,
2604            )
2605        };
2606        let border_base = if !enabled {
2607            palette
2608                .accent_border
2609                .with_alpha(interaction.disabled_content_opacity)
2610        } else {
2611            mix_color(
2612                palette.accent_border,
2613                palette.accent_border_hover,
2614                hover_progress,
2615            )
2616        };
2617        let border = if enabled {
2618            mix_color(border_base, palette.accent_border_focus, focus_progress)
2619        } else {
2620            border_base
2621        };
2622        let label_peak_lift = resolve_luminance_role(&theme.hdr, WidgetLuminanceRole::Standard);
2623        let label_color = if enabled {
2624            apply_hdr_policy_cap(self.resolved_text_style().color, label_peak_lift)
2625        } else {
2626            apply_hdr_policy_cap(palette.text_muted, label_peak_lift)
2627        };
2628
2629        if matches!(theme.hdr.mode, HdrThemeMode::Disabled) {
2630            return ButtonVisuals {
2631                background,
2632                border,
2633                focus_ring: (focus_progress > 0.0).then_some(
2634                    palette
2635                        .focus_ring
2636                        .with_alpha(palette.focus_ring.alpha * focus_progress),
2637                ),
2638                label_color,
2639                label_peak_lift,
2640                chrome_style: None,
2641            };
2642        }
2643
2644        let chrome_style = cap_resolved_hdr_style(resolve_widget_hdr_style(
2645            &theme.hdr,
2646            WidgetColorRole::Accent,
2647            WidgetLuminanceRole::SemanticAccent,
2648            WidgetMaterialRole::Flat,
2649            None,
2650        ));
2651        let focus_style = cap_resolved_hdr_style(resolve_widget_hdr_style(
2652            &theme.hdr,
2653            WidgetColorRole::Accent,
2654            WidgetLuminanceRole::Focused,
2655            WidgetMaterialRole::Flat,
2656            None,
2657        ));
2658        let hdr_background = if !enabled {
2659            background
2660        } else {
2661            mix_color(
2662                mix_color(chrome_style.color, palette.accent_hover, hover_progress),
2663                palette.accent_pressed,
2664                press_progress,
2665            )
2666        };
2667        let hdr_border_base = if !enabled {
2668            border
2669        } else {
2670            mix_color(
2671                palette.accent_border,
2672                palette.accent_border_hover,
2673                hover_progress,
2674            )
2675        };
2676        let hdr_border = if enabled {
2677            mix_color(hdr_border_base, focus_style.color, focus_progress)
2678        } else {
2679            hdr_border_base
2680        };
2681
2682        ButtonVisuals {
2683            background: hdr_background,
2684            border: hdr_border,
2685            focus_ring: (focus_progress > 0.0).then_some(
2686                focus_style
2687                    .color
2688                    .with_alpha(palette.focus_ring.alpha * focus_progress),
2689            ),
2690            label_color,
2691            label_peak_lift,
2692            chrome_style: Some(chrome_style),
2693        }
2694    }
2695
2696    fn button_content_rects(&self, bounds: Rect, padding: Insets) -> (Option<Rect>, Rect, f32) {
2697        let content = inset_rect(bounds, padding);
2698        let Some((icon_size, icon_gap)) = self.icon_extent() else {
2699            return (None, content, 0.5);
2700        };
2701
2702        let measurement = self.label_measurement;
2703        let natural_label_width = measurement.map(|value| value.width).unwrap_or(0.0);
2704        let icon_size = icon_size
2705            .min(content.width())
2706            .min(content.height())
2707            .max(0.0);
2708        let gap = if icon_size > 0.0 && natural_label_width > 0.0 {
2709            icon_gap.min(content.width())
2710        } else {
2711            0.0
2712        };
2713        let label_width = natural_label_width.min((content.width() - icon_size - gap).max(0.0));
2714        let group_width = icon_size + gap + label_width;
2715        let start_x = content.x() + ((content.width() - group_width).max(0.0) * 0.5);
2716        let icon_rect = Rect::new(
2717            start_x,
2718            content.y() + ((content.height() - icon_size) * 0.5),
2719            icon_size,
2720            icon_size,
2721        );
2722        let label_base = Rect::new(
2723            start_x + icon_size + gap,
2724            content.y(),
2725            label_width,
2726            content.height(),
2727        );
2728        (Some(icon_rect), label_base, 0.0)
2729    }
2730}
2731
2732impl Widget for Button {
2733    fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
2734        if !self.is_enabled() {
2735            if self.hovered || self.pressed {
2736                let theme = self.resolved_theme();
2737                self.hovered = false;
2738                self.pressed = false;
2739                set_hover_animation_target(&mut self.hover_animation, 0.0, &theme, ctx);
2740                set_press_animation_target(&mut self.press_animation, 0.0, &theme, ctx);
2741                ctx.request_paint();
2742                ctx.request_semantics();
2743            }
2744            return;
2745        }
2746
2747        match event {
2748            Event::Pointer(pointer) if pointer.kind == PointerEventKind::Move => {
2749                self.set_hovered(ctx.bounds().contains(pointer.position), ctx);
2750            }
2751            Event::Pointer(_pointer) if matches!(_pointer.kind, PointerEventKind::Enter) => {
2752                self.set_hovered(true, ctx);
2753            }
2754            Event::Pointer(_pointer) if matches!(_pointer.kind, PointerEventKind::Leave) => {
2755                self.set_hovered(false, ctx);
2756            }
2757            Event::Pointer(pointer)
2758                if pointer.kind == PointerEventKind::Down
2759                    && pointer.button == Some(PointerButton::Primary) =>
2760            {
2761                let theme = self.resolved_theme();
2762                self.pressed = true;
2763                self.hovered = true;
2764                set_hover_animation_target(&mut self.hover_animation, 1.0, &theme, ctx);
2765                set_press_animation_target(&mut self.press_animation, 1.0, &theme, ctx);
2766                ctx.request_pointer_capture(pointer.pointer_id);
2767                ctx.request_focus();
2768                ctx.request_paint();
2769                ctx.request_semantics();
2770                ctx.set_handled();
2771            }
2772            Event::Pointer(pointer)
2773                if pointer.kind == PointerEventKind::Up
2774                    && (pointer.button == Some(PointerButton::Primary) || self.pressed) =>
2775            {
2776                let theme = self.resolved_theme();
2777                let hovered = ctx.bounds().contains(pointer.position);
2778                let activate = self.pressed && hovered;
2779                self.pressed = false;
2780                self.hovered = hovered;
2781                set_hover_animation_target(
2782                    &mut self.hover_animation,
2783                    hovered as u8 as f32,
2784                    &theme,
2785                    ctx,
2786                );
2787                set_press_animation_target(&mut self.press_animation, 0.0, &theme, ctx);
2788                ctx.release_pointer_capture(pointer.pointer_id);
2789                if activate {
2790                    self.activate(ctx);
2791                }
2792                ctx.request_paint();
2793                ctx.request_semantics();
2794                ctx.set_handled();
2795            }
2796            Event::Pointer(pointer) if pointer.kind == PointerEventKind::Cancel => {
2797                if self.pressed {
2798                    let theme = self.resolved_theme();
2799                    self.pressed = false;
2800                    self.hovered = false;
2801                    set_hover_animation_target(&mut self.hover_animation, 0.0, &theme, ctx);
2802                    set_press_animation_target(&mut self.press_animation, 0.0, &theme, ctx);
2803                    ctx.release_pointer_capture(pointer.pointer_id);
2804                    ctx.request_paint();
2805                    ctx.request_semantics();
2806                    ctx.set_handled();
2807                }
2808            }
2809            Event::Keyboard(key)
2810                if key.state == KeyState::Pressed
2811                    && ctx.is_focused()
2812                    && matches!(key.key.as_str(), "Enter" | " ") =>
2813            {
2814                self.activate(ctx);
2815                ctx.request_paint();
2816                ctx.request_semantics();
2817                ctx.set_handled();
2818            }
2819            Event::Wake(sui_core::WakeEvent::AnimationFrame { time, .. }) => {
2820                if self.advance_animations(*time) {
2821                    ctx.request_animation_frame();
2822                }
2823                ctx.request_paint();
2824            }
2825            _ => {}
2826        }
2827    }
2828
2829    fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
2830        let text_style = self.resolved_text_style();
2831        let padding = self.resolved_padding();
2832        let min_size = self.resolved_min_size();
2833        let measured = measure_text(ctx, &self.label, &text_style);
2834        let label_layout = ctx
2835            .layout()
2836            .shape_text_persistent(
2837                self.label_layout.as_ref().map(|layout| layout.handle()),
2838                self.label.clone(),
2839                Size::new(
2840                    f32::INFINITY,
2841                    measured.height.max(text_style.line_height).max(1.0),
2842                ),
2843                text_style.clone(),
2844            )
2845            .ok();
2846        let measurement = label_layout
2847            .as_ref()
2848            .map(|layout| layout.measurement())
2849            .unwrap_or(measured);
2850        self.label_measurement = Some(measurement);
2851        self.label_layout = label_layout;
2852
2853        let (icon_size, icon_gap) = self.icon_extent().unwrap_or((0.0, 0.0));
2854        let content_width = icon_size + icon_gap + measurement.width;
2855        let content_height = measurement
2856            .height
2857            .max(text_style.line_height)
2858            .max(icon_size);
2859        let width = (content_width + padding.left + padding.right).max(min_size.width);
2860        let height = (content_height + padding.top + padding.bottom).max(min_size.height);
2861
2862        constraints.clamp(Size::new(width, height))
2863    }
2864
2865    fn paint(&self, ctx: &mut PaintCtx) {
2866        let theme = self.resolved_theme();
2867        let metrics = theme.metrics;
2868        let text_style = self.resolved_text_style();
2869        let padding = self.resolved_padding();
2870        let visuals = self.resolved_visuals_with_focus_progress(self.focus_animation.value);
2871        draw_control_frame(
2872            ctx,
2873            ctx.bounds(),
2874            metrics.corner_radius,
2875            metrics,
2876            visuals.background,
2877            visuals.border,
2878            visuals.focus_ring,
2879        );
2880        let (icon_rect, label_slot, label_alignment) =
2881            self.button_content_rects(ctx.bounds(), padding);
2882        if let (Some(icon), Some(icon_rect)) = (self.icon, icon_rect) {
2883            draw_icon_glyph(ctx, icon, icon_rect, visuals.label_color);
2884        }
2885        if self.is_enabled()
2886            && let Some(layout) = &self.label_layout
2887        {
2888            let layout_rect = aligned_text_rect_for_layout_with_mode(
2889                ctx,
2890                label_slot,
2891                layout.layout(),
2892                text_style.line_height,
2893                label_alignment,
2894                HorizontalTextAlignmentMode::Optical,
2895            );
2896            let layout_bounds = layout.measurement().bounds;
2897            ctx.push_clip_rect(layout_rect);
2898            ctx.draw_persistent_text_layout_with_color(
2899                Point::new(layout_rect.x() - layout_bounds.x(), layout_rect.y()),
2900                layout,
2901                visuals.label_color,
2902            );
2903            ctx.pop_clip();
2904            return;
2905        }
2906        let paint_style = TextStyle {
2907            color: visuals.label_color,
2908            ..text_style
2909        };
2910        paint_aligned_text(
2911            ctx,
2912            label_slot,
2913            &self.label,
2914            &paint_style,
2915            paint_style.line_height,
2916            label_alignment,
2917        );
2918    }
2919
2920    fn semantics(&self, ctx: &mut SemanticsCtx) {
2921        let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::Button, ctx.bounds());
2922        node.name = Some(
2923            self.semantic_name
2924                .clone()
2925                .unwrap_or_else(|| self.label.clone()),
2926        );
2927        node.description = self.semantic_description.clone();
2928        node.state.focused = ctx.is_focused();
2929        node.state.hovered = self.hovered && self.is_enabled();
2930        node.state.disabled = !self.is_enabled();
2931        node.actions = if self.is_enabled() {
2932            vec![SemanticsAction::Focus, SemanticsAction::Activate]
2933        } else {
2934            Vec::new()
2935        };
2936        ctx.push(node);
2937    }
2938
2939    fn accepts_focus(&self) -> bool {
2940        self.is_enabled()
2941    }
2942
2943    fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
2944        let theme = self.resolved_theme();
2945        set_focus_animation_target(&mut self.focus_animation, focused as u8 as f32, &theme, ctx);
2946        ctx.request_paint();
2947        ctx.request_semantics();
2948    }
2949}
2950
2951pub struct Checkbox {
2952    theme: Box<DefaultTheme>,
2953    theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
2954    label: String,
2955    checked: bool,
2956    appearance: ChoiceAppearance,
2957    text_style: Option<TextStyle>,
2958    padding: Option<Insets>,
2959    indicator_size: Option<f32>,
2960    gap: Option<f32>,
2961    hovered: bool,
2962    pressed: bool,
2963    hover_animation: AnimatedScalar,
2964    press_animation: AnimatedScalar,
2965    toggle_animation: AnimatedScalar,
2966    focus_animation: AnimatedScalar,
2967    label_measurement: Option<TextMeasurement>,
2968    on_toggle: Option<Box<dyn FnMut(bool)>>,
2969}
2970
2971#[derive(Clone, Copy, Debug, Default, PartialEq)]
2972pub struct CheckboxIndicatorState {
2973    pub checked: bool,
2974    pub hovered: bool,
2975    pub pressed: bool,
2976    pub focused: bool,
2977}
2978
2979impl CheckboxIndicatorState {
2980    pub fn new(checked: bool) -> Self {
2981        Self {
2982            checked,
2983            hovered: false,
2984            pressed: false,
2985            focused: false,
2986        }
2987    }
2988
2989    pub fn hovered(mut self, hovered: bool) -> Self {
2990        self.hovered = hovered;
2991        self
2992    }
2993
2994    pub fn pressed(mut self, pressed: bool) -> Self {
2995        self.pressed = pressed;
2996        self
2997    }
2998
2999    pub fn focused(mut self, focused: bool) -> Self {
3000        self.focused = focused;
3001        self
3002    }
3003}
3004
3005#[derive(Clone, Copy, Debug, Default)]
3006struct CheckboxIndicatorVisual {
3007    hover_progress: f32,
3008    press_progress: f32,
3009    toggle_progress: f32,
3010    focus_progress: f32,
3011}
3012
3013pub fn paint_checkbox_indicator(
3014    ctx: &mut PaintCtx,
3015    theme: &DefaultTheme,
3016    rect: Rect,
3017    state: CheckboxIndicatorState,
3018) {
3019    paint_checkbox_indicator_visual(
3020        ctx,
3021        theme,
3022        rect,
3023        CheckboxIndicatorVisual {
3024            hover_progress: state.hovered as u8 as f32,
3025            press_progress: state.pressed as u8 as f32,
3026            toggle_progress: state.checked as u8 as f32,
3027            focus_progress: state.focused as u8 as f32,
3028        },
3029    );
3030}
3031
3032fn paint_checkbox_indicator_visual(
3033    ctx: &mut PaintCtx,
3034    theme: &DefaultTheme,
3035    rect: Rect,
3036    visual: CheckboxIndicatorVisual,
3037) {
3038    if rect.width() <= 0.0 || rect.height() <= 0.0 {
3039        return;
3040    }
3041
3042    let palette = theme.palette;
3043    let metrics = theme.metrics;
3044    let interaction = theme.interaction;
3045    let hover_blend = visual.hover_progress * interaction.hover_blend;
3046    let press_blend = visual.press_progress * interaction.pressed_blend;
3047    let indicator_background = mix_color(
3048        mix_color(palette.control_active, palette.surface_focus, hover_blend),
3049        mix_color(
3050            mix_color(palette.accent, palette.accent_hover, hover_blend),
3051            palette.accent_pressed,
3052            press_blend,
3053        ),
3054        visual.toggle_progress,
3055    );
3056    let border = mix_color(
3057        mix_color(palette.border, palette.border_hover, visual.hover_progress),
3058        palette.border_focus,
3059        visual.focus_progress,
3060    );
3061    let indicator_border = mix_color(
3062        border,
3063        palette.accent_border_focus,
3064        visual.toggle_progress.max(visual.focus_progress),
3065    );
3066
3067    draw_control_shape(
3068        ctx,
3069        rect,
3070        metrics.indicator_corner_radius,
3071        metrics.border_width,
3072        indicator_background,
3073        indicator_border,
3074    );
3075    if visual.toggle_progress > 0.0 {
3076        let check_color = palette.accent_text.with_alpha(visual.toggle_progress);
3077        ctx.stroke(
3078            checkmark_path(rect.inflate(-4.0, -4.0)),
3079            check_color,
3080            StrokeStyle::new(physical_pixels(ctx, interaction.active_indicator_thickness)),
3081        );
3082    }
3083}
3084
3085impl Checkbox {
3086    pub fn new(label: impl Into<String>) -> Self {
3087        Self {
3088            theme: Box::new(DefaultTheme::default()),
3089            theme_reader: None,
3090            label: label.into(),
3091            checked: false,
3092            appearance: ChoiceAppearance::Plain,
3093            text_style: None,
3094            padding: None,
3095            indicator_size: None,
3096            gap: None,
3097            hovered: false,
3098            pressed: false,
3099            hover_animation: AnimatedScalar::new(0.0),
3100            press_animation: AnimatedScalar::new(0.0),
3101            toggle_animation: AnimatedScalar::new(0.0),
3102            focus_animation: AnimatedScalar::new(0.0),
3103            label_measurement: None,
3104            on_toggle: None,
3105        }
3106    }
3107
3108    pub fn checked(mut self, checked: bool) -> Self {
3109        self.checked = checked;
3110        self.toggle_animation = AnimatedScalar::new(checked as u8 as f32);
3111        self
3112    }
3113
3114    pub fn is_checked(&self) -> bool {
3115        self.checked
3116    }
3117
3118    /// Selects whether the complete checkbox row is plain or framed.
3119    pub fn appearance(mut self, appearance: ChoiceAppearance) -> Self {
3120        self.appearance = appearance;
3121        self
3122    }
3123
3124    /// Uses the quiet, transparent-at-rest row treatment.
3125    pub fn plain(self) -> Self {
3126        self.appearance(ChoiceAppearance::Plain)
3127    }
3128
3129    /// Uses the filled and bordered row treatment.
3130    pub fn framed(self) -> Self {
3131        self.appearance(ChoiceAppearance::Framed)
3132    }
3133
3134    pub fn theme(mut self, theme: DefaultTheme) -> Self {
3135        self.theme = Box::new(theme);
3136        self.theme_reader = None;
3137        self
3138    }
3139
3140    pub fn theme_when<F>(mut self, theme: F) -> Self
3141    where
3142        F: Fn() -> DefaultTheme + 'static,
3143    {
3144        self.theme_reader = Some(Box::new(theme));
3145        self
3146    }
3147
3148    pub fn text_style(mut self, text_style: TextStyle) -> Self {
3149        self.text_style = Some(text_style);
3150        self
3151    }
3152
3153    pub fn padding(mut self, padding: Insets) -> Self {
3154        self.padding = Some(padding);
3155        self
3156    }
3157
3158    pub fn indicator_size(mut self, indicator_size: f32) -> Self {
3159        self.indicator_size = Some(indicator_size.max(0.0));
3160        self
3161    }
3162
3163    pub fn gap(mut self, gap: f32) -> Self {
3164        self.gap = Some(gap.max(0.0));
3165        self
3166    }
3167
3168    pub fn set_checked(&mut self, checked: bool) {
3169        self.checked = checked;
3170        self.toggle_animation = AnimatedScalar::new(checked as u8 as f32);
3171    }
3172
3173    pub fn on_toggle<F>(mut self, on_toggle: F) -> Self
3174    where
3175        F: FnMut(bool) + 'static,
3176    {
3177        self.on_toggle = Some(Box::new(on_toggle));
3178        self
3179    }
3180
3181    fn toggle(&mut self) {
3182        self.checked = !self.checked;
3183        if let Some(on_toggle) = &mut self.on_toggle {
3184            on_toggle(self.checked);
3185        }
3186    }
3187
3188    fn set_hovered(&mut self, hovered: bool, ctx: &mut EventCtx) {
3189        if self.hovered != hovered {
3190            let theme = self.resolved_theme();
3191            self.hovered = hovered;
3192            set_hover_animation_target(
3193                &mut self.hover_animation,
3194                hovered as u8 as f32,
3195                &theme,
3196                ctx,
3197            );
3198            ctx.request_paint();
3199            ctx.request_semantics();
3200        }
3201    }
3202
3203    fn advance_animations(&mut self, time: f64) -> bool {
3204        self.hover_animation.advance(time)
3205            | self.press_animation.advance(time)
3206            | self.toggle_animation.advance(time)
3207            | self.focus_animation.advance(time)
3208    }
3209
3210    fn resolved_text_style(&self) -> TextStyle {
3211        self.text_style
3212            .clone()
3213            .unwrap_or_else(|| self.resolved_theme().body_text_style())
3214    }
3215
3216    fn resolved_padding(&self) -> Insets {
3217        self.padding
3218            .unwrap_or(self.resolved_theme().metrics.checkbox_padding)
3219    }
3220
3221    fn resolved_indicator_size(&self) -> f32 {
3222        self.indicator_size
3223            .unwrap_or(self.resolved_theme().metrics.checkbox_indicator_size)
3224    }
3225
3226    fn resolved_gap(&self) -> f32 {
3227        self.gap
3228            .unwrap_or(self.resolved_theme().metrics.checkbox_gap)
3229    }
3230
3231    fn resolved_theme(&self) -> DefaultTheme {
3232        self.theme_reader
3233            .as_ref()
3234            .map(|theme| theme())
3235            .unwrap_or(*self.theme)
3236    }
3237}
3238
3239impl Widget for Checkbox {
3240    fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
3241        match event {
3242            Event::Pointer(pointer) if pointer.kind == PointerEventKind::Move => {
3243                self.set_hovered(ctx.bounds().contains(pointer.position), ctx);
3244            }
3245            Event::Pointer(_pointer) if matches!(_pointer.kind, PointerEventKind::Enter) => {
3246                self.set_hovered(true, ctx);
3247            }
3248            Event::Pointer(_pointer) if matches!(_pointer.kind, PointerEventKind::Leave) => {
3249                self.set_hovered(false, ctx);
3250            }
3251            Event::Pointer(pointer)
3252                if pointer.kind == PointerEventKind::Down
3253                    && pointer.button == Some(PointerButton::Primary) =>
3254            {
3255                let theme = self.resolved_theme();
3256                self.pressed = true;
3257                self.hovered = true;
3258                set_hover_animation_target(&mut self.hover_animation, 1.0, &theme, ctx);
3259                set_press_animation_target(&mut self.press_animation, 1.0, &theme, ctx);
3260                ctx.request_pointer_capture(pointer.pointer_id);
3261                ctx.request_focus();
3262                ctx.request_paint();
3263                ctx.request_semantics();
3264                ctx.set_handled();
3265            }
3266            Event::Pointer(pointer)
3267                if pointer.kind == PointerEventKind::Up
3268                    && pointer.button == Some(PointerButton::Primary) =>
3269            {
3270                let theme = self.resolved_theme();
3271                let hovered = ctx.bounds().contains(pointer.position);
3272                let toggle = self.pressed && hovered;
3273                self.pressed = false;
3274                self.hovered = hovered;
3275                set_hover_animation_target(
3276                    &mut self.hover_animation,
3277                    hovered as u8 as f32,
3278                    &theme,
3279                    ctx,
3280                );
3281                set_press_animation_target(&mut self.press_animation, 0.0, &theme, ctx);
3282                ctx.release_pointer_capture(pointer.pointer_id);
3283                if toggle {
3284                    self.toggle();
3285                    set_toggle_animation_target(
3286                        &mut self.toggle_animation,
3287                        self.checked as u8 as f32,
3288                        &theme,
3289                        ctx,
3290                    );
3291                }
3292                ctx.request_paint();
3293                ctx.request_semantics();
3294                ctx.set_handled();
3295            }
3296            Event::Pointer(pointer) if pointer.kind == PointerEventKind::Cancel => {
3297                if self.pressed {
3298                    let theme = self.resolved_theme();
3299                    self.pressed = false;
3300                    self.hovered = false;
3301                    set_hover_animation_target(&mut self.hover_animation, 0.0, &theme, ctx);
3302                    set_press_animation_target(&mut self.press_animation, 0.0, &theme, ctx);
3303                    ctx.release_pointer_capture(pointer.pointer_id);
3304                    ctx.request_paint();
3305                    ctx.request_semantics();
3306                    ctx.set_handled();
3307                }
3308            }
3309            Event::Keyboard(key)
3310                if key.state == KeyState::Pressed
3311                    && ctx.is_focused()
3312                    && matches!(key.key.as_str(), "Enter" | " ") =>
3313            {
3314                let theme = self.resolved_theme();
3315                self.toggle();
3316                set_toggle_animation_target(
3317                    &mut self.toggle_animation,
3318                    self.checked as u8 as f32,
3319                    &theme,
3320                    ctx,
3321                );
3322                ctx.request_paint();
3323                ctx.request_semantics();
3324                ctx.set_handled();
3325            }
3326            Event::Wake(sui_core::WakeEvent::AnimationFrame { time, .. }) => {
3327                if self.advance_animations(*time) {
3328                    ctx.request_animation_frame();
3329                }
3330                ctx.request_paint();
3331            }
3332            _ => {}
3333        }
3334    }
3335
3336    fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
3337        let theme = self.resolved_theme();
3338        let text_style = self.resolved_text_style();
3339        let padding = self.resolved_padding();
3340        let indicator_size = self.resolved_indicator_size();
3341        let gap = self.resolved_gap();
3342        let measurement = measure_text(ctx, &self.label, &text_style);
3343        self.label_measurement = Some(measurement);
3344
3345        let width = padding.left + indicator_size + gap + measurement.width + padding.right;
3346        let content_height = indicator_size.max(measurement.height.max(text_style.line_height));
3347        let height = choice_control_height(
3348            content_height,
3349            padding,
3350            default_form_control_height(&theme),
3351            self.padding.is_some(),
3352        );
3353
3354        constraints.clamp(Size::new(width, height))
3355    }
3356
3357    fn paint(&self, ctx: &mut PaintCtx) {
3358        let theme = self.resolved_theme();
3359        let palette = theme.palette;
3360        let metrics = theme.metrics;
3361        let interaction = theme.interaction;
3362        let text_style = self.resolved_text_style();
3363        let padding = self.resolved_padding();
3364        let indicator_size = self.resolved_indicator_size();
3365        let gap = self.resolved_gap();
3366        let hover_progress = self.hover_animation.value * interaction.hover_blend;
3367        let press_progress = self.press_animation.value * interaction.pressed_blend;
3368        let toggle_progress = self.toggle_animation.value;
3369        let focus_progress = self.focus_animation.value;
3370        let framed_background = mix_color(
3371            mix_color(palette.control, palette.control_hover, hover_progress),
3372            palette.control_active,
3373            press_progress,
3374        );
3375        let framed_border = mix_color(
3376            mix_color(
3377                palette.border,
3378                palette.border_hover,
3379                self.hover_animation.value,
3380            ),
3381            palette.border_focus,
3382            focus_progress,
3383        );
3384        let frame_visuals = choice_frame_visuals(
3385            &theme,
3386            self.appearance,
3387            framed_background,
3388            framed_border,
3389            hover_progress,
3390            press_progress,
3391            focus_progress,
3392        );
3393        let layout_padding = choice_control_layout_padding(padding, self.padding.is_some());
3394        let indicator = indicator_rect(ctx.bounds(), layout_padding, indicator_size);
3395        let label_rect = checkbox_label_rect(ctx.bounds(), layout_padding, indicator_size, gap);
3396
3397        draw_choice_control_frame(
3398            ctx,
3399            ctx.bounds(),
3400            metrics.corner_radius,
3401            metrics,
3402            self.appearance,
3403            frame_visuals,
3404            (focus_progress > 0.0).then_some(
3405                palette
3406                    .focus_ring
3407                    .with_alpha(palette.focus_ring.alpha * focus_progress),
3408            ),
3409        );
3410
3411        paint_checkbox_indicator_visual(
3412            ctx,
3413            &theme,
3414            indicator,
3415            CheckboxIndicatorVisual {
3416                hover_progress: self.hover_animation.value,
3417                press_progress: self.press_animation.value,
3418                toggle_progress,
3419                focus_progress,
3420            },
3421        );
3422        paint_aligned_text(
3423            ctx,
3424            label_rect,
3425            &self.label,
3426            &text_style,
3427            text_style.line_height,
3428            0.0,
3429        );
3430    }
3431
3432    fn semantics(&self, ctx: &mut SemanticsCtx) {
3433        let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::CheckBox, ctx.bounds());
3434        node.name = Some(self.label.clone());
3435        node.state.focused = ctx.is_focused();
3436        node.state.hovered = self.hovered;
3437        node.state.checked = Some(if self.checked {
3438            ToggleState::Checked
3439        } else {
3440            ToggleState::Unchecked
3441        });
3442        node.actions = vec![SemanticsAction::Focus, SemanticsAction::Activate];
3443        ctx.push(node);
3444    }
3445
3446    fn accepts_focus(&self) -> bool {
3447        true
3448    }
3449
3450    fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
3451        let theme = self.resolved_theme();
3452        set_focus_animation_target(&mut self.focus_animation, focused as u8 as f32, &theme, ctx);
3453        ctx.request_paint();
3454        ctx.request_semantics();
3455    }
3456}
3457
3458pub struct Switch {
3459    theme: Box<DefaultTheme>,
3460    theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
3461    label: String,
3462    on: bool,
3463    appearance: ChoiceAppearance,
3464    text_style: Option<TextStyle>,
3465    padding: Option<Insets>,
3466    gap: Option<f32>,
3467    hovered: bool,
3468    pressed: bool,
3469    hover_animation: AnimatedScalar,
3470    press_animation: AnimatedScalar,
3471    toggle_animation: AnimatedScalar,
3472    focus_animation: AnimatedScalar,
3473    label_measurement: Option<TextMeasurement>,
3474    on_toggle: Option<Box<dyn FnMut(bool)>>,
3475}
3476
3477#[derive(Debug, Clone, Copy, PartialEq)]
3478struct SwitchVisuals {
3479    frame_background: Color,
3480    frame_border: Color,
3481    track_color: Color,
3482    track_border: Color,
3483    thumb_color: Color,
3484    label_color: Color,
3485    label_peak_lift: f32,
3486    indicator_style: Option<ResolvedHdrStyle>,
3487}
3488
3489impl Switch {
3490    pub fn new(label: impl Into<String>) -> Self {
3491        Self {
3492            theme: Box::new(DefaultTheme::default()),
3493            theme_reader: None,
3494            label: label.into(),
3495            on: false,
3496            appearance: ChoiceAppearance::Plain,
3497            text_style: None,
3498            padding: None,
3499            gap: None,
3500            hovered: false,
3501            pressed: false,
3502            hover_animation: AnimatedScalar::new(0.0),
3503            press_animation: AnimatedScalar::new(0.0),
3504            toggle_animation: AnimatedScalar::new(0.0),
3505            focus_animation: AnimatedScalar::new(0.0),
3506            label_measurement: None,
3507            on_toggle: None,
3508        }
3509    }
3510
3511    pub fn on(mut self, on: bool) -> Self {
3512        self.on = on;
3513        self.toggle_animation = AnimatedScalar::new(on as u8 as f32);
3514        self
3515    }
3516
3517    pub fn is_on(&self) -> bool {
3518        self.on
3519    }
3520
3521    /// Selects whether the complete switch row is plain or framed.
3522    pub fn appearance(mut self, appearance: ChoiceAppearance) -> Self {
3523        self.appearance = appearance;
3524        self
3525    }
3526
3527    /// Uses the quiet, transparent-at-rest row treatment.
3528    pub fn plain(self) -> Self {
3529        self.appearance(ChoiceAppearance::Plain)
3530    }
3531
3532    /// Uses the filled and bordered row treatment.
3533    pub fn framed(self) -> Self {
3534        self.appearance(ChoiceAppearance::Framed)
3535    }
3536
3537    pub fn set_on(&mut self, on: bool) {
3538        self.on = on;
3539        self.toggle_animation = AnimatedScalar::new(on as u8 as f32);
3540    }
3541
3542    pub fn theme(mut self, theme: DefaultTheme) -> Self {
3543        self.theme = Box::new(theme);
3544        self.theme_reader = None;
3545        self
3546    }
3547
3548    pub fn theme_when<F>(mut self, theme: F) -> Self
3549    where
3550        F: Fn() -> DefaultTheme + 'static,
3551    {
3552        self.theme_reader = Some(Box::new(theme));
3553        self
3554    }
3555
3556    pub fn text_style(mut self, text_style: TextStyle) -> Self {
3557        self.text_style = Some(text_style);
3558        self
3559    }
3560
3561    pub fn padding(mut self, padding: Insets) -> Self {
3562        self.padding = Some(padding);
3563        self
3564    }
3565
3566    pub fn gap(mut self, gap: f32) -> Self {
3567        self.gap = Some(gap.max(0.0));
3568        self
3569    }
3570
3571    pub fn on_toggle<F>(mut self, on_toggle: F) -> Self
3572    where
3573        F: FnMut(bool) + 'static,
3574    {
3575        self.on_toggle = Some(Box::new(on_toggle));
3576        self
3577    }
3578
3579    fn resolved_text_style(&self) -> TextStyle {
3580        self.text_style
3581            .clone()
3582            .unwrap_or_else(|| self.resolved_theme().body_text_style())
3583    }
3584
3585    fn resolved_padding(&self) -> Insets {
3586        self.padding
3587            .unwrap_or(self.resolved_theme().metrics.checkbox_padding)
3588    }
3589
3590    fn resolved_gap(&self) -> f32 {
3591        self.gap
3592            .unwrap_or(self.resolved_theme().metrics.checkbox_gap)
3593    }
3594
3595    fn resolved_theme(&self) -> DefaultTheme {
3596        self.theme_reader
3597            .as_ref()
3598            .map(|theme| theme())
3599            .unwrap_or(*self.theme)
3600    }
3601
3602    fn toggle(&mut self) {
3603        self.on = !self.on;
3604        if let Some(on_toggle) = &mut self.on_toggle {
3605            on_toggle(self.on);
3606        }
3607    }
3608
3609    fn set_hovered(&mut self, hovered: bool, ctx: &mut EventCtx) {
3610        if self.hovered != hovered {
3611            let theme = self.resolved_theme();
3612            self.hovered = hovered;
3613            set_hover_animation_target(
3614                &mut self.hover_animation,
3615                hovered as u8 as f32,
3616                &theme,
3617                ctx,
3618            );
3619            ctx.request_paint();
3620            ctx.request_semantics();
3621        }
3622    }
3623
3624    fn advance_animations(&mut self, time: f64) -> bool {
3625        self.hover_animation.advance(time)
3626            | self.press_animation.advance(time)
3627            | self.toggle_animation.advance(time)
3628            | self.focus_animation.advance(time)
3629    }
3630
3631    fn resolved_visuals_for_state(&self, on: bool, focused: bool) -> SwitchVisuals {
3632        let theme = self.resolved_theme();
3633        let palette = theme.palette;
3634        let interaction = theme.interaction;
3635        let hover_t = self.hover_animation.value * interaction.hover_blend;
3636        let press_t = self.press_animation.value * interaction.pressed_blend;
3637        let framed_background = mix_color(
3638            mix_color(
3639                palette.control,
3640                palette.control_hover,
3641                self.hover_animation.value,
3642            ),
3643            palette.control_active,
3644            press_t,
3645        );
3646        let framed_background = if focused {
3647            mix_color(framed_background, palette.surface_focus, 0.5)
3648        } else {
3649            framed_background
3650        };
3651        let framed_border = mix_color(
3652            mix_color(
3653                palette.border,
3654                palette.border_hover,
3655                self.hover_animation.value,
3656            ),
3657            palette.border_focus,
3658            focused as u8 as f32,
3659        );
3660        let frame_visuals = choice_frame_visuals(
3661            &theme,
3662            self.appearance,
3663            framed_background,
3664            framed_border,
3665            hover_t,
3666            press_t,
3667            focused as u8 as f32,
3668        );
3669        let baseline_track_color = if on {
3670            mix_color(
3671                mix_color(palette.accent, palette.accent_hover, hover_t),
3672                palette.accent_pressed,
3673                press_t,
3674            )
3675        } else {
3676            mix_color(palette.surface_focus, palette.control_active, hover_t)
3677        };
3678        let baseline_track_border = if on {
3679            palette.accent_border
3680        } else {
3681            mix_color(
3682                palette.border,
3683                palette.border_hover,
3684                self.hover_animation.value,
3685            )
3686        };
3687        let thumb_color = if matches!(
3688            theme.colors.scheme,
3689            ThemeColorScheme::Dark | ThemeColorScheme::HighContrast
3690        ) {
3691            palette.text
3692        } else {
3693            palette.accent_text
3694        };
3695        let label_peak_lift = resolve_luminance_role(&theme.hdr, WidgetLuminanceRole::Standard);
3696        let label_color = apply_hdr_policy_cap(self.resolved_text_style().color, label_peak_lift);
3697
3698        if matches!(theme.hdr.mode, HdrThemeMode::Disabled) || !on {
3699            return SwitchVisuals {
3700                frame_background: frame_visuals.background,
3701                frame_border: frame_visuals.border,
3702                track_color: baseline_track_color,
3703                track_border: baseline_track_border,
3704                thumb_color,
3705                label_color,
3706                label_peak_lift,
3707                indicator_style: None,
3708            };
3709        }
3710
3711        let indicator_style = cap_resolved_hdr_style(resolve_widget_hdr_style(
3712            &theme.hdr,
3713            WidgetColorRole::Accent,
3714            WidgetLuminanceRole::EmissiveIndicator,
3715            WidgetMaterialRole::Flat,
3716            None,
3717        ));
3718
3719        SwitchVisuals {
3720            frame_background: frame_visuals.background,
3721            frame_border: frame_visuals.border,
3722            track_color: mix_color(
3723                mix_color(indicator_style.color, palette.accent_hover, hover_t),
3724                palette.accent_pressed,
3725                press_t,
3726            ),
3727            track_border: if focused {
3728                indicator_style.color
3729            } else {
3730                palette.accent_border
3731            },
3732            thumb_color,
3733            label_color,
3734            label_peak_lift,
3735            indicator_style: Some(indicator_style),
3736        }
3737    }
3738
3739    fn resolved_visuals(&self, focused: bool) -> SwitchVisuals {
3740        self.resolved_visuals_for_state(self.on, focused)
3741    }
3742}
3743
3744impl Widget for Switch {
3745    fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
3746        match event {
3747            Event::Pointer(pointer) if pointer.kind == PointerEventKind::Move => {
3748                self.set_hovered(ctx.bounds().contains(pointer.position), ctx);
3749            }
3750            Event::Pointer(_pointer) if matches!(_pointer.kind, PointerEventKind::Enter) => {
3751                self.set_hovered(true, ctx);
3752            }
3753            Event::Pointer(_pointer) if matches!(_pointer.kind, PointerEventKind::Leave) => {
3754                self.set_hovered(false, ctx);
3755            }
3756            Event::Pointer(pointer)
3757                if pointer.kind == PointerEventKind::Down
3758                    && pointer.button == Some(PointerButton::Primary) =>
3759            {
3760                let theme = self.resolved_theme();
3761                self.pressed = true;
3762                self.hovered = true;
3763                set_hover_animation_target(&mut self.hover_animation, 1.0, &theme, ctx);
3764                set_press_animation_target(&mut self.press_animation, 1.0, &theme, ctx);
3765                ctx.request_pointer_capture(pointer.pointer_id);
3766                ctx.request_focus();
3767                ctx.request_paint();
3768                ctx.request_semantics();
3769                ctx.set_handled();
3770            }
3771            Event::Pointer(pointer)
3772                if pointer.kind == PointerEventKind::Up
3773                    && pointer.button == Some(PointerButton::Primary) =>
3774            {
3775                let theme = self.resolved_theme();
3776                let hovered = ctx.bounds().contains(pointer.position);
3777                let toggle = self.pressed && hovered;
3778                self.pressed = false;
3779                self.hovered = hovered;
3780                set_hover_animation_target(
3781                    &mut self.hover_animation,
3782                    hovered as u8 as f32,
3783                    &theme,
3784                    ctx,
3785                );
3786                set_press_animation_target(&mut self.press_animation, 0.0, &theme, ctx);
3787                ctx.release_pointer_capture(pointer.pointer_id);
3788                if toggle {
3789                    self.toggle();
3790                    set_toggle_animation_target(
3791                        &mut self.toggle_animation,
3792                        self.on as u8 as f32,
3793                        &theme,
3794                        ctx,
3795                    );
3796                }
3797                ctx.request_paint();
3798                ctx.request_semantics();
3799                ctx.set_handled();
3800            }
3801            Event::Pointer(pointer) if pointer.kind == PointerEventKind::Cancel => {
3802                if self.pressed {
3803                    let theme = self.resolved_theme();
3804                    self.pressed = false;
3805                    self.hovered = false;
3806                    set_hover_animation_target(&mut self.hover_animation, 0.0, &theme, ctx);
3807                    set_press_animation_target(&mut self.press_animation, 0.0, &theme, ctx);
3808                    ctx.release_pointer_capture(pointer.pointer_id);
3809                    ctx.request_paint();
3810                    ctx.request_semantics();
3811                    ctx.set_handled();
3812                }
3813            }
3814            Event::Keyboard(key)
3815                if key.state == KeyState::Pressed
3816                    && ctx.is_focused()
3817                    && matches!(key.key.as_str(), "Enter" | " ") =>
3818            {
3819                let theme = self.resolved_theme();
3820                self.toggle();
3821                set_toggle_animation_target(
3822                    &mut self.toggle_animation,
3823                    self.on as u8 as f32,
3824                    &theme,
3825                    ctx,
3826                );
3827                ctx.request_paint();
3828                ctx.request_semantics();
3829                ctx.set_handled();
3830            }
3831            Event::Wake(sui_core::WakeEvent::AnimationFrame { time, .. }) => {
3832                if self.advance_animations(*time) {
3833                    ctx.request_animation_frame();
3834                }
3835                ctx.request_paint();
3836            }
3837            _ => {}
3838        }
3839    }
3840
3841    fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
3842        let theme = self.resolved_theme();
3843        let text_style = self.resolved_text_style();
3844        let padding = self.resolved_padding();
3845        let gap = self.resolved_gap();
3846        let measurement = measure_text(ctx, &self.label, &text_style);
3847        self.label_measurement = Some(measurement);
3848        let track_width = theme.metrics.switch_track_width;
3849        let track_height = theme.metrics.switch_track_height;
3850
3851        let content_height = track_height.max(measurement.height.max(text_style.line_height));
3852
3853        constraints.clamp(Size::new(
3854            padding.left + track_width + gap + measurement.width + padding.right,
3855            choice_control_height(
3856                content_height,
3857                padding,
3858                default_form_control_height(&theme),
3859                self.padding.is_some(),
3860            ),
3861        ))
3862    }
3863
3864    fn paint(&self, ctx: &mut PaintCtx) {
3865        let theme = self.resolved_theme();
3866        let metrics = theme.metrics;
3867        let palette = theme.palette;
3868        let interaction = theme.interaction;
3869        let text_style = self.resolved_text_style();
3870        let padding = self.resolved_padding();
3871        let gap = self.resolved_gap();
3872        let track = switch_track_rect(ctx.bounds(), padding, metrics);
3873        let label_rect = switch_label_rect(ctx.bounds(), padding, metrics, gap);
3874        let visuals = self.resolved_visuals(ctx.is_focused());
3875        let off_visuals = self.resolved_visuals_for_state(false, ctx.is_focused());
3876        let on_visuals = self.resolved_visuals_for_state(true, ctx.is_focused());
3877        let hover_progress = self.hover_animation.value * interaction.hover_blend;
3878        let press_progress = self.press_animation.value * interaction.pressed_blend;
3879        let toggle_progress = self.toggle_animation.value;
3880        let focus_progress = self.focus_animation.value;
3881
3882        let framed_background = mix_color(
3883            mix_color(
3884                mix_color(palette.control, palette.control_hover, hover_progress),
3885                palette.surface_focus,
3886                focus_progress,
3887            ),
3888            palette.control_active,
3889            press_progress,
3890        );
3891        let framed_border = mix_color(
3892            mix_color(palette.border, palette.border_hover, hover_progress),
3893            palette.border_focus,
3894            focus_progress,
3895        );
3896        let frame_visuals = choice_frame_visuals(
3897            &theme,
3898            self.appearance,
3899            framed_background,
3900            framed_border,
3901            hover_progress,
3902            press_progress,
3903            focus_progress,
3904        );
3905
3906        draw_choice_control_frame(
3907            ctx,
3908            ctx.bounds(),
3909            metrics.corner_radius,
3910            metrics,
3911            self.appearance,
3912            frame_visuals,
3913            (focus_progress > 0.0).then_some(
3914                palette
3915                    .focus_ring
3916                    .with_alpha(palette.focus_ring.alpha * focus_progress),
3917            ),
3918        );
3919
3920        let thumb_inset = metrics.switch_thumb_inset;
3921        let thumb_size = (track.height() - (thumb_inset * 2.0)).max(0.0);
3922        let thumb_x_off = track.x() + thumb_inset;
3923        let thumb_x_on = track.max_x() - thumb_size - thumb_inset;
3924        let thumb = Rect::new(
3925            f32::interpolate(thumb_x_off, thumb_x_on, toggle_progress),
3926            track.y() + thumb_inset,
3927            thumb_size,
3928            thumb_size,
3929        );
3930
3931        let track_color = if toggle_progress <= f32::EPSILON {
3932            off_visuals.track_color
3933        } else if (1.0 - toggle_progress) <= f32::EPSILON {
3934            on_visuals.track_color
3935        } else {
3936            mix_color(
3937                off_visuals.track_color,
3938                on_visuals.track_color,
3939                toggle_progress,
3940            )
3941        };
3942        let track_border = if toggle_progress <= f32::EPSILON {
3943            off_visuals.track_border
3944        } else if (1.0 - toggle_progress) <= f32::EPSILON {
3945            on_visuals.track_border
3946        } else {
3947            mix_color(
3948                off_visuals.track_border,
3949                on_visuals.track_border,
3950                toggle_progress,
3951            )
3952        };
3953
3954        draw_control_shape(
3955            ctx,
3956            track,
3957            track.height() * 0.5,
3958            physical_pixels(ctx, metrics.border_width),
3959            track_color,
3960            track_border,
3961        );
3962        ctx.fill(
3963            Path::circle(rect_center(thumb), thumb.width() * 0.5),
3964            visuals.thumb_color,
3965        );
3966        let text_style = TextStyle {
3967            color: visuals.label_color,
3968            ..text_style
3969        };
3970        paint_aligned_text(
3971            ctx,
3972            label_rect,
3973            &self.label,
3974            &text_style,
3975            text_style.line_height,
3976            0.0,
3977        );
3978    }
3979
3980    fn semantics(&self, ctx: &mut SemanticsCtx) {
3981        let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::Switch, ctx.bounds());
3982        node.name = Some(self.label.clone());
3983        node.state.focused = ctx.is_focused();
3984        node.state.hovered = self.hovered;
3985        node.state.checked = Some(if self.on {
3986            ToggleState::Checked
3987        } else {
3988            ToggleState::Unchecked
3989        });
3990        node.actions = vec![SemanticsAction::Focus, SemanticsAction::Activate];
3991        ctx.push(node);
3992    }
3993
3994    fn accepts_focus(&self) -> bool {
3995        true
3996    }
3997
3998    fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
3999        let theme = self.resolved_theme();
4000        set_focus_animation_target(&mut self.focus_animation, focused as u8 as f32, &theme, ctx);
4001        ctx.request_paint();
4002        ctx.request_semantics();
4003    }
4004}
4005
4006pub struct RadioButton {
4007    theme: Box<DefaultTheme>,
4008    theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
4009    label: String,
4010    selected: bool,
4011    appearance: ChoiceAppearance,
4012    text_style: Option<TextStyle>,
4013    padding: Option<Insets>,
4014    indicator_size: Option<f32>,
4015    gap: Option<f32>,
4016    hovered: bool,
4017    pressed: bool,
4018    hover_animation: AnimatedScalar,
4019    press_animation: AnimatedScalar,
4020    toggle_animation: AnimatedScalar,
4021    focus_animation: AnimatedScalar,
4022    label_measurement: Option<TextMeasurement>,
4023    on_select: Option<Box<dyn FnMut()>>,
4024}
4025
4026impl RadioButton {
4027    pub fn new(label: impl Into<String>) -> Self {
4028        Self {
4029            theme: Box::new(DefaultTheme::default()),
4030            theme_reader: None,
4031            label: label.into(),
4032            selected: false,
4033            appearance: ChoiceAppearance::Plain,
4034            text_style: None,
4035            padding: None,
4036            indicator_size: None,
4037            gap: None,
4038            hovered: false,
4039            pressed: false,
4040            hover_animation: AnimatedScalar::new(0.0),
4041            press_animation: AnimatedScalar::new(0.0),
4042            toggle_animation: AnimatedScalar::new(0.0),
4043            focus_animation: AnimatedScalar::new(0.0),
4044            label_measurement: None,
4045            on_select: None,
4046        }
4047    }
4048
4049    pub fn selected(mut self, selected: bool) -> Self {
4050        self.selected = selected;
4051        self.toggle_animation = AnimatedScalar::new(selected as u8 as f32);
4052        self
4053    }
4054
4055    pub fn is_selected(&self) -> bool {
4056        self.selected
4057    }
4058
4059    /// Selects whether the complete radio row is plain or framed.
4060    pub fn appearance(mut self, appearance: ChoiceAppearance) -> Self {
4061        self.appearance = appearance;
4062        self
4063    }
4064
4065    /// Uses the quiet, transparent-at-rest row treatment.
4066    pub fn plain(self) -> Self {
4067        self.appearance(ChoiceAppearance::Plain)
4068    }
4069
4070    /// Uses the filled and bordered row treatment.
4071    pub fn framed(self) -> Self {
4072        self.appearance(ChoiceAppearance::Framed)
4073    }
4074
4075    pub fn set_selected(&mut self, selected: bool) {
4076        self.selected = selected;
4077        self.toggle_animation = AnimatedScalar::new(selected as u8 as f32);
4078    }
4079
4080    pub fn theme(mut self, theme: DefaultTheme) -> Self {
4081        self.theme = Box::new(theme);
4082        self.theme_reader = None;
4083        self
4084    }
4085
4086    pub fn theme_when<F>(mut self, theme: F) -> Self
4087    where
4088        F: Fn() -> DefaultTheme + 'static,
4089    {
4090        self.theme_reader = Some(Box::new(theme));
4091        self
4092    }
4093
4094    pub fn text_style(mut self, text_style: TextStyle) -> Self {
4095        self.text_style = Some(text_style);
4096        self
4097    }
4098
4099    pub fn padding(mut self, padding: Insets) -> Self {
4100        self.padding = Some(padding);
4101        self
4102    }
4103
4104    pub fn indicator_size(mut self, indicator_size: f32) -> Self {
4105        self.indicator_size = Some(indicator_size.max(0.0));
4106        self
4107    }
4108
4109    pub fn gap(mut self, gap: f32) -> Self {
4110        self.gap = Some(gap.max(0.0));
4111        self
4112    }
4113
4114    pub fn on_select<F>(mut self, on_select: F) -> Self
4115    where
4116        F: FnMut() + 'static,
4117    {
4118        self.on_select = Some(Box::new(on_select));
4119        self
4120    }
4121
4122    fn resolved_text_style(&self) -> TextStyle {
4123        self.text_style
4124            .clone()
4125            .unwrap_or_else(|| self.resolved_theme().body_text_style())
4126    }
4127
4128    fn resolved_padding(&self) -> Insets {
4129        self.padding
4130            .unwrap_or(self.resolved_theme().metrics.checkbox_padding)
4131    }
4132
4133    fn resolved_indicator_size(&self) -> f32 {
4134        self.indicator_size
4135            .unwrap_or(self.resolved_theme().metrics.checkbox_indicator_size)
4136    }
4137
4138    fn resolved_gap(&self) -> f32 {
4139        self.gap
4140            .unwrap_or(self.resolved_theme().metrics.checkbox_gap)
4141    }
4142
4143    fn resolved_theme(&self) -> DefaultTheme {
4144        self.theme_reader
4145            .as_ref()
4146            .map(|theme| theme())
4147            .unwrap_or(*self.theme)
4148    }
4149
4150    fn activate(&mut self, ctx: &mut EventCtx) {
4151        let theme = self.resolved_theme();
4152        let changed = !self.selected;
4153        self.selected = true;
4154        if changed {
4155            set_toggle_animation_target(&mut self.toggle_animation, 1.0, &theme, ctx);
4156        }
4157        if let Some(on_select) = &mut self.on_select {
4158            on_select();
4159        }
4160    }
4161
4162    fn set_hovered(&mut self, hovered: bool, ctx: &mut EventCtx) {
4163        if self.hovered != hovered {
4164            let theme = self.resolved_theme();
4165            self.hovered = hovered;
4166            set_hover_animation_target(
4167                &mut self.hover_animation,
4168                hovered as u8 as f32,
4169                &theme,
4170                ctx,
4171            );
4172            ctx.request_paint();
4173            ctx.request_semantics();
4174        }
4175    }
4176
4177    fn advance_animations(&mut self, time: f64) -> bool {
4178        self.hover_animation.advance(time)
4179            | self.press_animation.advance(time)
4180            | self.toggle_animation.advance(time)
4181            | self.focus_animation.advance(time)
4182    }
4183}
4184
4185impl Widget for RadioButton {
4186    fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
4187        match event {
4188            Event::Pointer(pointer) if pointer.kind == PointerEventKind::Move => {
4189                self.set_hovered(ctx.bounds().contains(pointer.position), ctx);
4190            }
4191            Event::Pointer(_pointer) if matches!(_pointer.kind, PointerEventKind::Enter) => {
4192                self.set_hovered(true, ctx);
4193            }
4194            Event::Pointer(_pointer) if matches!(_pointer.kind, PointerEventKind::Leave) => {
4195                self.set_hovered(false, ctx);
4196            }
4197            Event::Pointer(pointer)
4198                if pointer.kind == PointerEventKind::Down
4199                    && pointer.button == Some(PointerButton::Primary) =>
4200            {
4201                let theme = self.resolved_theme();
4202                self.pressed = true;
4203                self.hovered = true;
4204                set_hover_animation_target(&mut self.hover_animation, 1.0, &theme, ctx);
4205                set_press_animation_target(&mut self.press_animation, 1.0, &theme, ctx);
4206                ctx.request_pointer_capture(pointer.pointer_id);
4207                ctx.request_focus();
4208                ctx.request_paint();
4209                ctx.request_semantics();
4210                ctx.set_handled();
4211            }
4212            Event::Pointer(pointer)
4213                if pointer.kind == PointerEventKind::Up
4214                    && pointer.button == Some(PointerButton::Primary) =>
4215            {
4216                let theme = self.resolved_theme();
4217                let hovered = ctx.bounds().contains(pointer.position);
4218                let activate = self.pressed && hovered;
4219                self.pressed = false;
4220                self.hovered = hovered;
4221                set_hover_animation_target(
4222                    &mut self.hover_animation,
4223                    hovered as u8 as f32,
4224                    &theme,
4225                    ctx,
4226                );
4227                set_press_animation_target(&mut self.press_animation, 0.0, &theme, ctx);
4228                ctx.release_pointer_capture(pointer.pointer_id);
4229                if activate {
4230                    self.activate(ctx);
4231                }
4232                ctx.request_paint();
4233                ctx.request_semantics();
4234                ctx.set_handled();
4235            }
4236            Event::Pointer(pointer) if pointer.kind == PointerEventKind::Cancel => {
4237                if self.pressed {
4238                    let theme = self.resolved_theme();
4239                    self.pressed = false;
4240                    self.hovered = false;
4241                    set_hover_animation_target(&mut self.hover_animation, 0.0, &theme, ctx);
4242                    set_press_animation_target(&mut self.press_animation, 0.0, &theme, ctx);
4243                    ctx.release_pointer_capture(pointer.pointer_id);
4244                    ctx.request_paint();
4245                    ctx.request_semantics();
4246                    ctx.set_handled();
4247                }
4248            }
4249            Event::Keyboard(key)
4250                if key.state == KeyState::Pressed
4251                    && ctx.is_focused()
4252                    && matches!(key.key.as_str(), "Enter" | " ") =>
4253            {
4254                self.activate(ctx);
4255                ctx.request_paint();
4256                ctx.request_semantics();
4257                ctx.set_handled();
4258            }
4259            Event::Wake(sui_core::WakeEvent::AnimationFrame { time, .. }) => {
4260                if self.advance_animations(*time) {
4261                    ctx.request_animation_frame();
4262                }
4263                ctx.request_paint();
4264            }
4265            _ => {}
4266        }
4267    }
4268
4269    fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
4270        let text_style = self.resolved_text_style();
4271        let padding = self.resolved_padding();
4272        let indicator_size = self.resolved_indicator_size();
4273        let gap = self.resolved_gap();
4274        let measurement = measure_text(ctx, &self.label, &text_style);
4275        self.label_measurement = Some(measurement);
4276
4277        let theme = self.resolved_theme();
4278        let content_height = indicator_size.max(measurement.height.max(text_style.line_height));
4279
4280        constraints.clamp(Size::new(
4281            padding.left + indicator_size + gap + measurement.width + padding.right,
4282            choice_control_height(
4283                content_height,
4284                padding,
4285                default_form_control_height(&theme),
4286                self.padding.is_some(),
4287            ),
4288        ))
4289    }
4290
4291    fn paint(&self, ctx: &mut PaintCtx) {
4292        let theme = self.resolved_theme();
4293        let palette = theme.palette;
4294        let metrics = theme.metrics;
4295        let interaction = theme.interaction;
4296        let text_style = self.resolved_text_style();
4297        let padding = self.resolved_padding();
4298        let indicator_size = self.resolved_indicator_size();
4299        let gap = self.resolved_gap();
4300        let hover_progress = self.hover_animation.value * interaction.hover_blend;
4301        let press_progress = self.press_animation.value * interaction.pressed_blend;
4302        let toggle_progress = self.toggle_animation.value;
4303        let focus_progress = self.focus_animation.value;
4304        let layout_padding = choice_control_layout_padding(padding, self.padding.is_some());
4305        let indicator = indicator_rect(ctx.bounds(), layout_padding, indicator_size);
4306        let label_rect = checkbox_label_rect(ctx.bounds(), layout_padding, indicator_size, gap);
4307        let framed_background = mix_color(
4308            mix_color(
4309                mix_color(palette.control, palette.control_hover, hover_progress),
4310                palette.surface_focus,
4311                focus_progress,
4312            ),
4313            palette.control_active,
4314            press_progress,
4315        );
4316        let framed_border = mix_color(
4317            mix_color(palette.border, palette.border_hover, hover_progress),
4318            palette.border_focus,
4319            focus_progress,
4320        );
4321        let frame_visuals = choice_frame_visuals(
4322            &theme,
4323            self.appearance,
4324            framed_background,
4325            framed_border,
4326            hover_progress,
4327            press_progress,
4328            focus_progress,
4329        );
4330
4331        draw_choice_control_frame(
4332            ctx,
4333            ctx.bounds(),
4334            metrics.corner_radius,
4335            metrics,
4336            self.appearance,
4337            frame_visuals,
4338            (focus_progress > 0.0).then_some(
4339                palette
4340                    .focus_ring
4341                    .with_alpha(palette.focus_ring.alpha * focus_progress),
4342            ),
4343        );
4344
4345        ctx.fill(
4346            Path::circle(rect_center(indicator), indicator.width() * 0.5),
4347            mix_color(
4348                mix_color(
4349                    palette.control_active,
4350                    palette.surface_focus,
4351                    hover_progress,
4352                ),
4353                mix_color(
4354                    mix_color(palette.accent, palette.accent_hover, hover_progress),
4355                    palette.accent_pressed,
4356                    press_progress,
4357                ),
4358                toggle_progress,
4359            ),
4360        );
4361        ctx.stroke(
4362            Path::circle(rect_center(indicator), (indicator.width() * 0.5) - 0.5),
4363            mix_color(framed_border, palette.accent_border_focus, toggle_progress),
4364            StrokeStyle::new(physical_pixels(ctx, metrics.border_width)),
4365        );
4366        if toggle_progress > 0.0 {
4367            ctx.fill(
4368                Path::circle(
4369                    rect_center(indicator),
4370                    indicator.width() * 0.22 * toggle_progress,
4371                ),
4372                palette.accent_text.with_alpha(toggle_progress),
4373            );
4374        }
4375        paint_aligned_text(
4376            ctx,
4377            label_rect,
4378            &self.label,
4379            &text_style,
4380            text_style.line_height,
4381            0.0,
4382        );
4383    }
4384
4385    fn semantics(&self, ctx: &mut SemanticsCtx) {
4386        let mut node =
4387            SemanticsNode::new(ctx.widget_id(), SemanticsRole::RadioButton, ctx.bounds());
4388        node.name = Some(self.label.clone());
4389        node.state.focused = ctx.is_focused();
4390        node.state.hovered = self.hovered;
4391        node.state.selected = self.selected;
4392        node.actions = vec![SemanticsAction::Focus, SemanticsAction::Activate];
4393        ctx.push(node);
4394    }
4395
4396    fn accepts_focus(&self) -> bool {
4397        true
4398    }
4399
4400    fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
4401        let theme = self.resolved_theme();
4402        set_focus_animation_target(&mut self.focus_animation, focused as u8 as f32, &theme, ctx);
4403        ctx.request_paint();
4404        ctx.request_semantics();
4405    }
4406}
4407
4408pub struct RadioGroup {
4409    theme: Box<DefaultTheme>,
4410    theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
4411    name: String,
4412    options: Vec<String>,
4413    selected: Option<usize>,
4414    selected_reader: Option<Box<dyn Fn() -> Option<usize>>>,
4415    hovered: Option<usize>,
4416    pressed: Option<usize>,
4417    hover_visual: Option<usize>,
4418    press_visual: Option<usize>,
4419    selected_visual: Option<usize>,
4420    hover_animation: AnimatedScalar,
4421    press_animation: AnimatedScalar,
4422    selection_animation: AnimatedScalar,
4423    focus_animation: AnimatedScalar,
4424    label_measurements: Vec<TextMeasurement>,
4425    spacing: f32,
4426    on_change: Option<Box<dyn FnMut(usize, String)>>,
4427}
4428
4429impl RadioGroup {
4430    pub fn new(name: impl Into<String>) -> Self {
4431        Self {
4432            theme: Box::new(DefaultTheme::default()),
4433            theme_reader: None,
4434            name: name.into(),
4435            options: Vec::new(),
4436            selected: None,
4437            selected_reader: None,
4438            hovered: None,
4439            pressed: None,
4440            hover_visual: None,
4441            press_visual: None,
4442            selected_visual: None,
4443            hover_animation: AnimatedScalar::new(0.0),
4444            press_animation: AnimatedScalar::new(0.0),
4445            selection_animation: AnimatedScalar::new(0.0),
4446            focus_animation: AnimatedScalar::new(0.0),
4447            label_measurements: Vec::new(),
4448            spacing: 6.0,
4449            on_change: None,
4450        }
4451    }
4452
4453    pub fn theme(mut self, theme: DefaultTheme) -> Self {
4454        self.theme = Box::new(theme);
4455        self.theme_reader = None;
4456        self
4457    }
4458
4459    pub fn theme_when<F>(mut self, theme: F) -> Self
4460    where
4461        F: Fn() -> DefaultTheme + 'static,
4462    {
4463        self.theme_reader = Some(Box::new(theme));
4464        self
4465    }
4466
4467    pub fn option(mut self, option: impl Into<String>) -> Self {
4468        self.options.push(option.into());
4469        self
4470    }
4471
4472    pub fn options<I, S>(mut self, options: I) -> Self
4473    where
4474        I: IntoIterator<Item = S>,
4475        S: Into<String>,
4476    {
4477        self.options.extend(options.into_iter().map(Into::into));
4478        self
4479    }
4480
4481    pub fn selected(mut self, selected: usize) -> Self {
4482        self.selected = Some(selected);
4483        self.selected_reader = None;
4484        self.selected_visual = Some(selected);
4485        self.selection_animation = AnimatedScalar::new(1.0);
4486        self
4487    }
4488
4489    pub const fn selected_index(&self) -> Option<usize> {
4490        self.selected
4491    }
4492
4493    pub fn selected_when<F>(mut self, selected: F) -> Self
4494    where
4495        F: Fn() -> Option<usize> + 'static,
4496    {
4497        self.selected_reader = Some(Box::new(selected));
4498        self
4499    }
4500
4501    pub fn on_change<F>(mut self, on_change: F) -> Self
4502    where
4503        F: FnMut(usize, String) + 'static,
4504    {
4505        self.on_change = Some(Box::new(on_change));
4506        self
4507    }
4508
4509    fn row_height(&self) -> f32 {
4510        default_form_control_height(&self.resolved_theme())
4511    }
4512
4513    fn row_rect(&self, bounds: Rect, index: usize) -> Rect {
4514        let y = bounds.y() + (index as f32 * (self.row_height() + self.spacing));
4515        Rect::new(bounds.x(), y, bounds.width(), self.row_height())
4516    }
4517
4518    fn option_at(&self, bounds: Rect, position: Point) -> Option<usize> {
4519        self.options.iter().enumerate().find_map(|(index, _)| {
4520            self.row_rect(bounds, index)
4521                .contains(position)
4522                .then_some(index)
4523        })
4524    }
4525
4526    fn current_selected_index(&self) -> Option<usize> {
4527        self.selected_reader
4528            .as_ref()
4529            .map(|reader| reader())
4530            .unwrap_or(self.selected)
4531            .filter(|index| *index < self.options.len())
4532    }
4533
4534    fn select(&mut self, index: usize, ctx: &mut EventCtx) {
4535        if self.options.is_empty() {
4536            return;
4537        }
4538
4539        let selected = index.min(self.options.len().saturating_sub(1));
4540        let changed = self.current_selected_index() != Some(selected);
4541        self.selected = Some(selected);
4542        if changed || self.selected_visual != Some(selected) {
4543            let theme = self.resolved_theme();
4544            self.selected_visual = Some(selected);
4545            self.selection_animation = AnimatedScalar::new(0.0);
4546            set_toggle_animation_target(&mut self.selection_animation, 1.0, &theme, ctx);
4547        }
4548        if let Some(on_change) = &mut self.on_change {
4549            on_change(selected, self.options[selected].clone());
4550        }
4551    }
4552
4553    fn resolved_theme(&self) -> DefaultTheme {
4554        self.theme_reader
4555            .as_ref()
4556            .map(|theme| theme())
4557            .unwrap_or(*self.theme)
4558    }
4559
4560    fn set_hovered(&mut self, hovered: Option<usize>, ctx: &mut EventCtx) {
4561        if self.hovered == hovered && self.hover_visual == hovered {
4562            return;
4563        }
4564
4565        let theme = self.resolved_theme();
4566        self.hovered = hovered;
4567        match hovered {
4568            Some(index) => {
4569                if self.hover_visual != Some(index) {
4570                    self.hover_visual = Some(index);
4571                    self.hover_animation = AnimatedScalar::new(0.0);
4572                }
4573                set_hover_animation_target(&mut self.hover_animation, 1.0, &theme, ctx);
4574            }
4575            None => {
4576                set_hover_animation_target(&mut self.hover_animation, 0.0, &theme, ctx);
4577            }
4578        }
4579        ctx.request_paint();
4580        ctx.request_semantics();
4581    }
4582
4583    fn set_pressed(&mut self, pressed: Option<usize>, ctx: &mut EventCtx) {
4584        if self.pressed == pressed && self.press_visual == pressed {
4585            return;
4586        }
4587
4588        let theme = self.resolved_theme();
4589        self.pressed = pressed;
4590        match pressed {
4591            Some(index) => {
4592                if self.press_visual != Some(index) {
4593                    self.press_visual = Some(index);
4594                    self.press_animation = AnimatedScalar::new(0.0);
4595                }
4596                set_press_animation_target(&mut self.press_animation, 1.0, &theme, ctx);
4597            }
4598            None => {
4599                set_press_animation_target(&mut self.press_animation, 0.0, &theme, ctx);
4600            }
4601        }
4602        ctx.request_paint();
4603        ctx.request_semantics();
4604    }
4605
4606    fn hover_progress_for(&self, index: usize) -> f32 {
4607        if self.hover_visual == Some(index) {
4608            self.hover_animation.value
4609        } else {
4610            0.0
4611        }
4612    }
4613
4614    fn press_progress_for(&self, index: usize) -> f32 {
4615        if self.press_visual == Some(index) {
4616            self.press_animation.value
4617        } else {
4618            0.0
4619        }
4620    }
4621
4622    fn selection_progress_for(&self, index: usize) -> f32 {
4623        let selected = self.current_selected_index();
4624        if selected == Some(index) && self.selected_visual == Some(index) {
4625            self.selection_animation.value
4626        } else if selected == Some(index) {
4627            1.0
4628        } else {
4629            0.0
4630        }
4631    }
4632
4633    fn advance_animations(&mut self, time: f64) -> (bool, bool) {
4634        let previous_hover = self.hover_animation.value;
4635        let previous_press = self.press_animation.value;
4636        let previous_selection = self.selection_animation.value;
4637        let previous_focus = self.focus_animation.value;
4638        let active = self.hover_animation.advance(time)
4639            | self.press_animation.advance(time)
4640            | self.selection_animation.advance(time)
4641            | self.focus_animation.advance(time);
4642        let changed = self.hover_animation.changed_since(previous_hover)
4643            || self.press_animation.changed_since(previous_press)
4644            || self.selection_animation.changed_since(previous_selection)
4645            || self.focus_animation.changed_since(previous_focus);
4646
4647        if self.hovered.is_none() && !self.hover_animation.is_presented() {
4648            self.hover_visual = None;
4649        }
4650        if self.pressed.is_none() && !self.press_animation.is_presented() {
4651            self.press_visual = None;
4652        }
4653
4654        (changed, active)
4655    }
4656}
4657
4658impl Widget for RadioGroup {
4659    fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
4660        match event {
4661            Event::Pointer(pointer) if pointer.kind == PointerEventKind::Move => {
4662                self.set_hovered(self.option_at(ctx.bounds(), pointer.position), ctx);
4663            }
4664            Event::Pointer(pointer) if matches!(pointer.kind, PointerEventKind::Enter) => {
4665                self.set_hovered(self.option_at(ctx.bounds(), pointer.position), ctx);
4666            }
4667            Event::Pointer(_pointer) if matches!(_pointer.kind, PointerEventKind::Leave) => {
4668                self.set_hovered(None, ctx);
4669            }
4670            Event::Pointer(pointer)
4671                if pointer.kind == PointerEventKind::Down
4672                    && pointer.button == Some(PointerButton::Primary) =>
4673            {
4674                let hovered = self.option_at(ctx.bounds(), pointer.position);
4675                self.set_hovered(hovered, ctx);
4676                self.set_pressed(hovered, ctx);
4677                ctx.request_focus();
4678                ctx.request_pointer_capture(pointer.pointer_id);
4679                ctx.request_paint();
4680                ctx.request_semantics();
4681                ctx.set_handled();
4682            }
4683            Event::Pointer(pointer)
4684                if pointer.kind == PointerEventKind::Up
4685                    && pointer.button == Some(PointerButton::Primary) =>
4686            {
4687                let hovered = self.option_at(ctx.bounds(), pointer.position);
4688                let activate = self
4689                    .pressed
4690                    .zip(hovered)
4691                    .filter(|(pressed, hovered)| pressed == hovered);
4692                self.set_hovered(hovered, ctx);
4693                self.set_pressed(None, ctx);
4694                ctx.release_pointer_capture(pointer.pointer_id);
4695                if let Some((index, _)) = activate {
4696                    self.select(index, ctx);
4697                }
4698                ctx.request_paint();
4699                ctx.request_semantics();
4700                ctx.set_handled();
4701            }
4702            Event::Pointer(pointer) if pointer.kind == PointerEventKind::Cancel => {
4703                if self.pressed.is_some() {
4704                    self.set_pressed(None, ctx);
4705                    ctx.release_pointer_capture(pointer.pointer_id);
4706                    ctx.request_paint();
4707                    ctx.request_semantics();
4708                    ctx.set_handled();
4709                }
4710            }
4711            Event::Semantics(semantics) if semantics.target == ctx.widget_id() => {
4712                let SemanticsActionRequest::SetValue(SemanticsValue::Text(value)) =
4713                    &semantics.action
4714                else {
4715                    return;
4716                };
4717                let Some(index) = self.options.iter().position(|option| option == value) else {
4718                    return;
4719                };
4720                self.set_hovered(Some(index), ctx);
4721                self.select(index, ctx);
4722                ctx.request_paint();
4723                ctx.request_semantics();
4724                ctx.set_handled();
4725            }
4726            Event::Keyboard(key) if ctx.is_focused() && key.state == KeyState::Pressed => {
4727                if self.options.is_empty() {
4728                    return;
4729                }
4730
4731                let current = self
4732                    .current_selected_index()
4733                    .unwrap_or(0)
4734                    .min(self.options.len() - 1);
4735                let next = match key.key.as_str() {
4736                    "ArrowUp" | "ArrowLeft" => Some(current.saturating_sub(1)),
4737                    "ArrowDown" | "ArrowRight" => Some((current + 1).min(self.options.len() - 1)),
4738                    "Home" => Some(0),
4739                    "End" => Some(self.options.len() - 1),
4740                    "Enter" | " " => Some(current),
4741                    _ => None,
4742                };
4743
4744                if let Some(next) = next {
4745                    self.set_hovered(Some(next), ctx);
4746                    self.select(next, ctx);
4747                    ctx.request_paint();
4748                    ctx.request_semantics();
4749                    ctx.set_handled();
4750                }
4751            }
4752            Event::Wake(WakeEvent::AnimationFrame { time, .. }) => {
4753                let (changed, active) = self.advance_animations(*time);
4754                if changed {
4755                    ctx.request_paint();
4756                }
4757                if active {
4758                    ctx.request_animation_frame();
4759                }
4760                ctx.set_handled();
4761            }
4762            _ => {}
4763        }
4764    }
4765
4766    fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
4767        let theme = self.resolved_theme();
4768        let text_style = theme.body_text_style();
4769        let padding = theme.metrics.checkbox_padding;
4770        let indicator = theme.metrics.checkbox_indicator_size;
4771        let gap = theme.metrics.checkbox_gap;
4772        let mut width: f32 = 0.0;
4773        self.label_measurements.clear();
4774
4775        for option in &self.options {
4776            let measurement = measure_text(ctx, option, &text_style);
4777            self.label_measurements.push(measurement);
4778            width = width.max(padding.left + indicator + gap + measurement.width + padding.right);
4779        }
4780
4781        let count = self.options.len() as f32;
4782        let height = if self.options.is_empty() {
4783            self.row_height()
4784        } else {
4785            (count * self.row_height()) + ((count - 1.0) * self.spacing.max(0.0))
4786        };
4787
4788        constraints.clamp(Size::new(width.max(theme.metrics.button_min_width), height))
4789    }
4790
4791    fn paint(&self, ctx: &mut PaintCtx) {
4792        let theme = self.resolved_theme();
4793        let palette = theme.palette;
4794        let metrics = theme.metrics;
4795        let interaction = theme.interaction;
4796        let focus_progress = self.focus_animation.value;
4797        let row_padding = Insets {
4798            top: 0.0,
4799            bottom: 0.0,
4800            ..metrics.checkbox_padding
4801        };
4802
4803        if focus_progress > AnimatedScalar::EPSILON {
4804            let outset = physical_pixels(ctx, metrics.focus_ring_outset);
4805            ctx.stroke(
4806                rounded_rect_path(
4807                    ctx.bounds().inflate(outset, outset),
4808                    metrics.corner_radius + outset,
4809                ),
4810                palette
4811                    .focus_ring
4812                    .with_alpha(palette.focus_ring.alpha * focus_progress),
4813                StrokeStyle::new(physical_pixels(ctx, metrics.focus_ring_width)),
4814            );
4815        }
4816
4817        for (index, option) in self.options.iter().enumerate() {
4818            let row = self.row_rect(ctx.bounds(), index);
4819            let indicator = indicator_rect(row, row_padding, metrics.checkbox_indicator_size);
4820            let label_rect = checkbox_label_rect(
4821                row,
4822                row_padding,
4823                metrics.checkbox_indicator_size,
4824                metrics.checkbox_gap,
4825            );
4826            let hover_progress = self.hover_progress_for(index);
4827            let press_progress = self.press_progress_for(index);
4828            let selection_progress = self.selection_progress_for(index);
4829            let hover_amount = hover_progress * interaction.hover_blend;
4830            let press_amount = press_progress * interaction.pressed_blend;
4831            let background = mix_color(
4832                mix_color(palette.control, palette.control_hover, hover_amount),
4833                palette.control_active,
4834                press_amount,
4835            );
4836            let border = mix_color(
4837                mix_color(palette.border, palette.border_hover, hover_progress),
4838                palette.accent_border,
4839                selection_progress,
4840            );
4841            let indicator_fill = mix_color(
4842                mix_color(palette.control_active, palette.surface_focus, hover_amount),
4843                mix_color(
4844                    mix_color(palette.accent, palette.accent_hover, hover_amount),
4845                    palette.accent_pressed,
4846                    press_amount,
4847                ),
4848                selection_progress,
4849            );
4850
4851            draw_control_shape(
4852                ctx,
4853                row,
4854                metrics.corner_radius,
4855                physical_pixels(ctx, metrics.border_width),
4856                background,
4857                border,
4858            );
4859            ctx.fill(
4860                Path::circle(rect_center(indicator), indicator.width() * 0.5),
4861                indicator_fill,
4862            );
4863            ctx.stroke(
4864                Path::circle(rect_center(indicator), (indicator.width() * 0.5) - 0.5),
4865                border,
4866                StrokeStyle::new(physical_pixels(ctx, metrics.border_width)),
4867            );
4868            if selection_progress > AnimatedScalar::EPSILON {
4869                ctx.fill(
4870                    Path::circle(
4871                        rect_center(indicator),
4872                        indicator.width() * 0.22 * selection_progress,
4873                    ),
4874                    palette.accent_text.with_alpha(selection_progress),
4875                );
4876            }
4877            let text_style = theme.body_text_style();
4878            paint_aligned_text(
4879                ctx,
4880                label_rect,
4881                option,
4882                &text_style,
4883                text_style.line_height,
4884                0.0,
4885            );
4886        }
4887    }
4888
4889    fn semantics(&self, ctx: &mut SemanticsCtx) {
4890        let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::RadioGroup, ctx.bounds());
4891        node.name = Some(self.name.clone());
4892        node.value = self
4893            .current_selected_index()
4894            .and_then(|index| self.options.get(index).cloned())
4895            .map(SemanticsValue::Text);
4896        node.state.focused = ctx.is_focused();
4897        node.actions = vec![SemanticsAction::Focus, SemanticsAction::SetValue];
4898        ctx.push(node);
4899    }
4900
4901    fn accepts_focus(&self) -> bool {
4902        true
4903    }
4904
4905    fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
4906        let theme = self.resolved_theme();
4907        set_focus_animation_target(&mut self.focus_animation, focused as u8 as f32, &theme, ctx);
4908        ctx.request_paint();
4909        ctx.request_semantics();
4910    }
4911}
4912
4913pub struct Slider {
4914    theme: Box<DefaultTheme>,
4915    theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
4916    name: String,
4917    min: f64,
4918    max: f64,
4919    step: f64,
4920    value: f64,
4921    value_reader: Option<Box<dyn Fn() -> f64>>,
4922    hovered: bool,
4923    dragging: bool,
4924    hover_animation: AnimatedScalar,
4925    drag_animation: AnimatedScalar,
4926    focus_animation: AnimatedScalar,
4927    on_change: Option<Box<dyn FnMut(f64)>>,
4928    on_change_with_ctx: Option<Box<dyn FnMut(&mut EventCtx, f64)>>,
4929}
4930
4931impl Slider {
4932    pub fn new(name: impl Into<String>) -> Self {
4933        Self {
4934            theme: Box::new(DefaultTheme::default()),
4935            theme_reader: None,
4936            name: name.into(),
4937            min: 0.0,
4938            max: 1.0,
4939            step: 0.01,
4940            value: 0.0,
4941            value_reader: None,
4942            hovered: false,
4943            dragging: false,
4944            hover_animation: AnimatedScalar::new(0.0),
4945            drag_animation: AnimatedScalar::new(0.0),
4946            focus_animation: AnimatedScalar::new(0.0),
4947            on_change: None,
4948            on_change_with_ctx: None,
4949        }
4950    }
4951
4952    pub fn theme(mut self, theme: DefaultTheme) -> Self {
4953        self.theme = Box::new(theme);
4954        self.theme_reader = None;
4955        self
4956    }
4957
4958    pub fn theme_when<F>(mut self, theme: F) -> Self
4959    where
4960        F: Fn() -> DefaultTheme + 'static,
4961    {
4962        self.theme_reader = Some(Box::new(theme));
4963        self
4964    }
4965
4966    pub fn range(mut self, min: f64, max: f64) -> Self {
4967        self.min = min.min(max);
4968        self.max = max.max(min);
4969        self.value = clamp_and_snap_value(self.value, self.min, self.max, self.step);
4970        self
4971    }
4972
4973    pub fn step(mut self, step: f64) -> Self {
4974        self.step = step.abs();
4975        self.value = clamp_and_snap_value(self.value, self.min, self.max, self.step);
4976        self
4977    }
4978
4979    pub fn value(mut self, value: f64) -> Self {
4980        self.value = clamp_and_snap_value(value, self.min, self.max, self.step);
4981        self.value_reader = None;
4982        self
4983    }
4984
4985    pub fn value_when<F>(mut self, value: F) -> Self
4986    where
4987        F: Fn() -> f64 + 'static,
4988    {
4989        self.value_reader = Some(Box::new(value));
4990        self
4991    }
4992
4993    pub const fn current_value(&self) -> f64 {
4994        self.value
4995    }
4996
4997    pub fn on_change<F>(mut self, on_change: F) -> Self
4998    where
4999        F: FnMut(f64) + 'static,
5000    {
5001        self.on_change = Some(Box::new(on_change));
5002        self
5003    }
5004
5005    pub fn on_change_with_ctx<F>(mut self, on_change: F) -> Self
5006    where
5007        F: FnMut(&mut EventCtx, f64) + 'static,
5008    {
5009        self.on_change_with_ctx = Some(Box::new(on_change));
5010        self
5011    }
5012
5013    fn fraction(&self) -> f32 {
5014        if (self.max - self.min).abs() <= f64::EPSILON {
5015            return 0.0;
5016        }
5017
5018        ((self.value - self.min) / (self.max - self.min)).clamp(0.0, 1.0) as f32
5019    }
5020
5021    fn sync_external_value(&mut self) {
5022        if self.dragging {
5023            return;
5024        }
5025        let Some(reader) = &self.value_reader else {
5026            return;
5027        };
5028        self.value = clamp_and_snap_value(reader(), self.min, self.max, self.step);
5029    }
5030
5031    fn resolved_theme(&self) -> DefaultTheme {
5032        self.theme_reader
5033            .as_ref()
5034            .map(|theme| theme())
5035            .unwrap_or(*self.theme)
5036    }
5037
5038    fn track_rect(&self, bounds: Rect) -> Rect {
5039        let theme = self.resolved_theme();
5040        let padding = theme.metrics.slider_padding;
5041        let height = theme.metrics.slider_track_height.max(1.0);
5042        Rect::new(
5043            bounds.x() + padding.left,
5044            bounds.y() + ((bounds.height() - height) * 0.5),
5045            (bounds.width() - padding.left - padding.right).max(0.0),
5046            height,
5047        )
5048    }
5049
5050    fn thumb_rect(&self, bounds: Rect) -> Rect {
5051        let track = self.track_rect(bounds);
5052        let theme = self.resolved_theme();
5053        let thumb = theme.metrics.slider_thumb_size;
5054        Rect::new(
5055            track.x() + (track.width() * self.fraction()) - (thumb * 0.5),
5056            bounds.y() + ((bounds.height() - thumb) * 0.5),
5057            thumb,
5058            thumb,
5059        )
5060    }
5061
5062    fn emit_change(&mut self, ctx: &mut EventCtx) {
5063        if let Some(on_change) = &mut self.on_change {
5064            on_change(self.value);
5065        }
5066        if let Some(on_change_with_ctx) = &mut self.on_change_with_ctx {
5067            on_change_with_ctx(ctx, self.value);
5068        }
5069    }
5070
5071    fn set_from_position(&mut self, ctx: &mut EventCtx, bounds: Rect, position: Point) {
5072        let track = self.track_rect(bounds);
5073        if track.width() <= 0.0 {
5074            return;
5075        }
5076
5077        let fraction = ((position.x - track.x()) / track.width()).clamp(0.0, 1.0);
5078        let raw = self.min + ((self.max - self.min) * f64::from(fraction));
5079        let next = clamp_and_snap_value(raw, self.min, self.max, self.step);
5080        if (next - self.value).abs() > f64::EPSILON {
5081            self.value = next;
5082            self.emit_change(ctx);
5083        }
5084    }
5085
5086    fn set_hovered(&mut self, hovered: bool, ctx: &mut EventCtx) {
5087        if self.hovered != hovered {
5088            let theme = self.resolved_theme();
5089            self.hovered = hovered;
5090            set_hover_animation_target(
5091                &mut self.hover_animation,
5092                hovered as u8 as f32,
5093                &theme,
5094                ctx,
5095            );
5096            ctx.request_paint();
5097            ctx.request_semantics();
5098        }
5099    }
5100
5101    fn advance_animations(&mut self, time: f64) -> bool {
5102        self.hover_animation.advance(time)
5103            | self.drag_animation.advance(time)
5104            | self.focus_animation.advance(time)
5105    }
5106}
5107
5108impl Widget for Slider {
5109    fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
5110        self.sync_external_value();
5111
5112        match event {
5113            Event::Pointer(pointer) if pointer.kind == PointerEventKind::Move => {
5114                let hovered = ctx.bounds().contains(pointer.position);
5115                self.set_hovered(hovered, ctx);
5116                if self.dragging {
5117                    let previous = self.value;
5118                    self.set_from_position(ctx, ctx.bounds(), pointer.position);
5119                    if (self.value - previous).abs() > f64::EPSILON {
5120                        ctx.request_paint();
5121                        ctx.request_semantics();
5122                    }
5123                }
5124            }
5125            Event::Pointer(_pointer) if matches!(_pointer.kind, PointerEventKind::Enter) => {
5126                self.set_hovered(true, ctx);
5127            }
5128            Event::Pointer(_pointer) if matches!(_pointer.kind, PointerEventKind::Leave) => {
5129                self.set_hovered(false, ctx);
5130            }
5131            Event::Pointer(pointer)
5132                if pointer.kind == PointerEventKind::Down
5133                    && pointer.button == Some(PointerButton::Primary) =>
5134            {
5135                let theme = self.resolved_theme();
5136                self.dragging = true;
5137                self.hovered = true;
5138                set_hover_animation_target(&mut self.hover_animation, 1.0, &theme, ctx);
5139                set_press_animation_target(&mut self.drag_animation, 1.0, &theme, ctx);
5140                self.set_from_position(ctx, ctx.bounds(), pointer.position);
5141                ctx.request_pointer_capture(pointer.pointer_id);
5142                ctx.request_focus();
5143                ctx.request_paint();
5144                ctx.request_semantics();
5145                ctx.set_handled();
5146            }
5147            Event::Pointer(pointer)
5148                if pointer.kind == PointerEventKind::Up
5149                    && pointer.button == Some(PointerButton::Primary) =>
5150            {
5151                let theme = self.resolved_theme();
5152                self.dragging = false;
5153                self.hovered = ctx.bounds().contains(pointer.position);
5154                set_hover_animation_target(
5155                    &mut self.hover_animation,
5156                    self.hovered as u8 as f32,
5157                    &theme,
5158                    ctx,
5159                );
5160                set_press_animation_target(&mut self.drag_animation, 0.0, &theme, ctx);
5161                self.set_from_position(ctx, ctx.bounds(), pointer.position);
5162                ctx.release_pointer_capture(pointer.pointer_id);
5163                ctx.request_paint();
5164                ctx.request_semantics();
5165                ctx.set_handled();
5166            }
5167            Event::Pointer(pointer) if pointer.kind == PointerEventKind::Cancel => {
5168                if self.dragging {
5169                    let theme = self.resolved_theme();
5170                    self.dragging = false;
5171                    self.hovered = false;
5172                    set_hover_animation_target(&mut self.hover_animation, 0.0, &theme, ctx);
5173                    set_press_animation_target(&mut self.drag_animation, 0.0, &theme, ctx);
5174                    ctx.release_pointer_capture(pointer.pointer_id);
5175                    ctx.request_paint();
5176                    ctx.request_semantics();
5177                    ctx.set_handled();
5178                }
5179            }
5180            Event::Semantics(semantics) if semantics.target == ctx.widget_id() => {
5181                let next = match &semantics.action {
5182                    SemanticsActionRequest::Increment => Some(self.value + self.step.max(0.01)),
5183                    SemanticsActionRequest::Decrement => Some(self.value - self.step.max(0.01)),
5184                    SemanticsActionRequest::SetValue(SemanticsValue::Number(value)) => Some(*value),
5185                    SemanticsActionRequest::SetValue(SemanticsValue::Range { value, .. }) => {
5186                        Some(*value)
5187                    }
5188                    _ => None,
5189                };
5190                let Some(next) = next.filter(|value| value.is_finite()) else {
5191                    return;
5192                };
5193                let clamped = clamp_and_snap_value(next, self.min, self.max, self.step);
5194                if (clamped - self.value).abs() > f64::EPSILON {
5195                    self.value = clamped;
5196                    self.emit_change(ctx);
5197                }
5198                ctx.request_paint();
5199                ctx.request_semantics();
5200                ctx.set_handled();
5201            }
5202            Event::Keyboard(key) if ctx.is_focused() && key.state == KeyState::Pressed => {
5203                let next = match key.key.as_str() {
5204                    "ArrowLeft" | "ArrowDown" => Some(self.value - self.step.max(0.01)),
5205                    "ArrowRight" | "ArrowUp" => Some(self.value + self.step.max(0.01)),
5206                    "Home" => Some(self.min),
5207                    "End" => Some(self.max),
5208                    _ => None,
5209                };
5210
5211                if let Some(next) = next {
5212                    let clamped = clamp_and_snap_value(next, self.min, self.max, self.step);
5213                    if (clamped - self.value).abs() > f64::EPSILON {
5214                        self.value = clamped;
5215                        self.emit_change(ctx);
5216                    }
5217                    ctx.request_paint();
5218                    ctx.request_semantics();
5219                    ctx.set_handled();
5220                }
5221            }
5222            Event::Wake(sui_core::WakeEvent::AnimationFrame { time, .. }) => {
5223                if self.advance_animations(*time) {
5224                    ctx.request_animation_frame();
5225                }
5226                ctx.request_paint();
5227            }
5228            _ => {}
5229        }
5230    }
5231
5232    fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
5233        self.sync_external_value();
5234        let theme = self.resolved_theme();
5235
5236        constraints.clamp(Size::new(
5237            theme.metrics.slider_min_width,
5238            default_form_control_height(&theme),
5239        ))
5240    }
5241
5242    fn paint(&self, ctx: &mut PaintCtx) {
5243        let theme = self.resolved_theme();
5244        let palette = theme.palette;
5245        let metrics = theme.metrics;
5246        let hover_progress = self.hover_animation.value;
5247        let drag_progress = self.drag_animation.value;
5248        let focus_progress = self.focus_animation.value;
5249        let track = self.track_rect(ctx.bounds());
5250        let active = Rect::new(
5251            track.x(),
5252            track.y(),
5253            track.width() * self.fraction(),
5254            track.height(),
5255        );
5256        let thumb = self.thumb_rect(ctx.bounds());
5257
5258        draw_control_frame(
5259            ctx,
5260            ctx.bounds(),
5261            metrics.corner_radius,
5262            metrics,
5263            mix_color(
5264                mix_color(
5265                    palette.control,
5266                    palette.control_hover,
5267                    hover_progress.max(drag_progress),
5268                ),
5269                palette.surface_focus,
5270                focus_progress,
5271            ),
5272            mix_color(
5273                mix_color(palette.border, palette.border_hover, hover_progress),
5274                palette.border_focus,
5275                focus_progress,
5276            ),
5277            (focus_progress > 0.0).then_some(
5278                palette
5279                    .focus_ring
5280                    .with_alpha(palette.focus_ring.alpha * focus_progress),
5281            ),
5282        );
5283        ctx.fill(
5284            rounded_rect_path(track, track.height() * 0.5),
5285            palette.control_active,
5286        );
5287        ctx.fill(
5288            rounded_rect_path(active, track.height() * 0.5),
5289            palette.accent,
5290        );
5291        ctx.fill(
5292            Path::circle(rect_center(thumb), thumb.width() * 0.5),
5293            mix_color(
5294                mix_color(palette.accent, palette.accent_hover, hover_progress),
5295                palette.accent_pressed,
5296                drag_progress,
5297            ),
5298        );
5299        ctx.stroke(
5300            Path::circle(rect_center(thumb), (thumb.width() * 0.5) - 0.5),
5301            palette.accent_border,
5302            StrokeStyle::new(physical_pixels(ctx, metrics.border_width)),
5303        );
5304    }
5305
5306    fn semantics(&self, ctx: &mut SemanticsCtx) {
5307        let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::Slider, ctx.bounds());
5308        node.name = Some(self.name.clone());
5309        node.value = Some(SemanticsValue::Range {
5310            value: self.value,
5311            min: self.min,
5312            max: self.max,
5313        });
5314        node.numeric_step = Some(self.step.max(0.01));
5315        node.state.focused = ctx.is_focused();
5316        node.state.hovered = self.hovered;
5317        node.actions = vec![
5318            SemanticsAction::Focus,
5319            SemanticsAction::Increment,
5320            SemanticsAction::Decrement,
5321            SemanticsAction::SetValue,
5322        ];
5323        ctx.push(node);
5324    }
5325
5326    fn accepts_focus(&self) -> bool {
5327        true
5328    }
5329
5330    fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
5331        let theme = self.resolved_theme();
5332        set_focus_animation_target(&mut self.focus_animation, focused as u8 as f32, &theme, ctx);
5333        ctx.request_paint();
5334        ctx.request_semantics();
5335    }
5336}
5337
5338#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5339enum NumberInputStepperPart {
5340    Increment,
5341    Decrement,
5342}
5343
5344pub struct NumberInput {
5345    theme: Box<DefaultTheme>,
5346    theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
5347    name: String,
5348    value: f64,
5349    min: f64,
5350    max: f64,
5351    step: f64,
5352    precision: usize,
5353    buffer: String,
5354    hovered: bool,
5355    hovered_stepper: Option<NumberInputStepperPart>,
5356    pressed_stepper: Option<NumberInputStepperPart>,
5357    hover_animation: AnimatedScalar,
5358    stepper_hover_animation: AnimatedScalar,
5359    press_animation: AnimatedScalar,
5360    focus_animation: AnimatedScalar,
5361    editing: bool,
5362    value_reader: Option<Box<dyn Fn() -> f64>>,
5363    on_change: Option<Box<dyn FnMut(f64)>>,
5364}
5365
5366impl NumberInput {
5367    pub fn new(name: impl Into<String>) -> Self {
5368        let value = 0.0;
5369        Self {
5370            theme: Box::new(DefaultTheme::default()),
5371            theme_reader: None,
5372            name: name.into(),
5373            value,
5374            min: f64::NEG_INFINITY,
5375            max: f64::INFINITY,
5376            step: 1.0,
5377            precision: 2,
5378            buffer: format_number(value, 2),
5379            hovered: false,
5380            hovered_stepper: None,
5381            pressed_stepper: None,
5382            hover_animation: AnimatedScalar::new(0.0),
5383            stepper_hover_animation: AnimatedScalar::new(0.0),
5384            press_animation: AnimatedScalar::new(0.0),
5385            focus_animation: AnimatedScalar::new(0.0),
5386            editing: false,
5387            value_reader: None,
5388            on_change: None,
5389        }
5390    }
5391
5392    pub fn theme(mut self, theme: DefaultTheme) -> Self {
5393        self.theme = Box::new(theme);
5394        self.theme_reader = None;
5395        self
5396    }
5397
5398    pub fn theme_when<F>(mut self, theme: F) -> Self
5399    where
5400        F: Fn() -> DefaultTheme + 'static,
5401    {
5402        self.theme_reader = Some(Box::new(theme));
5403        self
5404    }
5405
5406    pub fn range(mut self, min: f64, max: f64) -> Self {
5407        self.min = min.min(max);
5408        self.max = max.max(min);
5409        self.value = clamp_and_snap_value(self.value, self.min, self.max, self.step);
5410        self.buffer = format_number(self.value, self.precision);
5411        self
5412    }
5413
5414    pub fn step(mut self, step: f64) -> Self {
5415        self.step = step.abs().max(f64::EPSILON);
5416        self.value = clamp_and_snap_value(self.value, self.min, self.max, self.step);
5417        self.buffer = format_number(self.value, self.precision);
5418        self
5419    }
5420
5421    pub fn precision(mut self, precision: usize) -> Self {
5422        self.precision = precision;
5423        self.buffer = format_number(self.value, self.precision);
5424        self
5425    }
5426
5427    pub fn value(mut self, value: f64) -> Self {
5428        self.value = clamp_and_snap_value(value, self.min, self.max, self.step);
5429        self.buffer = format_number(self.value, self.precision);
5430        self.value_reader = None;
5431        self
5432    }
5433
5434    pub fn value_when<F>(mut self, value: F) -> Self
5435    where
5436        F: Fn() -> f64 + 'static,
5437    {
5438        self.value_reader = Some(Box::new(value));
5439        self
5440    }
5441
5442    pub const fn current_value(&self) -> f64 {
5443        self.value
5444    }
5445
5446    pub fn on_change<F>(mut self, on_change: F) -> Self
5447    where
5448        F: FnMut(f64) + 'static,
5449    {
5450        self.on_change = Some(Box::new(on_change));
5451        self
5452    }
5453
5454    fn resolved_theme(&self) -> DefaultTheme {
5455        self.theme_reader
5456            .as_ref()
5457            .map(|theme| theme())
5458            .unwrap_or(*self.theme)
5459    }
5460
5461    fn text_style(&self) -> TextStyle {
5462        numeric_text_style(self.resolved_theme().body_text_style())
5463    }
5464
5465    fn sync_external_value(&mut self) {
5466        if self.editing {
5467            return;
5468        }
5469        let Some(reader) = &self.value_reader else {
5470            return;
5471        };
5472        let next = clamp_and_snap_value(reader(), self.min, self.max, self.step);
5473        if (next - self.value).abs() > f64::EPSILON {
5474            self.value = next;
5475            self.buffer = format_number(self.value, self.precision);
5476        }
5477    }
5478
5479    fn resolved_value(&self) -> f64 {
5480        if !self.editing
5481            && let Some(reader) = &self.value_reader
5482        {
5483            return clamp_and_snap_value(reader(), self.min, self.max, self.step);
5484        }
5485
5486        self.value
5487    }
5488
5489    fn display_buffer(&self) -> String {
5490        if !self.editing && self.value_reader.is_some() {
5491            format_number(self.resolved_value(), self.precision)
5492        } else {
5493            self.buffer.clone()
5494        }
5495    }
5496
5497    fn commit_buffer(&mut self) {
5498        if let Ok(parsed) = self.buffer.trim().parse::<f64>() {
5499            let next = clamp_and_snap_value(parsed, self.min, self.max, self.step);
5500            if (next - self.value).abs() > f64::EPSILON {
5501                self.value = next;
5502                if let Some(on_change) = &mut self.on_change {
5503                    on_change(self.value);
5504                }
5505            }
5506            self.buffer = format_number(self.value, self.precision);
5507        }
5508    }
5509
5510    fn apply_edit_buffer(&mut self) {
5511        let Ok(parsed) = self.buffer.trim().parse::<f64>() else {
5512            return;
5513        };
5514        if !parsed.is_finite() || parsed < self.min || parsed > self.max {
5515            return;
5516        }
5517        if (parsed - self.value).abs() > f64::EPSILON {
5518            self.value = parsed;
5519            if let Some(on_change) = &mut self.on_change {
5520                on_change(self.value);
5521            }
5522        }
5523    }
5524
5525    fn nudge(&mut self, delta: f64) {
5526        let next = clamp_and_snap_value(self.value + delta, self.min, self.max, self.step);
5527        if (next - self.value).abs() > f64::EPSILON {
5528            self.value = next;
5529            self.buffer = format_number(self.value, self.precision);
5530            if let Some(on_change) = &mut self.on_change {
5531                on_change(self.value);
5532            }
5533        }
5534    }
5535
5536    fn set_hover_state(
5537        &mut self,
5538        hovered: bool,
5539        hovered_stepper: Option<NumberInputStepperPart>,
5540        ctx: &mut EventCtx,
5541    ) {
5542        if self.hovered != hovered || self.hovered_stepper != hovered_stepper {
5543            let theme = self.resolved_theme();
5544            self.hovered = hovered;
5545            self.hovered_stepper = hovered_stepper;
5546            set_hover_animation_target(
5547                &mut self.hover_animation,
5548                hovered as u8 as f32,
5549                &theme,
5550                ctx,
5551            );
5552            set_hover_animation_target(
5553                &mut self.stepper_hover_animation,
5554                hovered_stepper.is_some() as u8 as f32,
5555                &theme,
5556                ctx,
5557            );
5558            ctx.request_paint();
5559            ctx.request_semantics();
5560        }
5561    }
5562
5563    fn set_pressed_stepper(
5564        &mut self,
5565        pressed_stepper: Option<NumberInputStepperPart>,
5566        ctx: &mut EventCtx,
5567    ) {
5568        if self.pressed_stepper != pressed_stepper {
5569            let theme = self.resolved_theme();
5570            self.pressed_stepper = pressed_stepper;
5571            set_press_animation_target(
5572                &mut self.press_animation,
5573                pressed_stepper.is_some() as u8 as f32,
5574                &theme,
5575                ctx,
5576            );
5577            ctx.request_paint();
5578            ctx.request_semantics();
5579        }
5580    }
5581
5582    fn advance_animations(&mut self, time: f64) -> bool {
5583        self.hover_animation.advance(time)
5584            | self.stepper_hover_animation.advance(time)
5585            | self.press_animation.advance(time)
5586            | self.focus_animation.advance(time)
5587    }
5588}
5589
5590impl Widget for NumberInput {
5591    fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
5592        self.sync_external_value();
5593        match event {
5594            Event::Pointer(pointer) if pointer.kind == PointerEventKind::Move => {
5595                let theme = self.resolved_theme();
5596                self.set_hover_state(
5597                    ctx.bounds().contains(pointer.position),
5598                    number_input_stepper_part(ctx.bounds(), theme.metrics, pointer.position),
5599                    ctx,
5600                );
5601            }
5602            Event::Pointer(pointer) if matches!(pointer.kind, PointerEventKind::Enter) => {
5603                let theme = self.resolved_theme();
5604                self.set_hover_state(
5605                    ctx.bounds().contains(pointer.position),
5606                    number_input_stepper_part(ctx.bounds(), theme.metrics, pointer.position),
5607                    ctx,
5608                );
5609            }
5610            Event::Pointer(_pointer) if matches!(_pointer.kind, PointerEventKind::Leave) => {
5611                self.set_hover_state(false, None, ctx);
5612            }
5613            Event::Pointer(pointer)
5614                if pointer.kind == PointerEventKind::Down
5615                    && pointer.button == Some(PointerButton::Primary) =>
5616            {
5617                let theme = self.resolved_theme();
5618                let stepper_part =
5619                    number_input_stepper_part(ctx.bounds(), theme.metrics, pointer.position);
5620                self.set_hover_state(ctx.bounds().contains(pointer.position), stepper_part, ctx);
5621                self.set_pressed_stepper(stepper_part, ctx);
5622                ctx.request_focus();
5623                ctx.request_pointer_capture(pointer.pointer_id);
5624                match stepper_part {
5625                    Some(NumberInputStepperPart::Increment) => self.nudge(self.step),
5626                    Some(NumberInputStepperPart::Decrement) => self.nudge(-self.step),
5627                    None => {}
5628                }
5629                ctx.request_paint();
5630                ctx.request_semantics();
5631                ctx.set_handled();
5632            }
5633            Event::Pointer(pointer)
5634                if pointer.kind == PointerEventKind::Up
5635                    && pointer.button == Some(PointerButton::Primary) =>
5636            {
5637                let theme = self.resolved_theme();
5638                self.set_hover_state(
5639                    ctx.bounds().contains(pointer.position),
5640                    number_input_stepper_part(ctx.bounds(), theme.metrics, pointer.position),
5641                    ctx,
5642                );
5643                self.set_pressed_stepper(None, ctx);
5644                ctx.release_pointer_capture(pointer.pointer_id);
5645                ctx.request_paint();
5646                ctx.request_semantics();
5647                ctx.set_handled();
5648            }
5649            Event::Pointer(pointer) if pointer.kind == PointerEventKind::Cancel => {
5650                if self.pressed_stepper.is_some() {
5651                    self.set_pressed_stepper(None, ctx);
5652                    ctx.release_pointer_capture(pointer.pointer_id);
5653                    ctx.request_paint();
5654                    ctx.request_semantics();
5655                    ctx.set_handled();
5656                }
5657            }
5658            Event::Semantics(semantics) if semantics.target == ctx.widget_id() => {
5659                let next = match &semantics.action {
5660                    SemanticsActionRequest::Increment => Some(self.value + self.step),
5661                    SemanticsActionRequest::Decrement => Some(self.value - self.step),
5662                    SemanticsActionRequest::SetValue(SemanticsValue::Number(value)) => Some(*value),
5663                    SemanticsActionRequest::SetValue(SemanticsValue::Range { value, .. }) => {
5664                        Some(*value)
5665                    }
5666                    _ => None,
5667                };
5668                let Some(next) = next.filter(|value| value.is_finite()) else {
5669                    return;
5670                };
5671                let next = clamp_and_snap_value(next, self.min, self.max, self.step);
5672                if (next - self.value).abs() > f64::EPSILON {
5673                    self.value = next;
5674                    self.buffer = format_number(self.value, self.precision);
5675                    if let Some(on_change) = &mut self.on_change {
5676                        on_change(self.value);
5677                    }
5678                }
5679                ctx.request_measure();
5680                ctx.request_paint();
5681                ctx.request_semantics();
5682                ctx.set_handled();
5683            }
5684            Event::Keyboard(key) if ctx.is_focused() && key.state == KeyState::Pressed => {
5685                match key.key.as_str() {
5686                    "ArrowUp" => self.nudge(self.step),
5687                    "ArrowDown" => self.nudge(-self.step),
5688                    "Enter" => self.commit_buffer(),
5689                    "Escape" => self.buffer = format_number(self.value, self.precision),
5690                    "Backspace" => {
5691                        self.buffer.pop();
5692                        self.apply_edit_buffer();
5693                    }
5694                    _ => {
5695                        if let Some(text) = keyboard_text(key)
5696                            && text.chars().all(is_numeric_input_char)
5697                        {
5698                            self.buffer.push_str(text);
5699                            self.apply_edit_buffer();
5700                        }
5701                    }
5702                }
5703                ctx.request_measure();
5704                ctx.request_paint();
5705                ctx.request_semantics();
5706                ctx.set_handled();
5707            }
5708            Event::Wake(WakeEvent::AnimationFrame { time, .. }) => {
5709                let previous_hover = self.hover_animation.value;
5710                let previous_stepper_hover = self.stepper_hover_animation.value;
5711                let previous_press = self.press_animation.value;
5712                let previous_focus = self.focus_animation.value;
5713                let animating = self.advance_animations(*time);
5714                let changed = self.hover_animation.changed_since(previous_hover)
5715                    || self
5716                        .stepper_hover_animation
5717                        .changed_since(previous_stepper_hover)
5718                    || self.press_animation.changed_since(previous_press)
5719                    || self.focus_animation.changed_since(previous_focus);
5720                if changed {
5721                    ctx.request_paint();
5722                }
5723                if animating {
5724                    ctx.request_animation_frame();
5725                }
5726                ctx.set_handled();
5727            }
5728            _ => {}
5729        }
5730    }
5731
5732    fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
5733        self.sync_external_value();
5734        let buffer = self.display_buffer();
5735        let text_style = self.text_style();
5736        let measurement = measure_text(ctx, &buffer, &text_style);
5737        let theme = self.resolved_theme();
5738        let padding = theme.metrics.text_input_padding;
5739        let height =
5740            (measurement.height.max(text_style.line_height) + padding.top + padding.bottom)
5741                .max(theme.metrics.min_height);
5742        constraints.clamp(Size::new(
5743            (measurement.width
5744                + padding.left
5745                + padding.right
5746                + theme.metrics.number_input_stepper_width)
5747                .max(theme.metrics.button_min_width + 60.0),
5748            height,
5749        ))
5750    }
5751
5752    fn paint(&self, ctx: &mut PaintCtx) {
5753        let theme = self.resolved_theme();
5754        let palette = theme.palette;
5755        let metrics = theme.metrics;
5756        let interaction = theme.interaction;
5757        let content = number_input_text_rect(ctx.bounds(), metrics);
5758        let stepper = number_input_stepper_rect(ctx.bounds(), metrics);
5759        let text_style = self.text_style();
5760        let buffer = self.display_buffer();
5761        let hover_progress = self.hover_animation.value * interaction.hover_blend;
5762        let stepper_hover_progress = self.stepper_hover_animation.value * interaction.hover_blend;
5763        let press_progress = self.press_animation.value * interaction.pressed_blend;
5764        let focus_progress = self.focus_animation.value;
5765        let base_background = mix_color(palette.control, palette.control_hover, hover_progress);
5766
5767        draw_control_frame(
5768            ctx,
5769            ctx.bounds(),
5770            metrics.corner_radius,
5771            metrics,
5772            mix_color(base_background, palette.surface_focus, focus_progress),
5773            mix_color(
5774                mix_color(
5775                    palette.border,
5776                    palette.border_hover,
5777                    self.hover_animation.value,
5778                ),
5779                palette.border_focus,
5780                focus_progress,
5781            ),
5782            (focus_progress > 0.0).then_some(
5783                palette
5784                    .focus_ring
5785                    .with_alpha(palette.focus_ring.alpha * focus_progress),
5786            ),
5787        );
5788
5789        paint_aligned_text(
5790            ctx,
5791            content,
5792            &buffer,
5793            &text_style,
5794            text_style.line_height,
5795            1.0,
5796        );
5797        ctx.stroke(
5798            line_path(
5799                Point::new(stepper.x(), ctx.bounds().y() + 6.0),
5800                Point::new(stepper.x(), ctx.bounds().max_y() - 6.0),
5801            ),
5802            palette.border,
5803            StrokeStyle::new(physical_pixels(ctx, metrics.border_width)),
5804        );
5805        for (part, rect) in [
5806            (
5807                NumberInputStepperPart::Increment,
5808                Rect::new(
5809                    stepper.x(),
5810                    stepper.y(),
5811                    stepper.width(),
5812                    stepper.height() * 0.5,
5813                ),
5814            ),
5815            (
5816                NumberInputStepperPart::Decrement,
5817                Rect::new(
5818                    stepper.x(),
5819                    stepper.y() + (stepper.height() * 0.5),
5820                    stepper.width(),
5821                    stepper.height() * 0.5,
5822                ),
5823            ),
5824        ] {
5825            let hover_amount = if self.hovered_stepper == Some(part) {
5826                stepper_hover_progress
5827            } else {
5828                0.0
5829            };
5830            let press_amount = if self.pressed_stepper == Some(part) {
5831                press_progress
5832            } else {
5833                0.0
5834            };
5835            if hover_amount > 0.0 || press_amount > 0.0 {
5836                let fill = mix_color(
5837                    mix_color(palette.control, palette.control_hover, hover_amount),
5838                    palette.control_active,
5839                    press_amount,
5840                );
5841                ctx.fill(
5842                    rounded_rect_path(rect.inflate(-2.0, -2.0), metrics.corner_radius - 2.0),
5843                    fill,
5844                );
5845            }
5846        }
5847        let increment_offset = if self.pressed_stepper == Some(NumberInputStepperPart::Increment) {
5848            Vector::new(0.0, self.press_animation.value * interaction.pressed_offset)
5849        } else {
5850            Vector::ZERO
5851        };
5852        let decrement_offset = if self.pressed_stepper == Some(NumberInputStepperPart::Decrement) {
5853            Vector::new(0.0, self.press_animation.value * interaction.pressed_offset)
5854        } else {
5855            Vector::ZERO
5856        };
5857        draw_icon_glyph(
5858            ctx,
5859            IconGlyph::ChevronUp,
5860            Rect::new(
5861                stepper.x(),
5862                stepper.y(),
5863                stepper.width(),
5864                stepper.height() * 0.5,
5865            )
5866            .translate(increment_offset),
5867            palette.text,
5868        );
5869        draw_icon_glyph(
5870            ctx,
5871            IconGlyph::ChevronDown,
5872            Rect::new(
5873                stepper.x(),
5874                stepper.y() + (stepper.height() * 0.5),
5875                stepper.width(),
5876                stepper.height() * 0.5,
5877            )
5878            .translate(decrement_offset),
5879            palette.text,
5880        );
5881
5882        if ctx.is_focused() {
5883            let caret_x = content.max_x();
5884            let caret_width = physical_pixels(ctx, metrics.caret_width);
5885            let caret = Rect::new(
5886                caret_x.min((content.max_x() - caret_width).max(content.x())),
5887                content.y(),
5888                caret_width,
5889                content.height(),
5890            );
5891            ctx.set_ime_composition_rect(caret);
5892            ctx.fill(rounded_rect_path(caret, caret_width * 0.5), palette.caret);
5893        }
5894    }
5895
5896    fn semantics(&self, ctx: &mut SemanticsCtx) {
5897        let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::SpinBox, ctx.bounds());
5898        node.name = Some(self.name.clone());
5899        node.value = Some(SemanticsValue::Range {
5900            value: self.resolved_value(),
5901            min: self.min,
5902            max: self.max,
5903        });
5904        node.numeric_step = Some(self.step);
5905        node.state.focused = ctx.is_focused();
5906        node.state.hovered = self.hovered;
5907        node.actions = vec![
5908            SemanticsAction::Focus,
5909            SemanticsAction::Increment,
5910            SemanticsAction::Decrement,
5911            SemanticsAction::SetValue,
5912        ];
5913        ctx.push(node);
5914    }
5915
5916    fn accepts_focus(&self) -> bool {
5917        true
5918    }
5919
5920    fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
5921        if focused {
5922            self.sync_external_value();
5923        }
5924        self.editing = focused;
5925        if !focused {
5926            self.commit_buffer();
5927            self.sync_external_value();
5928        }
5929        let theme = self.resolved_theme();
5930        set_focus_animation_target(&mut self.focus_animation, focused as u8 as f32, &theme, ctx);
5931        ctx.request_paint();
5932        ctx.request_semantics();
5933    }
5934}
5935
5936pub struct TextArea {
5937    theme: Box<DefaultTheme>,
5938    theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
5939    name: String,
5940    editor: EditorState,
5941    placeholder: String,
5942    read_only: bool,
5943    appearance: FieldAppearance,
5944    text_style: Option<TextStyle>,
5945    padding: Option<Insets>,
5946    min_width: Option<f32>,
5947    min_height: Option<f32>,
5948    hovered: bool,
5949    focused: bool,
5950    dragging_selection: bool,
5951    hover_animation: AnimatedScalar,
5952    focus_animation: AnimatedScalar,
5953    caret_blink: Blink,
5954    caret_timer: Option<TimerToken>,
5955    caret_visible: bool,
5956    display_layout: Option<PersistentTextLayout>,
5957    input_layout: Option<PersistentTextLayout>,
5958    selection_scope: Option<SelectionScope>,
5959    on_change: Option<Box<dyn FnMut(String)>>,
5960    on_change_with_ctx: Option<Box<dyn FnMut(&mut EventCtx, String)>>,
5961    on_submit: Option<Box<dyn FnMut(&str)>>,
5962    on_focus_change: Option<Box<dyn FnMut(bool)>>,
5963}
5964
5965impl TextArea {
5966    pub fn new(name: impl Into<String>) -> Self {
5967        Self {
5968            theme: Box::new(DefaultTheme::default()),
5969            theme_reader: None,
5970            name: name.into(),
5971            editor: EditorState::new(),
5972            placeholder: String::new(),
5973            read_only: false,
5974            appearance: FieldAppearance::Framed,
5975            text_style: None,
5976            padding: None,
5977            min_width: None,
5978            min_height: None,
5979            hovered: false,
5980            focused: false,
5981            dragging_selection: false,
5982            hover_animation: AnimatedScalar::new(0.0),
5983            focus_animation: AnimatedScalar::new(0.0),
5984            caret_blink: Blink::new(CARET_BLINK_PERIOD_SECONDS),
5985            caret_timer: None,
5986            caret_visible: true,
5987            display_layout: None,
5988            input_layout: None,
5989            selection_scope: None,
5990            on_change: None,
5991            on_change_with_ctx: None,
5992            on_submit: None,
5993            on_focus_change: None,
5994        }
5995    }
5996
5997    pub fn theme(mut self, theme: DefaultTheme) -> Self {
5998        self.theme = Box::new(theme);
5999        self.theme_reader = None;
6000        self
6001    }
6002
6003    pub fn theme_when<F>(mut self, theme: F) -> Self
6004    where
6005        F: Fn() -> DefaultTheme + 'static,
6006    {
6007        self.theme_reader = Some(Box::new(theme));
6008        self
6009    }
6010
6011    pub fn text_style(mut self, text_style: TextStyle) -> Self {
6012        self.text_style = Some(text_style);
6013        self
6014    }
6015
6016    pub fn appearance(mut self, appearance: FieldAppearance) -> Self {
6017        self.appearance = appearance;
6018        self
6019    }
6020
6021    pub fn bare(mut self) -> Self {
6022        self.appearance = FieldAppearance::Bare;
6023        self
6024    }
6025
6026    pub fn padding(mut self, padding: Insets) -> Self {
6027        self.padding = Some(padding);
6028        self
6029    }
6030
6031    pub fn min_width(mut self, width: f32) -> Self {
6032        self.min_width = Some(width.max(0.0));
6033        self
6034    }
6035
6036    pub fn min_height(mut self, height: f32) -> Self {
6037        self.min_height = Some(height.max(0.0));
6038        self
6039    }
6040
6041    pub fn placeholder(mut self, placeholder: impl Into<String>) -> Self {
6042        self.placeholder = placeholder.into();
6043        self
6044    }
6045
6046    pub fn read_only(mut self) -> Self {
6047        self.read_only = true;
6048        self
6049    }
6050
6051    pub fn selectable(mut self, selection_scope: SelectionScope) -> Self {
6052        self.selection_scope = Some(selection_scope);
6053        self
6054    }
6055
6056    pub fn selection_scope(mut self, selection_scope: SelectionScope) -> Self {
6057        self.selection_scope = Some(selection_scope);
6058        self
6059    }
6060
6061    pub fn value(mut self, value: impl Into<String>) -> Self {
6062        self.editor.set_text(value);
6063        self
6064    }
6065
6066    pub fn current_value(&self) -> &str {
6067        self.editor.document().text()
6068    }
6069
6070    pub fn set_value(&mut self, value: impl Into<String>) {
6071        self.editor.set_text(value);
6072    }
6073
6074    pub fn on_change<F>(mut self, on_change: F) -> Self
6075    where
6076        F: FnMut(String) + 'static,
6077    {
6078        self.on_change = Some(Box::new(on_change));
6079        self
6080    }
6081
6082    pub fn on_change_with_ctx<F>(mut self, on_change: F) -> Self
6083    where
6084        F: FnMut(&mut EventCtx, String) + 'static,
6085    {
6086        self.on_change_with_ctx = Some(Box::new(on_change));
6087        self
6088    }
6089
6090    /// Fire `on_submit(current_text)` when the user presses a plain `Enter` (no Shift/Ctrl/Meta
6091    /// modifier) while focused, *instead* of inserting a newline. `Shift+Enter` (and any modified
6092    /// Enter) still inserts a newline. When no `on_submit` is set, `Enter` inserts a newline as
6093    /// before, so this is fully backward-compatible.
6094    ///
6095    /// This turns the multi-line `TextArea` into a chat-style composer: Enter to send, Shift+Enter
6096    /// for a soft line break.
6097    pub fn on_submit<F>(mut self, on_submit: F) -> Self
6098    where
6099        F: FnMut(&str) + 'static,
6100    {
6101        self.on_submit = Some(Box::new(on_submit));
6102        self
6103    }
6104
6105    pub fn on_focus_change<F>(mut self, on_focus_change: F) -> Self
6106    where
6107        F: FnMut(bool) + 'static,
6108    {
6109        self.on_focus_change = Some(Box::new(on_focus_change));
6110        self
6111    }
6112
6113    fn input_text(&self) -> String {
6114        self.editor.display_text()
6115    }
6116
6117    fn display_text(&self) -> String {
6118        let input = self.input_text();
6119        if input.is_empty() {
6120            self.placeholder.clone()
6121        } else {
6122            input
6123        }
6124    }
6125
6126    fn resolved_text_style(&self) -> TextStyle {
6127        self.text_style
6128            .clone()
6129            .unwrap_or_else(|| self.resolved_theme().body_text_style())
6130    }
6131
6132    fn display_text_style(&self) -> TextStyle {
6133        let theme = self.resolved_theme();
6134        if self.input_text().is_empty() {
6135            theme.placeholder_text_style()
6136        } else if self.read_only {
6137            theme.text_style(theme.palette.text_muted)
6138        } else {
6139            self.resolved_text_style()
6140        }
6141    }
6142
6143    fn resolved_padding(&self) -> Insets {
6144        self.padding
6145            .unwrap_or(self.resolved_theme().metrics.text_input_padding)
6146    }
6147
6148    fn resolved_min_size(&self) -> Size {
6149        let theme = self.resolved_theme();
6150        Size::new(
6151            self.min_width.unwrap_or(theme.metrics.text_input_min_width),
6152            self.min_height
6153                .unwrap_or(theme.metrics.text_area_min_height),
6154        )
6155    }
6156
6157    fn resolved_theme(&self) -> DefaultTheme {
6158        self.theme_reader
6159            .as_ref()
6160            .map(|theme| theme())
6161            .unwrap_or(*self.theme)
6162    }
6163
6164    fn commit_text_change(&mut self, ctx: &mut EventCtx) {
6165        let value = self.current_value().to_string();
6166        if let Some(on_change) = &mut self.on_change {
6167            on_change(value.clone());
6168        }
6169        if let Some(on_change_with_ctx) = &mut self.on_change_with_ctx {
6170            on_change_with_ctx(ctx, value);
6171        }
6172    }
6173
6174    fn apply_editor_result(&mut self, ctx: &mut EventCtx, mut result: EditorCommandResult) {
6175        let copied_to_clipboard = result.clipboard_text.is_some();
6176        if let Some(text) = result.clipboard_text.take() {
6177            ctx.set_clipboard_text(text);
6178        }
6179        if result.text_changed {
6180            self.commit_text_change(ctx);
6181        }
6182        if result.layout_changed() {
6183            ctx.request_measure();
6184            ctx.request_paint();
6185        } else if result.overlay_changed() {
6186            ctx.request_paint();
6187        }
6188        if result.text_changed || result.selection_changed || result.composition_changed {
6189            sync_editor_selection_scope(ctx, self.selection_scope.as_ref(), &self.editor);
6190            ctx.request_semantics();
6191        }
6192        if result.handled {
6193            if self.focused {
6194                self.reset_caret_blink(ctx);
6195            }
6196            if !(copied_to_clipboard && self.selection_scope.is_some()) {
6197                ctx.set_handled();
6198            }
6199        }
6200    }
6201
6202    fn execute_editor_command(&mut self, ctx: &mut EventCtx, command: EditorCommand) {
6203        let result = self.editor.execute(command);
6204        self.apply_editor_result(ctx, result);
6205    }
6206
6207    /// Select the entire document.
6208    pub fn select_all(&mut self, ctx: &mut EventCtx) {
6209        self.execute_editor_command(ctx, EditorCommand::SelectAll);
6210    }
6211
6212    /// Copy the current selection to the clipboard. No-op when the selection
6213    /// is collapsed.
6214    pub fn copy(&mut self, ctx: &mut EventCtx) {
6215        self.execute_editor_command(ctx, EditorCommand::Copy);
6216    }
6217
6218    /// Copy the current selection to the clipboard and delete it. No-op when
6219    /// read-only or the selection is collapsed.
6220    pub fn cut(&mut self, ctx: &mut EventCtx) {
6221        if self.read_only {
6222            return;
6223        }
6224        self.execute_editor_command(ctx, EditorCommand::Cut);
6225    }
6226
6227    /// Replace the current selection with the clipboard text. No-op when
6228    /// read-only or the clipboard has no text.
6229    pub fn paste(&mut self, ctx: &mut EventCtx) {
6230        if self.read_only {
6231            return;
6232        }
6233        let command = paste_command(ctx);
6234        self.execute_editor_command(ctx, command);
6235    }
6236
6237    /// Currently selected document text (empty when the selection is
6238    /// collapsed).
6239    pub fn selected_text(&self) -> &str {
6240        self.editor.selected_text()
6241    }
6242
6243    fn apply_text_command(&mut self, ctx: &mut EventCtx, command: TextCommand) {
6244        match command {
6245            TextCommand::SelectAll => self.select_all(ctx),
6246            TextCommand::Copy => self.copy(ctx),
6247            TextCommand::Cut => self.cut(ctx),
6248            TextCommand::Paste => self.paste(ctx),
6249        }
6250    }
6251
6252    fn text_offset_at_position(&self, bounds: Rect, position: Point) -> usize {
6253        let content = inset_rect(bounds, self.resolved_padding());
6254        self.input_layout
6255            .as_ref()
6256            .map(|layout| {
6257                layout
6258                    .hit_test_point(Point::new(
6259                        position.x - content.x(),
6260                        position.y - content.y(),
6261                    ))
6262                    .utf8_offset
6263            })
6264            .unwrap_or(self.editor.document().len())
6265    }
6266
6267    fn set_caret_from_position(
6268        &mut self,
6269        bounds: Rect,
6270        position: Point,
6271        extend: bool,
6272        ctx: &mut EventCtx,
6273    ) {
6274        let offset = self.text_offset_at_position(bounds, position);
6275        let command = if extend {
6276            EditorCommand::SetSelection {
6277                anchor: self.editor.selection().anchor.utf8_offset,
6278                focus: offset,
6279            }
6280        } else {
6281            EditorCommand::MoveTo {
6282                offset,
6283                extend: false,
6284            }
6285        };
6286        let result = self.editor.execute(command);
6287        self.apply_editor_result(ctx, result);
6288    }
6289
6290    fn caret_blink_delay(&self) -> f64 {
6291        let span = if self.caret_visible {
6292            self.caret_blink.period * self.caret_blink.duty_cycle as f64
6293        } else {
6294            self.caret_blink.period * (1.0 - self.caret_blink.duty_cycle as f64)
6295        };
6296        span.max(f64::EPSILON)
6297    }
6298
6299    fn arm_caret_blink(&mut self, ctx: &mut EventCtx) {
6300        if let Some(token) = self.caret_timer.take() {
6301            ctx.cancel_timer(token);
6302        }
6303        if self.focused {
6304            self.caret_timer = Some(ctx.schedule_timer_after(self.caret_blink_delay()));
6305        }
6306    }
6307
6308    fn reset_caret_blink(&mut self, ctx: &mut EventCtx) {
6309        if self.read_only {
6310            if let Some(token) = self.caret_timer.take() {
6311                ctx.cancel_timer(token);
6312            }
6313            self.caret_visible = false;
6314            return;
6315        }
6316        self.caret_visible = self.focused;
6317        self.arm_caret_blink(ctx);
6318    }
6319
6320    fn set_hovered(&mut self, hovered: bool, ctx: &mut EventCtx) {
6321        if self.hovered != hovered {
6322            let theme = self.resolved_theme();
6323            self.hovered = hovered;
6324            set_hover_animation_target(
6325                &mut self.hover_animation,
6326                hovered as u8 as f32,
6327                &theme,
6328                ctx,
6329            );
6330            ctx.request_paint();
6331            ctx.request_semantics();
6332        }
6333    }
6334}
6335
6336impl Widget for TextArea {
6337    fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
6338        match event {
6339            Event::Pointer(pointer) if pointer.kind == PointerEventKind::Move => {
6340                self.set_hovered(ctx.bounds().contains(pointer.position), ctx);
6341                if self.dragging_selection
6342                    && ctx.phase() != EventPhase::Capture
6343                    && pointer.buttons.contains(PointerButton::Primary)
6344                {
6345                    let offset = self.text_offset_at_position(ctx.bounds(), pointer.position);
6346                    let result = self.editor.execute(EditorCommand::SetSelection {
6347                        anchor: self.editor.selection().anchor.utf8_offset,
6348                        focus: offset,
6349                    });
6350                    self.apply_editor_result(ctx, result);
6351                }
6352            }
6353            Event::Pointer(pointer) if pointer.kind == PointerEventKind::Enter => {
6354                self.set_hovered(ctx.bounds().contains(pointer.position), ctx);
6355            }
6356            Event::Pointer(_pointer) if matches!(_pointer.kind, PointerEventKind::Leave) => {
6357                self.set_hovered(false, ctx);
6358            }
6359            Event::Pointer(pointer)
6360                if pointer.kind == PointerEventKind::Down
6361                    && pointer.button == Some(PointerButton::Primary) =>
6362            {
6363                self.set_hovered(true, ctx);
6364                if self.focused {
6365                    self.reset_caret_blink(ctx);
6366                }
6367                self.set_caret_from_position(
6368                    ctx.bounds(),
6369                    pointer.position,
6370                    pointer.modifiers.shift,
6371                    ctx,
6372                );
6373                self.dragging_selection = true;
6374                ctx.request_pointer_capture(pointer.pointer_id);
6375                ctx.request_focus();
6376                ctx.request_paint();
6377                ctx.request_semantics();
6378                ctx.set_handled();
6379            }
6380            Event::Pointer(pointer)
6381                if pointer.kind == PointerEventKind::Up
6382                    && pointer.button == Some(PointerButton::Primary)
6383                    && self.dragging_selection =>
6384            {
6385                self.dragging_selection = false;
6386                ctx.release_pointer_capture(pointer.pointer_id);
6387                ctx.set_handled();
6388            }
6389            Event::Pointer(pointer) if pointer.kind == PointerEventKind::Cancel => {
6390                if self.dragging_selection {
6391                    self.dragging_selection = false;
6392                    ctx.release_pointer_capture(pointer.pointer_id);
6393                }
6394            }
6395            Event::Pointer(pointer)
6396                if pointer.kind == PointerEventKind::Down
6397                    && pointer.button == Some(PointerButton::Secondary)
6398                    && ctx.phase() != EventPhase::Capture
6399                    && ctx.bounds().contains(pointer.position) =>
6400            {
6401                // Focus on right-click (keeping the selection intact) so
6402                // follow-up clipboard commands land here. Deliberately not
6403                // handled: wrapping context menus react to the same press.
6404                self.set_hovered(true, ctx);
6405                if !ctx.is_focused() {
6406                    ctx.request_focus();
6407                    ctx.request_paint();
6408                    ctx.request_semantics();
6409                }
6410            }
6411            Event::Semantics(semantics) if semantics.target == ctx.widget_id() => {
6412                if let Some(commands) =
6413                    semantics_editor_commands(ctx, &semantics.action, self.read_only, false)
6414                {
6415                    for command in commands {
6416                        self.execute_editor_command(ctx, command);
6417                    }
6418                }
6419            }
6420            Event::Ime(ImeEvent::CompositionStart) if ctx.is_focused() => {
6421                if !self.read_only {
6422                    self.execute_editor_command(ctx, EditorCommand::StartComposition);
6423                }
6424            }
6425            Event::Ime(ImeEvent::CompositionUpdate { text, cursor_range }) if ctx.is_focused() => {
6426                if !self.read_only {
6427                    self.execute_editor_command(
6428                        ctx,
6429                        EditorCommand::UpdateComposition {
6430                            text: text.clone(),
6431                            cursor_range: cursor_range.clone(),
6432                        },
6433                    );
6434                }
6435            }
6436            Event::Ime(ImeEvent::CompositionCommit { text }) if ctx.is_focused() => {
6437                if !self.read_only {
6438                    self.execute_editor_command(
6439                        ctx,
6440                        EditorCommand::CommitComposition(text.clone()),
6441                    );
6442                }
6443            }
6444            Event::Ime(ImeEvent::CompositionEnd) if ctx.is_focused() => {
6445                if !self.read_only {
6446                    self.execute_editor_command(ctx, EditorCommand::EndComposition);
6447                }
6448            }
6449            Event::Keyboard(key)
6450                if !self.read_only
6451                    && key.state == KeyState::Pressed
6452                    && ctx.is_focused()
6453                    && key.key == "Backspace" =>
6454            {
6455                self.execute_editor_command(ctx, EditorCommand::DeleteBackward);
6456            }
6457            Event::Keyboard(key)
6458                if !self.read_only
6459                    && key.state == KeyState::Pressed
6460                    && ctx.is_focused()
6461                    && key.key == "Delete" =>
6462            {
6463                self.execute_editor_command(ctx, EditorCommand::DeleteForward);
6464            }
6465            Event::Keyboard(key)
6466                if key.state == KeyState::Pressed && ctx.is_focused() && key.key == "Enter" =>
6467            {
6468                // Chat-composer behavior (only when an `on_submit` is wired): a plain Enter (no
6469                // Shift/Ctrl/Meta) submits the current text and is consumed, while Shift+Enter (or
6470                // any modified Enter) inserts a newline as usual. With no `on_submit`, Enter always
6471                // inserts a newline (backward-compatible).
6472                let plain_enter =
6473                    !key.modifiers.shift && !key.modifiers.control && !key.modifiers.meta;
6474                if self.on_submit.is_some() && plain_enter {
6475                    let text = self.current_value().to_string();
6476                    if let Some(on_submit) = &mut self.on_submit {
6477                        on_submit(&text);
6478                    }
6479                    ctx.set_handled();
6480                } else if !self.read_only {
6481                    self.execute_editor_command(ctx, EditorCommand::InsertText("\n".to_string()));
6482                }
6483            }
6484            Event::Keyboard(key) if key.state == KeyState::Pressed && ctx.is_focused() => {
6485                let command_modifier = key.modifiers.control || key.modifiers.meta;
6486                let command = match key.key.as_str() {
6487                    "a" | "A" if command_modifier => EditorCommand::SelectAll,
6488                    "c" | "C" if command_modifier => EditorCommand::Copy,
6489                    "x" | "X" if command_modifier && !self.read_only => EditorCommand::Cut,
6490                    "v" | "V" if command_modifier && !self.read_only => paste_command(ctx),
6491                    "z" | "Z" if command_modifier && key.modifiers.shift && !self.read_only => {
6492                        EditorCommand::Redo
6493                    }
6494                    "z" | "Z" if command_modifier && !self.read_only => EditorCommand::Undo,
6495                    "y" | "Y" if command_modifier && !self.read_only => EditorCommand::Redo,
6496                    "ArrowLeft" if command_modifier => EditorCommand::MoveWordLeft {
6497                        extend: key.modifiers.shift,
6498                    },
6499                    "ArrowRight" if command_modifier => EditorCommand::MoveWordRight {
6500                        extend: key.modifiers.shift,
6501                    },
6502                    "ArrowLeft" => EditorCommand::MoveLeft {
6503                        extend: key.modifiers.shift,
6504                    },
6505                    "ArrowRight" => EditorCommand::MoveRight {
6506                        extend: key.modifiers.shift,
6507                    },
6508                    "ArrowUp" => EditorCommand::MoveUp {
6509                        extend: key.modifiers.shift,
6510                    },
6511                    "ArrowDown" => EditorCommand::MoveDown {
6512                        extend: key.modifiers.shift,
6513                    },
6514                    "Home" => EditorCommand::MoveLineStart {
6515                        extend: key.modifiers.shift,
6516                    },
6517                    "End" => EditorCommand::MoveLineEnd {
6518                        extend: key.modifiers.shift,
6519                    },
6520                    "PageUp" => EditorCommand::PageUp {
6521                        extend: key.modifiers.shift,
6522                        lines: 8,
6523                    },
6524                    "PageDown" => EditorCommand::PageDown {
6525                        extend: key.modifiers.shift,
6526                        lines: 8,
6527                    },
6528                    _ if !self.read_only && self.editor.composition().is_none() => {
6529                        keyboard_text(key)
6530                            .map(|text| EditorCommand::InsertText(text.to_string()))
6531                            .unwrap_or(EditorCommand::Noop)
6532                    }
6533                    _ => EditorCommand::Noop,
6534                };
6535                if !matches!(command, EditorCommand::Noop) {
6536                    self.execute_editor_command(ctx, command);
6537                }
6538            }
6539            Event::Wake(sui_core::WakeEvent::Timer { token, .. })
6540                if self.caret_timer == Some(*token) =>
6541            {
6542                self.caret_timer = None;
6543                if self.focused {
6544                    self.caret_visible = !self.caret_visible;
6545                    self.arm_caret_blink(ctx);
6546                    ctx.request_paint();
6547                    ctx.set_handled();
6548                }
6549            }
6550            Event::Wake(sui_core::WakeEvent::AnimationFrame { time, .. }) => {
6551                let previous_hover = self.hover_animation.value;
6552                let previous_focus = self.focus_animation.value;
6553                let animating =
6554                    self.hover_animation.advance(*time) | self.focus_animation.advance(*time);
6555                let changed = self.hover_animation.changed_since(previous_hover)
6556                    || self.focus_animation.changed_since(previous_focus);
6557                if animating {
6558                    ctx.request_animation_frame();
6559                }
6560                if changed {
6561                    ctx.request_paint();
6562                }
6563            }
6564            _ => {}
6565        }
6566    }
6567
6568    fn command(&mut self, ctx: &mut EventCtx, command: &Command<'_>) {
6569        let Some(command) = TextCommand::from_command(command) else {
6570            return;
6571        };
6572        if !ctx.is_focused() {
6573            ctx.request_focus();
6574        }
6575        self.apply_text_command(ctx, command);
6576    }
6577
6578    fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
6579        let text_style = self.resolved_text_style();
6580        let padding = self.resolved_padding();
6581        let min_size = self.resolved_min_size();
6582        let content_width = if constraints.max.width.is_finite() {
6583            (constraints.max.width - padding.left - padding.right).max(0.0)
6584        } else {
6585            (min_size.width - padding.left - padding.right).max(0.0)
6586        };
6587        let display_text = self.display_text();
6588        let input_text = self.input_text();
6589        let display_style = self.display_text_style();
6590        let display_min_height = display_style.line_height.max(1.0);
6591        let input_min_height = text_style.line_height.max(1.0);
6592        let display_box = Size::new(content_width.max(1.0), display_min_height);
6593        let input_box = Size::new(content_width.max(1.0), input_min_height);
6594
6595        let mut display_layout = ctx
6596            .layout()
6597            .shape_text_persistent(
6598                self.display_layout.as_ref().map(|layout| layout.handle()),
6599                display_text.clone(),
6600                display_box,
6601                display_style.clone(),
6602            )
6603            .ok();
6604        if let Some(required_height) = display_layout
6605            .as_ref()
6606            .map(|layout| layout.measurement().height.max(display_min_height).max(1.0))
6607            .filter(|height| *height > display_box.height + 0.01)
6608            && let Ok(layout) = ctx.layout().shape_text_persistent(
6609                self.display_layout.as_ref().map(|layout| layout.handle()),
6610                display_text,
6611                Size::new(content_width.max(1.0), required_height),
6612                display_style.clone(),
6613            )
6614        {
6615            display_layout = Some(layout);
6616        }
6617
6618        let mut input_layout = ctx
6619            .layout()
6620            .shape_text_persistent(
6621                self.input_layout.as_ref().map(|layout| layout.handle()),
6622                input_text.clone(),
6623                input_box,
6624                text_style.clone(),
6625            )
6626            .ok();
6627        if let Some(required_height) = input_layout
6628            .as_ref()
6629            .map(|layout| layout.measurement().height.max(input_min_height).max(1.0))
6630            .filter(|height| *height > input_box.height + 0.01)
6631            && let Ok(layout) = ctx.layout().shape_text_persistent(
6632                self.input_layout.as_ref().map(|layout| layout.handle()),
6633                input_text,
6634                Size::new(content_width.max(1.0), required_height),
6635                text_style.clone(),
6636            )
6637        {
6638            input_layout = Some(layout);
6639        }
6640
6641        let measured_height = display_layout
6642            .as_ref()
6643            .map(|layout| layout.measurement().height.max(display_style.line_height))
6644            .unwrap_or(display_style.line_height);
6645        self.display_layout = display_layout;
6646        self.input_layout = input_layout;
6647
6648        constraints.clamp(Size::new(
6649            min_size
6650                .width
6651                .max(content_width + padding.left + padding.right),
6652            min_size
6653                .height
6654                .max(measured_height + padding.top + padding.bottom),
6655        ))
6656    }
6657
6658    fn paint(&self, ctx: &mut PaintCtx) {
6659        let theme = self.resolved_theme();
6660        let palette = theme.palette;
6661        let metrics = theme.metrics;
6662        let padding = self.resolved_padding();
6663        let content = inset_rect(ctx.bounds(), padding);
6664        let focus_progress = self.focus_animation.value;
6665
6666        // Light fields lift from their slightly recessed rest fill to the
6667        // surface on hover. Focus then moves every scheme toward its soft
6668        // accent well; dark and Void keep their established resting depth.
6669        let background = field_background(
6670            &theme,
6671            self.read_only,
6672            self.hover_animation.value,
6673            focus_progress,
6674        );
6675        if self.appearance == FieldAppearance::Framed {
6676            draw_control_frame(
6677                ctx,
6678                ctx.bounds(),
6679                metrics.corner_radius,
6680                metrics,
6681                background,
6682                mix_color(
6683                    mix_color(
6684                        palette.border,
6685                        palette.border_hover,
6686                        self.hover_animation.value,
6687                    ),
6688                    palette.border_focus,
6689                    focus_progress,
6690                ),
6691                (focus_progress > 0.0).then_some(
6692                    palette
6693                        .focus_ring
6694                        .with_alpha(palette.focus_ring.alpha * focus_progress),
6695                ),
6696            );
6697        }
6698
6699        if let Some(layout) = &self.display_layout {
6700            ctx.push_clip_rect(content);
6701            let input_text = self.input_text();
6702            let selection = selection_range(&self.editor.display_selection(), input_text.len());
6703            if !selection.is_empty() {
6704                for rect in layout.selection_rects(selection) {
6705                    ctx.fill_rect(
6706                        rect.translate(content.origin.to_vector()),
6707                        palette.selection,
6708                    );
6709                }
6710            }
6711            ctx.draw_persistent_text_layout(content.origin, layout);
6712            ctx.pop_clip();
6713        }
6714
6715        if self.focused && !self.read_only {
6716            let text_style = self.resolved_text_style();
6717            let caret_width = physical_pixels(ctx, metrics.caret_width);
6718            let fallback_caret = Rect::new(
6719                content.x(),
6720                content.y(),
6721                caret_width,
6722                text_style.line_height.max(1.0),
6723            );
6724            let caret = self
6725                .input_layout
6726                .as_ref()
6727                .and_then(|layout| {
6728                    let caret = layout
6729                        .caret_rect(self.editor.display_selection().focus.utf8_offset)
6730                        .translate(content.origin.to_vector());
6731                    rect_is_finite(caret).then_some(caret)
6732                })
6733                .unwrap_or(fallback_caret);
6734            let caret = Rect::new(
6735                caret
6736                    .x()
6737                    .min((content.max_x() - caret_width).max(content.x()))
6738                    .max(content.x()),
6739                caret.y(),
6740                caret_width,
6741                caret.height().max(text_style.line_height).max(1.0),
6742            );
6743            ctx.set_ime_composition_rect(caret);
6744            if self.caret_visible {
6745                ctx.fill(rounded_rect_path(caret, caret_width * 0.5), palette.caret);
6746            }
6747        }
6748    }
6749
6750    fn semantics(&self, ctx: &mut SemanticsCtx) {
6751        let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::TextInput, ctx.bounds());
6752        let display_text = self.input_text();
6753        let display_selection = self.editor.display_selection();
6754        let selection = selection_range(&display_selection, display_text.len());
6755        node.name = Some(self.name.clone());
6756        node.value = Some(SemanticsValue::Text(display_text));
6757        node.state.focused = ctx.is_focused();
6758        node.state.hovered = self.hovered;
6759        node.editable_text = Some(EditableTextSemantics {
6760            caret_offset: display_selection.focus.utf8_offset,
6761            selection: SemanticsTextRange::new(selection.start, selection.end),
6762            multiline: true,
6763            password: false,
6764            readonly: self.read_only,
6765            scroll_x: 0.0,
6766            scroll_y: 0.0,
6767        });
6768        node.actions = if self.read_only {
6769            vec![
6770                SemanticsAction::Focus,
6771                SemanticsAction::SetSelection,
6772                SemanticsAction::Copy,
6773            ]
6774        } else {
6775            vec![
6776                SemanticsAction::Focus,
6777                SemanticsAction::SetValue,
6778                SemanticsAction::SetSelection,
6779                SemanticsAction::InsertText,
6780                SemanticsAction::DeleteBackward,
6781                SemanticsAction::DeleteForward,
6782                SemanticsAction::Copy,
6783                SemanticsAction::Cut,
6784                SemanticsAction::Paste,
6785                SemanticsAction::Undo,
6786                SemanticsAction::Redo,
6787            ]
6788        };
6789        ctx.push(node);
6790    }
6791
6792    fn accepts_focus(&self) -> bool {
6793        true
6794    }
6795
6796    fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
6797        self.focused = focused;
6798        if !focused {
6799            let result = self.editor.execute(EditorCommand::ClearComposition);
6800            if result.layout_changed() {
6801                ctx.request_measure();
6802            }
6803        }
6804        if focused {
6805            self.reset_caret_blink(ctx);
6806        } else {
6807            if let Some(token) = self.caret_timer.take() {
6808                ctx.cancel_timer(token);
6809            }
6810            self.caret_visible = false;
6811        }
6812        let theme = self.resolved_theme();
6813        set_focus_animation_target(&mut self.focus_animation, focused as u8 as f32, &theme, ctx);
6814        if let Some(on_focus_change) = &mut self.on_focus_change {
6815            on_focus_change(focused);
6816        }
6817        ctx.request_paint();
6818        ctx.request_semantics();
6819    }
6820}
6821
6822#[derive(Debug, Clone)]
6823struct SelectMenuPresentationState {
6824    theme: DefaultTheme,
6825    options: Vec<String>,
6826    selected: Option<usize>,
6827    hovered: Option<usize>,
6828    hover_visual: Option<usize>,
6829    hover_animation: AnimatedScalar,
6830    placement: SelectMenuPlacement,
6831    menu_bounds: Rect,
6832    reveal: AnimatedScalar,
6833}
6834
6835impl SelectMenuPresentationState {
6836    fn new() -> Self {
6837        Self {
6838            theme: DefaultTheme::default(),
6839            options: Vec::new(),
6840            selected: None,
6841            hovered: None,
6842            hover_visual: None,
6843            hover_animation: AnimatedScalar::new(0.0),
6844            placement: SelectMenuPlacement::Below,
6845            menu_bounds: Rect::ZERO,
6846            reveal: AnimatedScalar::new(0.0),
6847        }
6848    }
6849
6850    fn is_presented(&self) -> bool {
6851        self.reveal.is_presented()
6852    }
6853
6854    fn row_height(&self) -> f32 {
6855        default_form_control_height(&self.theme)
6856    }
6857
6858    fn row_rect(&self, index: usize, bounds: Rect) -> Rect {
6859        Rect::new(
6860            bounds.x(),
6861            bounds.y() + (index as f32 * self.row_height()),
6862            bounds.width(),
6863            self.row_height(),
6864        )
6865    }
6866
6867    fn set_hovered(&mut self, hovered: Option<usize>, animate: bool, ctx: &mut EventCtx) -> bool {
6868        if self.hovered == hovered && self.hover_visual == hovered {
6869            return false;
6870        }
6871
6872        self.hovered = hovered;
6873        match hovered {
6874            Some(index) => {
6875                if self.hover_visual != Some(index) {
6876                    self.hover_visual = Some(index);
6877                    self.hover_animation = AnimatedScalar::new(0.0);
6878                }
6879                if animate {
6880                    set_hover_animation_target(&mut self.hover_animation, 1.0, &self.theme, ctx);
6881                } else {
6882                    self.hover_animation = AnimatedScalar::new(1.0);
6883                }
6884            }
6885            None => {
6886                if animate {
6887                    set_hover_animation_target(&mut self.hover_animation, 0.0, &self.theme, ctx);
6888                } else {
6889                    self.hover_animation = AnimatedScalar::new(0.0);
6890                    self.hover_visual = None;
6891                }
6892            }
6893        }
6894        true
6895    }
6896
6897    fn sync_hovered_without_animation(&mut self, hovered: Option<usize>) -> bool {
6898        if self.hovered == hovered && self.hover_visual == hovered {
6899            return false;
6900        }
6901        self.hovered = hovered;
6902        self.hover_visual = hovered;
6903        self.hover_animation = AnimatedScalar::new(hovered.is_some() as u8 as f32);
6904        true
6905    }
6906
6907    fn advance_hover(&mut self, time: f64) -> (bool, bool) {
6908        let previous = self.hover_animation.value;
6909        let active = self.hover_animation.advance(time);
6910        let changed = self.hover_animation.changed_since(previous);
6911        if self.hovered.is_none() && !self.hover_animation.is_presented() {
6912            self.hover_visual = None;
6913        }
6914        (changed, active)
6915    }
6916
6917    fn hover_progress_for(&self, index: usize) -> f32 {
6918        if self.hover_visual == Some(index) {
6919            self.hover_animation.value
6920        } else {
6921            0.0
6922        }
6923    }
6924
6925    fn layer_properties(&self) -> LayerProperties {
6926        let direction = match self.placement {
6927            SelectMenuPlacement::Below => -1.0,
6928            SelectMenuPlacement::Above => 1.0,
6929        };
6930        LayerProperties {
6931            opacity: self.reveal.value,
6932            translation: Vector::new(
6933                0.0,
6934                self.theme.metrics.popover_reveal_offset * (1.0 - self.reveal.value) * direction,
6935            ),
6936        }
6937    }
6938}
6939
6940struct SelectMenuSurface {
6941    state: Rc<RefCell<SelectMenuPresentationState>>,
6942}
6943
6944impl SelectMenuSurface {
6945    fn new(state: Rc<RefCell<SelectMenuPresentationState>>) -> Self {
6946        Self { state }
6947    }
6948}
6949
6950impl Widget for SelectMenuSurface {
6951    fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
6952        match event {
6953            Event::Pointer(pointer)
6954                if matches!(
6955                    pointer.kind,
6956                    PointerEventKind::Move | PointerEventKind::Enter
6957                ) =>
6958            {
6959                let mut state = self.state.borrow_mut();
6960                let bounds = state.menu_bounds;
6961                let hovered = bounds.contains(pointer.position).then(|| {
6962                    state.options.iter().enumerate().find_map(|(index, _)| {
6963                        state
6964                            .row_rect(index, bounds)
6965                            .contains(pointer.position)
6966                            .then_some(index)
6967                    })
6968                });
6969                let changed = state.set_hovered(hovered.flatten(), true, ctx);
6970                drop(state);
6971                if changed {
6972                    ctx.request_paint();
6973                }
6974            }
6975            Event::Pointer(pointer) if pointer.kind == PointerEventKind::Leave => {
6976                let mut state = self.state.borrow_mut();
6977                let changed = state.set_hovered(None, true, ctx);
6978                drop(state);
6979                if changed {
6980                    ctx.request_paint();
6981                }
6982            }
6983            Event::Wake(WakeEvent::AnimationFrame { time, .. }) => {
6984                let mut state = self.state.borrow_mut();
6985                let (changed, active) = state.advance_hover(*time);
6986                drop(state);
6987                if changed {
6988                    ctx.request_paint();
6989                }
6990                if active {
6991                    ctx.request_animation_frame();
6992                }
6993                ctx.set_handled();
6994            }
6995            _ => {}
6996        }
6997    }
6998
6999    fn measure(&mut self, _ctx: &mut MeasureCtx, _constraints: Constraints) -> Size {
7000        let state = self.state.borrow();
7001        if state.is_presented() {
7002            state.menu_bounds.size
7003        } else {
7004            Size::ZERO
7005        }
7006    }
7007
7008    fn paint(&self, ctx: &mut PaintCtx) {
7009        let state = self.state.borrow();
7010        if !state.is_presented() {
7011            return;
7012        }
7013
7014        let menu = ctx.bounds();
7015        let theme = state.theme;
7016        let metrics = theme.metrics;
7017        let palette = theme.palette;
7018        let menu_radius = metrics.corner_radius + 2.0;
7019        paint_theme_shadow(ctx, menu, [menu_radius; 4], &theme.shadows.box_shadow.md);
7020        draw_control_shape(
7021            ctx,
7022            menu,
7023            menu_radius,
7024            physical_pixels(ctx, metrics.border_width),
7025            palette.surface_raised,
7026            palette.border,
7027        );
7028        ctx.push_clip_rect(menu);
7029        for (index, option) in state.options.iter().enumerate() {
7030            let row = state.row_rect(index, menu);
7031            let selected = state.selected == Some(index);
7032            let hover_progress = state.hover_progress_for(index);
7033            let text_style = theme.body_text_style();
7034            if hover_progress > AnimatedScalar::EPSILON || selected {
7035                let background = if selected {
7036                    mix_color(
7037                        palette.selection,
7038                        palette.control_hover,
7039                        hover_progress * theme.interaction.hover_blend,
7040                    )
7041                } else {
7042                    mix_color(
7043                        palette.surface_raised,
7044                        palette.control_hover,
7045                        hover_progress,
7046                    )
7047                };
7048                ctx.fill(
7049                    rounded_rect_path(row.inflate(-4.0, -4.0), metrics.corner_radius - 2.0),
7050                    background,
7051                );
7052            }
7053            let text_slot = horizontal_text_inset_rect(row, metrics.text_input_padding);
7054            ctx.push_clip_rect(text_slot);
7055            paint_aligned_text(
7056                ctx,
7057                text_slot,
7058                option,
7059                &text_style,
7060                text_style.line_height,
7061                0.0,
7062            );
7063            ctx.pop_clip();
7064        }
7065        ctx.pop_clip();
7066    }
7067
7068    fn layer_options(&self) -> LayerOptions {
7069        let presented = self.state.borrow().is_presented();
7070        LayerOptions {
7071            paint_boundary: PaintBoundaryMode::Explicit,
7072            composition_mode: if presented {
7073                LayerCompositionMode::Overlay
7074            } else {
7075                LayerCompositionMode::Normal
7076            },
7077        }
7078    }
7079
7080    fn layer_properties(&self) -> LayerProperties {
7081        self.state.borrow().layer_properties()
7082    }
7083
7084    fn stack_surface_options(&self) -> Option<StackSurfaceOptions> {
7085        self.state
7086            .borrow()
7087            .is_presented()
7088            .then_some(StackSurfaceOptions {
7089                transient: true,
7090                ..StackSurfaceOptions::default()
7091            })
7092    }
7093}
7094
7095pub struct Select {
7096    theme: Box<DefaultTheme>,
7097    theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
7098    name: String,
7099    options: Vec<String>,
7100    selected: Option<usize>,
7101    selected_reader: Option<Box<dyn Fn() -> Option<usize>>>,
7102    placeholder: String,
7103    expanded: bool,
7104    hovered_option: Option<usize>,
7105    hovered_header: bool,
7106    pressed_header: bool,
7107    hover_animation: AnimatedScalar,
7108    press_animation: AnimatedScalar,
7109    focus_animation: AnimatedScalar,
7110    menu_surface: SingleChild,
7111    menu_state: Rc<RefCell<SelectMenuPresentationState>>,
7112    on_change: Option<Box<dyn FnMut(usize, String)>>,
7113    on_change_with_ctx: Option<Box<dyn FnMut(&mut EventCtx, usize, String)>>,
7114}
7115
7116impl Select {
7117    pub fn new(name: impl Into<String>) -> Self {
7118        let menu_state = Rc::new(RefCell::new(SelectMenuPresentationState::new()));
7119        Self {
7120            theme: Box::new(DefaultTheme::default()),
7121            theme_reader: None,
7122            name: name.into(),
7123            options: Vec::new(),
7124            selected: None,
7125            selected_reader: None,
7126            placeholder: String::new(),
7127            expanded: false,
7128            hovered_option: None,
7129            hovered_header: false,
7130            pressed_header: false,
7131            hover_animation: AnimatedScalar::new(0.0),
7132            press_animation: AnimatedScalar::new(0.0),
7133            focus_animation: AnimatedScalar::new(0.0),
7134            menu_surface: SingleChild::new(SelectMenuSurface::new(Rc::clone(&menu_state))),
7135            menu_state,
7136            on_change: None,
7137            on_change_with_ctx: None,
7138        }
7139    }
7140
7141    pub fn theme(mut self, theme: DefaultTheme) -> Self {
7142        self.theme = Box::new(theme);
7143        self.theme_reader = None;
7144        self
7145    }
7146
7147    pub fn theme_when<F>(mut self, theme: F) -> Self
7148    where
7149        F: Fn() -> DefaultTheme + 'static,
7150    {
7151        self.theme_reader = Some(Box::new(theme));
7152        self
7153    }
7154
7155    pub fn placeholder(mut self, placeholder: impl Into<String>) -> Self {
7156        self.placeholder = placeholder.into();
7157        self
7158    }
7159
7160    pub fn option(mut self, option: impl Into<String>) -> Self {
7161        self.options.push(option.into());
7162        self
7163    }
7164
7165    pub fn options<I, S>(mut self, options: I) -> Self
7166    where
7167        I: IntoIterator<Item = S>,
7168        S: Into<String>,
7169    {
7170        self.options.extend(options.into_iter().map(Into::into));
7171        self
7172    }
7173
7174    pub fn selected(mut self, index: usize) -> Self {
7175        self.selected = Some(index);
7176        self.selected_reader = None;
7177        self
7178    }
7179
7180    pub fn expanded(mut self, expanded: bool) -> Self {
7181        self.expanded = expanded;
7182        if expanded {
7183            self.hovered_option = self.current_selected_index().or(Some(0));
7184        } else {
7185            self.hovered_option = None;
7186        }
7187        self.menu_state.borrow_mut().reveal = AnimatedScalar::new(expanded as u8 as f32);
7188        self
7189    }
7190
7191    pub fn selected_when<F>(mut self, selected: F) -> Self
7192    where
7193        F: Fn() -> Option<usize> + 'static,
7194    {
7195        self.selected_reader = Some(Box::new(selected));
7196        self
7197    }
7198
7199    pub const fn selected_index(&self) -> Option<usize> {
7200        self.selected
7201    }
7202
7203    pub fn current_value(&self) -> Option<&str> {
7204        self.current_selected_index()
7205            .and_then(|index| self.options.get(index).map(String::as_str))
7206    }
7207
7208    pub fn on_change<F>(mut self, on_change: F) -> Self
7209    where
7210        F: FnMut(usize, String) + 'static,
7211    {
7212        self.on_change = Some(Box::new(on_change));
7213        self
7214    }
7215
7216    pub fn on_change_with_ctx<F>(mut self, on_change: F) -> Self
7217    where
7218        F: FnMut(&mut EventCtx, usize, String) + 'static,
7219    {
7220        self.on_change_with_ctx = Some(Box::new(on_change));
7221        self
7222    }
7223
7224    fn resolved_theme(&self) -> DefaultTheme {
7225        self.theme_reader
7226            .as_ref()
7227            .map(|theme| theme())
7228            .unwrap_or(*self.theme)
7229    }
7230
7231    fn header_height(&self) -> f32 {
7232        default_form_control_height(&self.resolved_theme())
7233    }
7234
7235    fn current_label(&self) -> String {
7236        self.current_value()
7237            .map(str::to_string)
7238            .unwrap_or_else(|| self.placeholder.clone())
7239    }
7240
7241    fn current_selected_index(&self) -> Option<usize> {
7242        self.selected_reader
7243            .as_ref()
7244            .map(|reader| reader())
7245            .unwrap_or(self.selected)
7246            .filter(|index| *index < self.options.len())
7247    }
7248
7249    fn header_rect(&self, bounds: Rect) -> Rect {
7250        let height = self.header_height().min(bounds.height()).max(0.0);
7251        Rect::new(
7252            bounds.x(),
7253            bounds.y() + ((bounds.height() - height) * 0.5).max(0.0),
7254            bounds.width(),
7255            height,
7256        )
7257    }
7258
7259    fn menu_height(&self) -> f32 {
7260        (self.options.len() as f32 * self.header_height())
7261            .min(self.resolved_theme().metrics.select_menu_max_height)
7262    }
7263
7264    fn menu_layout(&self, bounds: Rect, viewport: Size) -> (SelectMenuPlacement, Rect) {
7265        let theme = self.resolved_theme();
7266        let viewport = if viewport.width.is_finite()
7267            && viewport.height.is_finite()
7268            && viewport.width > 0.0
7269            && viewport.height > 0.0
7270        {
7271            Rect::from_origin_size(Point::ZERO, viewport)
7272        } else {
7273            Rect::new(0.0, 0.0, f32::MAX / 4.0, f32::MAX / 4.0)
7274        };
7275        let result = place_overlay(
7276            &OverlayPlacementRequest::new(
7277                self.header_rect(bounds),
7278                Size::new(bounds.width(), self.menu_height()),
7279                viewport,
7280                OverlayPlacement::BOTTOM_START,
7281            )
7282            .fallbacks([OverlayPlacement::TOP_START])
7283            .gap(theme.metrics.select_menu_gap)
7284            .margin(theme.metrics.select_menu_edge_padding),
7285        );
7286        let placement = if result.placement == OverlayPlacement::TOP_START {
7287            SelectMenuPlacement::Above
7288        } else {
7289            SelectMenuPlacement::Below
7290        };
7291        (placement, result.bounds)
7292    }
7293
7294    fn menu_placement(&self, bounds: Rect, viewport: Size) -> SelectMenuPlacement {
7295        self.menu_layout(bounds, viewport).0
7296    }
7297
7298    fn menu_rect(&self, bounds: Rect, viewport: Size) -> Rect {
7299        self.menu_layout(bounds, viewport).1
7300    }
7301
7302    fn option_rect(&self, bounds: Rect, viewport: Size, index: usize) -> Rect {
7303        let menu = self.menu_rect(bounds, viewport);
7304        Rect::new(
7305            menu.x(),
7306            menu.y() + (index as f32 * self.header_height()),
7307            menu.width(),
7308            self.header_height(),
7309        )
7310    }
7311
7312    fn option_at(&self, bounds: Rect, viewport: Size, position: Point) -> Option<usize> {
7313        if !self.expanded {
7314            return None;
7315        }
7316
7317        let menu = self.menu_rect(bounds, viewport);
7318        if !menu.contains(position) {
7319            return None;
7320        }
7321
7322        self.options.iter().enumerate().find_map(|(index, _)| {
7323            self.option_rect(bounds, viewport, index)
7324                .contains(position)
7325                .then_some(index)
7326        })
7327    }
7328
7329    fn select_index(&mut self, ctx: &mut EventCtx, index: usize) {
7330        if self.options.is_empty() {
7331            return;
7332        }
7333        let index = index.min(self.options.len().saturating_sub(1));
7334        self.selected = Some(index);
7335        let value = self.options[index].clone();
7336        if let Some(on_change) = &mut self.on_change {
7337            on_change(index, value.clone());
7338        }
7339        if let Some(on_change_with_ctx) = &mut self.on_change_with_ctx {
7340            on_change_with_ctx(ctx, index, value);
7341        }
7342        self.refresh_menu_interaction_state(ctx);
7343    }
7344
7345    fn sync_menu_state(&self, bounds: Rect, viewport: Size) {
7346        let mut state = self.menu_state.borrow_mut();
7347        state.theme = self.resolved_theme();
7348        state.options = self.options.clone();
7349        state.selected = self.current_selected_index();
7350        if state.hovered != self.hovered_option {
7351            state.sync_hovered_without_animation(self.hovered_option);
7352        }
7353        state.placement = self.menu_placement(bounds, viewport);
7354        state.menu_bounds = self.menu_rect(bounds, viewport);
7355    }
7356
7357    fn refresh_menu_interaction_state(&self, ctx: &mut EventCtx) {
7358        let selected = self.current_selected_index();
7359        let hovered = self.hovered_option;
7360        let surface_id = self.menu_surface.child().id();
7361        let mut state = self.menu_state.borrow_mut();
7362        let selected_changed = state.selected != selected;
7363        state.selected = selected;
7364        let hover_changed = state.set_hovered(hovered, true, ctx);
7365        let changed = selected_changed || hover_changed;
7366        let presented = state.is_presented();
7367        drop(state);
7368
7369        if changed && presented {
7370            request_child_invalidation(ctx, surface_id, InvalidationKind::Paint);
7371        }
7372    }
7373
7374    fn set_expanded(&mut self, ctx: &mut EventCtx, expanded: bool) {
7375        if self.expanded == expanded {
7376            return;
7377        }
7378
7379        self.expanded = expanded;
7380        self.hovered_option = if expanded {
7381            self.current_selected_index().or(Some(0))
7382        } else {
7383            None
7384        };
7385
7386        let surface_id = self.menu_surface.child().id();
7387        let theme = self.resolved_theme();
7388        let mut state = self.menu_state.borrow_mut();
7389        state.theme = theme;
7390        let was_presented = state.is_presented();
7391        state.sync_hovered_without_animation(self.hovered_option);
7392        let should_animate = if expanded {
7393            let motion = theme.motion;
7394            state.reveal.set_target(
7395                1.0,
7396                ctx.current_time(),
7397                motion.entrance_duration(),
7398                motion.entrance_easing(),
7399            )
7400        } else {
7401            state.reveal = AnimatedScalar::new(0.0);
7402            false
7403        };
7404        let is_presented = state.is_presented();
7405        drop(state);
7406
7407        if expanded || was_presented != is_presented {
7408            ctx.request_measure();
7409            request_child_invalidation(ctx, surface_id, InvalidationKind::Visibility);
7410        }
7411        if should_animate {
7412            ctx.request_animation_frame();
7413        }
7414        ctx.request_paint();
7415        ctx.request_semantics();
7416    }
7417
7418    fn set_hover_state(
7419        &mut self,
7420        hovered_header: bool,
7421        hovered_option: Option<usize>,
7422        ctx: &mut EventCtx,
7423    ) {
7424        if self.hovered_header != hovered_header || self.hovered_option != hovered_option {
7425            let theme = self.resolved_theme();
7426            self.hovered_header = hovered_header;
7427            self.hovered_option = hovered_option;
7428            set_hover_animation_target(
7429                &mut self.hover_animation,
7430                hovered_header as u8 as f32,
7431                &theme,
7432                ctx,
7433            );
7434            let surface_id = self.menu_surface.child().id();
7435            let mut state = self.menu_state.borrow_mut();
7436            state.theme = theme;
7437            state.set_hovered(hovered_option, true, ctx);
7438            let presented = state.is_presented();
7439            drop(state);
7440            if presented {
7441                request_child_invalidation(ctx, surface_id, InvalidationKind::Paint);
7442            }
7443            ctx.request_paint();
7444            ctx.request_semantics();
7445        }
7446    }
7447
7448    fn set_pressed_header(&mut self, pressed: bool, ctx: &mut EventCtx) {
7449        if self.pressed_header != pressed {
7450            let theme = self.resolved_theme();
7451            self.pressed_header = pressed;
7452            set_press_animation_target(
7453                &mut self.press_animation,
7454                pressed as u8 as f32,
7455                &theme,
7456                ctx,
7457            );
7458            ctx.request_paint();
7459            ctx.request_semantics();
7460        }
7461    }
7462
7463    fn advance_header_animations(&mut self, time: f64) -> (bool, bool) {
7464        let previous_hover = self.hover_animation.value;
7465        let previous_press = self.press_animation.value;
7466        let previous_focus = self.focus_animation.value;
7467        let animating = self.hover_animation.advance(time)
7468            | self.press_animation.advance(time)
7469            | self.focus_animation.advance(time);
7470        let changed = self.hover_animation.changed_since(previous_hover)
7471            || self.press_animation.changed_since(previous_press)
7472            || self.focus_animation.changed_since(previous_focus);
7473        (changed, animating)
7474    }
7475}
7476
7477impl Widget for Select {
7478    fn command(&mut self, ctx: &mut EventCtx, command: &Command<'_>) {
7479        if command.get(OVERLAY_DISMISS_REQUEST).is_some() && self.expanded {
7480            self.set_expanded(ctx, false);
7481            ctx.set_handled();
7482        }
7483    }
7484
7485    fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
7486        match event {
7487            Event::Pointer(pointer) if pointer.kind == PointerEventKind::Move => {
7488                self.set_hover_state(
7489                    self.header_rect(ctx.bounds()).contains(pointer.position),
7490                    self.option_at(ctx.bounds(), ctx.dpi().viewport, pointer.position),
7491                    ctx,
7492                );
7493            }
7494            Event::Pointer(pointer) if matches!(pointer.kind, PointerEventKind::Enter) => {
7495                self.set_hover_state(
7496                    self.header_rect(ctx.bounds()).contains(pointer.position),
7497                    self.option_at(ctx.bounds(), ctx.dpi().viewport, pointer.position),
7498                    ctx,
7499                );
7500            }
7501            Event::Pointer(pointer) if matches!(pointer.kind, PointerEventKind::Leave) => {
7502                self.set_hover_state(
7503                    false,
7504                    self.option_at(ctx.bounds(), ctx.dpi().viewport, pointer.position),
7505                    ctx,
7506                );
7507            }
7508            Event::Pointer(pointer)
7509                if pointer.kind == PointerEventKind::Down
7510                    && pointer.button == Some(PointerButton::Primary) =>
7511            {
7512                let hovered_header = self.header_rect(ctx.bounds()).contains(pointer.position);
7513                let hovered_option =
7514                    self.option_at(ctx.bounds(), ctx.dpi().viewport, pointer.position);
7515                self.set_hover_state(hovered_header, hovered_option, ctx);
7516                self.set_pressed_header(hovered_header, ctx);
7517                ctx.request_focus();
7518                ctx.request_pointer_capture(pointer.pointer_id);
7519                ctx.request_paint();
7520                ctx.request_semantics();
7521                ctx.set_handled();
7522            }
7523            Event::Pointer(pointer)
7524                if pointer.kind == PointerEventKind::Up
7525                    && pointer.button == Some(PointerButton::Primary) =>
7526            {
7527                let hovered_header = self.header_rect(ctx.bounds()).contains(pointer.position);
7528                let hovered_option =
7529                    self.option_at(ctx.bounds(), ctx.dpi().viewport, pointer.position);
7530                let was_pressed_header = self.pressed_header;
7531
7532                if was_pressed_header && hovered_header {
7533                    self.set_expanded(ctx, !self.expanded);
7534                } else if let Some(index) = hovered_option {
7535                    self.select_index(ctx, index);
7536                    self.set_expanded(ctx, false);
7537                } else {
7538                    self.set_expanded(ctx, false);
7539                }
7540
7541                self.set_pressed_header(false, ctx);
7542                self.set_hover_state(
7543                    hovered_header,
7544                    if self.expanded {
7545                        self.hovered_option
7546                    } else {
7547                        None
7548                    },
7549                    ctx,
7550                );
7551                ctx.release_pointer_capture(pointer.pointer_id);
7552                ctx.request_paint();
7553                ctx.request_semantics();
7554                ctx.set_handled();
7555            }
7556            Event::Pointer(pointer) if pointer.kind == PointerEventKind::Cancel => {
7557                if self.pressed_header {
7558                    self.set_pressed_header(false, ctx);
7559                    self.set_hover_state(false, None, ctx);
7560                    ctx.release_pointer_capture(pointer.pointer_id);
7561                    ctx.request_paint();
7562                    ctx.request_semantics();
7563                    ctx.set_handled();
7564                }
7565            }
7566            Event::Keyboard(key) if ctx.is_focused() && key.state == KeyState::Pressed => {
7567                if self.options.is_empty() {
7568                    return;
7569                }
7570
7571                match key.key.as_str() {
7572                    "Enter" | " " => {
7573                        if self.expanded {
7574                            if let Some(index) = self
7575                                .hovered_option
7576                                .or_else(|| self.current_selected_index())
7577                            {
7578                                self.select_index(ctx, index);
7579                            }
7580                            self.set_expanded(ctx, false);
7581                        } else {
7582                            self.set_expanded(ctx, true);
7583                        }
7584                    }
7585                    "Escape" => self.set_expanded(ctx, false),
7586                    "ArrowDown" => {
7587                        if self.expanded {
7588                            let next = self
7589                                .hovered_option
7590                                .unwrap_or_else(|| self.current_selected_index().unwrap_or(0))
7591                                .saturating_add(1)
7592                                .min(self.options.len() - 1);
7593                            self.set_hover_state(self.hovered_header, Some(next), ctx);
7594                        } else {
7595                            let next = self
7596                                .current_selected_index()
7597                                .unwrap_or(0)
7598                                .saturating_add(1)
7599                                .min(self.options.len() - 1);
7600                            self.select_index(ctx, next);
7601                        }
7602                    }
7603                    "ArrowUp" => {
7604                        if self.expanded {
7605                            let next = self
7606                                .hovered_option
7607                                .unwrap_or_else(|| self.current_selected_index().unwrap_or(0))
7608                                .saturating_sub(1);
7609                            self.set_hover_state(self.hovered_header, Some(next), ctx);
7610                        } else {
7611                            let next = self.current_selected_index().unwrap_or(0).saturating_sub(1);
7612                            self.select_index(ctx, next);
7613                        }
7614                    }
7615                    "Home" => self.select_index(ctx, 0),
7616                    "End" => self.select_index(ctx, self.options.len() - 1),
7617                    _ => {}
7618                }
7619
7620                self.refresh_menu_interaction_state(ctx);
7621                ctx.request_paint();
7622                ctx.request_semantics();
7623                ctx.set_handled();
7624            }
7625            Event::Wake(WakeEvent::AnimationFrame { time, .. }) => {
7626                let (header_changed, header_animating) = self.advance_header_animations(*time);
7627                let surface_id = self.menu_surface.child().id();
7628                let mut state = self.menu_state.borrow_mut();
7629                let was_presented = state.is_presented();
7630                let previous = state.reveal.value;
7631                let (hover_changed, hover_animating) = state.advance_hover(*time);
7632                let animating = state.reveal.advance(*time);
7633                let changed = state.reveal.changed_since(previous);
7634                let is_presented = state.is_presented();
7635                drop(state);
7636
7637                if changed {
7638                    request_child_invalidation(ctx, surface_id, InvalidationKind::Transform);
7639                    request_child_invalidation(ctx, surface_id, InvalidationKind::Effect);
7640                }
7641                if was_presented != is_presented {
7642                    ctx.request_measure();
7643                    request_child_invalidation(ctx, surface_id, InvalidationKind::Visibility);
7644                }
7645                if hover_changed {
7646                    request_child_invalidation(ctx, surface_id, InvalidationKind::Paint);
7647                }
7648                if header_changed {
7649                    ctx.request_paint();
7650                }
7651                if animating || header_animating || hover_animating {
7652                    ctx.request_animation_frame();
7653                }
7654                ctx.set_handled();
7655            }
7656            _ => {}
7657        }
7658    }
7659
7660    fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
7661        let theme = self.resolved_theme();
7662        let padding = theme.metrics.text_input_padding;
7663        let text_style = theme.body_text_style();
7664        let widest_option = self
7665            .options
7666            .iter()
7667            .map(|label| measure_text(ctx, label, &text_style).width)
7668            .fold(0.0, f32::max);
7669        let placeholder_width =
7670            measure_text(ctx, &self.placeholder, &theme.placeholder_text_style()).width;
7671        let widest = widest_option.max(placeholder_width);
7672        let width = (widest + padding.left + padding.right + SELECT_CHEVRON_SLOT_WIDTH)
7673            .max(theme.metrics.button_min_width + SELECT_CHEVRON_SLOT_WIDTH + padding.right);
7674        let height = self.header_height();
7675        let presented = self.menu_state.borrow().is_presented();
7676        if presented {
7677            let menu_size = Size::new(width, self.menu_height());
7678            {
7679                let mut state = self.menu_state.borrow_mut();
7680                state.theme = theme;
7681                state.options = self.options.clone();
7682                state.selected = self.current_selected_index();
7683                if state.hovered != self.hovered_option {
7684                    state.sync_hovered_without_animation(self.hovered_option);
7685                }
7686                state.menu_bounds = Rect::from_origin_size(Point::ZERO, menu_size);
7687            }
7688            self.menu_surface
7689                .measure(ctx, Constraints::tight(menu_size));
7690        }
7691
7692        constraints.clamp(Size::new(width, height))
7693    }
7694
7695    fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
7696        self.sync_menu_state(bounds, ctx.dpi().viewport);
7697        let state = self.menu_state.borrow();
7698        let surface_bounds = if state.is_presented() {
7699            state.menu_bounds
7700        } else {
7701            Rect::from_origin_size(bounds.origin, Size::ZERO)
7702        };
7703        drop(state);
7704        self.menu_surface.arrange(ctx, surface_bounds);
7705    }
7706
7707    fn paint(&self, ctx: &mut PaintCtx) {
7708        let theme = self.resolved_theme();
7709        let palette = theme.palette;
7710        let metrics = theme.metrics;
7711        let interaction = theme.interaction;
7712        let header = self.header_rect(ctx.bounds());
7713        let label = self.current_label();
7714        let placeholder = self.current_value().is_none();
7715        let hover_progress = self.hover_animation.value * interaction.hover_blend;
7716        let press_progress = self.press_animation.value * interaction.pressed_blend;
7717        let focus_progress = self.focus_animation.value;
7718        let content_offset =
7719            Vector::new(0.0, self.press_animation.value * interaction.pressed_offset);
7720        let text_style = if placeholder {
7721            theme.placeholder_text_style()
7722        } else {
7723            theme.body_text_style()
7724        };
7725        let text_slot = Rect::new(
7726            header.x() + metrics.text_input_padding.left,
7727            header.y(),
7728            (header.width()
7729                - metrics.text_input_padding.left
7730                - metrics.text_input_padding.right
7731                - SELECT_CHEVRON_SLOT_WIDTH)
7732                .max(0.0),
7733            header.height(),
7734        );
7735        // Mesh selects are dressed fields: the closed control sits on the
7736        // field token; hover/press keep the well and animate the border.
7737        draw_control_frame(
7738            ctx,
7739            header,
7740            metrics.corner_radius,
7741            metrics,
7742            mix_color(
7743                mix_color(palette.field, palette.control_active, press_progress * 0.5),
7744                palette.surface_focus,
7745                focus_progress,
7746            ),
7747            mix_color(
7748                mix_color(
7749                    palette.border,
7750                    palette.border_hover,
7751                    self.hover_animation.value.max(hover_progress),
7752                ),
7753                palette.border_focus,
7754                focus_progress,
7755            ),
7756            (focus_progress > 0.0).then_some(
7757                palette
7758                    .focus_ring
7759                    .with_alpha(palette.focus_ring.alpha * focus_progress),
7760            ),
7761        );
7762        ctx.push_clip_rect(text_slot);
7763        paint_single_line_aligned_text(
7764            ctx,
7765            text_slot.translate(content_offset),
7766            &label,
7767            &text_style,
7768            text_style.line_height,
7769            0.0,
7770        );
7771        ctx.pop_clip();
7772        draw_icon_glyph(
7773            ctx,
7774            if self.expanded {
7775                IconGlyph::ChevronUp
7776            } else {
7777                IconGlyph::ChevronDown
7778            },
7779            select_chevron_icon_rect(header).translate(content_offset),
7780            palette.text,
7781        );
7782
7783        if self.menu_state.borrow().is_presented() {
7784            self.menu_surface.paint(ctx);
7785        }
7786    }
7787
7788    fn semantics(&self, ctx: &mut SemanticsCtx) {
7789        let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::ComboBox, ctx.bounds());
7790        node.name = Some(self.name.clone());
7791        node.value = Some(SemanticsValue::Text(self.current_label()));
7792        node.state.focused = ctx.is_focused();
7793        node.state.hovered = self.hovered_header || self.menu_state.borrow().hovered.is_some();
7794        node.state.expanded = Some(self.expanded);
7795        node.popup = Some(SemanticsPopupKind::ListBox);
7796        node.actions = vec![
7797            SemanticsAction::Focus,
7798            SemanticsAction::Expand,
7799            SemanticsAction::Collapse,
7800            SemanticsAction::SetValue,
7801        ];
7802        ctx.push(node);
7803    }
7804
7805    fn accepts_focus(&self) -> bool {
7806        true
7807    }
7808
7809    fn overlay_options(&self) -> Option<OverlayOptions> {
7810        (self.expanded || self.menu_state.borrow().is_presented()).then_some(
7811            OverlayOptions::new(OverlayKind::Menu)
7812                .dismiss(if self.expanded {
7813                    OverlayDismissPolicy::TRANSIENT
7814                } else {
7815                    OverlayDismissPolicy::NONE
7816                })
7817                .focus(OverlayFocusBehavior::NONE),
7818        )
7819    }
7820
7821    fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
7822        if !focused && self.expanded {
7823            self.set_expanded(ctx, false);
7824        }
7825        let theme = self.resolved_theme();
7826        set_focus_animation_target(&mut self.focus_animation, focused as u8 as f32, &theme, ctx);
7827        ctx.request_paint();
7828        ctx.request_semantics();
7829    }
7830
7831    fn visit_children(&self, visitor: &mut dyn WidgetPodVisitor) {
7832        if self.menu_state.borrow().is_presented() {
7833            self.menu_surface.visit_children(visitor);
7834        }
7835    }
7836
7837    fn visit_children_mut(&mut self, visitor: &mut dyn WidgetPodMutVisitor) {
7838        if self.menu_state.borrow().is_presented() {
7839            self.menu_surface.visit_children_mut(visitor);
7840        }
7841    }
7842}
7843
7844pub type Divider = Separator;
7845pub type SpinBox = NumberInput;
7846pub type MultilineTextInput = TextArea;
7847pub type ComboBox = Select;
7848
7849const PASSWORD_MASK: &str = "•";
7850
7851pub struct TextInput {
7852    theme: Box<DefaultTheme>,
7853    theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
7854    name: String,
7855    editor: EditorState,
7856    password: bool,
7857    placeholder: String,
7858    leading_icon: Option<IconGlyph>,
7859    read_only: bool,
7860    appearance: FieldAppearance,
7861    text_style: Option<TextStyle>,
7862    padding: Option<Insets>,
7863    min_width: Option<f32>,
7864    min_height: Option<f32>,
7865    hovered: bool,
7866    focused: bool,
7867    dragging_selection: bool,
7868    hover_animation: AnimatedScalar,
7869    focus_animation: AnimatedScalar,
7870    caret_blink: Blink,
7871    caret_timer: Option<TimerToken>,
7872    caret_visible: bool,
7873    visible_measurement: Option<TextMeasurement>,
7874    input_measurement: Option<TextMeasurement>,
7875    display_layout: Option<PersistentTextLayout>,
7876    input_layout: Option<PersistentTextLayout>,
7877    selection_scope: Option<SelectionScope>,
7878    on_change: Option<Box<dyn FnMut(String)>>,
7879    on_change_with_ctx: Option<Box<dyn FnMut(&mut EventCtx, String)>>,
7880    on_focus_change: Option<Box<dyn FnMut(bool)>>,
7881}
7882
7883impl TextInput {
7884    pub fn new(name: impl Into<String>) -> Self {
7885        Self {
7886            theme: Box::new(DefaultTheme::default()),
7887            theme_reader: None,
7888            name: name.into(),
7889            editor: EditorState::new(),
7890            password: false,
7891            placeholder: String::new(),
7892            leading_icon: None,
7893            read_only: false,
7894            appearance: FieldAppearance::Framed,
7895            text_style: None,
7896            padding: None,
7897            min_width: None,
7898            min_height: None,
7899            hovered: false,
7900            focused: false,
7901            dragging_selection: false,
7902            hover_animation: AnimatedScalar::new(0.0),
7903            focus_animation: AnimatedScalar::new(0.0),
7904            caret_blink: Blink::new(CARET_BLINK_PERIOD_SECONDS),
7905            caret_timer: None,
7906            caret_visible: true,
7907            visible_measurement: None,
7908            input_measurement: None,
7909            display_layout: None,
7910            input_layout: None,
7911            selection_scope: None,
7912            on_change: None,
7913            on_change_with_ctx: None,
7914            on_focus_change: None,
7915        }
7916    }
7917
7918    pub fn name(&self) -> &str {
7919        &self.name
7920    }
7921
7922    pub fn theme(mut self, theme: DefaultTheme) -> Self {
7923        self.theme = Box::new(theme);
7924        self.theme_reader = None;
7925        self
7926    }
7927
7928    pub fn theme_when<F>(mut self, theme: F) -> Self
7929    where
7930        F: Fn() -> DefaultTheme + 'static,
7931    {
7932        self.theme_reader = Some(Box::new(theme));
7933        self
7934    }
7935
7936    pub fn text_style(mut self, text_style: TextStyle) -> Self {
7937        self.text_style = Some(text_style);
7938        self
7939    }
7940
7941    pub fn appearance(mut self, appearance: FieldAppearance) -> Self {
7942        self.appearance = appearance;
7943        self
7944    }
7945
7946    pub fn bare(mut self) -> Self {
7947        self.appearance = FieldAppearance::Bare;
7948        self
7949    }
7950
7951    pub fn padding(mut self, padding: Insets) -> Self {
7952        self.padding = Some(padding);
7953        self
7954    }
7955
7956    pub fn min_width(mut self, width: f32) -> Self {
7957        self.min_width = Some(width.max(0.0));
7958        self
7959    }
7960
7961    pub fn min_height(mut self, height: f32) -> Self {
7962        self.min_height = Some(height.max(0.0));
7963        self
7964    }
7965
7966    pub fn placeholder(mut self, placeholder: impl Into<String>) -> Self {
7967        self.placeholder = placeholder.into();
7968        self
7969    }
7970
7971    pub fn leading_icon(mut self, icon: IconGlyph) -> Self {
7972        self.leading_icon = Some(icon);
7973        self
7974    }
7975
7976    pub fn read_only(mut self) -> Self {
7977        self.read_only = true;
7978        self
7979    }
7980
7981    pub fn selectable(mut self, selection_scope: SelectionScope) -> Self {
7982        self.selection_scope = Some(selection_scope);
7983        self
7984    }
7985
7986    pub fn selection_scope(mut self, selection_scope: SelectionScope) -> Self {
7987        self.selection_scope = Some(selection_scope);
7988        self
7989    }
7990
7991    pub fn value(mut self, value: impl Into<String>) -> Self {
7992        self.editor.set_text(single_line_text(value.into()));
7993        self
7994    }
7995
7996    fn password(mut self) -> Self {
7997        self.password = true;
7998        self
7999    }
8000
8001    pub fn current_value(&self) -> &str {
8002        self.editor.document().text()
8003    }
8004
8005    pub fn set_value(&mut self, value: impl Into<String>) {
8006        self.editor.set_text(single_line_text(value.into()));
8007    }
8008
8009    pub fn on_change<F>(mut self, on_change: F) -> Self
8010    where
8011        F: FnMut(String) + 'static,
8012    {
8013        self.on_change = Some(Box::new(on_change));
8014        self
8015    }
8016
8017    pub fn on_change_with_ctx<F>(mut self, on_change: F) -> Self
8018    where
8019        F: FnMut(&mut EventCtx, String) + 'static,
8020    {
8021        self.on_change_with_ctx = Some(Box::new(on_change));
8022        self
8023    }
8024
8025    pub fn on_focus_change<F>(mut self, on_focus_change: F) -> Self
8026    where
8027        F: FnMut(bool) + 'static,
8028    {
8029        self.on_focus_change = Some(Box::new(on_focus_change));
8030        self
8031    }
8032
8033    fn input_text(&self) -> String {
8034        self.editor.display_text()
8035    }
8036
8037    fn rendered_input_text(&self) -> String {
8038        let input = self.input_text();
8039        if self.password {
8040            PASSWORD_MASK.repeat(input.graphemes(true).count())
8041        } else {
8042            input
8043        }
8044    }
8045
8046    fn rendered_offset(&self, input: &str, editor_offset: usize) -> usize {
8047        if !self.password {
8048            return editor_offset.min(input.len());
8049        }
8050
8051        input
8052            .grapheme_indices(true)
8053            .take_while(|(offset, _)| *offset < editor_offset.min(input.len()))
8054            .count()
8055            * PASSWORD_MASK.len()
8056    }
8057
8058    fn editor_offset(&self, input: &str, rendered_offset: usize) -> usize {
8059        if !self.password {
8060            return rendered_offset.min(input.len());
8061        }
8062
8063        let grapheme_index = rendered_offset / PASSWORD_MASK.len();
8064        input
8065            .grapheme_indices(true)
8066            .nth(grapheme_index)
8067            .map(|(offset, _)| offset)
8068            .unwrap_or(input.len())
8069    }
8070
8071    fn rendered_selection_range(&self, input: &str) -> Range<usize> {
8072        let selection = selection_range(&self.editor.display_selection(), input.len());
8073        self.rendered_offset(input, selection.start)..self.rendered_offset(input, selection.end)
8074    }
8075
8076    fn display_caret_offset(&self) -> usize {
8077        let input = self.input_text();
8078        self.rendered_offset(&input, self.editor.display_selection().focus.utf8_offset)
8079    }
8080
8081    fn visible_text(&self) -> String {
8082        let input = self.rendered_input_text();
8083        if input.is_empty() {
8084            self.placeholder.clone()
8085        } else {
8086            input
8087        }
8088    }
8089
8090    fn display_text_style(&self) -> TextStyle {
8091        let theme = self.resolved_theme();
8092        if self.input_text().is_empty() {
8093            theme.placeholder_text_style()
8094        } else if self.read_only {
8095            theme.text_style(theme.palette.text_muted)
8096        } else {
8097            self.resolved_text_style()
8098        }
8099    }
8100
8101    fn commit_text_change(&mut self, ctx: &mut EventCtx) {
8102        let value = self.current_value().to_string();
8103        if let Some(on_change) = &mut self.on_change {
8104            on_change(value.clone());
8105        }
8106        if let Some(on_change_with_ctx) = &mut self.on_change_with_ctx {
8107            on_change_with_ctx(ctx, value);
8108        }
8109    }
8110
8111    fn apply_editor_result(&mut self, ctx: &mut EventCtx, mut result: EditorCommandResult) {
8112        let copied_to_clipboard = result.clipboard_text.is_some();
8113        if let Some(text) = result.clipboard_text.take() {
8114            ctx.set_clipboard_text(text);
8115        }
8116        if result.text_changed {
8117            self.commit_text_change(ctx);
8118        }
8119        if result.layout_changed() {
8120            ctx.request_measure();
8121            ctx.request_paint();
8122        } else if result.overlay_changed() {
8123            ctx.request_paint();
8124        }
8125        if result.text_changed || result.selection_changed || result.composition_changed {
8126            sync_editor_selection_scope(ctx, self.selection_scope.as_ref(), &self.editor);
8127            ctx.request_semantics();
8128        }
8129        if result.handled {
8130            if self.focused {
8131                self.reset_caret_blink(ctx);
8132            }
8133            if !(copied_to_clipboard && self.selection_scope.is_some()) {
8134                ctx.set_handled();
8135            }
8136        }
8137    }
8138
8139    fn execute_editor_command(&mut self, ctx: &mut EventCtx, command: EditorCommand) {
8140        let result = self.editor.execute(command);
8141        self.apply_editor_result(ctx, result);
8142    }
8143
8144    /// Select the entire document.
8145    pub fn select_all(&mut self, ctx: &mut EventCtx) {
8146        self.execute_editor_command(ctx, EditorCommand::SelectAll);
8147    }
8148
8149    /// Copy the current selection to the clipboard. No-op when the selection
8150    /// is collapsed.
8151    pub fn copy(&mut self, ctx: &mut EventCtx) {
8152        self.execute_editor_command(ctx, EditorCommand::Copy);
8153    }
8154
8155    /// Copy the current selection to the clipboard and delete it. No-op when
8156    /// read-only or the selection is collapsed.
8157    pub fn cut(&mut self, ctx: &mut EventCtx) {
8158        if self.read_only {
8159            return;
8160        }
8161        self.execute_editor_command(ctx, EditorCommand::Cut);
8162    }
8163
8164    /// Replace the current selection with the clipboard text (coerced to a
8165    /// single line). No-op when read-only or the clipboard has no text.
8166    pub fn paste(&mut self, ctx: &mut EventCtx) {
8167        if self.read_only {
8168            return;
8169        }
8170        let command = match paste_command(ctx) {
8171            EditorCommand::Paste(text) => EditorCommand::Paste(single_line_text(text)),
8172            command => command,
8173        };
8174        self.execute_editor_command(ctx, command);
8175    }
8176
8177    /// Currently selected document text (empty when the selection is
8178    /// collapsed).
8179    pub fn selected_text(&self) -> &str {
8180        self.editor.selected_text()
8181    }
8182
8183    fn apply_text_command(&mut self, ctx: &mut EventCtx, command: TextCommand) {
8184        match command {
8185            TextCommand::SelectAll => self.select_all(ctx),
8186            TextCommand::Copy => self.copy(ctx),
8187            TextCommand::Cut => self.cut(ctx),
8188            TextCommand::Paste => self.paste(ctx),
8189        }
8190    }
8191
8192    fn text_offset_at_position(&self, bounds: Rect, position: Point) -> usize {
8193        let content = self.text_content_rect(bounds);
8194        let rendered_offset = self
8195            .input_layout
8196            .as_ref()
8197            .map(|layout| {
8198                layout
8199                    .hit_test_point(Point::new(
8200                        position.x - content.x(),
8201                        position.y - content.y(),
8202                    ))
8203                    .utf8_offset
8204            })
8205            .unwrap_or(self.rendered_input_text().len());
8206        self.editor_offset(&self.input_text(), rendered_offset)
8207    }
8208
8209    fn set_caret_from_position(
8210        &mut self,
8211        bounds: Rect,
8212        position: Point,
8213        extend: bool,
8214        ctx: &mut EventCtx,
8215    ) {
8216        let offset = self.text_offset_at_position(bounds, position);
8217        let command = if extend {
8218            EditorCommand::SetSelection {
8219                anchor: self.editor.selection().anchor.utf8_offset,
8220                focus: offset,
8221            }
8222        } else {
8223            EditorCommand::MoveTo {
8224                offset,
8225                extend: false,
8226            }
8227        };
8228        let result = self.editor.execute(command);
8229        self.apply_editor_result(ctx, result);
8230        self.reset_caret_blink(ctx);
8231    }
8232
8233    fn caret_blink_delay(&self) -> f64 {
8234        let span = if self.caret_visible {
8235            self.caret_blink.period * self.caret_blink.duty_cycle as f64
8236        } else {
8237            self.caret_blink.period * (1.0 - self.caret_blink.duty_cycle as f64)
8238        };
8239        span.max(f64::EPSILON)
8240    }
8241
8242    fn arm_caret_blink(&mut self, ctx: &mut EventCtx) {
8243        if let Some(token) = self.caret_timer.take() {
8244            ctx.cancel_timer(token);
8245        }
8246        if self.focused {
8247            self.caret_timer = Some(ctx.schedule_timer_after(self.caret_blink_delay()));
8248        }
8249    }
8250
8251    fn reset_caret_blink(&mut self, ctx: &mut EventCtx) {
8252        if self.read_only {
8253            if let Some(token) = self.caret_timer.take() {
8254                ctx.cancel_timer(token);
8255            }
8256            self.caret_visible = false;
8257            return;
8258        }
8259        self.caret_visible = self.focused;
8260        self.arm_caret_blink(ctx);
8261    }
8262
8263    fn set_hovered(&mut self, hovered: bool, ctx: &mut EventCtx) {
8264        if self.hovered != hovered {
8265            let theme = self.resolved_theme();
8266            self.hovered = hovered;
8267            set_hover_animation_target(
8268                &mut self.hover_animation,
8269                hovered as u8 as f32,
8270                &theme,
8271                ctx,
8272            );
8273            ctx.request_paint();
8274            ctx.request_semantics();
8275        }
8276    }
8277
8278    fn resolved_text_style(&self) -> TextStyle {
8279        self.text_style
8280            .clone()
8281            .unwrap_or_else(|| self.resolved_theme().body_text_style())
8282    }
8283
8284    fn resolved_padding(&self) -> Insets {
8285        self.padding
8286            .unwrap_or(self.resolved_theme().metrics.text_input_padding)
8287    }
8288
8289    fn leading_icon_advance(&self) -> f32 {
8290        if self.leading_icon.is_some() {
8291            24.0
8292        } else {
8293            0.0
8294        }
8295    }
8296
8297    fn text_content_rect(&self, bounds: Rect) -> Rect {
8298        let content = inset_rect(bounds, self.resolved_padding());
8299        let leading = self.leading_icon_advance();
8300        Rect::new(
8301            (content.x() + leading).min(content.max_x()),
8302            content.y(),
8303            (content.width() - leading).max(0.0),
8304            content.height(),
8305        )
8306    }
8307
8308    fn resolved_min_size(&self) -> Size {
8309        let theme = self.resolved_theme();
8310        Size::new(
8311            self.min_width.unwrap_or(theme.metrics.text_input_min_width),
8312            self.min_height.unwrap_or(theme.metrics.min_height),
8313        )
8314    }
8315
8316    fn resolved_theme(&self) -> DefaultTheme {
8317        self.theme_reader
8318            .as_ref()
8319            .map(|theme| theme())
8320            .unwrap_or(*self.theme)
8321    }
8322
8323    fn single_line_layout_rect(
8324        &self,
8325        ctx: &PaintCtx,
8326        content: Rect,
8327        layout: &PersistentTextLayout,
8328        line_height: f32,
8329    ) -> Rect {
8330        aligned_text_rect_for_layout(ctx, content, layout.layout(), line_height, 0.0)
8331    }
8332
8333    fn single_line_text_rect(
8334        &self,
8335        ctx: &PaintCtx,
8336        content: Rect,
8337        text: &str,
8338        style: &TextStyle,
8339        line_height: f32,
8340    ) -> Rect {
8341        aligned_text_rect_for_text(ctx, content, text, style, line_height, 0.0)
8342    }
8343}
8344
8345impl Widget for TextInput {
8346    fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
8347        match event {
8348            Event::Pointer(pointer) if pointer.kind == PointerEventKind::Move => {
8349                self.set_hovered(ctx.bounds().contains(pointer.position), ctx);
8350                if self.dragging_selection
8351                    && ctx.phase() != EventPhase::Capture
8352                    && pointer.buttons.contains(PointerButton::Primary)
8353                {
8354                    let offset = self.text_offset_at_position(ctx.bounds(), pointer.position);
8355                    let result = self.editor.execute(EditorCommand::SetSelection {
8356                        anchor: self.editor.selection().anchor.utf8_offset,
8357                        focus: offset,
8358                    });
8359                    self.apply_editor_result(ctx, result);
8360                }
8361            }
8362            Event::Pointer(_pointer) if matches!(_pointer.kind, PointerEventKind::Enter) => {
8363                self.set_hovered(true, ctx);
8364            }
8365            Event::Pointer(_pointer) if matches!(_pointer.kind, PointerEventKind::Leave) => {
8366                self.set_hovered(false, ctx);
8367            }
8368            Event::Pointer(pointer)
8369                if pointer.kind == PointerEventKind::Down
8370                    && pointer.button == Some(PointerButton::Primary) =>
8371            {
8372                self.set_hovered(true, ctx);
8373                self.set_caret_from_position(
8374                    ctx.bounds(),
8375                    pointer.position,
8376                    pointer.modifiers.shift,
8377                    ctx,
8378                );
8379                self.dragging_selection = true;
8380                ctx.request_pointer_capture(pointer.pointer_id);
8381                ctx.request_focus();
8382                ctx.request_paint();
8383                ctx.request_semantics();
8384                ctx.set_handled();
8385            }
8386            Event::Pointer(pointer)
8387                if pointer.kind == PointerEventKind::Up
8388                    && pointer.button == Some(PointerButton::Primary)
8389                    && self.dragging_selection =>
8390            {
8391                self.dragging_selection = false;
8392                ctx.release_pointer_capture(pointer.pointer_id);
8393                ctx.set_handled();
8394            }
8395            Event::Pointer(pointer) if pointer.kind == PointerEventKind::Cancel => {
8396                if self.dragging_selection {
8397                    self.dragging_selection = false;
8398                    ctx.release_pointer_capture(pointer.pointer_id);
8399                }
8400            }
8401            Event::Pointer(pointer)
8402                if pointer.kind == PointerEventKind::Down
8403                    && pointer.button == Some(PointerButton::Secondary)
8404                    && ctx.phase() != EventPhase::Capture
8405                    && ctx.bounds().contains(pointer.position) =>
8406            {
8407                // Focus on right-click (keeping the selection intact) so
8408                // follow-up clipboard commands land here. Deliberately not
8409                // handled: wrapping context menus react to the same press.
8410                self.set_hovered(true, ctx);
8411                if !ctx.is_focused() {
8412                    ctx.request_focus();
8413                    ctx.request_paint();
8414                    ctx.request_semantics();
8415                }
8416            }
8417            Event::Semantics(semantics) if semantics.target == ctx.widget_id() => {
8418                if let Some(commands) =
8419                    semantics_editor_commands(ctx, &semantics.action, self.read_only, true)
8420                {
8421                    for command in commands {
8422                        self.execute_editor_command(ctx, command);
8423                    }
8424                }
8425            }
8426            Event::Ime(ImeEvent::CompositionStart) if ctx.is_focused() => {
8427                if !self.read_only {
8428                    self.execute_editor_command(ctx, EditorCommand::StartComposition);
8429                }
8430            }
8431            Event::Ime(ImeEvent::CompositionUpdate { text, cursor_range }) if ctx.is_focused() => {
8432                if !self.read_only {
8433                    self.execute_editor_command(
8434                        ctx,
8435                        EditorCommand::UpdateComposition {
8436                            text: single_line_text(text.clone()),
8437                            cursor_range: cursor_range.clone(),
8438                        },
8439                    );
8440                }
8441            }
8442            Event::Ime(ImeEvent::CompositionCommit { text }) if ctx.is_focused() => {
8443                if !self.read_only {
8444                    self.execute_editor_command(
8445                        ctx,
8446                        EditorCommand::CommitComposition(single_line_text(text.clone())),
8447                    );
8448                }
8449            }
8450            Event::Ime(ImeEvent::CompositionEnd) if ctx.is_focused() => {
8451                if !self.read_only {
8452                    self.execute_editor_command(ctx, EditorCommand::EndComposition);
8453                }
8454            }
8455            Event::Keyboard(key)
8456                if !self.read_only
8457                    && key.state == KeyState::Pressed
8458                    && ctx.is_focused()
8459                    && key.key == "Backspace" =>
8460            {
8461                self.execute_editor_command(ctx, EditorCommand::DeleteBackward);
8462            }
8463            Event::Keyboard(key)
8464                if !self.read_only
8465                    && key.state == KeyState::Pressed
8466                    && ctx.is_focused()
8467                    && key.key == "Delete" =>
8468            {
8469                self.execute_editor_command(ctx, EditorCommand::DeleteForward);
8470            }
8471            Event::Keyboard(key)
8472                if key.state == KeyState::Pressed && ctx.is_focused() && key.key == "ArrowLeft" =>
8473            {
8474                self.execute_editor_command(
8475                    ctx,
8476                    if key.modifiers.control || key.modifiers.meta {
8477                        EditorCommand::MoveWordLeft {
8478                            extend: key.modifiers.shift,
8479                        }
8480                    } else {
8481                        EditorCommand::MoveLeft {
8482                            extend: key.modifiers.shift,
8483                        }
8484                    },
8485                );
8486            }
8487            Event::Keyboard(key)
8488                if key.state == KeyState::Pressed
8489                    && ctx.is_focused()
8490                    && key.key == "ArrowRight" =>
8491            {
8492                self.execute_editor_command(
8493                    ctx,
8494                    if key.modifiers.control || key.modifiers.meta {
8495                        EditorCommand::MoveWordRight {
8496                            extend: key.modifiers.shift,
8497                        }
8498                    } else {
8499                        EditorCommand::MoveRight {
8500                            extend: key.modifiers.shift,
8501                        }
8502                    },
8503                );
8504            }
8505            Event::Keyboard(key)
8506                if key.state == KeyState::Pressed && ctx.is_focused() && key.key == "Home" =>
8507            {
8508                self.execute_editor_command(
8509                    ctx,
8510                    EditorCommand::MoveLineStart {
8511                        extend: key.modifiers.shift,
8512                    },
8513                );
8514            }
8515            Event::Keyboard(key)
8516                if key.state == KeyState::Pressed && ctx.is_focused() && key.key == "End" =>
8517            {
8518                self.execute_editor_command(
8519                    ctx,
8520                    EditorCommand::MoveLineEnd {
8521                        extend: key.modifiers.shift,
8522                    },
8523                );
8524            }
8525            Event::Keyboard(key) if key.state == KeyState::Pressed && ctx.is_focused() => {
8526                let command_modifier = key.modifiers.control || key.modifiers.meta;
8527                let command = match key.key.as_str() {
8528                    "a" | "A" if command_modifier => EditorCommand::SelectAll,
8529                    "c" | "C" if command_modifier => EditorCommand::Copy,
8530                    "x" | "X" if command_modifier && !self.read_only => EditorCommand::Cut,
8531                    "v" | "V" if command_modifier && !self.read_only => match paste_command(ctx) {
8532                        EditorCommand::Paste(text) => EditorCommand::Paste(single_line_text(text)),
8533                        command => command,
8534                    },
8535                    "z" | "Z" if command_modifier && key.modifiers.shift && !self.read_only => {
8536                        EditorCommand::Redo
8537                    }
8538                    "z" | "Z" if command_modifier && !self.read_only => EditorCommand::Undo,
8539                    "y" | "Y" if command_modifier && !self.read_only => EditorCommand::Redo,
8540                    _ if !self.read_only && self.editor.composition().is_none() => {
8541                        keyboard_text(key)
8542                            .map(|text| EditorCommand::InsertText(single_line_text(text)))
8543                            .unwrap_or(EditorCommand::Noop)
8544                    }
8545                    _ => EditorCommand::Noop,
8546                };
8547                if !matches!(command, EditorCommand::Noop) {
8548                    self.execute_editor_command(ctx, command);
8549                }
8550            }
8551            Event::Wake(sui_core::WakeEvent::Timer { token, .. })
8552                if self.caret_timer == Some(*token) =>
8553            {
8554                self.caret_timer = None;
8555                if self.focused {
8556                    self.caret_visible = !self.caret_visible;
8557                    self.arm_caret_blink(ctx);
8558                    ctx.request_paint();
8559                    ctx.set_handled();
8560                }
8561            }
8562            Event::Wake(sui_core::WakeEvent::AnimationFrame { time, .. }) => {
8563                let previous_hover = self.hover_animation.value;
8564                let previous_focus = self.focus_animation.value;
8565                let animating =
8566                    self.hover_animation.advance(*time) | self.focus_animation.advance(*time);
8567                let changed = self.hover_animation.changed_since(previous_hover)
8568                    || self.focus_animation.changed_since(previous_focus);
8569                if animating {
8570                    ctx.request_animation_frame();
8571                }
8572                if changed {
8573                    ctx.request_paint();
8574                }
8575            }
8576            _ => {}
8577        }
8578    }
8579
8580    fn command(&mut self, ctx: &mut EventCtx, command: &Command<'_>) {
8581        let Some(command) = TextCommand::from_command(command) else {
8582            return;
8583        };
8584        if !ctx.is_focused() {
8585            ctx.request_focus();
8586        }
8587        self.apply_text_command(ctx, command);
8588    }
8589
8590    fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
8591        let text_style = self.resolved_text_style();
8592        let padding = self.resolved_padding();
8593        let min_size = self.resolved_min_size();
8594        let visible_text = self.visible_text();
8595        let input_text = self.rendered_input_text();
8596        let display_style = self.display_text_style();
8597        let measured_visible = measure_text(ctx, &visible_text, &display_style);
8598        let measured_input = if input_text.is_empty() {
8599            TextMeasurement {
8600                width: 0.0,
8601                height: measured_visible.height,
8602                bounds: Rect::new(0.0, 0.0, 0.0, measured_visible.height),
8603                ascent: measured_visible.ascent,
8604                descent: measured_visible.descent,
8605                cap_height: measured_visible.cap_height,
8606            }
8607        } else {
8608            measure_text(ctx, &input_text, &text_style)
8609        };
8610        let display_line_height = display_style
8611            .line_height
8612            .max(measured_visible.height)
8613            .max(1.0);
8614        let input_line_height = text_style.line_height.max(measured_input.height).max(1.0);
8615        let display_line_box = Size::new(f32::INFINITY, display_line_height);
8616        let input_line_box = Size::new(f32::INFINITY, input_line_height);
8617        let display_layout = ctx
8618            .layout()
8619            .shape_text_persistent(
8620                self.display_layout.as_ref().map(|layout| layout.handle()),
8621                visible_text.clone(),
8622                display_line_box,
8623                display_style.clone(),
8624            )
8625            .ok();
8626        let input_layout = ctx
8627            .layout()
8628            .shape_text_persistent(
8629                self.input_layout.as_ref().map(|layout| layout.handle()),
8630                input_text.clone(),
8631                input_line_box,
8632                text_style.clone(),
8633            )
8634            .ok();
8635
8636        let visible_measurement = display_layout
8637            .as_ref()
8638            .map(|layout| layout.measurement())
8639            .unwrap_or(measured_visible);
8640        let input_measurement = input_layout
8641            .as_ref()
8642            .map(|layout| layout.measurement())
8643            .unwrap_or(measured_input);
8644
8645        self.visible_measurement = Some(visible_measurement);
8646        self.input_measurement = Some(input_measurement);
8647        self.display_layout = display_layout;
8648        self.input_layout = input_layout;
8649
8650        let width = (visible_measurement.width
8651            + self.leading_icon_advance()
8652            + padding.left
8653            + padding.right)
8654            .max(min_size.width);
8655        let height = (visible_measurement.height.max(display_style.line_height)
8656            + padding.top
8657            + padding.bottom)
8658            .max(min_size.height);
8659
8660        constraints.clamp(Size::new(width, height))
8661    }
8662
8663    fn paint(&self, ctx: &mut PaintCtx) {
8664        let theme = self.resolved_theme();
8665        let palette = theme.palette;
8666        let metrics = theme.metrics;
8667        let text_style = self.resolved_text_style();
8668        let padding = self.resolved_padding();
8669        let focus_progress = self.focus_animation.value;
8670        // Light fields lift from their slightly recessed rest fill to the
8671        // surface on hover. Focus then moves every scheme toward its soft
8672        // accent well; dark and Void keep their established resting depth.
8673        let background = field_background(
8674            &theme,
8675            self.read_only,
8676            self.hover_animation.value,
8677            focus_progress,
8678        );
8679        let border = mix_color(
8680            mix_color(
8681                palette.border,
8682                palette.border_hover,
8683                self.hover_animation.value,
8684            ),
8685            palette.border_focus,
8686            focus_progress,
8687        );
8688        let full_content_rect = inset_rect(ctx.bounds(), padding);
8689        let content_rect = self.text_content_rect(ctx.bounds());
8690        let display_text = self.visible_text();
8691        let placeholder = self.input_text().is_empty();
8692
8693        if self.appearance == FieldAppearance::Framed {
8694            draw_control_frame(
8695                ctx,
8696                ctx.bounds(),
8697                metrics.corner_radius,
8698                metrics,
8699                background,
8700                border,
8701                (focus_progress > 0.0).then_some(
8702                    palette
8703                        .focus_ring
8704                        .with_alpha(palette.focus_ring.alpha * focus_progress),
8705                ),
8706            );
8707        }
8708        if let Some(icon) = self.leading_icon {
8709            let icon_color = if self.read_only || placeholder {
8710                palette.text_muted
8711            } else {
8712                palette.text
8713            };
8714            let icon_side = 15.0;
8715            let icon_rect = Rect::new(
8716                full_content_rect.x() + 1.0,
8717                full_content_rect.y() + (full_content_rect.height() - icon_side) * 0.5,
8718                icon_side,
8719                icon_side,
8720            );
8721            draw_icon_glyph(ctx, icon, icon_rect, icon_color);
8722        }
8723        ctx.push_clip_rect(content_rect);
8724        if let Some(layout) = &self.display_layout {
8725            let layout_bounds = layout.measurement().bounds;
8726            let layout_rect =
8727                self.single_line_layout_rect(ctx, content_rect, layout, layout.style().line_height);
8728            let layout_origin = Point::new(layout_rect.x() - layout_bounds.x(), layout_rect.y());
8729            if !placeholder {
8730                let input = self.input_text();
8731                let selection = self.rendered_selection_range(&input);
8732                if !selection.is_empty() {
8733                    for rect in layout.selection_rects(selection) {
8734                        ctx.fill_rect(rect.translate(layout_origin.to_vector()), palette.selection);
8735                    }
8736                }
8737            }
8738            ctx.draw_persistent_text_layout(layout_origin, layout);
8739        } else {
8740            let display_style = if placeholder {
8741                theme.placeholder_text_style()
8742            } else if self.read_only {
8743                theme.text_style(palette.text_muted)
8744            } else {
8745                text_style.clone()
8746            };
8747            paint_aligned_text(
8748                ctx,
8749                content_rect,
8750                &display_text,
8751                &display_style,
8752                display_style.line_height,
8753                0.0,
8754            );
8755        }
8756        ctx.pop_clip();
8757
8758        if self.focused && !self.read_only {
8759            let caret_width = physical_pixels(ctx, metrics.caret_width);
8760            let input_text = self.rendered_input_text();
8761            let input_text_rect = self
8762                .input_layout
8763                .as_ref()
8764                .map(|layout| {
8765                    self.single_line_layout_rect(ctx, content_rect, layout, text_style.line_height)
8766                })
8767                .unwrap_or_else(|| {
8768                    self.single_line_text_rect(
8769                        ctx,
8770                        content_rect,
8771                        &input_text,
8772                        &text_style,
8773                        text_style.line_height,
8774                    )
8775                });
8776            let caret_rect = self
8777                .input_layout
8778                .as_ref()
8779                .map(|layout| {
8780                    layout
8781                        .caret_rect(self.display_caret_offset())
8782                        .translate(input_text_rect.origin.to_vector())
8783                })
8784                .unwrap_or(Rect::new(
8785                    input_text_rect.x()
8786                        + self
8787                            .input_measurement
8788                            .map(|measurement| measurement.width)
8789                            .unwrap_or(0.0),
8790                    input_text_rect.y(),
8791                    caret_width,
8792                    input_text_rect.height().max(text_style.line_height),
8793                ));
8794            let caret_rect = Rect::new(
8795                caret_rect
8796                    .x()
8797                    .min((content_rect.max_x() - caret_width).max(content_rect.x()))
8798                    .max(content_rect.x()),
8799                caret_rect.y(),
8800                caret_width,
8801                caret_rect.height().max(text_style.line_height),
8802            );
8803            ctx.set_ime_composition_rect(caret_rect);
8804            if self.caret_visible {
8805                ctx.fill(
8806                    rounded_rect_path(caret_rect, caret_width * 0.5),
8807                    palette.caret,
8808                );
8809            }
8810        }
8811    }
8812
8813    fn semantics(&self, ctx: &mut SemanticsCtx) {
8814        let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::TextInput, ctx.bounds());
8815        let display_text = self.input_text();
8816        let display_selection = self.editor.display_selection();
8817        let selection = selection_range(&display_selection, display_text.len());
8818        node.name = Some(self.name.clone());
8819        node.value = Some(SemanticsValue::Text(display_text));
8820        node.state.focused = ctx.is_focused();
8821        node.state.hovered = self.hovered;
8822        node.editable_text = Some(EditableTextSemantics {
8823            caret_offset: display_selection.focus.utf8_offset,
8824            selection: SemanticsTextRange::new(selection.start, selection.end),
8825            multiline: false,
8826            password: self.password,
8827            readonly: self.read_only,
8828            scroll_x: 0.0,
8829            scroll_y: 0.0,
8830        });
8831        node.actions = if self.read_only {
8832            vec![
8833                SemanticsAction::Focus,
8834                SemanticsAction::SetSelection,
8835                SemanticsAction::Copy,
8836            ]
8837        } else {
8838            vec![
8839                SemanticsAction::Focus,
8840                SemanticsAction::SetValue,
8841                SemanticsAction::SetSelection,
8842                SemanticsAction::InsertText,
8843                SemanticsAction::DeleteBackward,
8844                SemanticsAction::DeleteForward,
8845                SemanticsAction::Copy,
8846                SemanticsAction::Cut,
8847                SemanticsAction::Paste,
8848                SemanticsAction::Undo,
8849                SemanticsAction::Redo,
8850            ]
8851        };
8852        ctx.push(node);
8853    }
8854
8855    fn accepts_focus(&self) -> bool {
8856        true
8857    }
8858
8859    fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
8860        self.focused = focused;
8861        if !focused {
8862            let result = self.editor.execute(EditorCommand::ClearComposition);
8863            if result.layout_changed() {
8864                ctx.request_measure();
8865            }
8866        }
8867        if focused {
8868            self.reset_caret_blink(ctx);
8869        } else {
8870            if let Some(token) = self.caret_timer.take() {
8871                ctx.cancel_timer(token);
8872            }
8873            self.caret_visible = false;
8874        }
8875        let theme = self.resolved_theme();
8876        set_focus_animation_target(&mut self.focus_animation, focused as u8 as f32, &theme, ctx);
8877        if let Some(on_focus_change) = &mut self.on_focus_change {
8878            on_focus_change(focused);
8879        }
8880        ctx.request_paint();
8881        ctx.request_semantics();
8882    }
8883}
8884
8885/// A single-line text input that masks its visible value while retaining the
8886/// same selection, clipboard, IME, and change-callback behavior as
8887/// [`TextInput`].
8888pub struct PasswordInput {
8889    inner: TextInput,
8890}
8891
8892impl PasswordInput {
8893    pub fn new(name: impl Into<String>) -> Self {
8894        Self {
8895            inner: TextInput::new(name).password(),
8896        }
8897    }
8898
8899    pub fn theme(mut self, theme: DefaultTheme) -> Self {
8900        self.inner = self.inner.theme(theme);
8901        self
8902    }
8903
8904    pub fn theme_when<F>(mut self, theme: F) -> Self
8905    where
8906        F: Fn() -> DefaultTheme + 'static,
8907    {
8908        self.inner = self.inner.theme_when(theme);
8909        self
8910    }
8911
8912    pub fn placeholder(mut self, placeholder: impl Into<String>) -> Self {
8913        self.inner = self.inner.placeholder(placeholder);
8914        self
8915    }
8916
8917    pub fn value(mut self, value: impl Into<String>) -> Self {
8918        self.inner = self.inner.value(value);
8919        self
8920    }
8921
8922    pub fn min_width(mut self, width: f32) -> Self {
8923        self.inner = self.inner.min_width(width);
8924        self
8925    }
8926
8927    pub fn read_only(mut self) -> Self {
8928        self.inner = self.inner.read_only();
8929        self
8930    }
8931
8932    pub fn selectable(mut self, selection_scope: SelectionScope) -> Self {
8933        self.inner = self.inner.selectable(selection_scope);
8934        self
8935    }
8936
8937    pub fn on_change<F>(mut self, on_change: F) -> Self
8938    where
8939        F: FnMut(String) + 'static,
8940    {
8941        self.inner = self.inner.on_change(on_change);
8942        self
8943    }
8944
8945    pub fn on_change_with_ctx<F>(mut self, on_change: F) -> Self
8946    where
8947        F: FnMut(&mut EventCtx, String) + 'static,
8948    {
8949        self.inner = self.inner.on_change_with_ctx(on_change);
8950        self
8951    }
8952
8953    pub fn current_value(&self) -> &str {
8954        self.inner.current_value()
8955    }
8956
8957    pub fn set_value(&mut self, value: impl Into<String>) {
8958        self.inner.set_value(value);
8959    }
8960
8961    pub fn selected_text(&self) -> &str {
8962        self.inner.selected_text()
8963    }
8964
8965    pub fn select_all(&mut self, ctx: &mut EventCtx) {
8966        self.inner.select_all(ctx);
8967    }
8968
8969    pub fn copy(&mut self, ctx: &mut EventCtx) {
8970        self.inner.copy(ctx);
8971    }
8972
8973    pub fn cut(&mut self, ctx: &mut EventCtx) {
8974        self.inner.cut(ctx);
8975    }
8976
8977    pub fn paste(&mut self, ctx: &mut EventCtx) {
8978        self.inner.paste(ctx);
8979    }
8980}
8981
8982impl Widget for PasswordInput {
8983    fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
8984        self.inner.event(ctx, event);
8985    }
8986
8987    fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
8988        self.inner.measure(ctx, constraints)
8989    }
8990
8991    fn paint(&self, ctx: &mut PaintCtx) {
8992        self.inner.paint(ctx);
8993    }
8994
8995    fn semantics(&self, ctx: &mut SemanticsCtx) {
8996        self.inner.semantics(ctx);
8997    }
8998
8999    fn accepts_focus(&self) -> bool {
9000        self.inner.accepts_focus()
9001    }
9002
9003    fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
9004        self.inner.focus_changed(ctx, focused);
9005    }
9006}
9007
9008/// A lightweight single-line local date/time field. Values remain strings so
9009/// applications can choose their own parsing, timezone, and validation rules;
9010/// the suggested format is `YYYY-MM-DD HH:MM`.
9011pub struct DateTimeInput {
9012    inner: TextInput,
9013}
9014
9015impl DateTimeInput {
9016    pub fn new(name: impl Into<String>) -> Self {
9017        Self {
9018            inner: TextInput::new(name).placeholder("YYYY-MM-DD HH:MM"),
9019        }
9020    }
9021
9022    pub fn theme(mut self, theme: DefaultTheme) -> Self {
9023        self.inner = self.inner.theme(theme);
9024        self
9025    }
9026
9027    pub fn theme_when<F>(mut self, theme: F) -> Self
9028    where
9029        F: Fn() -> DefaultTheme + 'static,
9030    {
9031        self.inner = self.inner.theme_when(theme);
9032        self
9033    }
9034
9035    pub fn placeholder(mut self, placeholder: impl Into<String>) -> Self {
9036        self.inner = self.inner.placeholder(placeholder);
9037        self
9038    }
9039
9040    pub fn value(mut self, value: impl Into<String>) -> Self {
9041        self.inner = self.inner.value(value);
9042        self
9043    }
9044
9045    pub fn min_width(mut self, width: f32) -> Self {
9046        self.inner = self.inner.min_width(width);
9047        self
9048    }
9049
9050    pub fn read_only(mut self) -> Self {
9051        self.inner = self.inner.read_only();
9052        self
9053    }
9054
9055    pub fn selectable(mut self, selection_scope: SelectionScope) -> Self {
9056        self.inner = self.inner.selectable(selection_scope);
9057        self
9058    }
9059
9060    pub fn on_change<F>(mut self, on_change: F) -> Self
9061    where
9062        F: FnMut(String) + 'static,
9063    {
9064        self.inner = self.inner.on_change(on_change);
9065        self
9066    }
9067
9068    pub fn on_change_with_ctx<F>(mut self, on_change: F) -> Self
9069    where
9070        F: FnMut(&mut EventCtx, String) + 'static,
9071    {
9072        self.inner = self.inner.on_change_with_ctx(on_change);
9073        self
9074    }
9075
9076    pub fn current_value(&self) -> &str {
9077        self.inner.current_value()
9078    }
9079
9080    pub fn set_value(&mut self, value: impl Into<String>) {
9081        self.inner.set_value(value);
9082    }
9083
9084    pub fn selected_text(&self) -> &str {
9085        self.inner.selected_text()
9086    }
9087
9088    pub fn select_all(&mut self, ctx: &mut EventCtx) {
9089        self.inner.select_all(ctx);
9090    }
9091
9092    pub fn copy(&mut self, ctx: &mut EventCtx) {
9093        self.inner.copy(ctx);
9094    }
9095
9096    pub fn cut(&mut self, ctx: &mut EventCtx) {
9097        self.inner.cut(ctx);
9098    }
9099
9100    pub fn paste(&mut self, ctx: &mut EventCtx) {
9101        self.inner.paste(ctx);
9102    }
9103}
9104
9105impl Widget for DateTimeInput {
9106    fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
9107        self.inner.event(ctx, event);
9108    }
9109
9110    fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
9111        self.inner.measure(ctx, constraints)
9112    }
9113
9114    fn paint(&self, ctx: &mut PaintCtx) {
9115        self.inner.paint(ctx);
9116    }
9117
9118    fn semantics(&self, ctx: &mut SemanticsCtx) {
9119        self.inner.semantics(ctx);
9120    }
9121
9122    fn accepts_focus(&self) -> bool {
9123        self.inner.accepts_focus()
9124    }
9125
9126    fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
9127        self.inner.focus_changed(ctx, focused);
9128    }
9129}
9130
9131fn measure_text(ctx: &mut MeasureCtx, text: &str, style: &TextStyle) -> TextMeasurement {
9132    ctx.layout()
9133        .measure_text(text.to_string(), style.clone())
9134        .unwrap_or(TextMeasurement {
9135            width: 0.0,
9136            height: style.line_height,
9137            bounds: Rect::new(0.0, 0.0, 0.0, style.line_height),
9138            ascent: style.font_size,
9139            descent: 0.0,
9140            cap_height: Some(style.font_size),
9141        })
9142}
9143
9144fn numeric_text_style(mut style: TextStyle) -> TextStyle {
9145    style.features.enable(FontFeature::TABULAR_FIGURES);
9146    style
9147}
9148
9149fn single_line_text(text: impl Into<String>) -> String {
9150    text.into()
9151        .chars()
9152        .filter(|ch| *ch != '\r' && *ch != '\n')
9153        .collect()
9154}
9155
9156fn semantics_editor_commands(
9157    ctx: &EventCtx,
9158    action: &SemanticsActionRequest,
9159    read_only: bool,
9160    single_line: bool,
9161) -> Option<Vec<EditorCommand>> {
9162    let normalize = |text: String| {
9163        if single_line {
9164            single_line_text(text)
9165        } else {
9166            text
9167        }
9168    };
9169
9170    match action {
9171        SemanticsActionRequest::SetValue(SemanticsValue::Text(text)) if !read_only => Some(vec![
9172            EditorCommand::SelectAll,
9173            EditorCommand::InsertText(normalize(text.clone())),
9174        ]),
9175        SemanticsActionRequest::SetSelection(selection) => {
9176            Some(vec![EditorCommand::SetSelection {
9177                anchor: selection.start,
9178                focus: selection.end,
9179            }])
9180        }
9181        SemanticsActionRequest::InsertText(text) if !read_only => {
9182            Some(vec![EditorCommand::InsertText(normalize(text.clone()))])
9183        }
9184        SemanticsActionRequest::DeleteBackward if !read_only => {
9185            Some(vec![EditorCommand::DeleteBackward])
9186        }
9187        SemanticsActionRequest::DeleteForward if !read_only => {
9188            Some(vec![EditorCommand::DeleteForward])
9189        }
9190        SemanticsActionRequest::Copy => Some(vec![EditorCommand::Copy]),
9191        SemanticsActionRequest::Cut if !read_only => Some(vec![EditorCommand::Cut]),
9192        SemanticsActionRequest::Paste if !read_only => {
9193            let command = match paste_command(ctx) {
9194                EditorCommand::Paste(text) => EditorCommand::Paste(normalize(text)),
9195                command => command,
9196            };
9197            Some(vec![command])
9198        }
9199        SemanticsActionRequest::Undo if !read_only => Some(vec![EditorCommand::Undo]),
9200        SemanticsActionRequest::Redo if !read_only => Some(vec![EditorCommand::Redo]),
9201        _ => None,
9202    }
9203}
9204
9205fn keyboard_text(event: &sui_core::KeyboardEvent) -> Option<&str> {
9206    if event.state != KeyState::Pressed
9207        || event.is_composing
9208        || event.modifiers.control
9209        || event.modifiers.alt
9210        || event.modifiers.meta
9211    {
9212        return None;
9213    }
9214
9215    if let Some(text) = event
9216        .text
9217        .as_deref()
9218        .filter(|text| !text.is_empty() && !text.chars().any(char::is_control))
9219    {
9220        return Some(text);
9221    }
9222
9223    let key = event.key.as_str();
9224    (key.chars().count() == 1 && !key.chars().any(char::is_control)).then_some(key)
9225}
9226
9227fn center_square(bounds: Rect, side: f32) -> Rect {
9228    let side = side.min(bounds.width()).min(bounds.height()).max(0.0);
9229    Rect::new(
9230        bounds.x() + ((bounds.width() - side) * 0.5),
9231        bounds.y() + ((bounds.height() - side) * 0.5),
9232        side,
9233        side,
9234    )
9235}
9236
9237fn rect_center(rect: Rect) -> Point {
9238    Point::new(
9239        rect.x() + (rect.width() * 0.5),
9240        rect.y() + (rect.height() * 0.5),
9241    )
9242}
9243
9244fn switch_track_rect(bounds: Rect, padding: Insets, metrics: ControlMetrics) -> Rect {
9245    Rect::new(
9246        bounds.x() + padding.left,
9247        bounds.y() + ((bounds.height() - metrics.switch_track_height) * 0.5),
9248        metrics.switch_track_width,
9249        metrics.switch_track_height,
9250    )
9251}
9252
9253fn switch_label_rect(bounds: Rect, padding: Insets, metrics: ControlMetrics, gap: f32) -> Rect {
9254    let x = bounds.x() + padding.left + metrics.switch_track_width + gap;
9255    Rect::new(
9256        x,
9257        bounds.y(),
9258        (bounds.width() - (x - bounds.x()) - padding.right).max(0.0),
9259        bounds.height(),
9260    )
9261}
9262
9263fn horizontal_text_inset_rect(bounds: Rect, padding: Insets) -> Rect {
9264    Rect::new(
9265        bounds.x() + padding.left,
9266        bounds.y(),
9267        (bounds.width() - padding.left - padding.right).max(0.0),
9268        bounds.height(),
9269    )
9270}
9271
9272fn select_chevron_icon_rect(header: Rect) -> Rect {
9273    let x = header.max_x() - SELECT_CHEVRON_SLOT_WIDTH
9274        + ((SELECT_CHEVRON_SLOT_WIDTH - SELECT_CHEVRON_ICON_SIZE).max(0.0) * 0.5);
9275    Rect::new(x, header.y(), SELECT_CHEVRON_ICON_SIZE, header.height())
9276}
9277
9278fn number_input_stepper_rect(bounds: Rect, metrics: ControlMetrics) -> Rect {
9279    Rect::new(
9280        bounds.max_x() - metrics.number_input_stepper_width,
9281        bounds.y(),
9282        metrics.number_input_stepper_width,
9283        bounds.height(),
9284    )
9285}
9286
9287fn number_input_stepper_part(
9288    bounds: Rect,
9289    metrics: ControlMetrics,
9290    position: Point,
9291) -> Option<NumberInputStepperPart> {
9292    let stepper = number_input_stepper_rect(bounds, metrics);
9293    if !stepper.contains(position) {
9294        return None;
9295    }
9296    if position.y < stepper.y() + (stepper.height() * 0.5) {
9297        Some(NumberInputStepperPart::Increment)
9298    } else {
9299        Some(NumberInputStepperPart::Decrement)
9300    }
9301}
9302
9303fn number_input_text_rect(bounds: Rect, metrics: ControlMetrics) -> Rect {
9304    let padding = metrics.text_input_padding;
9305    Rect::new(
9306        bounds.x() + padding.left,
9307        bounds.y(),
9308        (bounds.width() - padding.left - padding.right - metrics.number_input_stepper_width)
9309            .max(0.0),
9310        bounds.height(),
9311    )
9312}
9313
9314fn clamp_and_snap_value(value: f64, min: f64, max: f64, step: f64) -> f64 {
9315    let clamped = value.clamp(min, max);
9316    if !step.is_finite() || step <= f64::EPSILON {
9317        return clamped;
9318    }
9319
9320    let snapped = (clamped / step).round() * step;
9321    snapped.clamp(min, max)
9322}
9323
9324fn format_number(value: f64, precision: usize) -> String {
9325    let mut text = format!("{value:.precision$}");
9326    if precision > 0 && text.contains('.') {
9327        while text.ends_with('0') {
9328            text.pop();
9329        }
9330        if text.ends_with('.') {
9331            text.pop();
9332        }
9333    }
9334    if text == "-0" { "0".to_string() } else { text }
9335}
9336
9337fn is_numeric_input_char(ch: char) -> bool {
9338    ch.is_ascii_digit() || matches!(ch, '.' | '-' | '+')
9339}
9340
9341/// Draw an [`IconGlyph`] tinted `color`, centered and fit within `bounds`. Exposed for bespoke
9342/// painters (application chrome) that draw an icon mark without composing an [`Icon`] widget; the
9343/// glyph is painted directly as native SUI path geometry.
9344pub fn draw_glyph(ctx: &mut PaintCtx, glyph: IconGlyph, bounds: Rect, color: Color) {
9345    draw_icon_glyph(ctx, glyph, bounds, color);
9346}
9347
9348pub(crate) fn draw_icon_glyph(ctx: &mut PaintCtx, glyph: IconGlyph, bounds: Rect, color: Color) {
9349    glyph.lucide_icon().paint(ctx, bounds, color);
9350}
9351
9352fn line_path(start: Point, end: Point) -> Path {
9353    let mut builder = PathBuilder::new();
9354    builder.move_to(start).line_to(end);
9355    builder.build()
9356}
9357
9358pub(crate) fn apply_hdr_policy_cap(color: Color, peak_lift: f32) -> Color {
9359    let cap = if peak_lift.is_finite() {
9360        peak_lift.max(0.0)
9361    } else {
9362        return color;
9363    };
9364
9365    Color {
9366        red: color.red.clamp(0.0, cap),
9367        green: color.green.clamp(0.0, cap),
9368        blue: color.blue.clamp(0.0, cap),
9369        ..color
9370    }
9371}
9372
9373pub(crate) fn cap_resolved_hdr_style(style: ResolvedHdrStyle) -> ResolvedHdrStyle {
9374    ResolvedHdrStyle {
9375        color: apply_hdr_policy_cap(style.color, style.peak_lift),
9376        effect: style.effect.map(|effect| ResolvedEffectStyle {
9377            color: apply_hdr_policy_cap(effect.color, style.peak_lift),
9378            ..effect
9379        }),
9380        ..style
9381    }
9382}
9383
9384fn draw_control_frame(
9385    ctx: &mut PaintCtx,
9386    bounds: Rect,
9387    radius: f32,
9388    metrics: ControlMetrics,
9389    background: Color,
9390    border: Color,
9391    focus_ring: Option<Color>,
9392) {
9393    draw_control_shape(
9394        ctx,
9395        bounds,
9396        radius,
9397        physical_pixels(ctx, metrics.border_width),
9398        background,
9399        border,
9400    );
9401
9402    draw_control_focus_ring(ctx, bounds, radius, metrics, focus_ring);
9403}
9404
9405fn draw_choice_control_frame(
9406    ctx: &mut PaintCtx,
9407    bounds: Rect,
9408    radius: f32,
9409    metrics: ControlMetrics,
9410    appearance: ChoiceAppearance,
9411    visuals: ChoiceFrameVisuals,
9412    focus_ring: Option<Color>,
9413) {
9414    if appearance == ChoiceAppearance::Framed {
9415        draw_control_frame(
9416            ctx,
9417            bounds,
9418            radius,
9419            metrics,
9420            visuals.background,
9421            visuals.border,
9422            focus_ring,
9423        );
9424        return;
9425    }
9426
9427    if visuals.background.alpha > f32::EPSILON {
9428        ctx.fill(rounded_rect_path(bounds, radius), visuals.background);
9429    }
9430    draw_control_focus_ring(ctx, bounds, radius, metrics, focus_ring);
9431}
9432
9433fn draw_control_focus_ring(
9434    ctx: &mut PaintCtx,
9435    bounds: Rect,
9436    radius: f32,
9437    metrics: ControlMetrics,
9438    focus_ring: Option<Color>,
9439) {
9440    if let Some(focus_ring) = focus_ring {
9441        let focus_ring_outset = physical_pixels(ctx, metrics.focus_ring_outset);
9442        ctx.stroke(
9443            rounded_rect_path(
9444                bounds.inflate(focus_ring_outset, focus_ring_outset),
9445                radius + focus_ring_outset,
9446            ),
9447            focus_ring,
9448            StrokeStyle::new(physical_pixels(ctx, metrics.focus_ring_width)),
9449        );
9450    }
9451}
9452
9453fn draw_control_shape(
9454    ctx: &mut PaintCtx,
9455    bounds: Rect,
9456    radius: f32,
9457    border_width: f32,
9458    background: Color,
9459    border: Color,
9460) {
9461    let fill_shape = rounded_rect_path(bounds, radius);
9462    ctx.fill(fill_shape, background);
9463
9464    if border_width > 0.0 {
9465        let inset = border_width * 0.5;
9466        let stroke_shape =
9467            rounded_rect_path(bounds.inflate(-inset, -inset), (radius - inset).max(0.0));
9468        ctx.stroke(stroke_shape, border, StrokeStyle::new(border_width));
9469    }
9470}
9471
9472fn rounded_rect_path(rect: Rect, radius: f32) -> Path {
9473    Path::rounded_rect(rect, radius.min(rect.width().min(rect.height()) * 0.5))
9474}
9475
9476fn checkmark_path(rect: Rect) -> Path {
9477    let mut builder = PathBuilder::new();
9478    builder
9479        .move_to(Point::new(
9480            rect.x() + (rect.width() * 0.18),
9481            rect.y() + (rect.height() * 0.54),
9482        ))
9483        .line_to(Point::new(
9484            rect.x() + (rect.width() * 0.42),
9485            rect.y() + (rect.height() * 0.76),
9486        ))
9487        .line_to(Point::new(
9488            rect.x() + (rect.width() * 0.82),
9489            rect.y() + (rect.height() * 0.28),
9490        ));
9491    builder.build()
9492}
9493
9494fn inset_rect(rect: Rect, padding: Insets) -> Rect {
9495    Rect::new(
9496        rect.x() + padding.left,
9497        rect.y() + padding.top,
9498        (rect.width() - padding.left - padding.right).max(0.0),
9499        (rect.height() - padding.top - padding.bottom).max(0.0),
9500    )
9501}
9502
9503fn choice_control_height(
9504    content_height: f32,
9505    padding: Insets,
9506    baseline_height: f32,
9507    has_explicit_padding: bool,
9508) -> f32 {
9509    let padding_height = if has_explicit_padding {
9510        padding.top + padding.bottom
9511    } else {
9512        0.0
9513    };
9514    (content_height + padding_height).max(baseline_height)
9515}
9516
9517fn default_form_control_height(theme: &DefaultTheme) -> f32 {
9518    let style = theme.body_text_style();
9519    let padding = theme.metrics.text_input_padding;
9520    (style.line_height + padding.top + padding.bottom).max(theme.metrics.min_height)
9521}
9522
9523fn choice_control_layout_padding(padding: Insets, has_explicit_padding: bool) -> Insets {
9524    if has_explicit_padding {
9525        padding
9526    } else {
9527        Insets {
9528            top: 0.0,
9529            bottom: 0.0,
9530            ..padding
9531        }
9532    }
9533}
9534
9535fn indicator_rect(bounds: Rect, padding: Insets, indicator_size: f32) -> Rect {
9536    let x = bounds.x() + padding.left;
9537    let content = inset_rect(bounds, padding);
9538    let y = content.y() + ((content.height() - indicator_size) * 0.5);
9539    Rect::new(x, y, indicator_size, indicator_size)
9540}
9541
9542fn checkbox_label_rect(bounds: Rect, padding: Insets, indicator_size: f32, gap: f32) -> Rect {
9543    let x = bounds.x() + padding.left + indicator_size + gap;
9544    let width = (bounds.width() - padding.left - padding.right - indicator_size - gap).max(0.0);
9545    let content = inset_rect(bounds, padding);
9546    Rect::new(x, content.y(), width, content.height())
9547}
9548
9549fn physical_pixels(ctx: &PaintCtx, value: f32) -> f32 {
9550    if value <= 0.0 {
9551        return 0.0;
9552    }
9553
9554    ctx.dpi().physical_pixels_to_logical(value)
9555}
9556
9557fn rect_is_finite(rect: Rect) -> bool {
9558    rect.x().is_finite()
9559        && rect.y().is_finite()
9560        && rect.width().is_finite()
9561        && rect.height().is_finite()
9562}
9563
9564fn request_selection_change(ctx: &mut EventCtx, change: SelectionChange) {
9565    for owner in change.affected_owners() {
9566        let widget_id = WidgetId::new(owner.get());
9567        ctx.request(InvalidationRequest::new(
9568            InvalidationTarget::Widget(widget_id),
9569            InvalidationKind::Paint,
9570        ));
9571        ctx.request(InvalidationRequest::new(
9572            InvalidationTarget::Widget(widget_id),
9573            InvalidationKind::Semantics,
9574        ));
9575    }
9576}
9577
9578fn sync_editor_selection_scope(
9579    ctx: &mut EventCtx,
9580    selection_scope: Option<&SelectionScope>,
9581    editor: &EditorState,
9582) {
9583    let Some(scope) = selection_scope else {
9584        return;
9585    };
9586    let owner = SelectionOwnerId::from(ctx.widget_id());
9587    let range = editor.selection_range();
9588    let selected = editor.selected_text().to_string();
9589    let change = scope.replace_text(owner, owner, range, editor.document().len(), selected);
9590    request_selection_change(ctx, change);
9591}
9592
9593#[cfg(test)]
9594mod tests {
9595    use std::{cell::RefCell, rc::Rc};
9596
9597    use super::{
9598        Button, ButtonAppearance, CARET_BLINK_PERIOD_SECONDS, Checkbox, ChoiceAppearance,
9599        DateTimeInput, DefaultTheme, FieldAppearance, Icon, IconButton, IconButtonPaint, IconGlyph,
9600        Label, Link, NumberInput, PasswordInput, RadioButton, RadioGroup, Select, Separator,
9601        Slider, Switch, TextArea, TextInput, paint_icon_button, rect_is_finite,
9602    };
9603    use crate::{
9604        HdrThemeMode, SemanticColorToken, SemanticTone, WidgetLuminanceRole, resolve_luminance_role,
9605    };
9606    use crate::{
9607        containers::{SizedBox, Stack},
9608        selection::SelectionScope,
9609        text_command::{TEXT_COMMAND, TextCommand},
9610    };
9611    use sui_core::{
9612        Color, Event, ImeEvent, KeyState, KeyboardEvent, Modifiers, Point, PointerButton,
9613        PointerButtons, PointerEvent, PointerEventKind, PointerKind, Rect, Result, SemanticsAction,
9614        SemanticsActionRequest, SemanticsRole, SemanticsTextRange, SemanticsValue, Size, Vector,
9615        WidgetId, WindowEvent,
9616    };
9617    use sui_layout::{Constraints, Padding as TestPadding};
9618    use sui_reactive::Signal;
9619    use sui_render_wgpu::{RgbaImage, WgpuRenderer};
9620    use sui_runtime::{
9621        Application, CommandDelivery, CommandTarget, MeasureCtx, PaintCtx, RenderOutput, Runtime,
9622        Widget, WindowBuilder, WindowRenderOptions, clear_window_render_options,
9623        set_window_render_options,
9624    };
9625    use sui_scene::{
9626        Brush, LayerCompositionMode, SceneCommand, SceneLayerDescriptor, SceneLayerUpdateKind,
9627    };
9628    use sui_text::{FontFeature, FontRegistry, TextStyle, TextSystem};
9629
9630    fn hover_duration() -> f64 {
9631        DefaultTheme::default().motion.hover_duration()
9632    }
9633
9634    fn press_duration() -> f64 {
9635        DefaultTheme::default().motion.press_duration()
9636    }
9637
9638    fn toggle_duration() -> f64 {
9639        DefaultTheme::default().motion.toggle_duration()
9640    }
9641
9642    fn focus_duration() -> f64 {
9643        DefaultTheme::default().motion.focus_duration()
9644    }
9645
9646    fn entrance_duration() -> f64 {
9647        DefaultTheme::default().motion.entrance_duration()
9648    }
9649
9650    fn slow_normal_motion_theme() -> DefaultTheme {
9651        let mut theme = DefaultTheme::default();
9652        theme.motion.duration_fast = 0.0;
9653        theme.motion.duration_normal = 0.6;
9654        theme
9655    }
9656
9657    fn slow_toggle_theme() -> DefaultTheme {
9658        slow_normal_motion_theme()
9659    }
9660
9661    fn build_runtime<W>(root: W) -> (Runtime, sui_core::WindowId)
9662    where
9663        W: Widget + 'static,
9664    {
9665        let runtime = Application::new()
9666            .window(WindowBuilder::new().title("Controls").root(root))
9667            .build()
9668            .unwrap();
9669        let window_id = runtime.window_ids()[0];
9670        (runtime, window_id)
9671    }
9672
9673    fn render<W>(root: W) -> RenderOutput
9674    where
9675        W: Widget + 'static,
9676    {
9677        let (mut runtime, window_id) = build_runtime(root);
9678        runtime.render(window_id).unwrap()
9679    }
9680
9681    fn render_isolated<W>(root: W) -> RenderOutput
9682    where
9683        W: Widget + 'static,
9684    {
9685        let mut runtime = Application::new()
9686            .window(
9687                WindowBuilder::new()
9688                    .title("Unused")
9689                    .root(Label::new("Unused")),
9690            )
9691            .window(WindowBuilder::new().title("Controls").root(root))
9692            .build()
9693            .unwrap();
9694        let window_id = runtime.window_ids()[1];
9695        runtime.render(window_id).unwrap()
9696    }
9697
9698    fn render_rgba<W>(root: W, feathering_enabled: bool) -> (RenderOutput, RgbaImage)
9699    where
9700        W: Widget + 'static,
9701    {
9702        let (mut runtime, window_id) = build_runtime(root);
9703        let output = runtime.render(window_id).unwrap();
9704        let mut renderer = WgpuRenderer::default();
9705        if feathering_enabled {
9706            renderer.set_feather_width(1.0);
9707            renderer.set_feathering_enabled(true);
9708        }
9709        renderer.render(&output.frame).unwrap();
9710        let image = renderer.capture_last_frame_rgba(window_id).unwrap();
9711        (output, image)
9712    }
9713
9714    fn dark_pixel_count(image: &RgbaImage, rect: Rect, max_channel: u8) -> usize {
9715        let min_x = rect.x().floor().max(0.0) as u32;
9716        let min_y = rect.y().floor().max(0.0) as u32;
9717        let max_x = rect.max_x().ceil().min(image.width() as f32) as u32;
9718        let max_y = rect.max_y().ceil().min(image.height() as f32) as u32;
9719        let pixels = image.pixels();
9720        let width = image.width() as usize;
9721
9722        let mut count = 0usize;
9723        for y in min_y..max_y {
9724            for x in min_x..max_x {
9725                let index = ((y as usize * width) + x as usize) * 4;
9726                let red = pixels[index];
9727                let green = pixels[index + 1];
9728                let blue = pixels[index + 2];
9729                let alpha = pixels[index + 3];
9730                if alpha != 0 && red <= max_channel && green <= max_channel && blue <= max_channel {
9731                    count += 1;
9732                }
9733            }
9734        }
9735
9736        count
9737    }
9738
9739    fn bright_pixel_count(image: &RgbaImage, rect: Rect, min_channel: u8) -> usize {
9740        let min_x = rect.x().floor().max(0.0) as u32;
9741        let min_y = rect.y().floor().max(0.0) as u32;
9742        let max_x = rect.max_x().ceil().min(image.width() as f32) as u32;
9743        let max_y = rect.max_y().ceil().min(image.height() as f32) as u32;
9744        let pixels = image.pixels();
9745        let width = image.width() as usize;
9746
9747        let mut count = 0usize;
9748        for y in min_y..max_y {
9749            for x in min_x..max_x {
9750                let index = ((y as usize * width) + x as usize) * 4;
9751                let red = pixels[index];
9752                let green = pixels[index + 1];
9753                let blue = pixels[index + 2];
9754                let alpha = pixels[index + 3];
9755                if alpha > 200 && red >= min_channel && green >= min_channel && blue >= min_channel
9756                {
9757                    count += 1;
9758                }
9759            }
9760        }
9761
9762        count
9763    }
9764
9765    fn first_text_run(output: &RenderOutput) -> sui_text::TextRun {
9766        output
9767            .frame
9768            .scene
9769            .commands()
9770            .iter()
9771            .find_map(|command| match command {
9772                SceneCommand::DrawText(text) => Some(text.clone()),
9773                SceneCommand::DrawShapedText(text) => text
9774                    .resolve(output.frame.text_layout_registry.as_ref())
9775                    .map(|layout| {
9776                        let mut style = layout.style().clone();
9777                        if let Some(color) = text.color_override {
9778                            style.color = color;
9779                        }
9780                        sui_text::TextRun {
9781                            rect: shaped_text_run_rect(text.origin, layout),
9782                            text: layout.text().to_string(),
9783                            style,
9784                        }
9785                    }),
9786                _ => None,
9787            })
9788            .expect("text draw command present")
9789    }
9790
9791    fn shaped_text_run_rect(origin: Point, layout: &sui_text::TextLayout) -> Rect {
9792        let measurement = layout.measurement();
9793        let bounds = measurement.bounds;
9794        let width = if bounds.width().is_finite() && bounds.width() > 0.0 {
9795            bounds.width()
9796        } else {
9797            measurement.width
9798        };
9799        Rect::new(
9800            origin.x + bounds.x(),
9801            origin.y + ((layout.box_size().height - measurement.height).max(0.0) * 0.5),
9802            width,
9803            layout.style().line_height.max(measurement.height),
9804        )
9805    }
9806
9807    fn first_shaped_text(output: &RenderOutput) -> &sui_text::ShapedText {
9808        output
9809            .frame
9810            .scene
9811            .commands()
9812            .iter()
9813            .find_map(|command| match command {
9814                SceneCommand::DrawShapedText(text) => Some(text),
9815                _ => None,
9816            })
9817            .expect("shaped text draw command present")
9818    }
9819
9820    fn solid_fill_colors(output: &RenderOutput) -> Vec<Color> {
9821        let mut colors = Vec::new();
9822        output
9823            .frame
9824            .scene
9825            .visit_commands(&mut |command| match command {
9826                SceneCommand::FillRect {
9827                    brush: Brush::Solid(color),
9828                    ..
9829                }
9830                | SceneCommand::FillPath {
9831                    brush: Brush::Solid(color),
9832                    ..
9833                } => colors.push(*color),
9834                _ => {}
9835            });
9836        colors
9837    }
9838
9839    fn solid_stroke_colors(output: &RenderOutput) -> Vec<Color> {
9840        let mut colors = Vec::new();
9841        output
9842            .frame
9843            .scene
9844            .visit_commands(&mut |command| match command {
9845                SceneCommand::StrokeRect {
9846                    brush: Brush::Solid(color),
9847                    ..
9848                }
9849                | SceneCommand::StrokePath {
9850                    brush: Brush::Solid(color),
9851                    ..
9852                } => colors.push(*color),
9853                _ => {}
9854            });
9855        colors
9856    }
9857
9858    fn non_lucide_stroke_colors(output: &RenderOutput) -> Vec<Color> {
9859        let mut colors = Vec::new();
9860        output
9861            .frame
9862            .scene
9863            .visit_commands(&mut |command| match command {
9864                SceneCommand::StrokeRect {
9865                    brush: Brush::Solid(color),
9866                    ..
9867                } => colors.push(*color),
9868                SceneCommand::StrokePath {
9869                    brush: Brush::Solid(color),
9870                    stroke,
9871                    ..
9872                } if stroke.cap != sui_scene::StrokeCap::Round
9873                    || stroke.join != sui_scene::StrokeJoin::Round =>
9874                {
9875                    colors.push(*color);
9876                }
9877                _ => {}
9878            });
9879        colors
9880    }
9881
9882    fn solid_stroke_path_bounds(output: &RenderOutput, expected_color: Color) -> Vec<Rect> {
9883        let mut bounds = Vec::new();
9884        output.frame.scene.visit_commands(&mut |command| {
9885            if let SceneCommand::StrokePath {
9886                path,
9887                brush: Brush::Solid(color),
9888                ..
9889            } = command
9890                && *color == expected_color
9891            {
9892                bounds.push(path.bounds());
9893            }
9894        });
9895        bounds
9896    }
9897
9898    fn assert_rect_approx_eq(actual: Rect, expected: Rect) {
9899        const TOLERANCE: f32 = 0.01;
9900        assert!(
9901            (actual.x() - expected.x()).abs() <= TOLERANCE
9902                && (actual.y() - expected.y()).abs() <= TOLERANCE
9903                && (actual.width() - expected.width()).abs() <= TOLERANCE
9904                && (actual.height() - expected.height()).abs() <= TOLERANCE,
9905            "rect mismatch: actual={actual:?}, expected={expected:?}"
9906        );
9907    }
9908
9909    fn lucide_strokes(output: &RenderOutput) -> Vec<(Rect, Color, sui_scene::StrokeStyle)> {
9910        let mut strokes = Vec::new();
9911        output.frame.scene.visit_commands(&mut |command| {
9912            if let SceneCommand::StrokePath {
9913                path,
9914                brush: Brush::Solid(color),
9915                stroke,
9916            } = command
9917                && stroke.cap == sui_scene::StrokeCap::Round
9918                && stroke.join == sui_scene::StrokeJoin::Round
9919            {
9920                strokes.push((path.bounds(), *color, *stroke));
9921            }
9922        });
9923        strokes
9924    }
9925
9926    fn first_lucide_icon_rect(output: &RenderOutput) -> Rect {
9927        let (ink_bounds, _, stroke) = lucide_strokes(output)
9928            .into_iter()
9929            .next()
9930            .expect("Lucide icon should paint as a native stroked path");
9931        let side = stroke.width * 12.0;
9932        Rect::new(
9933            ink_bounds.x() + (ink_bounds.width() - side) * 0.5,
9934            ink_bounds.y() + (ink_bounds.height() - side) * 0.5,
9935            side,
9936            side,
9937        )
9938    }
9939
9940    fn assert_color_approx_eq(actual: Color, expected: Color) {
9941        const CHANNEL_TOLERANCE: f32 = 1.0 / 255.0;
9942        assert_eq!(actual.space, expected.space);
9943        assert!(
9944            (actual.red - expected.red).abs() <= CHANNEL_TOLERANCE
9945                && (actual.green - expected.green).abs() <= CHANNEL_TOLERANCE
9946                && (actual.blue - expected.blue).abs() <= CHANNEL_TOLERANCE
9947                && (actual.alpha - expected.alpha).abs() <= CHANNEL_TOLERANCE,
9948            "color {actual:?} did not match {expected:?} within one channel step"
9949        );
9950    }
9951
9952    fn text_run_for(output: &RenderOutput, text: &str) -> sui_text::TextRun {
9953        let mut found = None;
9954        output.frame.scene.visit_commands(&mut |command| {
9955            if found.is_some() {
9956                return;
9957            }
9958            found = match command {
9959                SceneCommand::DrawText(run) if run.text == text => Some(run.clone()),
9960                SceneCommand::DrawShapedText(run) => run
9961                    .resolve(output.frame.text_layout_registry.as_ref())
9962                    .filter(|layout| layout.text() == text)
9963                    .map(|layout| {
9964                        let mut style = layout.style().clone();
9965                        if let Some(color) = run.color_override {
9966                            style.color = color;
9967                        }
9968                        sui_text::TextRun {
9969                            rect: shaped_text_run_rect(run.origin, layout),
9970                            text: layout.text().to_string(),
9971                            style,
9972                        }
9973                    }),
9974                SceneCommand::DrawShapedTextWindow(run) => run
9975                    .resolve(output.frame.text_layout_registry.as_ref())
9976                    .filter(|layout| layout.text() == text)
9977                    .map(|layout| {
9978                        let mut style = layout.style().clone();
9979                        if let Some(color) = run.color_override {
9980                            style.color = color;
9981                        }
9982                        sui_text::TextRun {
9983                            rect: run.translated_bounds(),
9984                            text: layout.text().to_string(),
9985                            style,
9986                        }
9987                    }),
9988                _ => None,
9989            };
9990        });
9991        found.expect("text draw command present")
9992    }
9993
9994    fn draw_clip_rect_for(output: &RenderOutput, text: &str) -> Rect {
9995        let mut stack = Vec::new();
9996        let mut found = None;
9997        output.frame.scene.visit_commands(&mut |command| {
9998            if found.is_some() {
9999                return;
10000            }
10001            match command {
10002                SceneCommand::PushClip { rect } => stack.push(*rect),
10003                SceneCommand::PopClip => {
10004                    stack.pop();
10005                }
10006                SceneCommand::DrawText(run) if run.text == text => {
10007                    found = stack.last().copied();
10008                }
10009                SceneCommand::DrawShapedText(run)
10010                    if run
10011                        .resolve(output.frame.text_layout_registry.as_ref())
10012                        .is_some_and(|layout| layout.text() == text) =>
10013                {
10014                    found = stack.last().copied();
10015                }
10016                SceneCommand::DrawShapedTextWindow(run)
10017                    if run
10018                        .resolve(output.frame.text_layout_registry.as_ref())
10019                        .is_some_and(|layout| layout.text() == text) =>
10020                {
10021                    found = stack.last().copied();
10022                }
10023                _ => {}
10024            }
10025        });
10026        found.expect("text draw command should have an active clip")
10027    }
10028
10029    fn shaped_text_layout_for(output: &RenderOutput, text: &str) -> sui_text::TextLayout {
10030        let mut found = None;
10031        output.frame.scene.visit_commands(&mut |command| {
10032            if found.is_some() {
10033                return;
10034            }
10035            found = match command {
10036                SceneCommand::DrawShapedText(run) => run
10037                    .resolve(output.frame.text_layout_registry.as_ref())
10038                    .filter(|layout| layout.text() == text)
10039                    .cloned(),
10040                SceneCommand::DrawShapedTextWindow(run) => run
10041                    .resolve(output.frame.text_layout_registry.as_ref())
10042                    .filter(|layout| layout.text() == text)
10043                    .cloned(),
10044                _ => None,
10045            };
10046        });
10047        found.expect("shaped text layout present")
10048    }
10049
10050    fn visual_center(measurement: sui_text::TextMeasurement, optical_centering: bool) -> f32 {
10051        let top = if optical_centering {
10052            -measurement.cap_height.unwrap_or(measurement.ascent)
10053        } else {
10054            -measurement.ascent
10055        };
10056        let bottom = if optical_centering {
10057            measurement.descent * 0.5
10058        } else {
10059            measurement.descent
10060        };
10061
10062        (top + bottom) * 0.5
10063    }
10064
10065    fn optical_visual_center(measurement: sui_text::TextMeasurement) -> f32 {
10066        visual_center(measurement, true)
10067    }
10068
10069    fn text_run_layout(run: &sui_text::TextRun) -> sui_text::TextLayout {
10070        TextSystem::new()
10071            .shape_text(
10072                run.text.clone(),
10073                Size::new(f32::INFINITY, run.rect.height().max(1.0)),
10074                run.style.clone(),
10075                &FontRegistry::new(),
10076            )
10077            .expect("text run should shape")
10078    }
10079
10080    fn text_run_visual_center(run: &sui_text::TextRun) -> f32 {
10081        let layout = text_run_layout(run);
10082        let line = layout
10083            .lines()
10084            .first()
10085            .expect("text run should contain a line");
10086        run.rect.y() + line.baseline + optical_visual_center(layout.measurement())
10087    }
10088
10089    fn assert_tall_body_text_centered(
10090        output: &RenderOutput,
10091        text: &str,
10092        theme: DefaultTheme,
10093        expected_center_y: f32,
10094    ) {
10095        let run = text_run_for(output, text);
10096        let layout = shaped_text_layout_for(output, text);
10097
10098        assert_eq!(run.style.font_size, theme.typography.body_font_size);
10099        assert_eq!(run.style.line_height, theme.typography.body_line_height);
10100        assert!(
10101            (text_run_visual_center(&run) - expected_center_y).abs() < 0.75,
10102            "{text} visual center should match {expected_center_y}; rect={:?}, measurement={:?}",
10103            run.rect,
10104            layout.measurement()
10105        );
10106    }
10107
10108    fn layer_descriptor_for(
10109        output: &RenderOutput,
10110        owner: WidgetId,
10111    ) -> Option<SceneLayerDescriptor> {
10112        let mut descriptor = None;
10113        output.frame.scene.visit_layers(&mut |layer| {
10114            if layer.widget_id() == owner {
10115                descriptor = Some(layer.descriptor.clone());
10116            }
10117        });
10118        descriptor
10119    }
10120
10121    fn overlay_layer_descriptor(output: &RenderOutput) -> Option<SceneLayerDescriptor> {
10122        let mut descriptor = None;
10123        output.frame.scene.visit_layers(&mut |layer| {
10124            if layer.descriptor.composition_mode == LayerCompositionMode::Overlay {
10125                descriptor = Some(layer.descriptor.clone());
10126            }
10127        });
10128        descriptor
10129    }
10130
10131    fn overlay_layer_owner(output: &RenderOutput) -> Option<WidgetId> {
10132        let mut owner = None;
10133        output.frame.scene.visit_layers(&mut |layer| {
10134            if layer.descriptor.composition_mode == LayerCompositionMode::Overlay {
10135                owner = Some(layer.widget_id());
10136            }
10137        });
10138        owner
10139    }
10140
10141    fn primary_pointer(kind: PointerEventKind, position: Point, pressed: bool) -> Event {
10142        let mut buttons = PointerButtons::NONE;
10143        if pressed {
10144            buttons.insert(PointerButton::Primary);
10145        }
10146
10147        Event::Pointer(PointerEvent {
10148            pointer_id: 1,
10149            kind,
10150            position,
10151            delta: Vector::ZERO,
10152            scroll_delta: None,
10153            button: Some(PointerButton::Primary),
10154            buttons,
10155            modifiers: Modifiers::NONE,
10156            pointer_kind: PointerKind::Mouse,
10157            is_primary: true,
10158        })
10159    }
10160
10161    fn secondary_pointer_down(position: Point) -> Event {
10162        let mut buttons = PointerButtons::NONE;
10163        buttons.insert(PointerButton::Secondary);
10164        Event::Pointer(PointerEvent {
10165            pointer_id: 2,
10166            kind: PointerEventKind::Down,
10167            position,
10168            delta: Vector::ZERO,
10169            scroll_delta: None,
10170            button: Some(PointerButton::Secondary),
10171            buttons,
10172            modifiers: Modifiers::NONE,
10173            pointer_kind: PointerKind::Mouse,
10174            is_primary: true,
10175        })
10176    }
10177
10178    fn command_key(key: &str) -> Event {
10179        let mut event = KeyboardEvent::new(key, KeyState::Pressed);
10180        event.modifiers.control = true;
10181        Event::Keyboard(event)
10182    }
10183
10184    fn key_without_text(key: &str) -> Event {
10185        let mut event = KeyboardEvent::new(key, KeyState::Pressed);
10186        event.text = None;
10187        Event::Keyboard(event)
10188    }
10189
10190    fn handle_ready_events(runtime: &mut Runtime) -> Result<usize> {
10191        let ready = runtime.drain_ready_events();
10192        let count = ready.len();
10193        for (ready_window, event) in ready {
10194            runtime.handle_event(ready_window, event)?;
10195        }
10196        Ok(count)
10197    }
10198
10199    #[test]
10200    fn label_paints_text_and_exposes_text_semantics() {
10201        let output = render(Label::new("Hello SUI").color(Color::rgba(0.8, 0.9, 1.0, 1.0)));
10202
10203        assert!(output.frame.viewport.height >= 16.0);
10204        assert!(matches!(
10205            output.frame.scene.commands()[0],
10206            SceneCommand::DrawShapedText(_)
10207        ));
10208        assert_eq!(output.semantics[0].role, SemanticsRole::Text);
10209        assert_eq!(output.semantics[0].name.as_deref(), Some("Hello SUI"));
10210    }
10211
10212    #[test]
10213    fn icon_color_when_uses_external_color() -> Result<()> {
10214        let color = Rc::new(RefCell::new(Color::rgba(0.2, 0.5, 0.9, 1.0)));
10215        let reader = Rc::clone(&color);
10216        let (mut runtime, window_id) = build_runtime(
10217            Icon::new(IconGlyph::Sparkles)
10218                .size(24.0)
10219                .label("Agent")
10220                .color_when(move || *reader.borrow()),
10221        );
10222
10223        let output = runtime.render(window_id)?;
10224        assert!(
10225            lucide_strokes(&output)
10226                .iter()
10227                .any(|(_, stroke_color, _)| *stroke_color == Color::rgba(0.2, 0.5, 0.9, 1.0))
10228        );
10229
10230        assert!(
10231            output
10232                .semantics
10233                .iter()
10234                .any(|node| node.role == SemanticsRole::Image
10235                    && node.name.as_deref() == Some("Agent"))
10236        );
10237        Ok(())
10238    }
10239
10240    #[test]
10241    fn selectable_label_syncs_selected_text_to_scope() -> Result<()> {
10242        let selection = SelectionScope::new();
10243        let (mut runtime, window_id) =
10244            build_runtime(Label::new("Hello SUI").selectable(selection.clone()));
10245        let output = runtime.render(window_id)?;
10246        let label = output
10247            .semantics
10248            .iter()
10249            .find(|node| {
10250                node.role == SemanticsRole::Text && node.name.as_deref() == Some("Hello SUI")
10251            })
10252            .expect("selectable label semantics should exist");
10253        let center = Point::new(
10254            label.bounds.x() + 4.0,
10255            label.bounds.y() + label.bounds.height() * 0.5,
10256        );
10257
10258        runtime.handle_event(
10259            window_id,
10260            primary_pointer(PointerEventKind::Down, center, true),
10261        )?;
10262        runtime.handle_event(
10263            window_id,
10264            primary_pointer(PointerEventKind::Up, center, false),
10265        )?;
10266        runtime.handle_event(window_id, command_key("a"))?;
10267
10268        assert_eq!(selection.selected_text().as_deref(), Some("Hello SUI"));
10269        Ok(())
10270    }
10271
10272    #[test]
10273    fn selectable_label_copies_with_hotkey_command_and_semantics() -> Result<()> {
10274        let selection = SelectionScope::new();
10275        let (mut runtime, window_id) = build_runtime(Label::new("Hello SUI").selectable(selection));
10276        let output = runtime.render(window_id)?;
10277        let label = output
10278            .semantics
10279            .iter()
10280            .find(|node| {
10281                node.role == SemanticsRole::Text && node.name.as_deref() == Some("Hello SUI")
10282            })
10283            .expect("selectable label semantics should exist");
10284        let label_id = label.id;
10285        let center = Point::new(
10286            label.bounds.x() + 4.0,
10287            label.bounds.y() + label.bounds.height() * 0.5,
10288        );
10289
10290        runtime.handle_event(window_id, secondary_pointer_down(center))?;
10291        let focused = runtime.render(window_id)?;
10292        let label = focused
10293            .semantics
10294            .iter()
10295            .find(|node| node.id == label_id)
10296            .expect("selectable label semantics should remain present");
10297        assert!(
10298            label.state.focused,
10299            "right click should focus selectable text"
10300        );
10301        assert!(label.actions.contains(&SemanticsAction::Copy));
10302
10303        runtime.handle_event(window_id, command_key("a"))?;
10304        runtime.handle_event(window_id, command_key("c"))?;
10305        assert_eq!(runtime.clipboard().text().as_deref(), Some("Hello SUI"));
10306
10307        runtime.clipboard().set_text("");
10308        runtime.handle_command(
10309            CommandTarget::FocusedWidget(window_id),
10310            CommandDelivery::Directed,
10311            TEXT_COMMAND,
10312            TextCommand::Copy,
10313        );
10314        assert_eq!(runtime.clipboard().text().as_deref(), Some("Hello SUI"));
10315
10316        runtime.clipboard().set_text("");
10317        assert!(runtime.handle_semantics_action(
10318            window_id,
10319            label_id,
10320            SemanticsActionRequest::Copy,
10321        )?);
10322        assert_eq!(runtime.clipboard().text().as_deref(), Some("Hello SUI"));
10323        Ok(())
10324    }
10325
10326    #[test]
10327    fn selectable_labels_sharing_scope_replace_previous_selection() -> Result<()> {
10328        let selection = SelectionScope::new();
10329        let root = Stack::vertical()
10330            .spacing(4.0)
10331            .with_child(Label::new("First").selectable(selection.clone()))
10332            .with_child(Label::new("Second").selectable(selection.clone()));
10333        let (mut runtime, window_id) = build_runtime(root);
10334        let output = runtime.render(window_id)?;
10335        let first = output
10336            .semantics
10337            .iter()
10338            .find(|node| node.role == SemanticsRole::Text && node.name.as_deref() == Some("First"))
10339            .expect("first label semantics should exist")
10340            .bounds;
10341        let second = output
10342            .semantics
10343            .iter()
10344            .find(|node| node.role == SemanticsRole::Text && node.name.as_deref() == Some("Second"))
10345            .expect("second label semantics should exist")
10346            .bounds;
10347
10348        let first_center = Point::new(first.x() + 2.0, first.y() + first.height() * 0.5);
10349        runtime.handle_event(
10350            window_id,
10351            primary_pointer(PointerEventKind::Down, first_center, true),
10352        )?;
10353        runtime.handle_event(
10354            window_id,
10355            primary_pointer(PointerEventKind::Up, first_center, false),
10356        )?;
10357        runtime.handle_event(window_id, command_key("a"))?;
10358        assert_eq!(selection.selected_text().as_deref(), Some("First"));
10359
10360        let second_center = Point::new(second.x() + 2.0, second.y() + second.height() * 0.5);
10361        runtime.handle_event(
10362            window_id,
10363            primary_pointer(PointerEventKind::Down, second_center, true),
10364        )?;
10365        runtime.handle_event(
10366            window_id,
10367            primary_pointer(PointerEventKind::Up, second_center, false),
10368        )?;
10369        runtime.handle_event(window_id, command_key("a"))?;
10370
10371        assert_eq!(selection.selected_text().as_deref(), Some("Second"));
10372        Ok(())
10373    }
10374
10375    #[test]
10376    fn label_dynamic_text_updates_named_semantic_value() -> Result<()> {
10377        let text = Rc::new(RefCell::new("Zoom 25%".to_string()));
10378        let text_reader = Rc::clone(&text);
10379        let (mut runtime, window_id) = build_runtime(
10380            Label::dynamic("Zoom --", move || text_reader.borrow().clone())
10381                .semantic_name("Zoom level"),
10382        );
10383
10384        let output = runtime.render(window_id)?;
10385        assert_eq!(output.semantics[0].role, SemanticsRole::Text);
10386        assert_eq!(output.semantics[0].name.as_deref(), Some("Zoom level"));
10387        assert_eq!(
10388            output.semantics[0].value,
10389            Some(SemanticsValue::Text("Zoom 25%".to_string()))
10390        );
10391
10392        *text.borrow_mut() = "Zoom 50%".to_string();
10393        runtime.handle_event(
10394            window_id,
10395            Event::Window(WindowEvent::Resized(Size::new(320.0, 80.0))),
10396        )?;
10397        let output = runtime.render(window_id)?;
10398        assert_eq!(
10399            output.semantics[0].value,
10400            Some(SemanticsValue::Text("Zoom 50%".to_string()))
10401        );
10402        Ok(())
10403    }
10404
10405    #[test]
10406    fn label_observable_text_invalidates_without_window_refresh() -> Result<()> {
10407        let text = Signal::named("zoom_label", "Zoom 25%".to_string());
10408        let (mut runtime, window_id) = build_runtime(
10409            Label::new("Zoom --")
10410                .text_from(text.clone())
10411                .semantic_name("Zoom level"),
10412        );
10413
10414        let output = runtime.render(window_id)?;
10415        assert_eq!(
10416            output.semantics[0].value,
10417            Some(SemanticsValue::Text("Zoom 25%".to_string()))
10418        );
10419
10420        assert!(text.set("Zoom 50%".to_string()));
10421        let output = runtime.render(window_id)?;
10422        assert_eq!(
10423            output.semantics[0].value,
10424            Some(SemanticsValue::Text("Zoom 50%".to_string()))
10425        );
10426        assert!(
10427            output
10428                .diagnostics
10429                .reactive_invalidations
10430                .iter()
10431                .any(|sample| sample.source_name == "zoom_label")
10432        );
10433        Ok(())
10434    }
10435
10436    #[test]
10437    fn link_exposes_link_semantics_and_activates_on_click() -> Result<()> {
10438        let opened = Rc::new(RefCell::new(None::<String>));
10439        let opened_for_link = Rc::clone(&opened);
10440        let (mut runtime, window_id) = build_runtime(
10441            Link::new("Open login", "https://example.test/device").on_open(move |url| {
10442                *opened_for_link.borrow_mut() = Some(url.to_string());
10443            }),
10444        );
10445
10446        let output = runtime.render(window_id)?;
10447        let link = output
10448            .semantics
10449            .iter()
10450            .find(|node| node.role == SemanticsRole::Link)
10451            .expect("link semantics should be present");
10452        assert_eq!(link.name.as_deref(), Some("Open login"));
10453        assert_eq!(
10454            link.value,
10455            Some(SemanticsValue::Text(
10456                "https://example.test/device".to_string()
10457            ))
10458        );
10459        assert!(link.actions.contains(&SemanticsAction::Focus));
10460        assert!(link.actions.contains(&SemanticsAction::Activate));
10461
10462        runtime.handle_event(
10463            window_id,
10464            primary_pointer(PointerEventKind::Down, Point::new(12.0, 12.0), true),
10465        )?;
10466        runtime.handle_event(
10467            window_id,
10468            primary_pointer(PointerEventKind::Up, Point::new(12.0, 12.0), false),
10469        )?;
10470        assert_eq!(
10471            opened.borrow().as_deref(),
10472            Some("https://example.test/device")
10473        );
10474        Ok(())
10475    }
10476
10477    #[test]
10478    fn link_with_empty_url_collapses_out_of_semantics() {
10479        let output = render(
10480            SizedBox::new()
10481                .width(160.0)
10482                .height(24.0)
10483                .with_child(Link::new("Open login", "")),
10484        );
10485
10486        assert!(
10487            output
10488                .semantics
10489                .iter()
10490                .all(|node| node.role != SemanticsRole::Link)
10491        );
10492    }
10493
10494    #[test]
10495    fn label_measures_wrapped_height_when_width_is_constrained() {
10496        let output = render(SizedBox::new().width(96.0).with_child(Label::new(
10497            "This label should wrap onto multiple lines when its layout width is constrained.",
10498        )));
10499
10500        assert!(output.frame.viewport.height > DefaultTheme::default().typography.body_line_height);
10501    }
10502
10503    #[test]
10504    fn label_measures_explicit_multiline_text_height() {
10505        let text = "First line\nSecond line";
10506        let output = render(Label::new(text));
10507        let layout = shaped_text_layout_for(&output, text);
10508        let label = output
10509            .semantics
10510            .iter()
10511            .find(|node| node.role == SemanticsRole::Text && node.name.as_deref() == Some(text))
10512            .expect("label semantics should exist");
10513
10514        assert_eq!(layout.lines().len(), 2);
10515        assert!(label.bounds.height() >= layout.measurement().height - 0.01);
10516        assert!(label.bounds.height() > DefaultTheme::default().typography.body_line_height);
10517    }
10518
10519    #[test]
10520    fn label_centers_explicit_multiline_text_as_a_block() {
10521        let text = "First line\nSecond line";
10522        let output = render(
10523            SizedBox::new()
10524                .width(180.0)
10525                .height(96.0)
10526                .with_child(Label::new(text)),
10527        );
10528        let shaped = first_shaped_text(&output);
10529        let layout = shaped_text_layout_for(&output, text);
10530        let expected_origin_y =
10531            (output.frame.viewport.height - layout.measurement().height).max(0.0) * 0.5;
10532
10533        assert_eq!(layout.lines().len(), 2);
10534        assert!(
10535            (shaped.origin.y - expected_origin_y).abs() < 0.75,
10536            "multiline label origin should block-center at {expected_origin_y}, got {}",
10537            shaped.origin.y
10538        );
10539    }
10540
10541    #[test]
10542    fn label_visual_center_matches_tall_allocation_center() {
10543        let output = render(
10544            SizedBox::new()
10545                .width(160.0)
10546                .height(48.0)
10547                .with_child(Label::new("Body")),
10548        );
10549        let text = text_run_for(&output, "Body");
10550        let layout = TextSystem::new()
10551            .shape_text_run(&text, &FontRegistry::new())
10552            .expect("label text should shape");
10553        let line = layout
10554            .lines()
10555            .first()
10556            .expect("label text should contain one line");
10557        let actual_visual_center =
10558            text.rect.y() + line.baseline + optical_visual_center(layout.measurement());
10559        let allocation_center = output.frame.viewport.height * 0.5;
10560
10561        assert!((actual_visual_center - allocation_center).abs() < 0.75);
10562    }
10563
10564    #[test]
10565    fn label_preserves_tall_measurement_in_compact_line_box() {
10566        let mut style = DefaultTheme::default().body_text_style();
10567        style.font_size = 30.0;
10568        style.line_height = 10.0;
10569
10570        let output = render(
10571            SizedBox::new()
10572                .width(160.0)
10573                .height(48.0)
10574                .with_child(Label::new("Body").style(style.clone())),
10575        );
10576        let text = text_run_for(&output, "Body");
10577        let layout = shaped_text_layout_for(&output, "Body");
10578        let allocation_center = output.frame.viewport.height * 0.5;
10579
10580        assert_eq!(text.style.font_size, style.font_size);
10581        assert_eq!(text.style.line_height, style.line_height);
10582        assert!(text.rect.height() >= layout.measurement().height - 0.01);
10583        assert!(text.rect.height() > text.style.line_height);
10584        assert!((text_run_visual_center(&text) - allocation_center).abs() < 0.75);
10585    }
10586
10587    #[test]
10588    fn label_window_option_keeps_geometric_label_centered() {
10589        let (mut runtime, window_id) = build_runtime(
10590            SizedBox::new()
10591                .width(160.0)
10592                .height(48.0)
10593                .with_child(Label::new("Body")),
10594        );
10595        set_window_render_options(
10596            window_id,
10597            WindowRenderOptions::new(true, 1.0).with_optical_vertical_text_alignment_enabled(false),
10598        );
10599        let output = runtime.render(window_id).unwrap();
10600        clear_window_render_options(window_id);
10601        let text = text_run_for(&output, "Body");
10602        let layout = TextSystem::new()
10603            .shape_text_run(&text, &FontRegistry::new())
10604            .expect("label text should shape");
10605        let line = layout
10606            .lines()
10607            .first()
10608            .expect("label text should contain one line");
10609        let actual_visual_center =
10610            text.rect.y() + line.baseline + visual_center(layout.measurement(), false);
10611        let allocation_center = output.frame.viewport.height * 0.5;
10612
10613        assert!((actual_visual_center - allocation_center).abs() < 0.75);
10614    }
10615
10616    #[test]
10617    fn button_activates_on_primary_pointer_click() -> Result<()> {
10618        let activations = Rc::new(RefCell::new(0usize));
10619        let on_press = Rc::clone(&activations);
10620        let (mut runtime, window_id) = build_runtime(Button::new("Save").on_press(move || {
10621            *on_press.borrow_mut() += 1;
10622        }));
10623
10624        let _ = runtime.render(window_id)?;
10625        runtime.handle_event(
10626            window_id,
10627            primary_pointer(PointerEventKind::Down, Point::new(12.0, 12.0), true),
10628        )?;
10629        runtime.handle_event(
10630            window_id,
10631            primary_pointer(PointerEventKind::Up, Point::new(12.0, 12.0), false),
10632        )?;
10633
10634        assert_eq!(*activations.borrow(), 1);
10635
10636        let output = runtime.render(window_id)?;
10637        let button = output
10638            .semantics
10639            .iter()
10640            .find(|node| node.role == SemanticsRole::Button)
10641            .unwrap();
10642        assert_eq!(button.name.as_deref(), Some("Save"));
10643        Ok(())
10644    }
10645
10646    #[test]
10647    fn button_releases_primary_press_on_unlabelled_pointer_up() -> Result<()> {
10648        let activations = Rc::new(RefCell::new(0usize));
10649        let on_press = Rc::clone(&activations);
10650        let (mut runtime, window_id) = build_runtime(Button::new("Save").on_press(move || {
10651            *on_press.borrow_mut() += 1;
10652        }));
10653
10654        let _ = runtime.render(window_id)?;
10655        runtime.handle_event(
10656            window_id,
10657            primary_pointer(PointerEventKind::Down, Point::new(12.0, 12.0), true),
10658        )?;
10659        let mut up = primary_pointer(PointerEventKind::Up, Point::new(12.0, 12.0), false);
10660        if let Event::Pointer(pointer) = &mut up {
10661            pointer.button = None;
10662        }
10663        runtime.handle_event(window_id, up)?;
10664
10665        assert_eq!(*activations.borrow(), 1);
10666        Ok(())
10667    }
10668
10669    #[test]
10670    fn disabled_button_exposes_semantics_and_ignores_activation() -> Result<()> {
10671        let activations = Rc::new(RefCell::new(0usize));
10672        let on_press = Rc::clone(&activations);
10673        let (mut runtime, window_id) = build_runtime(
10674            Button::new("Save")
10675                .enabled(false)
10676                .on_press(move || *on_press.borrow_mut() += 1),
10677        );
10678
10679        let _ = runtime.render(window_id)?;
10680        runtime.handle_event(
10681            window_id,
10682            primary_pointer(PointerEventKind::Down, Point::new(12.0, 12.0), true),
10683        )?;
10684        runtime.handle_event(
10685            window_id,
10686            primary_pointer(PointerEventKind::Up, Point::new(12.0, 12.0), false),
10687        )?;
10688
10689        assert_eq!(*activations.borrow(), 0);
10690        let output = runtime.render(window_id)?;
10691        let button = output
10692            .semantics
10693            .iter()
10694            .find(|node| node.role == SemanticsRole::Button)
10695            .expect("button semantics should be present");
10696        assert!(button.state.disabled);
10697        assert!(button.actions.is_empty());
10698        Ok(())
10699    }
10700
10701    #[test]
10702    fn button_semantic_name_and_description_override_visible_label() {
10703        let output = render(
10704            Button::new("Cancel")
10705                .semantic_name("Cancel report export")
10706                .description("Stop the active report export task"),
10707        );
10708        let button = output
10709            .semantics
10710            .iter()
10711            .find(|node| node.role == SemanticsRole::Button)
10712            .expect("button semantics should be present");
10713        assert_eq!(button.name.as_deref(), Some("Cancel report export"));
10714        assert_eq!(
10715            button.description.as_deref(),
10716            Some("Stop the active report export task")
10717        );
10718        let text = text_run_for(&output, "Cancel");
10719        assert_eq!(text.text, "Cancel");
10720    }
10721
10722    #[test]
10723    fn icon_button_description_is_exposed_to_semantics() {
10724        let output = render(
10725            IconButton::new(IconGlyph::Close, "Close activity")
10726                .description("Hide the runtime activity panel"),
10727        );
10728        let button = output
10729            .semantics
10730            .iter()
10731            .find(|node| node.role == SemanticsRole::Button)
10732            .expect("icon button semantics should be present");
10733        assert_eq!(button.name.as_deref(), Some("Close activity"));
10734        assert_eq!(
10735            button.description.as_deref(),
10736            Some("Hide the runtime activity panel")
10737        );
10738    }
10739
10740    #[test]
10741    fn button_appearance_and_tone_resolve_without_theme_remapping() {
10742        let theme = DefaultTheme::default();
10743        let danger = theme.semantic_tone_color(SemanticTone::Danger);
10744        let outline = Button::new("Delete")
10745            .theme(theme)
10746            .appearance(ButtonAppearance::Outline)
10747            .tone(SemanticTone::Danger)
10748            .resolved_visuals(false);
10749
10750        assert_eq!(outline.background, Color::TRANSPARENT);
10751        assert_eq!(outline.border, danger.with_alpha(0.72));
10752        assert_eq!(outline.label_color, danger);
10753
10754        let tonal = Button::new("Retry")
10755            .theme(theme)
10756            .appearance(ButtonAppearance::Tonal)
10757            .tone(SemanticTone::Warning)
10758            .resolved_visuals(false);
10759        let (soft_fill, soft_text) = theme.semantic_tone_soft_colors(SemanticTone::Warning);
10760        assert_eq!(tonal.background, soft_fill);
10761        assert_eq!(tonal.label_color, soft_text);
10762    }
10763
10764    #[test]
10765    fn button_defaults_are_quiet_and_explicit_action_helpers_are_filled() {
10766        let theme = DefaultTheme::default();
10767        assert_eq!(ButtonAppearance::default(), ButtonAppearance::Tonal);
10768
10769        let ordinary = Button::new("More options").theme(theme);
10770        assert_eq!(ordinary.appearance, ButtonAppearance::Tonal);
10771        assert_eq!(ordinary.tone, SemanticTone::Neutral);
10772        let (neutral_fill, neutral_text) = theme.semantic_tone_soft_colors(SemanticTone::Neutral);
10773        let ordinary_visuals = ordinary.resolved_visuals(false);
10774        assert_eq!(ordinary_visuals.background, neutral_fill);
10775        assert_eq!(ordinary_visuals.label_color, neutral_text);
10776
10777        let primary = Button::primary("Save").theme(theme);
10778        assert_eq!(primary.appearance, ButtonAppearance::Filled);
10779        assert_eq!(primary.tone, SemanticTone::Accent);
10780        assert_eq!(
10781            primary.resolved_visuals(false).background,
10782            theme.palette.accent
10783        );
10784
10785        let danger = Button::danger("Delete").theme(theme);
10786        assert_eq!(danger.appearance, ButtonAppearance::Filled);
10787        assert_eq!(danger.tone, SemanticTone::Danger);
10788        assert_eq!(
10789            danger.resolved_visuals(false).background,
10790            theme.semantic_tone_color(SemanticTone::Danger)
10791        );
10792
10793        let overridden = Button::new("Retry")
10794            .primary_action()
10795            .appearance(ButtonAppearance::Ghost)
10796            .tone(SemanticTone::Warning);
10797        assert_eq!(overridden.appearance, ButtonAppearance::Ghost);
10798        assert_eq!(overridden.tone, SemanticTone::Warning);
10799    }
10800
10801    #[test]
10802    fn choice_controls_are_plain_by_default_and_framed_on_request() {
10803        let theme = DefaultTheme::default();
10804        let checkbox = Checkbox::new("Visible");
10805        let switch = Switch::new("Wifi");
10806        let radio = RadioButton::new("Automatic");
10807        assert_eq!(checkbox.appearance, ChoiceAppearance::Plain);
10808        assert_eq!(switch.appearance, ChoiceAppearance::Plain);
10809        assert_eq!(radio.appearance, ChoiceAppearance::Plain);
10810
10811        for output in [render(checkbox), render(switch), render(radio)] {
10812            assert!(
10813                !solid_fill_colors(&output).contains(&theme.palette.control),
10814                "plain choice rows should not paint the permanent control fill"
10815            );
10816        }
10817
10818        for output in [
10819            render(Checkbox::new("Visible").framed()),
10820            render(Switch::new("Wifi").appearance(ChoiceAppearance::Framed)),
10821            render(RadioButton::new("Automatic").framed()),
10822        ] {
10823            assert!(
10824                solid_fill_colors(&output).contains(&theme.palette.control),
10825                "framed choice rows should preserve the control fill"
10826            );
10827        }
10828    }
10829
10830    #[test]
10831    fn plain_choice_row_reveals_soft_hover_wash() -> Result<()> {
10832        let theme = DefaultTheme::default();
10833        let expected_wash = super::choice_frame_visuals(
10834            &theme,
10835            ChoiceAppearance::Plain,
10836            theme.palette.control,
10837            theme.palette.border,
10838            theme.interaction.hover_blend,
10839            0.0,
10840            0.0,
10841        )
10842        .background;
10843        let (mut runtime, window_id) = build_runtime(Checkbox::new("Visible"));
10844
10845        let rest = runtime.render(window_id)?;
10846        assert!(!solid_fill_colors(&rest).contains(&expected_wash));
10847        runtime.handle_event(
10848            window_id,
10849            primary_pointer(PointerEventKind::Move, Point::new(10.0, 10.0), false),
10850        )?;
10851        runtime.tick(hover_duration());
10852        assert_eq!(handle_ready_events(&mut runtime)?, 1);
10853
10854        let hovered = runtime.render(window_id)?;
10855        assert!(solid_fill_colors(&hovered).contains(&expected_wash));
10856        Ok(())
10857    }
10858
10859    #[test]
10860    fn icon_button_appearance_and_tone_use_semantic_tokens() {
10861        let theme = DefaultTheme::default();
10862        let output = render(IconButtonPaintFixture {
10863            theme,
10864            style: IconButtonPaint::new()
10865                .appearance(ButtonAppearance::Ghost)
10866                .tone(SemanticTone::Danger)
10867                .hovered(true),
10868        });
10869        let (soft_fill, _) = theme.semantic_tone_soft_colors(SemanticTone::Danger);
10870        let expected =
10871            super::mix_color(Color::TRANSPARENT, soft_fill, theme.interaction.hover_blend);
10872        assert_color_approx_eq(solid_fill_colors(&output)[0], expected);
10873        assert!(
10874            non_lucide_stroke_colors(&output)
10875                .iter()
10876                .all(|color| color.alpha <= f32::EPSILON)
10877        );
10878    }
10879
10880    #[test]
10881    fn bare_text_editors_leave_chrome_to_their_container() {
10882        let framed = render(TextArea::new("Notes").value("Body"));
10883        let bare = render(
10884            TextArea::new("Notes")
10885                .appearance(FieldAppearance::Bare)
10886                .value("Body"),
10887        );
10888        assert!(!solid_fill_colors(&framed).is_empty());
10889        assert!(!solid_stroke_colors(&framed).is_empty());
10890        assert!(solid_fill_colors(&bare).is_empty());
10891        assert!(solid_stroke_colors(&bare).is_empty());
10892
10893        let bare_input = render(TextInput::new("Search").bare().value("query"));
10894        assert!(solid_fill_colors(&bare_input).is_empty());
10895        assert!(solid_stroke_colors(&bare_input).is_empty());
10896    }
10897
10898    #[test]
10899    fn disabled_button_label_uses_disabled_muted_text() {
10900        let theme = DefaultTheme::default();
10901        let output = render(Button::new("Save").enabled(false).theme(theme));
10902        let text = text_run_for(&output, "Save");
10903
10904        assert_eq!(
10905            text.style.color,
10906            theme
10907                .palette
10908                .text_muted
10909                .with_alpha(theme.interaction.disabled_content_opacity)
10910        );
10911    }
10912
10913    #[test]
10914    fn button_cached_label_uses_visual_color_without_changing_layout_metrics() {
10915        let text_color = Color::rgba(0.18, 0.42, 0.91, 1.0);
10916        let output = render(Button::new("Apply").text_style(TextStyle {
10917            font_size: 17.0,
10918            line_height: 29.0,
10919            color: text_color,
10920            ..TextStyle::default()
10921        }));
10922
10923        let shaped = first_shaped_text(&output);
10924        let layout = shaped
10925            .resolve(output.frame.text_layout_registry.as_ref())
10926            .expect("button label layout should resolve");
10927
10928        assert_eq!(layout.style().font_size, 17.0);
10929        assert_eq!(layout.style().line_height, 29.0);
10930        assert_eq!(layout.style().color, text_color);
10931        assert_eq!(shaped.color_override, Some(text_color));
10932    }
10933
10934    #[test]
10935    fn button_with_icon_keeps_label_semantics_and_paints_icon() {
10936        let plain = render(Button::new("Export").min_width(96.0));
10937        let with_icon = render_isolated(
10938            Button::new("Export")
10939                .icon(IconGlyph::Download)
10940                .min_width(96.0),
10941        );
10942
10943        let button = with_icon
10944            .semantics
10945            .iter()
10946            .find(|node| node.role == SemanticsRole::Button)
10947            .expect("button semantics should exist");
10948        assert_eq!(button.name.as_deref(), Some("Export"));
10949        assert!(
10950            with_icon.frame.scene.commands().len() > plain.frame.scene.commands().len(),
10951            "icon button should add visible icon ink"
10952        );
10953        let icon_rect = first_lucide_icon_rect(&with_icon);
10954        let text = text_run_for(&with_icon, "Export");
10955        let layout = TextSystem::new()
10956            .shape_text_run(&text, &FontRegistry::new())
10957            .expect("button label should shape");
10958        let line = layout
10959            .lines()
10960            .first()
10961            .expect("button label should contain one line");
10962        let label_visual_center =
10963            text.rect.y() + line.baseline + optical_visual_center(layout.measurement());
10964        let icon_center = icon_rect.y() + (icon_rect.height() * 0.5);
10965
10966        assert!((label_visual_center - icon_center).abs() < 0.75);
10967    }
10968
10969    #[test]
10970    fn button_with_icon_preserves_tall_label_measurement_and_icon_centering() {
10971        let text_style = TextStyle {
10972            font_size: 28.0,
10973            line_height: 12.0,
10974            color: Color::rgba(0.95, 0.98, 1.0, 1.0),
10975            ..TextStyle::default()
10976        };
10977        let output = render_isolated(
10978            Button::new("Export")
10979                .icon(IconGlyph::Download)
10980                .text_style(text_style.clone())
10981                .min_width(220.0)
10982                .min_height(64.0),
10983        );
10984        let icon_rect = first_lucide_icon_rect(&output);
10985        let text = text_run_for(&output, "Export");
10986        let layout = shaped_text_layout_for(&output, "Export");
10987        let line = layout
10988            .lines()
10989            .first()
10990            .expect("button label should contain one line");
10991        let label_visual_center =
10992            text.rect.y() + line.baseline + optical_visual_center(layout.measurement());
10993        let icon_center = icon_rect.y() + (icon_rect.height() * 0.5);
10994        let control_center = output.frame.viewport.height * 0.5;
10995
10996        assert_eq!(text.style.font_size, text_style.font_size);
10997        assert_eq!(text.style.line_height, text_style.line_height);
10998        assert!(text.rect.height() >= layout.measurement().height - 0.01);
10999        assert!(text.rect.height() > text.style.line_height);
11000        assert!((label_visual_center - icon_center).abs() < 0.75);
11001        assert!((label_visual_center - control_center).abs() < 0.75);
11002    }
11003
11004    #[test]
11005    fn disabled_icon_button_exposes_semantics_and_ignores_activation() -> Result<()> {
11006        let activations = Rc::new(RefCell::new(0usize));
11007        let on_press = Rc::clone(&activations);
11008        let (mut runtime, window_id) = build_runtime(
11009            IconButton::new(IconGlyph::Add, "Add")
11010                .enabled(false)
11011                .on_press(move || *on_press.borrow_mut() += 1),
11012        );
11013
11014        let _ = runtime.render(window_id)?;
11015        runtime.handle_event(
11016            window_id,
11017            primary_pointer(PointerEventKind::Down, Point::new(12.0, 12.0), true),
11018        )?;
11019        runtime.handle_event(
11020            window_id,
11021            primary_pointer(PointerEventKind::Up, Point::new(12.0, 12.0), false),
11022        )?;
11023
11024        assert_eq!(*activations.borrow(), 0);
11025        let output = runtime.render(window_id)?;
11026        let button = output
11027            .semantics
11028            .iter()
11029            .find(|node| node.role == SemanticsRole::Button)
11030            .expect("icon button semantics should be present");
11031        assert!(button.state.disabled);
11032        assert!(button.actions.is_empty());
11033        Ok(())
11034    }
11035
11036    #[test]
11037    fn density_modes_resize_core_controls() {
11038        let compact = DefaultTheme::compact();
11039        let touch = DefaultTheme::touch();
11040
11041        assert!(
11042            render(Button::new("Density").theme(compact))
11043                .frame
11044                .viewport
11045                .height
11046                < render(Button::new("Density").theme(touch))
11047                    .frame
11048                    .viewport
11049                    .height
11050        );
11051        assert!(
11052            render(IconButton::new(IconGlyph::Search, "Search").theme(compact))
11053                .frame
11054                .viewport
11055                .width
11056                < render(IconButton::new(IconGlyph::Search, "Search").theme(touch))
11057                    .frame
11058                    .viewport
11059                    .width
11060        );
11061        assert!(
11062            render(TextInput::new("Name").theme(compact))
11063                .frame
11064                .viewport
11065                .height
11066                < render(TextInput::new("Name").theme(touch))
11067                    .frame
11068                    .viewport
11069                    .height
11070        );
11071        assert!(
11072            render(TextArea::new("Notes").theme(compact))
11073                .frame
11074                .viewport
11075                .height
11076                < render(TextArea::new("Notes").theme(touch))
11077                    .frame
11078                    .viewport
11079                    .height
11080        );
11081        assert!(
11082            render(Checkbox::new("Visible").theme(compact))
11083                .frame
11084                .viewport
11085                .height
11086                < render(Checkbox::new("Visible").theme(touch))
11087                    .frame
11088                    .viewport
11089                    .height
11090        );
11091        assert!(
11092            render(Switch::new("Enabled").theme(compact))
11093                .frame
11094                .viewport
11095                .height
11096                < render(Switch::new("Enabled").theme(touch))
11097                    .frame
11098                    .viewport
11099                    .height
11100        );
11101        assert!(
11102            render(Slider::new("Opacity").theme(compact))
11103                .frame
11104                .viewport
11105                .height
11106                < render(Slider::new("Opacity").theme(touch))
11107                    .frame
11108                    .viewport
11109                    .height
11110        );
11111    }
11112
11113    #[test]
11114    fn button_hover_animation_advances_over_multiple_frames() -> Result<()> {
11115        let theme = DefaultTheme::default();
11116        let rest_background = super::semantic_button_visuals(
11117            &theme,
11118            ButtonAppearance::Tonal,
11119            SemanticTone::Neutral,
11120            true,
11121            0.0,
11122            0.0,
11123        )
11124        .background;
11125        let settled_background = super::semantic_button_visuals(
11126            &theme,
11127            ButtonAppearance::Tonal,
11128            SemanticTone::Neutral,
11129            true,
11130            1.0,
11131            0.0,
11132        )
11133        .background;
11134        let (mut runtime, window_id) = build_runtime(Button::new("Hover"));
11135
11136        let _ = runtime.render(window_id)?;
11137        runtime.handle_event(
11138            window_id,
11139            primary_pointer(PointerEventKind::Move, Point::new(12.0, 12.0), false),
11140        )?;
11141
11142        runtime.tick(hover_duration() * 0.5);
11143        assert_eq!(handle_ready_events(&mut runtime)?, 1);
11144        let mid = runtime.render(window_id)?;
11145        let mid_background = solid_fill_colors(&mid)[0];
11146        assert_ne!(mid_background, rest_background);
11147        assert_ne!(mid_background, settled_background);
11148        assert!(runtime.next_wakeup_time(window_id)?.is_some());
11149
11150        runtime.tick(hover_duration());
11151        assert_eq!(handle_ready_events(&mut runtime)?, 1);
11152        let end = runtime.render(window_id)?;
11153        let end_background = solid_fill_colors(&end)[0];
11154        assert_eq!(end_background, settled_background);
11155        assert_eq!(runtime.next_wakeup_time(window_id)?, None);
11156        Ok(())
11157    }
11158
11159    #[test]
11160    fn button_press_changes_color_without_moving_content() -> Result<()> {
11161        let mut theme = DefaultTheme::default();
11162        theme.interaction.pressed_offset = 7.0;
11163        let (mut runtime, window_id) =
11164            build_runtime(Button::new("Press").icon(IconGlyph::Brush).theme(theme));
11165        let rest = runtime.render(window_id)?;
11166        let rest_background = solid_fill_colors(&rest)[0];
11167        let rest_label = text_run_for(&rest, "Press").rect;
11168        let rest_icon = first_lucide_icon_rect(&rest);
11169        let point = Point::new(12.0, 12.0);
11170
11171        runtime.handle_event(
11172            window_id,
11173            primary_pointer(PointerEventKind::Down, point, true),
11174        )?;
11175        runtime.tick(press_duration());
11176        assert_eq!(handle_ready_events(&mut runtime)?, 1);
11177
11178        let pressed = runtime.render(window_id)?;
11179        assert_ne!(solid_fill_colors(&pressed)[0], rest_background);
11180        assert_eq!(text_run_for(&pressed, "Press").rect, rest_label);
11181        assert_eq!(first_lucide_icon_rect(&pressed), rest_icon);
11182        Ok(())
11183    }
11184
11185    #[test]
11186    fn switch_thumb_animation_tracks_progress_and_completion() -> Result<()> {
11187        let theme = slow_toggle_theme();
11188        let toggle_time = theme.motion.toggle_duration();
11189        let (mut runtime, window_id) = build_runtime(Switch::new("Wifi").theme(theme));
11190
11191        let _ = runtime.render(window_id)?;
11192        runtime.handle_event(
11193            window_id,
11194            primary_pointer(PointerEventKind::Down, Point::new(12.0, 12.0), true),
11195        )?;
11196        runtime.handle_event(
11197            window_id,
11198            primary_pointer(PointerEventKind::Up, Point::new(12.0, 12.0), false),
11199        )?;
11200
11201        runtime.tick(toggle_time * 0.5);
11202        assert_eq!(handle_ready_events(&mut runtime)?, 1);
11203        assert!(runtime.next_wakeup_time(window_id)?.is_some());
11204
11205        runtime.tick(toggle_time);
11206        assert_eq!(handle_ready_events(&mut runtime)?, 1);
11207        assert_eq!(runtime.next_wakeup_time(window_id)?, None);
11208
11209        let output = runtime.render(window_id)?;
11210        let switch = output
11211            .semantics
11212            .iter()
11213            .find(|node| node.role == SemanticsRole::Switch)
11214            .unwrap();
11215        assert_eq!(switch.state.checked, Some(sui_core::ToggleState::Checked));
11216        Ok(())
11217    }
11218
11219    #[test]
11220    fn switch_track_hover_and_press_use_theme_motion() -> Result<()> {
11221        let theme = DefaultTheme::default();
11222        let hover_time = hover_duration();
11223        let press_time = press_duration();
11224        let (mut runtime, window_id) = build_runtime(Switch::new("Wifi").on(true));
11225
11226        let _ = runtime.render(window_id)?;
11227        let point = Point::new(12.0, 12.0);
11228        runtime.handle_event(
11229            window_id,
11230            primary_pointer(PointerEventKind::Move, point, false),
11231        )?;
11232
11233        runtime.tick(hover_time * 0.5);
11234        assert_eq!(handle_ready_events(&mut runtime)?, 1);
11235        let mid_hover = runtime.render(window_id)?;
11236        let mid_hover_track = solid_fill_colors(&mid_hover)[1];
11237        let settled_hover_track = super::mix_color(
11238            theme.palette.accent,
11239            theme.palette.accent_hover,
11240            theme.interaction.hover_blend,
11241        );
11242        assert_ne!(mid_hover_track, theme.palette.accent);
11243        assert_ne!(mid_hover_track, settled_hover_track);
11244
11245        runtime.tick(hover_time);
11246        assert_eq!(handle_ready_events(&mut runtime)?, 1);
11247        let hover = runtime.render(window_id)?;
11248        assert_eq!(solid_fill_colors(&hover)[1], settled_hover_track);
11249
11250        runtime.handle_event(
11251            window_id,
11252            primary_pointer(PointerEventKind::Down, point, true),
11253        )?;
11254
11255        runtime.tick(hover_time + (press_time * 0.5));
11256        assert_eq!(handle_ready_events(&mut runtime)?, 1);
11257        let mid_press = runtime.render(window_id)?;
11258        let mid_press_track = solid_fill_colors(&mid_press)[1];
11259        let settled_press_track = super::mix_color(
11260            settled_hover_track,
11261            theme.palette.accent_pressed,
11262            theme.interaction.pressed_blend,
11263        );
11264        assert_ne!(mid_press_track, settled_hover_track);
11265        assert_ne!(mid_press_track, settled_press_track);
11266
11267        runtime.tick(hover_time + press_time);
11268        assert_eq!(handle_ready_events(&mut runtime)?, 1);
11269        let press = runtime.render(window_id)?;
11270        assert_eq!(solid_fill_colors(&press)[1], settled_press_track);
11271        Ok(())
11272    }
11273
11274    #[test]
11275    fn slider_thumb_hover_animation_requests_followup_frames_until_complete() -> Result<()> {
11276        let (mut runtime, window_id) = build_runtime(Slider::new("Gain"));
11277
11278        let _ = runtime.render(window_id)?;
11279        runtime.handle_event(
11280            window_id,
11281            primary_pointer(PointerEventKind::Move, Point::new(32.0, 16.0), false),
11282        )?;
11283
11284        runtime.tick(hover_duration() * 0.5);
11285        assert_eq!(handle_ready_events(&mut runtime)?, 1);
11286        assert!(runtime.next_wakeup_time(window_id)?.is_some());
11287
11288        runtime.tick(hover_duration());
11289        assert_eq!(handle_ready_events(&mut runtime)?, 1);
11290        assert_eq!(runtime.next_wakeup_time(window_id)?, None);
11291        Ok(())
11292    }
11293
11294    #[test]
11295    fn select_header_hover_animation_uses_theme_motion() -> Result<()> {
11296        let theme = DefaultTheme::default();
11297        let (mut runtime, window_id) =
11298            build_runtime(Select::new("Mode").placeholder("Choose mode").options([
11299                "Automatic",
11300                "Linear",
11301                "Gamma",
11302            ]));
11303
11304        let _ = runtime.render(window_id)?;
11305        runtime.handle_event(
11306            window_id,
11307            primary_pointer(PointerEventKind::Move, Point::new(12.0, 12.0), false),
11308        )?;
11309
11310        runtime.tick(hover_duration() * 0.5);
11311        assert_eq!(handle_ready_events(&mut runtime)?, 1);
11312        let mid = runtime.render(window_id)?;
11313        // Mesh selects are dressed fields: the well stays on the field token
11314        // while hover animates the border toward border_hover.
11315        assert!(solid_fill_colors(&mid).contains(&theme.palette.field));
11316        let mid_strokes = solid_stroke_colors(&mid);
11317        assert!(!mid_strokes.contains(&theme.palette.border));
11318        assert!(!mid_strokes.contains(&theme.palette.border_hover));
11319        assert!(runtime.next_wakeup_time(window_id)?.is_some());
11320
11321        runtime.tick(hover_duration());
11322        assert_eq!(handle_ready_events(&mut runtime)?, 1);
11323        let end = runtime.render(window_id)?;
11324        assert!(solid_fill_colors(&end).contains(&theme.palette.field));
11325        assert!(solid_stroke_colors(&end).contains(&theme.palette.border_hover));
11326        assert_eq!(runtime.next_wakeup_time(window_id)?, None);
11327        Ok(())
11328    }
11329
11330    #[test]
11331    fn expanded_select_option_hover_animation_uses_theme_motion() -> Result<()> {
11332        let theme = DefaultTheme::default();
11333        let (mut runtime, window_id) = build_runtime(crate::Padding::all(
11334            12.0,
11335            Select::new("Mode")
11336                .placeholder("Choose mode")
11337                .options(["Automatic", "Linear", "Gamma"])
11338                .selected(2),
11339        ));
11340
11341        let _ = runtime.render(window_id)?;
11342        runtime.handle_event(
11343            window_id,
11344            primary_pointer(PointerEventKind::Down, Point::new(20.0, 20.0), true),
11345        )?;
11346        runtime.handle_event(
11347            window_id,
11348            primary_pointer(PointerEventKind::Up, Point::new(20.0, 20.0), false),
11349        )?;
11350
11351        let entrance_time = entrance_duration();
11352        let hover_time = hover_duration();
11353        runtime.tick(entrance_time);
11354        assert_eq!(handle_ready_events(&mut runtime)?, 1);
11355        let expanded = runtime.render(window_id)?;
11356        let select = expanded
11357            .semantics
11358            .iter()
11359            .find(|node| node.role == SemanticsRole::ComboBox)
11360            .expect("select semantics present after expand");
11361        let menu = overlay_layer_descriptor(&expanded).expect("select menu overlay present");
11362        let menu_owner = overlay_layer_owner(&expanded).expect("select menu overlay owner");
11363        let option_point = Point::new(
11364            menu.bounds.x() + 20.0,
11365            menu.bounds.y() + (select.bounds.height() * 0.5),
11366        );
11367        let menu_node = runtime
11368            .widget_graph(window_id)?
11369            .nodes
11370            .into_iter()
11371            .find(|node| node.id == menu_owner)
11372            .expect("menu surface in widget graph");
11373        assert!(
11374            menu_node.geometry.input_bounds.contains(option_point),
11375            "option point {option_point:?} should hit menu input bounds {:?}",
11376            menu_node.geometry.input_bounds
11377        );
11378        runtime.handle_event(
11379            window_id,
11380            primary_pointer(PointerEventKind::Move, option_point, false),
11381        )?;
11382
11383        runtime.tick(entrance_time + (hover_time * 0.5));
11384        assert!(handle_ready_events(&mut runtime)? >= 1);
11385        let mid = runtime.render(window_id)?;
11386        let mid_fills = solid_fill_colors(&mid);
11387        assert!(
11388            !mid_fills.contains(&theme.palette.control_hover),
11389            "expanded select option hover should not snap directly to the settled hover token"
11390        );
11391        assert!(runtime.next_wakeup_time(window_id)?.is_some());
11392
11393        // Allow a tiny margin because opening the managed overlay can schedule
11394        // an independent focus-frame at the same timestamp as the menu reveal.
11395        runtime.tick(entrance_time + hover_time + 0.001);
11396        assert!(handle_ready_events(&mut runtime)? >= 1);
11397        let settled = runtime.render(window_id)?;
11398        let settled_fills = solid_fill_colors(&settled);
11399        assert!(
11400            settled_fills.contains(&theme.palette.control_hover),
11401            "expanded select option hover should settle to the theme hover token; fills={settled_fills:?}, expected={:?}",
11402            theme.palette.control_hover
11403        );
11404        assert_eq!(runtime.next_wakeup_time(window_id)?, None);
11405        Ok(())
11406    }
11407
11408    #[test]
11409    fn number_input_stepper_press_animation_uses_theme_motion() -> Result<()> {
11410        let (mut runtime, window_id) = build_runtime(
11411            SizedBox::new()
11412                .width(180.0)
11413                .with_child(NumberInput::new("Gamma").value(1.0)),
11414        );
11415
11416        let initial = runtime.render(window_id)?;
11417        let spin = initial
11418            .semantics
11419            .iter()
11420            .find(|node| node.role == SemanticsRole::SpinBox)
11421            .expect("number input semantics present")
11422            .bounds;
11423        let stepper_point = Point::new(spin.max_x() - 8.0, spin.y() + (spin.height() * 0.25));
11424        runtime.handle_event(
11425            window_id,
11426            primary_pointer(PointerEventKind::Move, stepper_point, false),
11427        )?;
11428
11429        runtime.tick(hover_duration() * 0.5);
11430        assert_eq!(handle_ready_events(&mut runtime)?, 1);
11431        assert!(runtime.next_wakeup_time(window_id)?.is_some());
11432
11433        runtime.handle_event(
11434            window_id,
11435            primary_pointer(PointerEventKind::Down, stepper_point, true),
11436        )?;
11437        let press_mid_time = (hover_duration() * 0.5) + (press_duration() * 0.5);
11438        runtime.tick(press_mid_time);
11439        assert_eq!(handle_ready_events(&mut runtime)?, 1);
11440        assert!(runtime.next_wakeup_time(window_id)?.is_some());
11441
11442        runtime.handle_event(
11443            window_id,
11444            primary_pointer(PointerEventKind::Up, stepper_point, false),
11445        )?;
11446        runtime.tick(press_mid_time + focus_duration() + press_duration() + 0.01);
11447        assert_eq!(handle_ready_events(&mut runtime)?, 1);
11448        assert_eq!(runtime.next_wakeup_time(window_id)?, None);
11449
11450        let output = runtime.render(window_id)?;
11451        let spin = output
11452            .semantics
11453            .iter()
11454            .find(|node| node.role == SemanticsRole::SpinBox)
11455            .expect("number input semantics present after stepper press");
11456        assert_eq!(
11457            spin.value,
11458            Some(SemanticsValue::Range {
11459                value: 2.0,
11460                min: f64::NEG_INFINITY,
11461                max: f64::INFINITY,
11462            })
11463        );
11464        assert_eq!(spin.numeric_step, Some(1.0));
11465        Ok(())
11466    }
11467
11468    #[test]
11469    fn text_input_hover_animation_uses_theme_motion() -> Result<()> {
11470        let theme = DefaultTheme::default();
11471        let (mut runtime, window_id) =
11472            build_runtime(TextInput::new("Name").placeholder("Type a name"));
11473
11474        let _ = runtime.render(window_id)?;
11475        runtime.handle_event(
11476            window_id,
11477            primary_pointer(PointerEventKind::Move, Point::new(12.0, 12.0), false),
11478        )?;
11479
11480        runtime.tick(hover_duration() * 0.5);
11481        assert_eq!(handle_ready_events(&mut runtime)?, 1);
11482        let mid = runtime.render(window_id)?;
11483        // The light field well lifts toward the card surface while the border
11484        // strengthens, without snapping either transition.
11485        let mid_background = solid_fill_colors(&mid)[0];
11486        assert_ne!(mid_background, theme.palette.field);
11487        assert_ne!(mid_background, theme.palette.surface);
11488        let mid_strokes = solid_stroke_colors(&mid);
11489        assert!(!mid_strokes.contains(&theme.palette.border));
11490        assert!(!mid_strokes.contains(&theme.palette.border_hover));
11491        assert!(runtime.next_wakeup_time(window_id)?.is_some());
11492
11493        runtime.tick(hover_duration());
11494        assert_eq!(handle_ready_events(&mut runtime)?, 1);
11495        let end = runtime.render(window_id)?;
11496        assert_eq!(
11497            solid_fill_colors(&end)[0],
11498            super::mix_color(
11499                theme.palette.field,
11500                theme.palette.surface,
11501                theme.interaction.hover_blend,
11502            )
11503        );
11504        assert!(solid_stroke_colors(&end).contains(&theme.palette.border_hover));
11505        assert_eq!(runtime.next_wakeup_time(window_id)?, None);
11506        Ok(())
11507    }
11508
11509    #[test]
11510    fn text_area_hover_animation_uses_theme_motion() -> Result<()> {
11511        let (mut runtime, window_id) =
11512            build_runtime(TextArea::new("Notes").placeholder("Write notes"));
11513
11514        let _ = runtime.render(window_id)?;
11515        runtime.handle_event(
11516            window_id,
11517            primary_pointer(PointerEventKind::Move, Point::new(12.0, 12.0), false),
11518        )?;
11519
11520        runtime.tick(hover_duration() * 0.5);
11521        assert_eq!(handle_ready_events(&mut runtime)?, 1);
11522        assert!(runtime.next_wakeup_time(window_id)?.is_some());
11523
11524        runtime.tick(hover_duration());
11525        assert_eq!(handle_ready_events(&mut runtime)?, 1);
11526        assert_eq!(runtime.next_wakeup_time(window_id)?, None);
11527        Ok(())
11528    }
11529
11530    struct IconButtonPaintFixture {
11531        theme: DefaultTheme,
11532        style: IconButtonPaint,
11533    }
11534
11535    impl Widget for IconButtonPaintFixture {
11536        fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
11537            constraints.clamp(Size::new(28.0, 28.0))
11538        }
11539
11540        fn paint(&self, ctx: &mut PaintCtx) {
11541            paint_icon_button(ctx, &self.theme, ctx.bounds(), IconGlyph::Close, self.style);
11542        }
11543    }
11544
11545    #[test]
11546    fn icon_button_paint_matches_widget_visual_states() {
11547        let theme = DefaultTheme::default();
11548        let output = render(IconButtonPaintFixture {
11549            theme,
11550            style: IconButtonPaint::new()
11551                .hovered(true)
11552                .selected(true)
11553                .icon_size(16.0),
11554        });
11555
11556        let selected_base = super::mix_color(
11557            theme.palette.control,
11558            theme.palette.accent,
11559            theme.interaction.selected_blend,
11560        );
11561        let selected_hover = super::mix_color(selected_base, theme.palette.accent_hover, 0.18);
11562        assert_color_approx_eq(
11563            solid_fill_colors(&output)[0],
11564            super::mix_color(selected_base, selected_hover, theme.interaction.hover_blend),
11565        );
11566        assert!(!lucide_strokes(&output).is_empty());
11567    }
11568
11569    #[test]
11570    fn icon_button_press_changes_color_without_moving_icon() {
11571        let mut theme = DefaultTheme::default();
11572        theme.interaction.pressed_offset = 7.0;
11573        let rest = render(IconButtonPaintFixture {
11574            theme,
11575            style: IconButtonPaint::new().icon_size(16.0),
11576        });
11577        let pressed = render(IconButtonPaintFixture {
11578            theme,
11579            style: IconButtonPaint::new().pressed(true).icon_size(16.0),
11580        });
11581
11582        assert_ne!(solid_fill_colors(&pressed)[0], solid_fill_colors(&rest)[0]);
11583        assert_eq!(
11584            first_lucide_icon_rect(&pressed),
11585            first_lucide_icon_rect(&rest)
11586        );
11587    }
11588
11589    #[test]
11590    fn icon_button_hover_and_press_use_theme_motion() -> Result<()> {
11591        let theme = DefaultTheme::default();
11592        let hover_time = hover_duration();
11593        let press_time = press_duration();
11594        let (mut runtime, window_id) = build_runtime(IconButton::new(IconGlyph::Brush, "Brush"));
11595
11596        let _ = runtime.render(window_id)?;
11597        let point = Point::new(12.0, 12.0);
11598        runtime.handle_event(
11599            window_id,
11600            primary_pointer(PointerEventKind::Move, point, false),
11601        )?;
11602
11603        runtime.tick(hover_time * 0.5);
11604        assert_eq!(handle_ready_events(&mut runtime)?, 1);
11605        let mid_hover = runtime.render(window_id)?;
11606        let mid_hover_background = solid_fill_colors(&mid_hover)[0];
11607        let settled_hover_background = super::mix_color(
11608            theme.palette.control,
11609            theme.palette.control_hover,
11610            theme.interaction.hover_blend,
11611        );
11612        assert_ne!(mid_hover_background, theme.palette.control);
11613        assert_ne!(mid_hover_background, settled_hover_background);
11614
11615        runtime.tick(hover_time);
11616        assert_eq!(handle_ready_events(&mut runtime)?, 1);
11617        let hover = runtime.render(window_id)?;
11618        assert_color_approx_eq(solid_fill_colors(&hover)[0], settled_hover_background);
11619
11620        runtime.handle_event(
11621            window_id,
11622            primary_pointer(PointerEventKind::Down, point, true),
11623        )?;
11624
11625        runtime.tick(hover_time + (press_time * 0.5));
11626        assert_eq!(handle_ready_events(&mut runtime)?, 1);
11627        let mid_press = runtime.render(window_id)?;
11628        let mid_press_background = solid_fill_colors(&mid_press)[0];
11629        let settled_press_background = super::mix_color(
11630            settled_hover_background,
11631            theme.palette.control_active,
11632            theme.interaction.pressed_blend,
11633        );
11634        assert_ne!(mid_press_background, settled_hover_background);
11635        assert_ne!(mid_press_background, settled_press_background);
11636
11637        runtime.tick(hover_time + press_time);
11638        assert_eq!(handle_ready_events(&mut runtime)?, 1);
11639        let press = runtime.render(window_id)?;
11640        assert_color_approx_eq(solid_fill_colors(&press)[0], settled_press_background);
11641        Ok(())
11642    }
11643
11644    #[test]
11645    fn icon_button_pressed_animation_decays_after_release() -> Result<()> {
11646        let theme = DefaultTheme::default();
11647        let (mut runtime, window_id) =
11648            build_runtime(super::IconButton::new(super::IconGlyph::Add, "Add"));
11649
11650        let _ = runtime.render(window_id)?;
11651        runtime.handle_event(
11652            window_id,
11653            primary_pointer(PointerEventKind::Down, Point::new(12.0, 12.0), true),
11654        )?;
11655        runtime.handle_event(
11656            window_id,
11657            primary_pointer(PointerEventKind::Up, Point::new(12.0, 12.0), false),
11658        )?;
11659
11660        runtime.tick(press_duration() * 0.5);
11661        assert_eq!(handle_ready_events(&mut runtime)?, 1);
11662        let mid = runtime.render(window_id)?;
11663        let mid_background = solid_fill_colors(&mid)[0];
11664        assert_ne!(mid_background, theme.palette.control_active);
11665        assert_ne!(mid_background, theme.palette.control_hover);
11666        assert!(runtime.next_wakeup_time(window_id)?.is_some());
11667
11668        runtime.tick(hover_duration());
11669        assert_eq!(handle_ready_events(&mut runtime)?, 1);
11670        let end = runtime.render(window_id)?;
11671        let end_fills = solid_fill_colors(&end);
11672        assert_ne!(end_fills, solid_fill_colors(&mid));
11673        assert!(!end_fills.contains(&theme.palette.control_active));
11674        if runtime.next_wakeup_time(window_id)?.is_some() {
11675            runtime.tick(focus_duration());
11676            assert_eq!(handle_ready_events(&mut runtime)?, 1);
11677        }
11678        assert_eq!(runtime.next_wakeup_time(window_id)?, None);
11679        Ok(())
11680    }
11681
11682    #[test]
11683    fn icon_button_selected_state_is_exposed_to_semantics() {
11684        let output =
11685            render(super::IconButton::new(super::IconGlyph::Check, "Brush tool").selected(true));
11686        let button = output
11687            .semantics
11688            .iter()
11689            .find(|node| node.role == SemanticsRole::Button)
11690            .expect("icon button semantics should exist");
11691
11692        assert_eq!(button.name.as_deref(), Some("Brush tool"));
11693        assert!(button.state.selected);
11694    }
11695
11696    #[test]
11697    fn editor_icon_glyphs_paint_visible_ink() {
11698        for glyph in [
11699            IconGlyph::Undo,
11700            IconGlyph::Redo,
11701            IconGlyph::Brush,
11702            IconGlyph::Eraser,
11703            IconGlyph::PaintBucket,
11704            IconGlyph::Hand,
11705            IconGlyph::Lock,
11706            IconGlyph::Unlock,
11707            IconGlyph::Trash,
11708            IconGlyph::Download,
11709            IconGlyph::FitView,
11710            IconGlyph::ActualSize,
11711            IconGlyph::AudioLines,
11712            IconGlyph::Mic,
11713            IconGlyph::MicOff,
11714            IconGlyph::Camera,
11715            IconGlyph::CameraOff,
11716            IconGlyph::Video,
11717            IconGlyph::VideoOff,
11718            IconGlyph::Phone,
11719            IconGlyph::PhoneOff,
11720            IconGlyph::Monitor,
11721            IconGlyph::ScreenShare,
11722        ] {
11723            let output = render(IconButton::new(glyph, "Editor command"));
11724            assert!(
11725                output.frame.scene.commands().len() > 2,
11726                "{glyph:?} should paint more than the button frame"
11727            );
11728        }
11729    }
11730
11731    #[test]
11732    fn icon_button_paints_lucide_native_path() {
11733        let glyph = IconGlyph::Brush;
11734        let handle = glyph.lucide_icon().handle();
11735        let output = render(IconButton::new(glyph, "Brush tool"));
11736
11737        assert!(!output.frame.image_registry.contains(handle));
11738        assert!(
11739            !lucide_strokes(&output).is_empty(),
11740            "{glyph:?} should paint native Lucide path geometry"
11741        );
11742        assert!(
11743            !output.frame.scene.commands().iter().any(|command| matches!(
11744                command,
11745                SceneCommand::DrawImage { source, .. } if source.image == handle
11746            )),
11747            "{glyph:?} should bypass the raster image path"
11748        );
11749    }
11750
11751    #[test]
11752    fn checkbox_check_indicator_animation_progresses_deterministically() -> Result<()> {
11753        let theme = slow_toggle_theme();
11754        let toggle_time = theme.motion.toggle_duration();
11755        let (mut runtime, window_id) = build_runtime(Checkbox::new("Subscribe").theme(theme));
11756
11757        let _ = runtime.render(window_id)?;
11758        runtime.handle_event(
11759            window_id,
11760            primary_pointer(PointerEventKind::Down, Point::new(10.0, 10.0), true),
11761        )?;
11762        runtime.handle_event(
11763            window_id,
11764            primary_pointer(PointerEventKind::Up, Point::new(10.0, 10.0), false),
11765        )?;
11766
11767        runtime.tick(toggle_time * 0.5);
11768        assert_eq!(handle_ready_events(&mut runtime)?, 1);
11769        let mid = runtime.render(window_id)?;
11770        let fills = solid_fill_colors(&mid);
11771        assert!(!fills.is_empty());
11772        assert!(runtime.next_wakeup_time(window_id)?.is_some());
11773
11774        runtime.tick(toggle_time);
11775        assert_eq!(handle_ready_events(&mut runtime)?, 1);
11776        let end = runtime.render(window_id)?;
11777        let checkbox = end
11778            .semantics
11779            .iter()
11780            .find(|node| node.role == SemanticsRole::CheckBox)
11781            .unwrap();
11782        assert_eq!(checkbox.state.checked, Some(sui_core::ToggleState::Checked));
11783        assert_eq!(runtime.next_wakeup_time(window_id)?, None);
11784        Ok(())
11785    }
11786
11787    #[test]
11788    fn checkbox_focus_border_uses_theme_motion() -> Result<()> {
11789        let theme = DefaultTheme::default();
11790        let (mut runtime, window_id) = build_runtime(Checkbox::new("Subscribe"));
11791
11792        let _ = runtime.render(window_id)?;
11793        runtime.handle_event(
11794            window_id,
11795            primary_pointer(PointerEventKind::Down, Point::new(10.0, 10.0), true),
11796        )?;
11797
11798        runtime.tick(focus_duration() * 0.5);
11799        assert!(handle_ready_events(&mut runtime)? >= 1);
11800        let mid_focus = runtime.render(window_id)?;
11801        assert!(
11802            !solid_stroke_colors(&mid_focus).contains(&theme.palette.border_focus),
11803            "checkbox focus border should not snap to the settled focus border color"
11804        );
11805
11806        runtime.tick(focus_duration());
11807        assert!(handle_ready_events(&mut runtime)? >= 1);
11808        let settled_focus = runtime.render(window_id)?;
11809        assert!(
11810            solid_stroke_colors(&settled_focus).contains(&theme.palette.border_focus),
11811            "checkbox focus border should settle to the theme focus border color"
11812        );
11813        Ok(())
11814    }
11815
11816    #[test]
11817    fn focused_control_ring_path_sits_outside_control_bounds() -> Result<()> {
11818        let theme = DefaultTheme::default();
11819        assert_eq!(theme.metrics.focus_ring_outset, 2.0);
11820        let (mut runtime, window_id) = build_runtime(Button::new("Save").theme(theme));
11821
11822        let _ = runtime.render(window_id)?;
11823        runtime.handle_event(
11824            window_id,
11825            primary_pointer(PointerEventKind::Down, Point::new(16.0, 16.0), true),
11826        )?;
11827        runtime.tick(focus_duration());
11828        assert!(handle_ready_events(&mut runtime)? >= 1);
11829
11830        let output = runtime.render(window_id)?;
11831        let button = output
11832            .semantics
11833            .iter()
11834            .find(|node| node.role == SemanticsRole::Button && node.name.as_deref() == Some("Save"))
11835            .expect("focused button semantics present");
11836        let focus_bounds = solid_stroke_path_bounds(&output, theme.palette.focus_ring);
11837
11838        assert!(
11839            focus_bounds.len() == 1,
11840            "expected one focused control ring, got {focus_bounds:?}"
11841        );
11842        assert_rect_approx_eq(
11843            focus_bounds[0],
11844            button.bounds.inflate(
11845                theme.metrics.focus_ring_outset,
11846                theme.metrics.focus_ring_outset,
11847            ),
11848        );
11849        Ok(())
11850    }
11851
11852    #[test]
11853    fn checkbox_hover_and_press_use_theme_motion() -> Result<()> {
11854        let theme = DefaultTheme::default();
11855        let hover_time = hover_duration();
11856        let press_time = press_duration();
11857        let (mut runtime, window_id) = build_runtime(Checkbox::new("Subscribe").framed());
11858
11859        let _ = runtime.render(window_id)?;
11860        let point = Point::new(10.0, 10.0);
11861        runtime.handle_event(
11862            window_id,
11863            primary_pointer(PointerEventKind::Move, point, false),
11864        )?;
11865
11866        runtime.tick(hover_time * 0.5);
11867        assert_eq!(handle_ready_events(&mut runtime)?, 1);
11868        let mid_hover = runtime.render(window_id)?;
11869        let mid_hover_background = solid_fill_colors(&mid_hover)[0];
11870        let settled_hover_background = super::mix_color(
11871            theme.palette.control,
11872            theme.palette.control_hover,
11873            theme.interaction.hover_blend,
11874        );
11875        assert_ne!(mid_hover_background, theme.palette.control);
11876        assert_ne!(mid_hover_background, settled_hover_background);
11877
11878        runtime.tick(hover_time);
11879        assert_eq!(handle_ready_events(&mut runtime)?, 1);
11880        let hover = runtime.render(window_id)?;
11881        assert_color_approx_eq(solid_fill_colors(&hover)[0], settled_hover_background);
11882
11883        runtime.handle_event(
11884            window_id,
11885            primary_pointer(PointerEventKind::Down, point, true),
11886        )?;
11887
11888        runtime.tick(hover_time + (press_time * 0.5));
11889        assert_eq!(handle_ready_events(&mut runtime)?, 1);
11890        let mid_press = runtime.render(window_id)?;
11891        let mid_press_background = solid_fill_colors(&mid_press)[0];
11892        let settled_press_background = super::mix_color(
11893            settled_hover_background,
11894            theme.palette.control_active,
11895            theme.interaction.pressed_blend,
11896        );
11897        assert_ne!(mid_press_background, settled_hover_background);
11898        assert_ne!(mid_press_background, settled_press_background);
11899
11900        runtime.tick(hover_time + press_time);
11901        assert_eq!(handle_ready_events(&mut runtime)?, 1);
11902        let press = runtime.render(window_id)?;
11903        assert_color_approx_eq(solid_fill_colors(&press)[0], settled_press_background);
11904        Ok(())
11905    }
11906
11907    #[test]
11908    fn radio_button_selection_animation_uses_theme_motion() -> Result<()> {
11909        let theme = slow_toggle_theme();
11910        let toggle_time = theme.motion.toggle_duration();
11911        let (mut runtime, window_id) = build_runtime(RadioButton::new("Manual").theme(theme));
11912
11913        let _ = runtime.render(window_id)?;
11914        runtime.handle_event(
11915            window_id,
11916            primary_pointer(PointerEventKind::Down, Point::new(10.0, 10.0), true),
11917        )?;
11918        runtime.handle_event(
11919            window_id,
11920            primary_pointer(PointerEventKind::Up, Point::new(10.0, 10.0), false),
11921        )?;
11922
11923        runtime.tick(toggle_time * 0.5);
11924        assert_eq!(handle_ready_events(&mut runtime)?, 1);
11925        assert!(runtime.next_wakeup_time(window_id)?.is_some());
11926
11927        runtime.tick(toggle_time);
11928        assert_eq!(handle_ready_events(&mut runtime)?, 1);
11929        let end = runtime.render(window_id)?;
11930        let radio = end
11931            .semantics
11932            .iter()
11933            .find(|node| node.role == SemanticsRole::RadioButton)
11934            .unwrap();
11935        assert!(radio.state.selected);
11936        assert_eq!(runtime.next_wakeup_time(window_id)?, None);
11937        Ok(())
11938    }
11939
11940    #[test]
11941    fn radio_button_hover_and_press_use_theme_motion() -> Result<()> {
11942        let theme = DefaultTheme::default();
11943        let hover_time = hover_duration();
11944        let press_time = press_duration();
11945        let (mut runtime, window_id) = build_runtime(RadioButton::new("Manual").selected(true));
11946
11947        let _ = runtime.render(window_id)?;
11948        let point = Point::new(10.0, 10.0);
11949        runtime.handle_event(
11950            window_id,
11951            primary_pointer(PointerEventKind::Move, point, false),
11952        )?;
11953
11954        runtime.tick(hover_time * 0.5);
11955        assert_eq!(handle_ready_events(&mut runtime)?, 1);
11956        let mid_hover = runtime.render(window_id)?;
11957        let mid_hover_indicator = solid_fill_colors(&mid_hover)[1];
11958        let settled_hover_indicator = super::mix_color(
11959            theme.palette.accent,
11960            theme.palette.accent_hover,
11961            theme.interaction.hover_blend,
11962        );
11963        assert_ne!(mid_hover_indicator, theme.palette.accent);
11964        assert_ne!(mid_hover_indicator, settled_hover_indicator);
11965
11966        runtime.tick(hover_time);
11967        assert_eq!(handle_ready_events(&mut runtime)?, 1);
11968        let hover = runtime.render(window_id)?;
11969        assert_color_approx_eq(solid_fill_colors(&hover)[1], settled_hover_indicator);
11970
11971        runtime.handle_event(
11972            window_id,
11973            primary_pointer(PointerEventKind::Down, point, true),
11974        )?;
11975
11976        runtime.tick(hover_time + (press_time * 0.5));
11977        assert_eq!(handle_ready_events(&mut runtime)?, 1);
11978        let mid_press = runtime.render(window_id)?;
11979        let mid_press_indicator = solid_fill_colors(&mid_press)[1];
11980        let settled_press_indicator = super::mix_color(
11981            settled_hover_indicator,
11982            theme.palette.accent_pressed,
11983            theme.interaction.pressed_blend,
11984        );
11985        assert_ne!(mid_press_indicator, settled_hover_indicator);
11986        assert_ne!(mid_press_indicator, settled_press_indicator);
11987
11988        runtime.tick(hover_time + press_time);
11989        assert_eq!(handle_ready_events(&mut runtime)?, 1);
11990        let press = runtime.render(window_id)?;
11991        assert_color_approx_eq(solid_fill_colors(&press)[1], settled_press_indicator);
11992        Ok(())
11993    }
11994
11995    #[test]
11996    fn radio_group_hover_press_and_selection_use_theme_motion() -> Result<()> {
11997        let theme = DefaultTheme::default();
11998        let hover_time = hover_duration();
11999        let press_time = press_duration();
12000        let toggle_time = toggle_duration();
12001        let (mut runtime, window_id) =
12002            build_runtime(RadioGroup::new("Mode").options(["Manual", "Automatic"]));
12003
12004        let _ = runtime.render(window_id)?;
12005        let row_point = Point::new(10.0, 10.0);
12006        runtime.handle_event(
12007            window_id,
12008            primary_pointer(PointerEventKind::Move, row_point, false),
12009        )?;
12010
12011        runtime.tick(hover_time * 0.5);
12012        assert!(handle_ready_events(&mut runtime)? >= 1);
12013        let mid_hover = runtime.render(window_id)?;
12014        let mid_hover_background = solid_fill_colors(&mid_hover)[0];
12015        let settled_hover_background = super::mix_color(
12016            theme.palette.control,
12017            theme.palette.control_hover,
12018            theme.interaction.hover_blend,
12019        );
12020        assert_ne!(mid_hover_background, theme.palette.control);
12021        assert_ne!(mid_hover_background, settled_hover_background);
12022
12023        runtime.tick(hover_time);
12024        assert!(handle_ready_events(&mut runtime)? >= 1);
12025        let hover = runtime.render(window_id)?;
12026        assert_eq!(solid_fill_colors(&hover)[0], settled_hover_background);
12027
12028        runtime.handle_event(
12029            window_id,
12030            primary_pointer(PointerEventKind::Down, row_point, true),
12031        )?;
12032        runtime.tick(hover_time + (press_time * 0.5));
12033        assert!(handle_ready_events(&mut runtime)? >= 1);
12034        let mid_press = runtime.render(window_id)?;
12035        let mid_press_background = solid_fill_colors(&mid_press)[0];
12036        let settled_press_background = super::mix_color(
12037            settled_hover_background,
12038            theme.palette.control_active,
12039            theme.interaction.pressed_blend,
12040        );
12041        assert_ne!(mid_press_background, settled_hover_background);
12042        assert_ne!(mid_press_background, settled_press_background);
12043
12044        runtime.tick(hover_time + press_time);
12045        assert!(handle_ready_events(&mut runtime)? >= 1);
12046        let press = runtime.render(window_id)?;
12047        assert_eq!(solid_fill_colors(&press)[0], settled_press_background);
12048
12049        runtime.handle_event(
12050            window_id,
12051            primary_pointer(PointerEventKind::Up, row_point, false),
12052        )?;
12053        let selection_start = hover_time + press_time;
12054        runtime.tick(selection_start + (toggle_time * 0.5));
12055        assert!(handle_ready_events(&mut runtime)? >= 1);
12056        let mid_selection = runtime.render(window_id)?;
12057        assert!(
12058            !solid_fill_colors(&mid_selection).contains(&theme.palette.accent_text),
12059            "radio group selection dot should not snap directly to the settled selected color"
12060        );
12061
12062        runtime.tick(selection_start + toggle_time);
12063        assert!(handle_ready_events(&mut runtime)? >= 1);
12064        let selected = runtime.render(window_id)?;
12065        assert!(
12066            solid_fill_colors(&selected).contains(&theme.palette.accent_text),
12067            "radio group selection dot should settle to the theme selected text color"
12068        );
12069        Ok(())
12070    }
12071
12072    #[test]
12073    fn radio_group_focus_ring_uses_theme_motion() -> Result<()> {
12074        let theme = DefaultTheme::default();
12075        let (mut runtime, window_id) =
12076            build_runtime(RadioGroup::new("Mode").options(["Manual", "Automatic"]));
12077
12078        let _ = runtime.render(window_id)?;
12079        runtime.handle_event(
12080            window_id,
12081            primary_pointer(PointerEventKind::Down, Point::new(10.0, 10.0), true),
12082        )?;
12083
12084        runtime.tick(focus_duration() * 0.5);
12085        assert!(handle_ready_events(&mut runtime)? >= 1);
12086        let mid_focus = runtime.render(window_id)?;
12087        assert!(
12088            !solid_stroke_colors(&mid_focus).contains(&theme.palette.focus_ring),
12089            "radio group focus ring should not snap to the settled focus color"
12090        );
12091
12092        runtime.tick(focus_duration());
12093        assert!(handle_ready_events(&mut runtime)? >= 1);
12094        let settled_focus = runtime.render(window_id)?;
12095        assert!(
12096            solid_stroke_colors(&settled_focus).contains(&theme.palette.focus_ring),
12097            "radio group focus ring should settle to the theme focus color"
12098        );
12099        Ok(())
12100    }
12101
12102    #[test]
12103    fn checkbox_toggles_and_updates_semantics() -> Result<()> {
12104        let states = Rc::new(RefCell::new(Vec::new()));
12105        let on_toggle = Rc::clone(&states);
12106        let (mut runtime, window_id) =
12107            build_runtime(Checkbox::new("Subscribe").on_toggle(move |checked| {
12108                on_toggle.borrow_mut().push(checked);
12109            }));
12110
12111        let _ = runtime.render(window_id)?;
12112        runtime.handle_event(
12113            window_id,
12114            primary_pointer(PointerEventKind::Down, Point::new(10.0, 10.0), true),
12115        )?;
12116        runtime.handle_event(
12117            window_id,
12118            primary_pointer(PointerEventKind::Up, Point::new(10.0, 10.0), false),
12119        )?;
12120
12121        assert_eq!(states.borrow().as_slice(), &[true]);
12122
12123        let output = runtime.render(window_id)?;
12124        let checkbox = output
12125            .semantics
12126            .iter()
12127            .find(|node| node.role == SemanticsRole::CheckBox)
12128            .unwrap();
12129        assert_eq!(checkbox.state.checked, Some(sui_core::ToggleState::Checked));
12130        Ok(())
12131    }
12132
12133    #[test]
12134    fn checkbox_indicator_and_label_respect_asymmetric_padding() {
12135        let theme = DefaultTheme::default();
12136        let padding = TestPadding {
12137            left: 8.0,
12138            top: 4.0,
12139            right: 8.0,
12140            bottom: 22.0,
12141        };
12142        let output = render(Checkbox::new("Visible").padding(padding));
12143        let checkbox = output
12144            .semantics
12145            .iter()
12146            .find(|node| node.role == SemanticsRole::CheckBox)
12147            .expect("checkbox semantics should exist");
12148        let content_center = checkbox.bounds.y()
12149            + padding.top
12150            + ((checkbox.bounds.height() - padding.top - padding.bottom) * 0.5);
12151        let text = text_run_for(&output, "Visible");
12152        let mut indicator_bounds = None;
12153        output.frame.scene.visit_commands(&mut |command| {
12154            if indicator_bounds.is_some() {
12155                return;
12156            }
12157            if let SceneCommand::FillPath { path, .. } = command {
12158                let bounds = path.bounds();
12159                if (bounds.width() - theme.metrics.checkbox_indicator_size).abs() < 0.75
12160                    && (bounds.height() - theme.metrics.checkbox_indicator_size).abs() < 0.75
12161                {
12162                    indicator_bounds = Some(bounds);
12163                }
12164            }
12165        });
12166        let indicator = indicator_bounds.expect("checkbox indicator should paint");
12167
12168        assert!((text_run_visual_center(&text) - content_center).abs() < 0.75);
12169        assert!((super::rect_center(indicator).y - content_center).abs() < 0.75);
12170    }
12171
12172    #[test]
12173    fn text_input_caret_blink_toggles_visibility_as_time_advances() -> Result<()> {
12174        let theme = DefaultTheme::default();
12175        let (mut runtime, window_id) =
12176            build_runtime(TextInput::new("Name").placeholder("Type a name"));
12177
12178        let _ = runtime.render(window_id)?;
12179        runtime.handle_event(
12180            window_id,
12181            primary_pointer(PointerEventKind::Down, Point::new(20.0, 16.0), true),
12182        )?;
12183        let focused = runtime.render(window_id)?;
12184        let caret_color = theme.palette.caret;
12185        let focused_caret_count = solid_fill_colors(&focused)
12186            .into_iter()
12187            .filter(|color| *color == caret_color)
12188            .count();
12189        assert!(focused.ime_composition_rect.is_some());
12190        assert!(focused_caret_count > 0);
12191
12192        runtime.tick(CARET_BLINK_PERIOD_SECONDS * 0.75);
12193        assert!(handle_ready_events(&mut runtime)? >= 1);
12194        let blinked = runtime.render(window_id)?;
12195        let blinked_caret_count = solid_fill_colors(&blinked)
12196            .into_iter()
12197            .filter(|color| *color == caret_color)
12198            .count();
12199        assert!(blinked.ime_composition_rect.is_some());
12200        assert_eq!(blinked_caret_count, 0);
12201        Ok(())
12202    }
12203
12204    #[test]
12205    fn text_input_browser_back_clears_focus_and_disables_ime() -> Result<()> {
12206        let (mut runtime, window_id) = build_runtime(TextInput::new("API key").value("secret"));
12207
12208        let _ = runtime.render(window_id)?;
12209        runtime.handle_event(
12210            window_id,
12211            primary_pointer(PointerEventKind::Down, Point::new(20.0, 16.0), true),
12212        )?;
12213        assert!(runtime.render(window_id)?.ime_composition_rect.is_some());
12214
12215        assert!(runtime.dispatch_event(
12216            window_id,
12217            Event::Keyboard(KeyboardEvent::new("BrowserBack", KeyState::Pressed)),
12218        )?);
12219        assert_eq!(runtime.focused_widget(window_id)?, None);
12220        assert!(runtime.render(window_id)?.ime_composition_rect.is_none());
12221        Ok(())
12222    }
12223
12224    #[test]
12225    fn text_input_selection_scope_tracks_keyboard_selection() -> Result<()> {
12226        let selection = SelectionScope::new();
12227        let (mut runtime, window_id) = build_runtime(
12228            TextInput::new("Name")
12229                .value("Ada Lovelace")
12230                .selectable(selection.clone()),
12231        );
12232
12233        let _ = runtime.render(window_id)?;
12234        runtime.handle_event(
12235            window_id,
12236            primary_pointer(PointerEventKind::Down, Point::new(8.0, 8.0), true),
12237        )?;
12238        runtime.handle_event(window_id, command_key("a"))?;
12239
12240        assert_eq!(selection.selected_text().as_deref(), Some("Ada Lovelace"));
12241        Ok(())
12242    }
12243
12244    #[test]
12245    fn text_input_paints_keyboard_selection_and_copies_it() -> Result<()> {
12246        let theme = DefaultTheme::default();
12247        let (mut runtime, window_id) = build_runtime(TextInput::new("Name").value("Ada Lovelace"));
12248
12249        let _ = runtime.render(window_id)?;
12250        runtime.handle_event(
12251            window_id,
12252            primary_pointer(PointerEventKind::Down, Point::new(8.0, 8.0), true),
12253        )?;
12254        runtime.handle_event(window_id, command_key("a"))?;
12255        let selected = runtime.render(window_id)?;
12256
12257        assert!(
12258            solid_fill_colors(&selected).contains(&theme.palette.selection),
12259            "TextInput should paint its active selection before the text"
12260        );
12261
12262        runtime.handle_event(window_id, command_key("c"))?;
12263        assert_eq!(runtime.clipboard().text().as_deref(), Some("Ada Lovelace"));
12264        Ok(())
12265    }
12266
12267    #[test]
12268    fn password_input_masks_display_but_edits_and_copies_actual_value() -> Result<()> {
12269        let value = Rc::new(RefCell::new(String::new()));
12270        let captured = Rc::clone(&value);
12271        let (mut runtime, window_id) = build_runtime(
12272            PasswordInput::new("Password")
12273                .value("sëcret")
12274                .on_change(move |text| *captured.borrow_mut() = text),
12275        );
12276
12277        let output = runtime.render(window_id)?;
12278        let input = output
12279            .semantics
12280            .iter()
12281            .find(|node| node.role == SemanticsRole::TextInput)
12282            .expect("password input semantics present");
12283        let editable = input
12284            .editable_text
12285            .as_ref()
12286            .expect("password input should expose editable semantics");
12287
12288        assert_eq!(
12289            input.value,
12290            Some(SemanticsValue::Text("sëcret".to_string()))
12291        );
12292        assert!(editable.password);
12293        assert_eq!(text_run_for(&output, "••••••").text, "••••••");
12294
12295        runtime.handle_event(
12296            window_id,
12297            primary_pointer(PointerEventKind::Down, Point::new(8.0, 8.0), true),
12298        )?;
12299        runtime.handle_event(window_id, command_key("a"))?;
12300        runtime.handle_event(window_id, command_key("c"))?;
12301        assert_eq!(runtime.clipboard().text().as_deref(), Some("sëcret"));
12302
12303        runtime.clipboard().set_text("new secret");
12304        runtime.handle_event(window_id, command_key("v"))?;
12305        assert_eq!(value.borrow().as_str(), "new secret");
12306        Ok(())
12307    }
12308
12309    #[test]
12310    fn datetime_input_edits_and_pastes_a_single_line_value() -> Result<()> {
12311        let value = Rc::new(RefCell::new(String::new()));
12312        let captured = Rc::clone(&value);
12313        let (mut runtime, window_id) = build_runtime(
12314            DateTimeInput::new("Scheduled for")
12315                .value("2026-07-15 09:30")
12316                .on_change(move |text| *captured.borrow_mut() = text),
12317        );
12318
12319        let output = runtime.render(window_id)?;
12320        let input = output
12321            .semantics
12322            .iter()
12323            .find(|node| node.role == SemanticsRole::TextInput)
12324            .expect("date/time input semantics present");
12325        assert_eq!(
12326            input.value,
12327            Some(SemanticsValue::Text("2026-07-15 09:30".to_string()))
12328        );
12329        assert!(!input.editable_text.as_ref().unwrap().password);
12330
12331        runtime.handle_event(
12332            window_id,
12333            primary_pointer(PointerEventKind::Down, Point::new(8.0, 8.0), true),
12334        )?;
12335        runtime.handle_event(window_id, command_key("a"))?;
12336        runtime.clipboard().set_text("2026-08-01\n14:45");
12337        runtime.handle_event(window_id, command_key("v"))?;
12338
12339        assert_eq!(value.borrow().as_str(), "2026-08-0114:45");
12340        Ok(())
12341    }
12342
12343    #[test]
12344    fn text_area_selection_scope_tracks_keyboard_selection() -> Result<()> {
12345        let selection = SelectionScope::new();
12346        let (mut runtime, window_id) = build_runtime(
12347            TextArea::new("Notes")
12348                .value("first line\nsecond line")
12349                .selectable(selection.clone()),
12350        );
12351
12352        let _ = runtime.render(window_id)?;
12353        runtime.handle_event(
12354            window_id,
12355            primary_pointer(PointerEventKind::Down, Point::new(8.0, 8.0), true),
12356        )?;
12357        runtime.handle_event(window_id, command_key("a"))?;
12358
12359        assert_eq!(
12360            selection.selected_text().as_deref(),
12361            Some("first line\nsecond line")
12362        );
12363        Ok(())
12364    }
12365
12366    #[test]
12367    fn read_only_text_area_paints_selection_and_copies_it() -> Result<()> {
12368        let theme = DefaultTheme::default();
12369        let selection = SelectionScope::new();
12370        let (mut runtime, window_id) = build_runtime(
12371            TextArea::new("Connection details")
12372                .value("node = local\naddress = 127.0.0.1:21353")
12373                .read_only()
12374                .selectable(selection.clone()),
12375        );
12376
12377        let _ = runtime.render(window_id)?;
12378        runtime.handle_event(
12379            window_id,
12380            primary_pointer(PointerEventKind::Down, Point::new(8.0, 8.0), true),
12381        )?;
12382        runtime.handle_event(window_id, command_key("a"))?;
12383        let selected = runtime.render(window_id)?;
12384
12385        assert_eq!(
12386            selection.selected_text().as_deref(),
12387            Some("node = local\naddress = 127.0.0.1:21353")
12388        );
12389        assert!(
12390            solid_fill_colors(&selected).contains(&theme.palette.selection),
12391            "read-only TextArea should paint the active selection before its text"
12392        );
12393
12394        runtime.handle_event(window_id, command_key("c"))?;
12395        assert_eq!(
12396            runtime.clipboard().text().as_deref(),
12397            Some("node = local\naddress = 127.0.0.1:21353")
12398        );
12399        Ok(())
12400    }
12401
12402    #[test]
12403    fn text_input_copy_and_paste_use_runtime_clipboard() -> Result<()> {
12404        let value = Rc::new(RefCell::new(String::new()));
12405        let captured = Rc::clone(&value);
12406        let (mut runtime, window_id) = build_runtime(
12407            TextInput::new("Name")
12408                .value("Ada Lovelace")
12409                .on_change(move |text| *captured.borrow_mut() = text),
12410        );
12411
12412        let _ = runtime.render(window_id)?;
12413        runtime.handle_event(
12414            window_id,
12415            primary_pointer(PointerEventKind::Down, Point::new(8.0, 8.0), true),
12416        )?;
12417        runtime.handle_event(window_id, command_key("a"))?;
12418        runtime.handle_event(window_id, command_key("c"))?;
12419
12420        assert_eq!(runtime.clipboard().text().as_deref(), Some("Ada Lovelace"));
12421
12422        runtime.clipboard().set_text("Grace\nHopper");
12423        runtime.handle_event(window_id, command_key("a"))?;
12424        runtime.handle_event(window_id, command_key("v"))?;
12425
12426        // Pasted text is coerced to a single line.
12427        assert_eq!(value.borrow().as_str(), "GraceHopper");
12428        Ok(())
12429    }
12430
12431    #[test]
12432    fn text_area_paste_with_empty_clipboard_preserves_selection() -> Result<()> {
12433        let (mut runtime, window_id) = build_runtime(TextArea::new("Notes").value("alpha"));
12434
12435        let _ = runtime.render(window_id)?;
12436        runtime.handle_event(
12437            window_id,
12438            primary_pointer(PointerEventKind::Down, Point::new(8.0, 8.0), true),
12439        )?;
12440        runtime.handle_event(window_id, command_key("a"))?;
12441        runtime.handle_event(window_id, command_key("v"))?;
12442        runtime.handle_event(window_id, command_key("c"))?;
12443
12444        // An empty clipboard paste must not delete the selection, so the
12445        // follow-up copy still captures the full document.
12446        assert_eq!(runtime.clipboard().text().as_deref(), Some("alpha"));
12447        Ok(())
12448    }
12449
12450    #[test]
12451    fn text_area_mouse_drag_selects_text() -> Result<()> {
12452        let selection = SelectionScope::new();
12453        let (mut runtime, window_id) = build_runtime(
12454            TextArea::new("Notes")
12455                .value("alpha beta gamma")
12456                .selectable(selection.clone()),
12457        );
12458
12459        let _ = runtime.render(window_id)?;
12460        runtime.handle_event(
12461            window_id,
12462            primary_pointer(PointerEventKind::Down, Point::new(8.0, 8.0), true),
12463        )?;
12464        runtime.handle_event(
12465            window_id,
12466            primary_pointer(PointerEventKind::Move, Point::new(360.0, 8.0), true),
12467        )?;
12468        runtime.handle_event(
12469            window_id,
12470            primary_pointer(PointerEventKind::Up, Point::new(360.0, 8.0), false),
12471        )?;
12472
12473        let selected = selection.selected_text().unwrap_or_default();
12474        assert!(
12475            selected.starts_with("alpha"),
12476            "drag from the line start should select leading text, got {selected:?}"
12477        );
12478        Ok(())
12479    }
12480
12481    #[test]
12482    fn text_input_mouse_drag_selects_text() -> Result<()> {
12483        let selection = SelectionScope::new();
12484        let (mut runtime, window_id) = build_runtime(
12485            TextInput::new("Name")
12486                .value("hello world")
12487                .selectable(selection.clone()),
12488        );
12489
12490        let _ = runtime.render(window_id)?;
12491        runtime.handle_event(
12492            window_id,
12493            primary_pointer(PointerEventKind::Down, Point::new(8.0, 8.0), true),
12494        )?;
12495        runtime.handle_event(
12496            window_id,
12497            primary_pointer(PointerEventKind::Move, Point::new(360.0, 8.0), true),
12498        )?;
12499        runtime.handle_event(
12500            window_id,
12501            primary_pointer(PointerEventKind::Up, Point::new(360.0, 8.0), false),
12502        )?;
12503
12504        let selected = selection.selected_text().unwrap_or_default();
12505        assert!(
12506            selected.starts_with("hello"),
12507            "drag from the field start should select leading text, got {selected:?}"
12508        );
12509        Ok(())
12510    }
12511
12512    #[test]
12513    fn typed_text_commands_drive_clipboard_actions() -> Result<()> {
12514        let (mut runtime, window_id) = build_runtime(TextArea::new("Notes").value("alpha"));
12515
12516        let _ = runtime.render(window_id)?;
12517        runtime.handle_event(
12518            window_id,
12519            Event::Keyboard(KeyboardEvent::new("Tab", KeyState::Pressed)),
12520        )?;
12521        runtime.handle_command(
12522            CommandTarget::FocusedWidget(window_id),
12523            CommandDelivery::Directed,
12524            TEXT_COMMAND,
12525            TextCommand::SelectAll,
12526        );
12527        runtime.handle_command(
12528            CommandTarget::FocusedWidget(window_id),
12529            CommandDelivery::Directed,
12530            TEXT_COMMAND,
12531            TextCommand::Copy,
12532        );
12533        assert_eq!(runtime.clipboard().text().as_deref(), Some("alpha"));
12534
12535        runtime.clipboard().set_text("beta");
12536        for command in [
12537            TextCommand::SelectAll,
12538            TextCommand::Paste,
12539            TextCommand::SelectAll,
12540            TextCommand::Copy,
12541        ] {
12542            runtime.handle_command(
12543                CommandTarget::FocusedWidget(window_id),
12544                CommandDelivery::Directed,
12545                TEXT_COMMAND,
12546                command,
12547            );
12548        }
12549        assert_eq!(runtime.clipboard().text().as_deref(), Some("beta"));
12550        Ok(())
12551    }
12552
12553    #[test]
12554    fn text_input_caret_uses_theme_palette_color() -> Result<()> {
12555        let mut theme = DefaultTheme::default();
12556        theme.palette.caret = Color::rgba(0.02, 0.18, 0.72, 1.0);
12557        // A sentinel accent_text distinct from the (white) field well, so the
12558        // background fill cannot mask an accent_text-colored caret.
12559        theme.palette.accent_text = Color::rgba(0.9, 0.05, 0.85, 1.0);
12560        let caret_color = theme.palette.caret;
12561        let accent_text = theme.palette.accent_text;
12562        let (mut runtime, window_id) = build_runtime(
12563            TextInput::new("Name")
12564                .theme(theme)
12565                .value("Visible caret on white"),
12566        );
12567
12568        let _ = runtime.render(window_id)?;
12569        runtime.handle_event(
12570            window_id,
12571            primary_pointer(PointerEventKind::Down, Point::new(80.0, 16.0), true),
12572        )?;
12573        let output = runtime.render(window_id)?;
12574        let fill_colors = solid_fill_colors(&output);
12575
12576        assert!(fill_colors.contains(&caret_color));
12577        assert!(!fill_colors.contains(&accent_text));
12578        Ok(())
12579    }
12580
12581    #[test]
12582    fn text_input_text_visual_center_matches_tall_control_center() {
12583        let output = render(
12584            TextInput::new("Name")
12585                .value("Ada")
12586                .min_width(180.0)
12587                .min_height(52.0),
12588        );
12589        let text = text_run_for(&output, "Ada");
12590        let layout = TextSystem::new()
12591            .shape_text_run(&text, &FontRegistry::new())
12592            .expect("text input value should shape");
12593        let line = layout
12594            .lines()
12595            .first()
12596            .expect("text input value should contain one line");
12597        let actual_visual_center =
12598            text.rect.y() + line.baseline + optical_visual_center(layout.measurement());
12599        let control_center = output.frame.viewport.height * 0.5;
12600
12601        assert!((actual_visual_center - control_center).abs() < 0.75);
12602    }
12603
12604    #[test]
12605    fn text_input_value_preserves_tall_measurement_and_centering() {
12606        let mut theme = DefaultTheme::default();
12607        theme.typography.body_font_size = 30.0;
12608        theme.typography.body_line_height = 10.0;
12609        let output = render(
12610            TextInput::new("Name")
12611                .theme(theme)
12612                .value("Ada")
12613                .min_width(180.0)
12614                .min_height(56.0),
12615        );
12616
12617        assert_tall_body_text_centered(&output, "Ada", theme, output.frame.viewport.height * 0.5);
12618    }
12619
12620    #[test]
12621    fn text_input_placeholder_visual_center_matches_tall_control_center() {
12622        let theme = DefaultTheme::default();
12623        let output = render(
12624            TextInput::new("Name")
12625                .placeholder("Type a name")
12626                .min_width(180.0)
12627                .min_height(52.0),
12628        );
12629        let text = text_run_for(&output, "Type a name");
12630        let control_center = output.frame.viewport.height * 0.5;
12631
12632        assert_eq!(text.style.color, theme.placeholder_text_style().color);
12633        assert!((text_run_visual_center(&text) - control_center).abs() < 0.75);
12634    }
12635
12636    #[test]
12637    fn text_input_leading_icon_offsets_placeholder_and_keeps_editing() -> Result<()> {
12638        let changes = Rc::new(RefCell::new(Vec::new()));
12639        let on_change = Rc::clone(&changes);
12640        let (mut runtime, window_id) = build_runtime(
12641            TextInput::new("Search")
12642                .placeholder("Search conversations")
12643                .leading_icon(IconGlyph::Search)
12644                .min_width(220.0)
12645                .on_change(move |value| on_change.borrow_mut().push(value)),
12646        );
12647
12648        let output = runtime.render(window_id)?;
12649        let icon_rect = first_lucide_icon_rect(&output);
12650        let placeholder = text_run_for(&output, "Search conversations");
12651        assert!(
12652            placeholder.rect.x() >= icon_rect.max_x() + 4.0,
12653            "placeholder should start after the leading icon"
12654        );
12655
12656        runtime.handle_event(
12657            window_id,
12658            primary_pointer(PointerEventKind::Down, Point::new(8.0, 16.0), true),
12659        )?;
12660        runtime.handle_event(
12661            window_id,
12662            Event::Ime(ImeEvent::CompositionCommit {
12663                text: "repo".to_string(),
12664            }),
12665        )?;
12666
12667        assert_eq!(changes.borrow().as_slice(), &["repo".to_string()]);
12668        Ok(())
12669    }
12670
12671    #[test]
12672    fn text_input_placeholder_preserves_tall_measurement_and_centering() {
12673        let mut theme = DefaultTheme::default();
12674        theme.typography.body_font_size = 30.0;
12675        theme.typography.body_line_height = 10.0;
12676        let output = render(
12677            TextInput::new("Name")
12678                .theme(theme)
12679                .placeholder("Type a name")
12680                .min_width(180.0)
12681                .min_height(56.0),
12682        );
12683        let text = text_run_for(&output, "Type a name");
12684
12685        assert_eq!(text.style.color, theme.placeholder_text_style().color);
12686        assert_tall_body_text_centered(
12687            &output,
12688            "Type a name",
12689            theme,
12690            output.frame.viewport.height * 0.5,
12691        );
12692    }
12693
12694    #[test]
12695    fn text_input_accepts_printable_key_without_text_payload() -> Result<()> {
12696        let changes = Rc::new(RefCell::new(Vec::new()));
12697        let on_change = Rc::clone(&changes);
12698        let (mut runtime, window_id) = build_runtime(
12699            TextInput::new("Name").on_change(move |value| on_change.borrow_mut().push(value)),
12700        );
12701
12702        let _ = runtime.render(window_id)?;
12703        runtime.handle_event(
12704            window_id,
12705            primary_pointer(PointerEventKind::Down, Point::new(18.0, 18.0), true),
12706        )?;
12707        runtime.handle_event(window_id, key_without_text("h"))?;
12708
12709        assert_eq!(changes.borrow().last().map(String::as_str), Some("h"));
12710        let output = runtime.render(window_id)?;
12711        let input = output
12712            .semantics
12713            .iter()
12714            .find(|node| node.role == SemanticsRole::TextInput)
12715            .expect("text input semantics present");
12716        assert_eq!(input.value, Some(SemanticsValue::Text("h".to_string())));
12717        Ok(())
12718    }
12719
12720    #[test]
12721    fn text_input_on_change_with_ctx_receives_text() -> Result<()> {
12722        let changes = Rc::new(RefCell::new(Vec::new()));
12723        let on_change = Rc::clone(&changes);
12724        let (mut runtime, window_id) = build_runtime(
12725            TextInput::new("Name")
12726                .on_change_with_ctx(move |_, value| on_change.borrow_mut().push(value)),
12727        );
12728
12729        let _ = runtime.render(window_id)?;
12730        runtime.handle_event(
12731            window_id,
12732            primary_pointer(PointerEventKind::Down, Point::new(18.0, 18.0), true),
12733        )?;
12734        runtime.handle_event(window_id, key_without_text("h"))?;
12735
12736        assert_eq!(changes.borrow().as_slice(), &["h".to_string()]);
12737        Ok(())
12738    }
12739
12740    #[test]
12741    fn text_input_read_only_uses_muted_text_and_blocks_mutation() -> Result<()> {
12742        let theme = DefaultTheme::default();
12743        let changes = Rc::new(RefCell::new(Vec::new()));
12744        let on_change = Rc::clone(&changes);
12745        let (mut runtime, window_id) = build_runtime(
12746            TextInput::new("Name")
12747                .value("Locked")
12748                .min_height(52.0)
12749                .read_only()
12750                .on_change(move |value| on_change.borrow_mut().push(value)),
12751        );
12752
12753        let _ = runtime.render(window_id)?;
12754        runtime.handle_event(
12755            window_id,
12756            primary_pointer(PointerEventKind::Down, Point::new(40.0, 16.0), true),
12757        )?;
12758        runtime.handle_event(
12759            window_id,
12760            Event::Ime(ImeEvent::CompositionCommit {
12761                text: "!".to_string(),
12762            }),
12763        )?;
12764        runtime.handle_event(
12765            window_id,
12766            Event::Keyboard(KeyboardEvent::new("Backspace", KeyState::Pressed)),
12767        )?;
12768        let output = runtime.render(window_id)?;
12769        let input = output
12770            .semantics
12771            .iter()
12772            .find(|node| node.role == SemanticsRole::TextInput)
12773            .expect("text input semantics present");
12774        let editable = input
12775            .editable_text
12776            .as_ref()
12777            .expect("text input should expose editable semantics");
12778
12779        assert_eq!(
12780            input.value,
12781            Some(SemanticsValue::Text("Locked".to_string()))
12782        );
12783        assert!(editable.readonly);
12784        assert!(input.actions.contains(&SemanticsAction::Copy));
12785        assert!(!input.actions.contains(&SemanticsAction::InsertText));
12786        assert!(!input.actions.contains(&SemanticsAction::SetValue));
12787        assert!(changes.borrow().is_empty());
12788        let text = text_run_for(&output, "Locked");
12789        assert_eq!(text.style.color, theme.palette.text_muted);
12790        assert!(
12791            (text_run_visual_center(&text) - (input.bounds.y() + input.bounds.height() * 0.5))
12792                .abs()
12793                < 0.75
12794        );
12795        assert!(!solid_fill_colors(&output).contains(&theme.palette.caret));
12796        assert!(output.ime_composition_rect.is_none());
12797        Ok(())
12798    }
12799
12800    #[test]
12801    fn text_input_focus_animation_settles_into_blink_timer_without_frame_spin() -> Result<()> {
12802        let (mut runtime, window_id) =
12803            build_runtime(TextInput::new("Name").placeholder("Type a name"));
12804
12805        let _ = runtime.render(window_id)?;
12806        runtime.handle_event(
12807            window_id,
12808            primary_pointer(PointerEventKind::Down, Point::new(100.0, 16.0), true),
12809        )?;
12810        let _ = runtime.render(window_id)?;
12811
12812        let settled_at = focus_duration() + 0.01;
12813        runtime.tick(settled_at);
12814        assert_eq!(handle_ready_events(&mut runtime)?, 1);
12815        let next = runtime
12816            .next_wakeup_time(window_id)?
12817            .expect("caret blink timer should remain armed after focus settles");
12818        assert!(next >= (CARET_BLINK_PERIOD_SECONDS * 0.5) - 1e-6);
12819        assert!(next - settled_at > 0.25);
12820
12821        Ok(())
12822    }
12823
12824    #[test]
12825    fn text_input_click_while_focused_restores_hidden_caret() -> Result<()> {
12826        let theme = DefaultTheme::default();
12827        let (mut runtime, window_id) =
12828            build_runtime(TextInput::new("Name").placeholder("Type a name"));
12829
12830        let _ = runtime.render(window_id)?;
12831        runtime.handle_event(
12832            window_id,
12833            primary_pointer(PointerEventKind::Down, Point::new(20.0, 16.0), true),
12834        )?;
12835        let _ = runtime.render(window_id)?;
12836
12837        runtime.tick(CARET_BLINK_PERIOD_SECONDS * 0.75);
12838        assert!(handle_ready_events(&mut runtime)? >= 1);
12839        let hidden = runtime.render(window_id)?;
12840        let caret_color = theme.palette.caret;
12841        assert_eq!(
12842            solid_fill_colors(&hidden)
12843                .into_iter()
12844                .filter(|color| *color == caret_color)
12845                .count(),
12846            0
12847        );
12848
12849        runtime.handle_event(
12850            window_id,
12851            primary_pointer(PointerEventKind::Down, Point::new(20.0, 16.0), true),
12852        )?;
12853        let restored = runtime.render(window_id)?;
12854        assert!(
12855            solid_fill_colors(&restored)
12856                .into_iter()
12857                .filter(|color| *color == caret_color)
12858                .count()
12859                > 0
12860        );
12861
12862        Ok(())
12863    }
12864
12865    #[test]
12866    fn text_area_click_while_focused_restores_hidden_caret() -> Result<()> {
12867        let theme = DefaultTheme::default();
12868        let (mut runtime, window_id) =
12869            build_runtime(TextArea::new("Notes").placeholder("Type notes"));
12870
12871        let _ = runtime.render(window_id)?;
12872        runtime.handle_event(
12873            window_id,
12874            primary_pointer(PointerEventKind::Down, Point::new(20.0, 20.0), true),
12875        )?;
12876        let _ = runtime.render(window_id)?;
12877
12878        runtime.tick(CARET_BLINK_PERIOD_SECONDS * 0.75);
12879        assert!(handle_ready_events(&mut runtime)? >= 1);
12880        let hidden = runtime.render(window_id)?;
12881        let caret_color = theme.palette.caret;
12882        assert_eq!(
12883            solid_fill_colors(&hidden)
12884                .into_iter()
12885                .filter(|color| *color == caret_color)
12886                .count(),
12887            0
12888        );
12889
12890        runtime.handle_event(
12891            window_id,
12892            primary_pointer(PointerEventKind::Down, Point::new(20.0, 20.0), true),
12893        )?;
12894        let restored = runtime.render(window_id)?;
12895        assert!(
12896            solid_fill_colors(&restored)
12897                .into_iter()
12898                .filter(|color| *color == caret_color)
12899                .count()
12900                > 0
12901        );
12902
12903        Ok(())
12904    }
12905
12906    #[test]
12907    fn text_area_read_only_exposes_readonly_semantics_and_blocks_mutation() -> Result<()> {
12908        let theme = DefaultTheme::default();
12909        let (mut runtime, window_id) =
12910            build_runtime(TextArea::new("Notes").value("Pinned\nNotes").read_only());
12911
12912        let _ = runtime.render(window_id)?;
12913        runtime.handle_event(
12914            window_id,
12915            primary_pointer(PointerEventKind::Down, Point::new(20.0, 20.0), true),
12916        )?;
12917        runtime.handle_event(
12918            window_id,
12919            Event::Keyboard(KeyboardEvent::new("Enter", KeyState::Pressed)),
12920        )?;
12921        runtime.handle_event(
12922            window_id,
12923            Event::Keyboard(KeyboardEvent::new("Backspace", KeyState::Pressed)),
12924        )?;
12925        let output = runtime.render(window_id)?;
12926        let input = output
12927            .semantics
12928            .iter()
12929            .find(|node| node.role == SemanticsRole::TextInput)
12930            .expect("text area semantics present");
12931        let editable = input
12932            .editable_text
12933            .as_ref()
12934            .expect("text area should expose editable semantics");
12935
12936        assert_eq!(
12937            input.value,
12938            Some(SemanticsValue::Text("Pinned\nNotes".to_string()))
12939        );
12940        assert!(editable.readonly);
12941        assert!(editable.multiline);
12942        assert!(input.actions.contains(&SemanticsAction::Copy));
12943        assert!(!input.actions.contains(&SemanticsAction::InsertText));
12944        assert!(!input.actions.contains(&SemanticsAction::DeleteBackward));
12945        assert_eq!(
12946            text_run_for(&output, "Pinned\nNotes").style.color,
12947            theme.palette.text_muted
12948        );
12949        assert!(!solid_fill_colors(&output).contains(&theme.palette.caret));
12950        assert!(output.ime_composition_rect.is_none());
12951        Ok(())
12952    }
12953
12954    #[test]
12955    fn text_area_placeholder_uses_placeholder_style_and_top_line_slot() {
12956        let theme = DefaultTheme::default();
12957        let output = render(
12958            TextArea::new("Notes")
12959                .placeholder("Write notes")
12960                .min_width(260.0)
12961                .min_height(96.0),
12962        );
12963        let text = text_run_for(&output, "Write notes");
12964        let layout = TextSystem::new()
12965            .shape_text_run(&text, &FontRegistry::new())
12966            .expect("text area placeholder should shape");
12967
12968        assert_eq!(text.style.color, theme.placeholder_text_style().color);
12969        assert!((text.rect.y() - theme.metrics.text_input_padding.top).abs() < 0.75);
12970        assert!(
12971            (layout.box_size().height - text.style.line_height).abs() < 0.75,
12972            "placeholder line box should use the placeholder line height"
12973        );
12974    }
12975
12976    #[test]
12977    fn text_area_placeholder_preserves_tall_measurement_in_top_line_slot() {
12978        let mut theme = DefaultTheme::default();
12979        theme.typography.body_font_size = 30.0;
12980        theme.typography.body_line_height = 10.0;
12981        let output = render(
12982            TextArea::new("Notes")
12983                .theme(theme)
12984                .placeholder("Write notes")
12985                .min_width(260.0)
12986                .min_height(96.0),
12987        );
12988        let text = text_run_for(&output, "Write notes");
12989        let layout = shaped_text_layout_for(&output, "Write notes");
12990
12991        assert_eq!(text.style.color, theme.placeholder_text_style().color);
12992        assert_eq!(text.style.font_size, theme.typography.body_font_size);
12993        assert_eq!(text.style.line_height, theme.typography.body_line_height);
12994        assert!((text.rect.y() - theme.metrics.text_input_padding.top).abs() < 0.75);
12995        assert!(text.rect.height() >= layout.measurement().height - 0.01);
12996        assert!(text.rect.height() > text.style.line_height);
12997    }
12998
12999    #[test]
13000    fn text_area_read_only_value_preserves_tall_measurement_and_muted_text() {
13001        let mut theme = DefaultTheme::default();
13002        theme.typography.body_font_size = 30.0;
13003        theme.typography.body_line_height = 10.0;
13004        let output = render(
13005            TextArea::new("Notes")
13006                .theme(theme)
13007                .value("Pinned notes")
13008                .read_only()
13009                .min_width(260.0)
13010                .min_height(96.0),
13011        );
13012        let text = text_run_for(&output, "Pinned notes");
13013        let layout = shaped_text_layout_for(&output, "Pinned notes");
13014
13015        assert_eq!(text.style.color, theme.palette.text_muted);
13016        assert_eq!(text.style.font_size, theme.typography.body_font_size);
13017        assert_eq!(text.style.line_height, theme.typography.body_line_height);
13018        assert!((text.rect.y() - theme.metrics.text_input_padding.top).abs() < 0.75);
13019        assert!(text.rect.height() >= layout.measurement().height - 0.01);
13020        assert!(text.rect.height() > text.style.line_height);
13021    }
13022
13023    #[test]
13024    fn text_area_shapes_multiline_value_with_finite_positions() {
13025        let notes = "Pinned notes for inspector workflows.\nSupports multiline editing.";
13026        let output = render(
13027            SizedBox::new().width(420.0).with_child(
13028                TextArea::new("Notes")
13029                    .min_height(150.0)
13030                    .value(notes)
13031                    .placeholder("Write notes"),
13032            ),
13033        );
13034        let layout = shaped_text_layout_for(&output, notes);
13035
13036        assert!(layout.box_size().height.is_finite());
13037        assert!(layout.lines().iter().all(|line| rect_is_finite(line.rect)));
13038        assert!(
13039            layout
13040                .glyphs()
13041                .iter()
13042                .all(|glyph| glyph.origin_x.is_finite() && glyph.origin_y.is_finite())
13043        );
13044    }
13045
13046    #[test]
13047    fn text_area_focus_ring_animation_progresses_without_losing_ime_rect() -> Result<()> {
13048        let (mut runtime, window_id) =
13049            build_runtime(TextArea::new("Notes").placeholder("Type notes"));
13050
13051        let _ = runtime.render(window_id)?;
13052        runtime.handle_event(
13053            window_id,
13054            primary_pointer(PointerEventKind::Down, Point::new(20.0, 20.0), true),
13055        )?;
13056        let initial = runtime.render(window_id)?;
13057        assert!(initial.ime_composition_rect.is_some());
13058
13059        runtime.tick(focus_duration() * 0.5);
13060        assert_eq!(handle_ready_events(&mut runtime)?, 1);
13061        let mid = runtime.render(window_id)?;
13062        assert!(mid.ime_composition_rect.is_some());
13063        assert_ne!(solid_fill_colors(&initial), solid_fill_colors(&mid));
13064
13065        Ok(())
13066    }
13067
13068    #[test]
13069    fn text_input_commits_ime_text_and_supports_backspace() -> Result<()> {
13070        let changes = Rc::new(RefCell::new(Vec::new()));
13071        let on_change = Rc::clone(&changes);
13072        let (mut runtime, window_id) = build_runtime(
13073            TextInput::new("Name")
13074                .placeholder("Type a name")
13075                .on_change(move |value| on_change.borrow_mut().push(value)),
13076        );
13077
13078        let _ = runtime.render(window_id)?;
13079        runtime.handle_event(
13080            window_id,
13081            primary_pointer(PointerEventKind::Down, Point::new(20.0, 16.0), true),
13082        )?;
13083        runtime.handle_event(
13084            window_id,
13085            Event::Ime(ImeEvent::CompositionCommit {
13086                text: "Ada".to_string(),
13087            }),
13088        )?;
13089        runtime.handle_event(
13090            window_id,
13091            Event::Keyboard(KeyboardEvent {
13092                key: "Backspace".to_string(),
13093                code: "Backspace".to_string(),
13094                text: None,
13095                state: KeyState::Pressed,
13096                modifiers: Modifiers::NONE,
13097                repeat: false,
13098                is_composing: false,
13099            }),
13100        )?;
13101
13102        assert_eq!(
13103            changes.borrow().as_slice(),
13104            &["Ada".to_string(), "Ad".to_string()]
13105        );
13106
13107        let output = runtime.render(window_id)?;
13108        let input = output
13109            .semantics
13110            .iter()
13111            .find(|node| node.role == SemanticsRole::TextInput)
13112            .unwrap();
13113        assert_eq!(input.name.as_deref(), Some("Name"));
13114        assert_eq!(
13115            input.value,
13116            Some(sui_core::SemanticsValue::Text("Ad".to_string()))
13117        );
13118        assert!(output.ime_composition_rect.is_some());
13119        Ok(())
13120    }
13121
13122    #[test]
13123    fn text_input_edits_at_caret_with_keyboard_navigation() -> Result<()> {
13124        let changes = Rc::new(RefCell::new(Vec::new()));
13125        let on_change = Rc::clone(&changes);
13126        let (mut runtime, window_id) = build_runtime(
13127            TextInput::new("Name")
13128                .value("Ada")
13129                .on_change(move |value| on_change.borrow_mut().push(value)),
13130        );
13131
13132        let _ = runtime.render(window_id)?;
13133        runtime.handle_event(
13134            window_id,
13135            primary_pointer(PointerEventKind::Down, Point::new(100.0, 16.0), true),
13136        )?;
13137        runtime.handle_event(
13138            window_id,
13139            Event::Keyboard(KeyboardEvent::new("ArrowLeft", KeyState::Pressed)),
13140        )?;
13141        runtime.handle_event(
13142            window_id,
13143            Event::Ime(ImeEvent::CompositionCommit {
13144                text: "m".to_string(),
13145            }),
13146        )?;
13147        runtime.handle_event(
13148            window_id,
13149            Event::Keyboard(KeyboardEvent::new("Backspace", KeyState::Pressed)),
13150        )?;
13151        runtime.handle_event(
13152            window_id,
13153            Event::Keyboard(KeyboardEvent::new("ArrowLeft", KeyState::Pressed)),
13154        )?;
13155        runtime.handle_event(
13156            window_id,
13157            Event::Keyboard(KeyboardEvent::new("Delete", KeyState::Pressed)),
13158        )?;
13159
13160        assert_eq!(
13161            changes.borrow().as_slice(),
13162            &["Adma".to_string(), "Ada".to_string(), "Aa".to_string()]
13163        );
13164
13165        let output = runtime.render(window_id)?;
13166        let input = output
13167            .semantics
13168            .iter()
13169            .find(|node| node.role == SemanticsRole::TextInput)
13170            .unwrap();
13171        assert_eq!(
13172            input.value,
13173            Some(sui_core::SemanticsValue::Text("Aa".to_string()))
13174        );
13175        Ok(())
13176    }
13177
13178    #[test]
13179    fn text_input_uses_shared_editor_commands_and_editable_semantics() -> Result<()> {
13180        let changes = Rc::new(RefCell::new(Vec::new()));
13181        let on_change = Rc::clone(&changes);
13182        let (mut runtime, window_id) = build_runtime(
13183            TextInput::new("Name")
13184                .value("hello world")
13185                .on_change(move |value| on_change.borrow_mut().push(value)),
13186        );
13187
13188        let _ = runtime.render(window_id)?;
13189        runtime.handle_event(
13190            window_id,
13191            primary_pointer(PointerEventKind::Down, Point::new(100.0, 16.0), true),
13192        )?;
13193        runtime.handle_event(window_id, command_key("a"))?;
13194        runtime.handle_event(window_id, command_key("x"))?;
13195        runtime.handle_event(window_id, command_key("v"))?;
13196        runtime.handle_event(window_id, command_key("z"))?;
13197        runtime.handle_event(window_id, command_key("y"))?;
13198        runtime.handle_event(
13199            window_id,
13200            Event::Ime(ImeEvent::CompositionCommit {
13201                text: "\n!".to_string(),
13202            }),
13203        )?;
13204
13205        let output = runtime.render(window_id)?;
13206        let input = output
13207            .semantics
13208            .iter()
13209            .find(|node| node.role == SemanticsRole::TextInput)
13210            .unwrap();
13211        assert_eq!(
13212            input.value,
13213            Some(sui_core::SemanticsValue::Text("hello world!".to_string()))
13214        );
13215        let editable = input
13216            .editable_text
13217            .as_ref()
13218            .expect("text input should expose editable semantics");
13219        assert!(!editable.multiline);
13220        assert_eq!(editable.caret_offset, "hello world!".len());
13221        assert_eq!(
13222            editable.selection,
13223            SemanticsTextRange::new("hello world!".len(), "hello world!".len())
13224        );
13225        assert_eq!(
13226            changes.borrow().last().map(String::as_str),
13227            Some("hello world!")
13228        );
13229        Ok(())
13230    }
13231
13232    #[test]
13233    fn text_input_click_positions_caret_for_insertion() -> Result<()> {
13234        let changes = Rc::new(RefCell::new(Vec::new()));
13235        let on_change = Rc::clone(&changes);
13236        let (mut runtime, window_id) = build_runtime(
13237            TextInput::new("Name")
13238                .value("Ada")
13239                .on_change(move |value| on_change.borrow_mut().push(value)),
13240        );
13241
13242        let _ = runtime.render(window_id)?;
13243        runtime.handle_event(
13244            window_id,
13245            primary_pointer(PointerEventKind::Down, Point::new(1.0, 16.0), true),
13246        )?;
13247        runtime.handle_event(
13248            window_id,
13249            Event::Ime(ImeEvent::CompositionCommit {
13250                text: "Lady ".to_string(),
13251            }),
13252        )?;
13253
13254        assert_eq!(changes.borrow().as_slice(), &["Lady Ada".to_string()]);
13255
13256        let output = runtime.render(window_id)?;
13257        let input = output
13258            .semantics
13259            .iter()
13260            .find(|node| node.role == SemanticsRole::TextInput)
13261            .unwrap();
13262        assert_eq!(
13263            input.value,
13264            Some(sui_core::SemanticsValue::Text("Lady Ada".to_string()))
13265        );
13266        Ok(())
13267    }
13268
13269    #[test]
13270    fn text_input_ignores_process_key_without_text() -> Result<()> {
13271        let changes = Rc::new(RefCell::new(Vec::new()));
13272        let on_change = Rc::clone(&changes);
13273        let (mut runtime, window_id) = build_runtime(
13274            TextInput::new("Name")
13275                .placeholder("Type a name")
13276                .on_change(move |value| on_change.borrow_mut().push(value)),
13277        );
13278
13279        let _ = runtime.render(window_id)?;
13280        runtime.handle_event(
13281            window_id,
13282            primary_pointer(PointerEventKind::Down, Point::new(20.0, 16.0), true),
13283        )?;
13284        runtime.handle_event(
13285            window_id,
13286            Event::Keyboard(KeyboardEvent {
13287                key: "Process".to_string(),
13288                code: "KeyA".to_string(),
13289                text: None,
13290                state: KeyState::Pressed,
13291                modifiers: Modifiers::NONE,
13292                repeat: false,
13293                is_composing: false,
13294            }),
13295        )?;
13296
13297        assert!(changes.borrow().is_empty());
13298
13299        let output = runtime.render(window_id)?;
13300        let input = output
13301            .semantics
13302            .iter()
13303            .find(|node| node.role == SemanticsRole::TextInput)
13304            .unwrap();
13305        assert_eq!(
13306            input.value,
13307            Some(sui_core::SemanticsValue::Text(String::new()))
13308        );
13309        Ok(())
13310    }
13311
13312    #[test]
13313    fn button_obeys_minimum_size() {
13314        let output = render(Button::new("Go").min_width(140.0).min_height(40.0));
13315        assert_eq!(output.frame.viewport, Size::new(140.0, 40.0));
13316    }
13317
13318    #[test]
13319    fn button_preserves_sdr_palette_when_hdr_mode_disabled() {
13320        let mut theme = DefaultTheme::default();
13321        theme.hdr.mode = HdrThemeMode::Disabled;
13322        theme.hdr.color_roles.accent = SemanticColorToken::from_sdr(theme.palette.accent)
13323            .with_hdr(Color::linear_display_p3(1.35, 0.28, 0.22, 1.0));
13324
13325        let visuals = Button::primary("Go").theme(theme).resolved_visuals(true);
13326        let fills = solid_fill_colors(&render(Button::primary("Go").theme(theme)));
13327
13328        assert_eq!(visuals.background, theme.palette.accent);
13329        assert_eq!(visuals.border, theme.palette.accent_border_focus);
13330        assert_eq!(visuals.focus_ring, Some(theme.palette.focus_ring));
13331        assert_eq!(visuals.label_color, theme.palette.accent_text);
13332        assert_eq!(visuals.label_peak_lift, theme.hdr.luminance.reference_white);
13333        assert!(visuals.chrome_style.is_none());
13334        assert_eq!(fills.first().copied(), Some(theme.palette.accent));
13335        assert_ne!(
13336            fills.first().copied(),
13337            theme.hdr.color_roles.accent.hdr,
13338            "disabled mode should paint the SDR accent, not the HDR token"
13339        );
13340    }
13341
13342    #[test]
13343    fn button_can_resolve_constrained_hdr_accent_style() {
13344        let mut theme = DefaultTheme::default();
13345        theme.hdr.mode = HdrThemeMode::ConstrainedHdr;
13346        theme.hdr.luminance.semantic_accent = 1.18;
13347        theme.hdr.policy.max_large_area_lift = 1.22;
13348        theme.hdr.color_roles.accent = SemanticColorToken::from_sdr(theme.palette.accent)
13349            .with_hdr(Color::linear_display_p3(1.28, 0.42, 0.30, 1.0));
13350
13351        let visuals = Button::primary("Go").theme(theme).resolved_visuals(true);
13352        let chrome_style = visuals.chrome_style.expect("hdr accent style present");
13353
13354        assert_eq!(visuals.background, chrome_style.color);
13355        assert!(visuals.border.red <= theme.hdr.policy.max_large_area_lift);
13356        assert_ne!(visuals.background, theme.palette.accent);
13357        assert_eq!(chrome_style.peak_lift, 1.18);
13358        assert!((chrome_style.color.red - chrome_style.peak_lift).abs() < f32::EPSILON);
13359        assert!(visuals.focus_ring.is_some());
13360    }
13361
13362    #[test]
13363    fn button_hdr_style_keeps_label_at_reference_white() {
13364        let mut theme = DefaultTheme::default();
13365        theme.hdr.mode = HdrThemeMode::ConstrainedHdr;
13366        theme.hdr.luminance.semantic_accent = 1.2;
13367        theme.hdr.policy.max_large_area_lift = 1.25;
13368        theme.hdr.color_roles.accent = SemanticColorToken::from_sdr(theme.palette.accent)
13369            .with_hdr(Color::linear_display_p3(1.20, 0.36, 0.30, 1.0));
13370
13371        let visuals = Button::primary("Go").theme(theme).resolved_visuals(false);
13372
13373        assert_eq!(visuals.label_color, theme.palette.accent_text);
13374        assert_eq!(visuals.label_peak_lift, theme.hdr.luminance.reference_white);
13375        assert!(visuals.label_peak_lift <= theme.hdr.policy.max_large_area_lift);
13376    }
13377
13378    #[test]
13379    fn button_centers_label_within_available_content_width() {
13380        let theme = DefaultTheme::default();
13381        let optical = render(Button::new("Go").min_width(140.0));
13382        let optical_label = first_text_run(&optical).rect;
13383
13384        assert!(optical_label.x() > theme.metrics.button_padding.left);
13385        assert!(optical_label.max_y() <= optical.frame.viewport.height);
13386    }
13387
13388    #[test]
13389    fn button_optically_centers_label_ink_with_side_bearings() {
13390        let mut style = DefaultTheme::default().button_text_style();
13391        style.font_size = 48.0;
13392        style.line_height = 56.0;
13393        let candidates = ["j", "T.", "f)", "(f", "AV", "To", "WA", "1"];
13394        let (label, offset) = candidates
13395            .iter()
13396            .find_map(|candidate| {
13397                let measurement = TextSystem::new()
13398                    .measure_text(candidate.to_string(), style.clone(), &FontRegistry::new())
13399                    .ok()?;
13400                let offset = measurement.bounds.x() + (measurement.bounds.width() * 0.5)
13401                    - (measurement.width * 0.5);
13402                (offset.abs() > 0.75).then_some((*candidate, offset))
13403            })
13404            .expect("test font should expose a label with asymmetric side bearings");
13405        let output = render(Button::new(label).text_style(style).min_width(220.0));
13406        let text = first_shaped_text(&output);
13407        let ink_bounds = text.translated_bounds();
13408        let ink_center = ink_bounds.x() + (ink_bounds.width() * 0.5);
13409        let control_center = output.frame.viewport.width * 0.5;
13410
13411        assert!(offset.abs() > 0.75);
13412        assert!((ink_center - control_center).abs() < 0.75);
13413    }
13414
13415    #[test]
13416    fn button_window_option_keeps_button_label_centered() {
13417        let (mut runtime, window_id) = build_runtime(Button::new("Go").min_width(140.0));
13418        set_window_render_options(
13419            window_id,
13420            WindowRenderOptions::new(true, 1.0).with_optical_vertical_text_alignment_enabled(false),
13421        );
13422        let geometric = runtime.render(window_id).unwrap();
13423        clear_window_render_options(window_id);
13424        let text = first_shaped_text(&geometric);
13425        let layout = text
13426            .resolve(geometric.frame.text_layout_registry.as_ref())
13427            .expect("button label layout should resolve");
13428        let line = layout
13429            .lines()
13430            .first()
13431            .expect("button label should contain one line");
13432        let actual_visual_center =
13433            text.origin.y + line.baseline + visual_center(layout.measurement(), false);
13434        let control_center = geometric.frame.viewport.height * 0.5;
13435
13436        assert!((actual_visual_center - control_center).abs() < 0.75);
13437    }
13438
13439    #[test]
13440    fn button_label_visual_center_matches_control_center() {
13441        let output = render(Button::new("Go").min_width(140.0));
13442        let text = first_shaped_text(&output);
13443        let layout = text
13444            .resolve(output.frame.text_layout_registry.as_ref())
13445            .expect("button label layout should resolve");
13446        let line = layout
13447            .lines()
13448            .first()
13449            .expect("button label should contain one line");
13450        let actual_visual_center =
13451            text.origin.y + line.baseline + optical_visual_center(layout.measurement());
13452        let control_center = output.frame.viewport.height * 0.5;
13453
13454        assert!((actual_visual_center - control_center).abs() < 0.75);
13455    }
13456
13457    #[test]
13458    fn button_label_visual_center_respects_asymmetric_padding() {
13459        let padding = TestPadding {
13460            left: 12.0,
13461            top: 4.0,
13462            right: 12.0,
13463            bottom: 20.0,
13464        };
13465        let output = render(
13466            Button::new("Go")
13467                .padding(padding)
13468                .min_width(140.0)
13469                .min_height(64.0),
13470        );
13471        let text = first_shaped_text(&output);
13472        let layout = text
13473            .resolve(output.frame.text_layout_registry.as_ref())
13474            .expect("button label layout should resolve");
13475        let line = layout
13476            .lines()
13477            .first()
13478            .expect("button label should contain one line");
13479        let actual_visual_center =
13480            text.origin.y + line.baseline + optical_visual_center(layout.measurement());
13481        let content_center =
13482            padding.top + ((output.frame.viewport.height - padding.top - padding.bottom) * 0.5);
13483
13484        assert!((actual_visual_center - content_center).abs() < 0.75);
13485    }
13486
13487    #[test]
13488    fn button_persistent_label_visual_center_matches_control_center() {
13489        let output = render(Button::new("Apply").min_width(140.0));
13490        let text = first_shaped_text(&output);
13491        let layout = text
13492            .resolve(output.frame.text_layout_registry.as_ref())
13493            .expect("button label layout should resolve");
13494        let line = layout
13495            .lines()
13496            .first()
13497            .expect("button label should contain one line");
13498        let actual_visual_center =
13499            text.origin.y + line.baseline + optical_visual_center(layout.measurement());
13500        let control_center = output.frame.viewport.height * 0.5;
13501
13502        assert!((actual_visual_center - control_center).abs() < 0.75);
13503    }
13504
13505    #[test]
13506    fn switch_label_visual_center_matches_control_center() {
13507        let output = render(Switch::new("Airplane mode"));
13508        let text = first_text_run(&output);
13509        let layout = TextSystem::new()
13510            .shape_text_run(&text, &FontRegistry::new())
13511            .expect("switch label should shape");
13512        let line = layout
13513            .lines()
13514            .first()
13515            .expect("switch label should contain one line");
13516        let actual_visual_center =
13517            text.rect.y() + line.baseline + optical_visual_center(layout.measurement());
13518        let control_center = output.frame.viewport.height * 0.5;
13519
13520        assert!((actual_visual_center - control_center).abs() < 0.75);
13521    }
13522
13523    #[test]
13524    fn switch_label_visual_center_ignores_asymmetric_padding() {
13525        let output = render(Switch::new("Wifi").padding(TestPadding {
13526            left: 8.0,
13527            top: 0.0,
13528            right: 8.0,
13529            bottom: 18.0,
13530        }));
13531        let text = first_text_run(&output);
13532        let layout = TextSystem::new()
13533            .shape_text_run(&text, &FontRegistry::new())
13534            .expect("switch label should shape");
13535        let line = layout
13536            .lines()
13537            .first()
13538            .expect("switch label should contain one line");
13539        let actual_visual_center =
13540            text.rect.y() + line.baseline + optical_visual_center(layout.measurement());
13541        let track_center = output.frame.viewport.height * 0.5;
13542
13543        assert!((actual_visual_center - track_center).abs() < 0.75);
13544    }
13545
13546    #[test]
13547    fn switch_thumb_uses_foreground_in_dark_theme_variants() {
13548        let light = DefaultTheme::default();
13549        assert_eq!(
13550            Switch::new("Wifi")
13551                .theme(light)
13552                .resolved_visuals(false)
13553                .thumb_color,
13554            light.palette.accent_text
13555        );
13556
13557        for theme in [DefaultTheme::dark(), DefaultTheme::high_contrast()] {
13558            for on in [false, true] {
13559                assert_eq!(
13560                    Switch::new("Wifi")
13561                        .on(on)
13562                        .theme(theme)
13563                        .resolved_visuals(false)
13564                        .thumb_color,
13565                    theme.palette.text
13566                );
13567            }
13568
13569            let fills = solid_fill_colors(&render(Switch::new("Wifi").theme(theme)));
13570            assert!(fills.contains(&theme.palette.text));
13571        }
13572    }
13573
13574    #[test]
13575    fn switch_on_state_can_use_emissive_indicator_role() {
13576        let mut theme = DefaultTheme::default();
13577        theme.hdr.mode = HdrThemeMode::ConstrainedHdr;
13578        theme.hdr.luminance.emissive_indicator = 1.3;
13579        theme.hdr.policy.max_constrained_lift = 1.35;
13580        theme.hdr.color_roles.accent = SemanticColorToken::from_sdr(theme.palette.accent)
13581            .with_hdr(Color::linear_display_p3(1.30, 0.48, 0.32, 1.0));
13582
13583        let visuals = Switch::new("Wifi")
13584            .on(true)
13585            .theme(theme)
13586            .resolved_visuals(false);
13587        let indicator_style = visuals
13588            .indicator_style
13589            .expect("emissive indicator style present");
13590
13591        assert_eq!(visuals.track_color, indicator_style.color);
13592        assert_eq!(
13593            indicator_style.peak_lift,
13594            resolve_luminance_role(&theme.hdr, WidgetLuminanceRole::EmissiveIndicator)
13595        );
13596        assert_eq!(visuals.label_peak_lift, theme.hdr.luminance.reference_white);
13597    }
13598
13599    #[test]
13600    fn switch_label_readability_preserved_when_hdr_mode_disabled() {
13601        let mut theme = DefaultTheme::default();
13602        theme.hdr.mode = HdrThemeMode::Disabled;
13603        theme.hdr.color_roles.accent = SemanticColorToken::from_sdr(theme.palette.accent)
13604            .with_hdr(Color::linear_display_p3(1.34, 0.40, 0.30, 1.0));
13605
13606        let visuals = Switch::new("Wifi")
13607            .on(true)
13608            .theme(theme)
13609            .resolved_visuals(true);
13610
13611        assert_eq!(visuals.label_color, theme.palette.text);
13612        assert_eq!(visuals.label_peak_lift, theme.hdr.luminance.reference_white);
13613        assert!(visuals.indicator_style.is_none());
13614    }
13615
13616    #[test]
13617    fn switch_constrained_hdr_does_not_overshoot_full_hdr_limits() {
13618        let mut constrained = DefaultTheme::default();
13619        constrained.hdr.mode = HdrThemeMode::ConstrainedHdr;
13620        constrained.hdr.luminance.emissive_indicator = 2.5;
13621        constrained.hdr.policy.max_constrained_lift = 1.3;
13622        constrained.hdr.policy.max_emissive_lift = 2.1;
13623        constrained.hdr.color_roles.accent =
13624            SemanticColorToken::from_sdr(constrained.palette.accent)
13625                .with_hdr(Color::linear_display_p3(2.5, 0.48, 0.32, 1.0));
13626
13627        let mut full = constrained;
13628        full.hdr.mode = HdrThemeMode::FullHdr;
13629
13630        let constrained_visuals = Switch::new("Wifi")
13631            .on(true)
13632            .theme(constrained)
13633            .resolved_visuals(false);
13634        let full_visuals = Switch::new("Wifi")
13635            .on(true)
13636            .theme(full)
13637            .resolved_visuals(false);
13638        let constrained_track =
13639            solid_fill_colors(&render(Switch::new("Wifi").on(true).theme(constrained)));
13640        let full_track = solid_fill_colors(&render(Switch::new("Wifi").on(true).theme(full)));
13641
13642        let constrained_peak = constrained_visuals
13643            .indicator_style
13644            .expect("constrained indicator style")
13645            .peak_lift;
13646        let full_peak = full_visuals
13647            .indicator_style
13648            .expect("full indicator style")
13649            .peak_lift;
13650
13651        assert_eq!(constrained_peak, 1.3);
13652        assert_eq!(full_peak, 2.1);
13653        assert!(constrained_peak < full_peak);
13654        assert!(constrained_track.contains(&constrained_visuals.track_color));
13655        assert!(full_track.contains(&full_visuals.track_color));
13656        assert!((constrained_visuals.track_color.red - constrained_peak).abs() < f32::EPSILON);
13657        assert!((full_visuals.track_color.red - full_peak).abs() < f32::EPSILON);
13658    }
13659
13660    #[test]
13661    fn radio_button_label_visual_center_matches_control_center() {
13662        let output = render(RadioButton::new("Option A"));
13663        let text = first_text_run(&output);
13664        let layout = TextSystem::new()
13665            .shape_text_run(&text, &FontRegistry::new())
13666            .expect("radio button label should shape");
13667        let line = layout
13668            .lines()
13669            .first()
13670            .expect("radio button label should contain one line");
13671        let actual_visual_center =
13672            text.rect.y() + line.baseline + optical_visual_center(layout.measurement());
13673        let control_center = output.frame.viewport.height * 0.5;
13674
13675        assert!((actual_visual_center - control_center).abs() < 0.75);
13676    }
13677
13678    #[test]
13679    fn radio_group_first_label_visual_center_matches_row_center() {
13680        let output = render(RadioGroup::new("Choices").options(["Alpha", "Beta"]));
13681        let text = text_run_for(&output, "Alpha");
13682        let layout = TextSystem::new()
13683            .shape_text_run(&text, &FontRegistry::new())
13684            .expect("radio group label should shape");
13685        let line = layout
13686            .lines()
13687            .first()
13688            .expect("radio group label should contain one line");
13689        let actual_visual_center =
13690            text.rect.y() + line.baseline + optical_visual_center(layout.measurement());
13691        let theme = DefaultTheme::default();
13692        let row_center = super::default_form_control_height(&theme) * 0.5;
13693
13694        assert!((actual_visual_center - row_center).abs() < 0.75);
13695    }
13696
13697    #[test]
13698    fn toggle_and_radio_labels_preserve_tall_measurements_and_control_centering() {
13699        let mut theme = DefaultTheme::default();
13700        theme.text.sm.size = 28.0;
13701        theme.text.sm.line_height = 10.0;
13702        theme.sync_derived_fields();
13703        theme.metrics.min_height = 56.0;
13704
13705        let checkbox = render(Checkbox::new("Accept").theme(theme));
13706        assert_tall_body_text_centered(
13707            &checkbox,
13708            "Accept",
13709            theme,
13710            checkbox.frame.viewport.height * 0.5,
13711        );
13712
13713        let switch = render(Switch::new("Wifi").theme(theme));
13714        assert_tall_body_text_centered(&switch, "Wifi", theme, switch.frame.viewport.height * 0.5);
13715
13716        let radio_button = render(RadioButton::new("Option A").theme(theme));
13717        assert_tall_body_text_centered(
13718            &radio_button,
13719            "Option A",
13720            theme,
13721            radio_button.frame.viewport.height * 0.5,
13722        );
13723
13724        let radio_group = render(
13725            RadioGroup::new("Choices")
13726                .theme(theme)
13727                .options(["Alpha", "Beta"]),
13728        );
13729        assert_tall_body_text_centered(
13730            &radio_group,
13731            "Alpha",
13732            theme,
13733            theme.metrics.min_height * 0.5,
13734        );
13735    }
13736
13737    #[test]
13738    fn controls_default_to_native_form_height() {
13739        let theme = DefaultTheme::default();
13740        let expected = super::default_form_control_height(&theme);
13741
13742        macro_rules! assert_default_height {
13743            ($widget:expr, $name:literal) => {{
13744                let height = render($widget).frame.viewport.height;
13745                assert!(
13746                    (height - expected).abs() < 0.01,
13747                    "expected {} height to match native form height {}, got {}",
13748                    $name,
13749                    expected,
13750                    height
13751                );
13752            }};
13753        }
13754
13755        assert_default_height!(Button::new("Go"), "button");
13756        assert_default_height!(Checkbox::new("Subscribe"), "checkbox");
13757        assert_default_height!(Switch::new("Enabled"), "switch");
13758        assert_default_height!(RadioButton::new("Manual"), "radio button");
13759        assert_default_height!(
13760            RadioGroup::new("Choices").options(["Alpha"]),
13761            "single-row radio group"
13762        );
13763        assert_default_height!(Slider::new("Opacity"), "slider");
13764        assert_default_height!(NumberInput::new("Size"), "number input");
13765        assert_default_height!(Select::new("Blend mode").options(["Normal"]), "select");
13766        assert_default_height!(TextInput::new("Name"), "text input");
13767    }
13768
13769    #[test]
13770    fn button_theme_is_public_and_changes_metrics_and_typography() {
13771        let mut theme = DefaultTheme::default();
13772        theme.metrics.button_min_width = 156.0;
13773        theme.metrics.min_height = 52.0;
13774        theme.typography.body_font_size = 16.0;
13775        theme.typography.body_line_height = 24.0;
13776        theme.palette.accent_text = Color::rgba(0.10, 0.12, 0.15, 1.0);
13777
13778        let output = render(Button::primary("Theme").theme(theme));
13779
13780        assert_eq!(output.frame.viewport, Size::new(156.0, 52.0));
13781        let label = first_text_run(&output);
13782        assert_eq!(label.style.font_size, 16.0);
13783        assert_eq!(label.style.line_height, 24.0);
13784        assert_eq!(label.style.color, theme.palette.accent_text);
13785    }
13786
13787    #[test]
13788    fn separator_theme_when_reads_current_theme() {
13789        let mut theme = DefaultTheme::dark();
13790        theme.metrics.separator_thickness = 3.0;
13791
13792        let separator = Separator::vertical().theme_when(move || theme);
13793
13794        assert_eq!(
13795            separator.resolved_theme().colors.scheme,
13796            theme.colors.scheme
13797        );
13798        assert_eq!(separator.resolved_thickness(), 3.0);
13799    }
13800
13801    #[test]
13802    fn label_theme_uses_default_widget_typography() {
13803        let mut theme = DefaultTheme::default();
13804        theme.typography.body_font_size = 15.0;
13805        theme.typography.body_line_height = 22.0;
13806        theme.palette.text = Color::rgba(0.78, 0.82, 0.90, 1.0);
13807
13808        let output = render(Label::new("Body").theme(theme));
13809        let label = first_text_run(&output);
13810
13811        assert_eq!(label.style.font_size, 15.0);
13812        assert_eq!(label.style.line_height, 22.0);
13813        assert_eq!(label.style.color, theme.palette.text);
13814    }
13815
13816    #[test]
13817    fn button_scales_border_width_for_hidpi() -> Result<()> {
13818        let (mut runtime, window_id) = build_runtime(Button::new("HiDPI"));
13819
13820        runtime.handle_event(
13821            window_id,
13822            Event::Window(WindowEvent::ScaleFactorChanged {
13823                scale_factor: 2.0,
13824                raw_dpi: Some(192.0),
13825                suggested_size: None,
13826            }),
13827        )?;
13828
13829        let output = runtime.render(window_id)?;
13830        let stroke = output
13831            .frame
13832            .scene
13833            .commands()
13834            .iter()
13835            .find_map(|command| match command {
13836                SceneCommand::StrokePath { stroke, .. } => Some(*stroke),
13837                _ => None,
13838            })
13839            .expect("button border stroke command present");
13840
13841        assert_eq!(stroke.width, 0.5);
13842        Ok(())
13843    }
13844
13845    #[test]
13846    fn text_input_scales_caret_width_for_hidpi() -> Result<()> {
13847        let (mut runtime, window_id) = build_runtime(TextInput::new("Name").value("Ada"));
13848
13849        runtime.handle_event(
13850            window_id,
13851            Event::Window(WindowEvent::ScaleFactorChanged {
13852                scale_factor: 2.0,
13853                raw_dpi: Some(192.0),
13854                suggested_size: None,
13855            }),
13856        )?;
13857        let _ = runtime.render(window_id)?;
13858        runtime.handle_event(
13859            window_id,
13860            primary_pointer(PointerEventKind::Down, Point::new(20.0, 16.0), true),
13861        )?;
13862
13863        let output = runtime.render(window_id)?;
13864
13865        assert_eq!(
13866            output
13867                .ime_composition_rect
13868                .expect("focused text input caret")
13869                .width(),
13870            1.0
13871        );
13872        Ok(())
13873    }
13874
13875    #[test]
13876    fn switch_toggles_and_reports_switch_semantics() -> Result<()> {
13877        let states = Rc::new(RefCell::new(Vec::new()));
13878        let on_toggle = Rc::clone(&states);
13879        let (mut runtime, window_id) =
13880            build_runtime(Switch::new("Airplane mode").on_toggle(move |checked| {
13881                on_toggle.borrow_mut().push(checked);
13882            }));
13883
13884        let _ = runtime.render(window_id)?;
13885        runtime.handle_event(
13886            window_id,
13887            primary_pointer(PointerEventKind::Down, Point::new(12.0, 12.0), true),
13888        )?;
13889        runtime.handle_event(
13890            window_id,
13891            primary_pointer(PointerEventKind::Up, Point::new(12.0, 12.0), false),
13892        )?;
13893
13894        assert_eq!(states.borrow().as_slice(), &[true]);
13895
13896        let output = runtime.render(window_id)?;
13897        let switch = output
13898            .semantics
13899            .iter()
13900            .find(|node| node.role == SemanticsRole::Switch)
13901            .expect("switch semantics present");
13902        assert_eq!(switch.state.checked, Some(sui_core::ToggleState::Checked));
13903        Ok(())
13904    }
13905
13906    #[test]
13907    fn radio_group_applies_typed_semantic_text_value_through_selection_callback() -> Result<()> {
13908        let changes = Rc::new(RefCell::new(Vec::new()));
13909        let on_change = Rc::clone(&changes);
13910        let (mut runtime, window_id) = build_runtime(
13911            RadioGroup::new("Mode")
13912                .options(["Alpha", "Beta", "Gamma"])
13913                .selected(0)
13914                .on_change(move |index, value| on_change.borrow_mut().push((index, value))),
13915        );
13916        let group_id = runtime
13917            .render(window_id)?
13918            .semantics
13919            .iter()
13920            .find(|node| node.role == SemanticsRole::RadioGroup)
13921            .expect("radio group semantics present")
13922            .id;
13923
13924        assert!(runtime.handle_semantics_action(
13925            window_id,
13926            group_id,
13927            SemanticsActionRequest::SetValue(SemanticsValue::Text("Beta".to_string())),
13928        )?);
13929        assert!(!runtime.handle_semantics_action(
13930            window_id,
13931            group_id,
13932            SemanticsActionRequest::SetValue(SemanticsValue::Text("Missing".to_string())),
13933        )?);
13934        assert_eq!(changes.borrow().as_slice(), &[(1, "Beta".to_string())]);
13935
13936        let group = runtime
13937            .render(window_id)?
13938            .semantics
13939            .into_iter()
13940            .find(|node| node.id == group_id)
13941            .expect("radio group semantics remain present");
13942        assert_eq!(group.value, Some(SemanticsValue::Text("Beta".to_string())));
13943        Ok(())
13944    }
13945
13946    #[test]
13947    fn slider_accepts_keyboard_adjustment_and_reports_range_semantics() -> Result<()> {
13948        let changes = Rc::new(RefCell::new(Vec::new()));
13949        let on_change = Rc::clone(&changes);
13950        let (mut runtime, window_id) = build_runtime(
13951            Slider::new("Opacity")
13952                .range(0.0, 1.0)
13953                .step(0.25)
13954                .value(0.0)
13955                .on_change(move |value| on_change.borrow_mut().push(value)),
13956        );
13957
13958        let _ = runtime.render(window_id)?;
13959        runtime.handle_event(
13960            window_id,
13961            primary_pointer(PointerEventKind::Down, Point::new(12.0, 20.0), true),
13962        )?;
13963        runtime.handle_event(
13964            window_id,
13965            Event::Keyboard(KeyboardEvent::new("ArrowRight", KeyState::Pressed)),
13966        )?;
13967
13968        assert!(
13969            changes
13970                .borrow()
13971                .last()
13972                .is_some_and(|value| (*value - 0.25).abs() < 1e-6)
13973        );
13974
13975        let output = runtime.render(window_id)?;
13976        let slider = output
13977            .semantics
13978            .iter()
13979            .find(|node| node.role == SemanticsRole::Slider)
13980            .expect("slider semantics present");
13981        assert_eq!(
13982            slider.value,
13983            Some(SemanticsValue::Range {
13984                value: 0.25,
13985                min: 0.0,
13986                max: 1.0,
13987            })
13988        );
13989        assert_eq!(slider.numeric_step, Some(0.25));
13990        Ok(())
13991    }
13992
13993    #[test]
13994    fn slider_applies_typed_semantic_numeric_actions_through_step_and_callbacks() -> Result<()> {
13995        let changes = Rc::new(RefCell::new(Vec::new()));
13996        let on_change = Rc::clone(&changes);
13997        let (mut runtime, window_id) = build_runtime(
13998            Slider::new("Opacity")
13999                .range(0.0, 1.0)
14000                .step(0.25)
14001                .value(0.25)
14002                .on_change(move |value| on_change.borrow_mut().push(value)),
14003        );
14004        let slider_id = runtime
14005            .render(window_id)?
14006            .semantics
14007            .iter()
14008            .find(|node| node.role == SemanticsRole::Slider)
14009            .expect("slider semantics present")
14010            .id;
14011
14012        assert!(runtime.handle_semantics_action(
14013            window_id,
14014            slider_id,
14015            SemanticsActionRequest::Increment,
14016        )?);
14017        assert!(runtime.handle_semantics_action(
14018            window_id,
14019            slider_id,
14020            SemanticsActionRequest::SetValue(SemanticsValue::Number(0.88)),
14021        )?);
14022        assert!(runtime.handle_semantics_action(
14023            window_id,
14024            slider_id,
14025            SemanticsActionRequest::Decrement,
14026        )?);
14027        assert!(runtime.handle_semantics_action(
14028            window_id,
14029            slider_id,
14030            SemanticsActionRequest::SetValue(SemanticsValue::Range {
14031                value: 0.24,
14032                min: -100.0,
14033                max: 100.0,
14034            }),
14035        )?);
14036        assert!(!runtime.handle_semantics_action(
14037            window_id,
14038            slider_id,
14039            SemanticsActionRequest::SetValue(SemanticsValue::Text("invalid".to_string())),
14040        )?);
14041
14042        assert_eq!(changes.borrow().as_slice(), &[0.5, 1.0, 0.75, 0.25]);
14043        let slider = runtime
14044            .render(window_id)?
14045            .semantics
14046            .into_iter()
14047            .find(|node| node.id == slider_id)
14048            .expect("slider semantics remain present");
14049        assert_eq!(
14050            slider.value,
14051            Some(SemanticsValue::Range {
14052                value: 0.25,
14053                min: 0.0,
14054                max: 1.0,
14055            })
14056        );
14057        assert_eq!(slider.numeric_step, Some(0.25));
14058        Ok(())
14059    }
14060
14061    #[test]
14062    fn slider_value_when_syncs_external_value() -> Result<()> {
14063        let value = Rc::new(RefCell::new(0.25));
14064        let value_reader = Rc::clone(&value);
14065        let (mut runtime, window_id) = build_runtime(
14066            Slider::new("Opacity")
14067                .range(0.0, 1.0)
14068                .step(0.01)
14069                .value_when(move || *value_reader.borrow()),
14070        );
14071
14072        let output = runtime.render(window_id)?;
14073        let slider = output
14074            .semantics
14075            .iter()
14076            .find(|node| node.role == SemanticsRole::Slider)
14077            .expect("slider semantics present");
14078        assert_eq!(
14079            slider.value,
14080            Some(SemanticsValue::Range {
14081                value: 0.25,
14082                min: 0.0,
14083                max: 1.0,
14084            })
14085        );
14086        assert_eq!(slider.numeric_step, Some(0.01));
14087
14088        *value.borrow_mut() = 0.75;
14089        runtime.handle_event(
14090            window_id,
14091            Event::Window(WindowEvent::Resized(Size::new(200.0, 32.0))),
14092        )?;
14093        let output = runtime.render(window_id)?;
14094        let slider = output
14095            .semantics
14096            .iter()
14097            .find(|node| node.role == SemanticsRole::Slider)
14098            .expect("slider semantics present after external update");
14099        assert_eq!(
14100            slider.value,
14101            Some(SemanticsValue::Range {
14102                value: 0.75,
14103                min: 0.0,
14104                max: 1.0,
14105            })
14106        );
14107        assert_eq!(slider.numeric_step, Some(0.01));
14108        Ok(())
14109    }
14110
14111    #[test]
14112    fn slider_on_change_with_ctx_receives_value() -> Result<()> {
14113        let changes = Rc::new(RefCell::new(Vec::new()));
14114        let on_change = Rc::clone(&changes);
14115        let (mut runtime, window_id) = build_runtime(
14116            SizedBox::new().width(200.0).height(32.0).with_child(
14117                Slider::new("Opacity")
14118                    .range(0.0, 1.0)
14119                    .step(0.01)
14120                    .on_change_with_ctx(move |ctx, value| {
14121                        on_change.borrow_mut().push(value);
14122                        ctx.request_semantics();
14123                    }),
14124            ),
14125        );
14126        let output = runtime.render(window_id)?;
14127        let slider = output
14128            .semantics
14129            .iter()
14130            .find(|node| node.role == SemanticsRole::Slider)
14131            .expect("slider semantics present");
14132        let position = Point::new(
14133            slider.bounds.x() + (slider.bounds.width() * 0.5),
14134            slider.bounds.y() + (slider.bounds.height() * 0.5),
14135        );
14136
14137        runtime.handle_event(
14138            window_id,
14139            primary_pointer(PointerEventKind::Down, position, true),
14140        )?;
14141        runtime.handle_event(
14142            window_id,
14143            primary_pointer(PointerEventKind::Up, position, false),
14144        )?;
14145
14146        assert!(
14147            changes
14148                .borrow()
14149                .last()
14150                .is_some_and(|value| (*value - 0.5).abs() < 1e-6)
14151        );
14152        Ok(())
14153    }
14154
14155    #[test]
14156    fn slider_clears_hover_state_after_pointer_moves_off_control() -> Result<()> {
14157        let (mut runtime, window_id) = build_runtime(crate::Padding::all(
14158            12.0,
14159            Slider::new("Opacity").range(0.0, 1.0).step(0.25).value(0.5),
14160        ));
14161
14162        let _ = runtime.render(window_id)?;
14163        runtime.handle_event(
14164            window_id,
14165            primary_pointer(PointerEventKind::Move, Point::new(20.0, 20.0), false),
14166        )?;
14167        runtime.handle_event(
14168            window_id,
14169            primary_pointer(PointerEventKind::Move, Point::new(4.0, 4.0), false),
14170        )?;
14171
14172        let output = runtime.render(window_id)?;
14173        let slider = output
14174            .semantics
14175            .iter()
14176            .find(|node| node.role == SemanticsRole::Slider)
14177            .expect("slider semantics present");
14178        assert!(!slider.state.hovered);
14179        Ok(())
14180    }
14181
14182    #[test]
14183    fn number_input_nudges_value_and_exposes_numeric_semantics() -> Result<()> {
14184        let changes = Rc::new(RefCell::new(Vec::new()));
14185        let on_change = Rc::clone(&changes);
14186        let (mut runtime, window_id) = build_runtime(
14187            NumberInput::new("Count")
14188                .range(0.0, 10.0)
14189                .step(2.0)
14190                .value(4.0)
14191                .on_change(move |value| on_change.borrow_mut().push(value)),
14192        );
14193
14194        let _ = runtime.render(window_id)?;
14195        runtime.handle_event(
14196            window_id,
14197            primary_pointer(PointerEventKind::Down, Point::new(20.0, 16.0), true),
14198        )?;
14199        runtime.handle_event(
14200            window_id,
14201            Event::Keyboard(KeyboardEvent::new("ArrowUp", KeyState::Pressed)),
14202        )?;
14203
14204        assert_eq!(changes.borrow().as_slice(), &[6.0]);
14205
14206        let output = runtime.render(window_id)?;
14207        let input = output
14208            .semantics
14209            .iter()
14210            .find(|node| node.role == SemanticsRole::SpinBox)
14211            .expect("spinbox semantics present");
14212        assert_eq!(
14213            input.value,
14214            Some(SemanticsValue::Range {
14215                value: 6.0,
14216                min: 0.0,
14217                max: 10.0,
14218            })
14219        );
14220        assert_eq!(input.numeric_step, Some(2.0));
14221        Ok(())
14222    }
14223
14224    #[test]
14225    fn number_input_applies_typed_semantic_numeric_actions_through_step_and_callbacks() -> Result<()>
14226    {
14227        let changes = Rc::new(RefCell::new(Vec::new()));
14228        let on_change = Rc::clone(&changes);
14229        let (mut runtime, window_id) = build_runtime(
14230            NumberInput::new("Count")
14231                .range(0.0, 10.0)
14232                .step(2.0)
14233                .precision(0)
14234                .value(4.0)
14235                .on_change(move |value| on_change.borrow_mut().push(value)),
14236        );
14237        let input_id = runtime
14238            .render(window_id)?
14239            .semantics
14240            .iter()
14241            .find(|node| node.role == SemanticsRole::SpinBox)
14242            .expect("number input semantics present")
14243            .id;
14244
14245        assert!(runtime.handle_semantics_action(
14246            window_id,
14247            input_id,
14248            SemanticsActionRequest::Increment,
14249        )?);
14250        assert!(runtime.handle_semantics_action(
14251            window_id,
14252            input_id,
14253            SemanticsActionRequest::SetValue(SemanticsValue::Range {
14254                value: 9.0,
14255                min: -100.0,
14256                max: 100.0,
14257            }),
14258        )?);
14259        assert!(runtime.handle_semantics_action(
14260            window_id,
14261            input_id,
14262            SemanticsActionRequest::Decrement,
14263        )?);
14264        assert!(runtime.handle_semantics_action(
14265            window_id,
14266            input_id,
14267            SemanticsActionRequest::SetValue(SemanticsValue::Number(3.1)),
14268        )?);
14269
14270        assert_eq!(changes.borrow().as_slice(), &[6.0, 10.0, 8.0, 4.0]);
14271        let input = runtime
14272            .render(window_id)?
14273            .semantics
14274            .into_iter()
14275            .find(|node| node.id == input_id)
14276            .expect("number input semantics remain present");
14277        assert_eq!(
14278            input.value,
14279            Some(SemanticsValue::Range {
14280                value: 4.0,
14281                min: 0.0,
14282                max: 10.0,
14283            })
14284        );
14285        assert_eq!(input.numeric_step, Some(2.0));
14286        Ok(())
14287    }
14288
14289    #[test]
14290    fn number_input_preserves_raw_text_while_typing() -> Result<()> {
14291        let changes = Rc::new(RefCell::new(Vec::new()));
14292        let on_change = Rc::clone(&changes);
14293        let (mut runtime, window_id) = build_runtime(
14294            NumberInput::new("Count")
14295                .range(0.0, 10.0)
14296                .precision(2)
14297                .value(0.0)
14298                .on_change(move |value| on_change.borrow_mut().push(value)),
14299        );
14300
14301        let _ = runtime.render(window_id)?;
14302        runtime.handle_event(
14303            window_id,
14304            primary_pointer(PointerEventKind::Down, Point::new(20.0, 16.0), true),
14305        )?;
14306        runtime.handle_event(
14307            window_id,
14308            Event::Keyboard(KeyboardEvent::new("Backspace", KeyState::Pressed)),
14309        )?;
14310        runtime.handle_event(
14311            window_id,
14312            Event::Keyboard(KeyboardEvent::new("2", KeyState::Pressed)),
14313        )?;
14314        runtime.handle_event(
14315            window_id,
14316            Event::Keyboard(KeyboardEvent::new(".", KeyState::Pressed)),
14317        )?;
14318
14319        assert_eq!(changes.borrow().as_slice(), &[2.0]);
14320
14321        let output = runtime.render(window_id)?;
14322        let run = text_run_for(&output, "2.");
14323        assert_eq!(run.text, "2.");
14324
14325        let input = output
14326            .semantics
14327            .iter()
14328            .find(|node| node.role == SemanticsRole::SpinBox)
14329            .expect("spinbox semantics present");
14330        assert_eq!(
14331            input.value,
14332            Some(SemanticsValue::Range {
14333                value: 2.0,
14334                min: 0.0,
14335                max: 10.0,
14336            })
14337        );
14338        assert_eq!(input.numeric_step, Some(1.0));
14339        Ok(())
14340    }
14341
14342    #[test]
14343    fn number_input_clears_hover_state_after_pointer_moves_off_control() -> Result<()> {
14344        let (mut runtime, window_id) = build_runtime(crate::Padding::all(
14345            12.0,
14346            NumberInput::new("Count")
14347                .range(0.0, 10.0)
14348                .step(1.0)
14349                .value(4.0),
14350        ));
14351
14352        let _ = runtime.render(window_id)?;
14353        runtime.handle_event(
14354            window_id,
14355            primary_pointer(PointerEventKind::Move, Point::new(20.0, 20.0), false),
14356        )?;
14357        runtime.handle_event(
14358            window_id,
14359            primary_pointer(PointerEventKind::Move, Point::new(4.0, 4.0), false),
14360        )?;
14361
14362        let output = runtime.render(window_id)?;
14363        let input = output
14364            .semantics
14365            .iter()
14366            .find(|node| node.role == SemanticsRole::SpinBox)
14367            .expect("spinbox semantics present");
14368        assert!(!input.state.hovered);
14369        Ok(())
14370    }
14371
14372    #[test]
14373    fn number_input_retains_stepper_ink_when_feathering_is_enabled() {
14374        let root = crate::Padding::all(
14375            12.0,
14376            NumberInput::new("Count")
14377                .range(0.0, 20.0)
14378                .step(1.0)
14379                .value(12.0),
14380        );
14381
14382        let (feathered_output, feathered_image) = render_rgba(root, true);
14383        let number_input_bounds = feathered_output
14384            .semantics
14385            .iter()
14386            .find(|node| node.role == SemanticsRole::SpinBox)
14387            .map(|node| node.bounds)
14388            .expect("number input semantics present");
14389
14390        let (_, hard_image) = render_rgba(
14391            crate::Padding::all(
14392                12.0,
14393                NumberInput::new("Count")
14394                    .range(0.0, 20.0)
14395                    .step(1.0)
14396                    .value(12.0),
14397            ),
14398            false,
14399        );
14400
14401        let stepper_crop = Rect::new(
14402            number_input_bounds.max_x() - 32.0,
14403            number_input_bounds.y(),
14404            32.0,
14405            number_input_bounds.height(),
14406        );
14407        let feathered_ink = dark_pixel_count(&feathered_image, stepper_crop, 224);
14408        let hard_ink = dark_pixel_count(&hard_image, stepper_crop, 224);
14409
14410        assert!(
14411            feathered_ink * 3 >= hard_ink * 2,
14412            "feathered number-input stepper lost too much dark ink (feathered={feathered_ink}, hard={hard_ink}, crop={stepper_crop:?})"
14413        );
14414    }
14415
14416    #[test]
14417    fn number_input_value_text_visual_center_matches_control_center() {
14418        let output = render(NumberInput::new("Count").value(12.0));
14419        let text = text_run_for(&output, "12");
14420        let layout = text_run_layout(&text);
14421        let line = layout
14422            .lines()
14423            .first()
14424            .expect("number input text should contain one line");
14425        let actual_visual_center =
14426            text.rect.y() + line.baseline + optical_visual_center(layout.measurement());
14427        let control_center = output.frame.viewport.height * 0.5;
14428
14429        assert!((actual_visual_center - control_center).abs() < 0.75);
14430    }
14431
14432    #[test]
14433    fn number_input_value_uses_tabular_figures_and_end_alignment() {
14434        let theme = DefaultTheme::default();
14435        let output = render(
14436            SizedBox::new()
14437                .width(180.0)
14438                .with_child(NumberInput::new("Count").precision(0).value(12.0)),
14439        );
14440        let text = text_run_for(&output, "12");
14441        let spinbox = output
14442            .semantics
14443            .iter()
14444            .find(|node| node.role == SemanticsRole::SpinBox)
14445            .expect("number input semantics present");
14446        let content_right = spinbox.bounds.max_x()
14447            - theme.metrics.number_input_stepper_width
14448            - theme.metrics.text_input_padding.right;
14449
14450        assert!(
14451            text.style
14452                .features
14453                .iter()
14454                .any(|feature| feature.tag == FontFeature::TABULAR_FIGURES && feature.value == 1)
14455        );
14456        assert!((text.rect.max_x() - content_right).abs() < 1.0);
14457    }
14458
14459    #[test]
14460    fn number_input_value_preserves_tall_measurement_and_end_alignment() {
14461        let mut theme = DefaultTheme::default();
14462        theme.typography.body_font_size = 28.0;
14463        theme.typography.body_line_height = 12.0;
14464        theme.metrics.min_height = 64.0;
14465        let metrics = theme.metrics;
14466        let output = render_isolated(
14467            SizedBox::new().width(220.0).height(64.0).with_child(
14468                NumberInput::new("Count")
14469                    .theme(theme)
14470                    .precision(0)
14471                    .value(12.0),
14472            ),
14473        );
14474        let text = text_run_for(&output, "12");
14475        let layout = text_run_layout(&text);
14476        let line = layout
14477            .lines()
14478            .first()
14479            .expect("number input text should contain one line");
14480        let actual_visual_center =
14481            text.rect.y() + line.baseline + optical_visual_center(layout.measurement());
14482        let spinbox = output
14483            .semantics
14484            .iter()
14485            .find(|node| node.role == SemanticsRole::SpinBox)
14486            .expect("number input semantics present");
14487        let content_right = spinbox.bounds.max_x()
14488            - metrics.number_input_stepper_width
14489            - metrics.text_input_padding.right;
14490
14491        assert_eq!(text.style.font_size, 28.0);
14492        assert_eq!(text.style.line_height, 12.0);
14493        assert!(text.rect.height() >= layout.measurement().height - 0.01);
14494        assert!(text.rect.height() > text.style.line_height);
14495        assert!((text.rect.max_x() - content_right).abs() < 1.0);
14496        let control_center = spinbox.bounds.y() + (spinbox.bounds.height() * 0.5);
14497        assert!((actual_visual_center - control_center).abs() < 0.75);
14498    }
14499
14500    #[test]
14501    fn number_input_value_when_syncs_unfocused_external_value() {
14502        let value = Rc::new(RefCell::new(12.0));
14503        let value_reader = Rc::clone(&value);
14504        let (mut runtime, window_id) = build_runtime(
14505            NumberInput::new("Count")
14506                .range(0.0, 96.0)
14507                .precision(0)
14508                .value_when(move || *value_reader.borrow()),
14509        );
14510
14511        let output = runtime.render(window_id).unwrap();
14512        let count = output
14513            .semantics
14514            .iter()
14515            .find(|node| {
14516                node.role == SemanticsRole::SpinBox && node.name.as_deref() == Some("Count")
14517            })
14518            .expect("number input semantics should exist");
14519        assert_eq!(
14520            count.value,
14521            Some(SemanticsValue::Range {
14522                value: 12.0,
14523                min: 0.0,
14524                max: 96.0,
14525            })
14526        );
14527        assert_eq!(count.numeric_step, Some(1.0));
14528
14529        *value.borrow_mut() = 36.0;
14530        let position = Point::new(
14531            count.bounds.x() + (count.bounds.width() * 0.5),
14532            count.bounds.y() + (count.bounds.height() * 0.5),
14533        );
14534        let mut move_event = PointerEvent::new(PointerEventKind::Move, position);
14535        move_event.pointer_id = 1;
14536        runtime
14537            .handle_event(window_id, Event::Pointer(move_event))
14538            .unwrap();
14539        let output = runtime.render(window_id).unwrap();
14540        let count = output
14541            .semantics
14542            .iter()
14543            .find(|node| {
14544                node.role == SemanticsRole::SpinBox && node.name.as_deref() == Some("Count")
14545            })
14546            .expect("number input semantics should still exist");
14547        assert_eq!(
14548            count.value,
14549            Some(SemanticsValue::Range {
14550                value: 36.0,
14551                min: 0.0,
14552                max: 96.0,
14553            })
14554        );
14555        assert_eq!(count.numeric_step, Some(1.0));
14556        text_run_for(&output, "36");
14557    }
14558
14559    #[test]
14560    fn text_area_supports_multiline_input() -> Result<()> {
14561        let changes = Rc::new(RefCell::new(Vec::new()));
14562        let on_change = Rc::clone(&changes);
14563        let (mut runtime, window_id) = build_runtime(
14564            TextArea::new("Notes").on_change(move |value| on_change.borrow_mut().push(value)),
14565        );
14566
14567        let _ = runtime.render(window_id)?;
14568        runtime.handle_event(
14569            window_id,
14570            primary_pointer(PointerEventKind::Down, Point::new(18.0, 18.0), true),
14571        )?;
14572        runtime.handle_event(
14573            window_id,
14574            Event::Ime(ImeEvent::CompositionCommit {
14575                text: "Line 1".to_string(),
14576            }),
14577        )?;
14578        runtime.handle_event(
14579            window_id,
14580            Event::Keyboard(KeyboardEvent::new("Enter", KeyState::Pressed)),
14581        )?;
14582        runtime.handle_event(
14583            window_id,
14584            Event::Ime(ImeEvent::CompositionCommit {
14585                text: "Line 2".to_string(),
14586            }),
14587        )?;
14588
14589        assert_eq!(
14590            changes.borrow().last().map(String::as_str),
14591            Some("Line 1\nLine 2")
14592        );
14593
14594        let output = runtime.render(window_id)?;
14595        let input = output
14596            .semantics
14597            .iter()
14598            .find(|node| node.role == SemanticsRole::TextInput)
14599            .expect("text area semantics present");
14600        assert_eq!(
14601            input.value,
14602            Some(SemanticsValue::Text("Line 1\nLine 2".to_string()))
14603        );
14604        Ok(())
14605    }
14606
14607    #[test]
14608    fn text_inputs_apply_typed_semantic_value_selection_and_edit_actions() -> Result<()> {
14609        let input_changes = Rc::new(RefCell::new(Vec::new()));
14610        let on_input_change = Rc::clone(&input_changes);
14611        let (mut input_runtime, input_window_id) = build_runtime(
14612            TextInput::new("Name")
14613                .value("alpha")
14614                .on_change(move |value| on_input_change.borrow_mut().push(value)),
14615        );
14616        let input_id = input_runtime
14617            .render(input_window_id)?
14618            .semantics
14619            .iter()
14620            .find(|node| node.role == SemanticsRole::TextInput)
14621            .expect("text input semantics present")
14622            .id;
14623
14624        assert!(input_runtime.handle_semantics_action(
14625            input_window_id,
14626            input_id,
14627            SemanticsActionRequest::SetSelection(SemanticsTextRange::new(0, 5)),
14628        )?);
14629        assert!(input_runtime.handle_semantics_action(
14630            input_window_id,
14631            input_id,
14632            SemanticsActionRequest::InsertText("Ada\nLovelace".to_string()),
14633        )?);
14634        let input = input_runtime
14635            .render(input_window_id)?
14636            .semantics
14637            .into_iter()
14638            .find(|node| node.id == input_id)
14639            .expect("text input semantics remain present");
14640        assert_eq!(
14641            input.value,
14642            Some(SemanticsValue::Text("AdaLovelace".to_string()))
14643        );
14644        assert_eq!(
14645            input_changes.borrow().as_slice(),
14646            &["AdaLovelace".to_string()]
14647        );
14648
14649        let area_changes = Rc::new(RefCell::new(Vec::new()));
14650        let on_area_change = Rc::clone(&area_changes);
14651        let (mut area_runtime, area_window_id) = build_runtime(
14652            TextArea::new("Notes")
14653                .value("old")
14654                .on_change(move |value| on_area_change.borrow_mut().push(value)),
14655        );
14656        let area_id = area_runtime
14657            .render(area_window_id)?
14658            .semantics
14659            .iter()
14660            .find(|node| node.role == SemanticsRole::TextInput)
14661            .expect("text area semantics present")
14662            .id;
14663        assert!(area_runtime.handle_semantics_action(
14664            area_window_id,
14665            area_id,
14666            SemanticsActionRequest::SetValue(SemanticsValue::Text("Line 1\nLine 2".to_string())),
14667        )?);
14668        let area = area_runtime
14669            .render(area_window_id)?
14670            .semantics
14671            .into_iter()
14672            .find(|node| node.id == area_id)
14673            .expect("text area semantics remain present");
14674        assert_eq!(
14675            area.value,
14676            Some(SemanticsValue::Text("Line 1\nLine 2".to_string()))
14677        );
14678        assert_eq!(
14679            area_changes.borrow().as_slice(),
14680            &["Line 1\nLine 2".to_string()]
14681        );
14682        Ok(())
14683    }
14684
14685    #[test]
14686    fn text_area_accepts_printable_key_without_text_payload() -> Result<()> {
14687        let changes = Rc::new(RefCell::new(Vec::new()));
14688        let on_change = Rc::clone(&changes);
14689        let (mut runtime, window_id) = build_runtime(
14690            TextArea::new("Notes").on_change(move |value| on_change.borrow_mut().push(value)),
14691        );
14692
14693        let _ = runtime.render(window_id)?;
14694        runtime.handle_event(
14695            window_id,
14696            primary_pointer(PointerEventKind::Down, Point::new(18.0, 18.0), true),
14697        )?;
14698        runtime.handle_event(window_id, key_without_text("h"))?;
14699
14700        assert_eq!(changes.borrow().last().map(String::as_str), Some("h"));
14701        let output = runtime.render(window_id)?;
14702        let input = output
14703            .semantics
14704            .iter()
14705            .find(|node| node.role == SemanticsRole::TextInput)
14706            .expect("text area semantics present");
14707        assert_eq!(input.value, Some(SemanticsValue::Text("h".to_string())));
14708        Ok(())
14709    }
14710
14711    #[test]
14712    fn text_area_on_change_with_ctx_receives_text() -> Result<()> {
14713        let changes = Rc::new(RefCell::new(Vec::new()));
14714        let on_change = Rc::clone(&changes);
14715        let (mut runtime, window_id) = build_runtime(
14716            TextArea::new("Notes")
14717                .on_change_with_ctx(move |_, value| on_change.borrow_mut().push(value)),
14718        );
14719
14720        let _ = runtime.render(window_id)?;
14721        runtime.handle_event(
14722            window_id,
14723            primary_pointer(PointerEventKind::Down, Point::new(18.0, 18.0), true),
14724        )?;
14725        runtime.handle_event(
14726            window_id,
14727            Event::Ime(ImeEvent::CompositionCommit {
14728                text: "Line 1".to_string(),
14729            }),
14730        )?;
14731        runtime.handle_event(
14732            window_id,
14733            Event::Keyboard(KeyboardEvent::new("Enter", KeyState::Pressed)),
14734        )?;
14735
14736        assert_eq!(
14737            changes.borrow().as_slice(),
14738            &["Line 1".to_string(), "Line 1\n".to_string()]
14739        );
14740        Ok(())
14741    }
14742
14743    #[test]
14744    fn text_area_on_submit_fires_on_plain_enter_and_shift_enter_inserts_newline() -> Result<()> {
14745        let submits = Rc::new(RefCell::new(Vec::new()));
14746        let on_submit = Rc::clone(&submits);
14747        let (mut runtime, window_id) = build_runtime(
14748            TextArea::new("Composer")
14749                .value("hello")
14750                .on_submit(move |text| on_submit.borrow_mut().push(text.to_string())),
14751        );
14752
14753        let _ = runtime.render(window_id)?;
14754        // Focus the composer.
14755        runtime.handle_event(
14756            window_id,
14757            primary_pointer(PointerEventKind::Down, Point::new(18.0, 18.0), true),
14758        )?;
14759
14760        // Shift+Enter inserts a newline rather than submitting.
14761        let mut shift_enter = KeyboardEvent::new("Enter", KeyState::Pressed);
14762        shift_enter.modifiers.shift = true;
14763        runtime.handle_event(window_id, Event::Keyboard(shift_enter))?;
14764        assert!(
14765            submits.borrow().is_empty(),
14766            "Shift+Enter must not submit; it inserts a newline"
14767        );
14768
14769        // The Shift+Enter inserted exactly one newline into "hello" (the caret position depends on
14770        // the click hit-test, so assert on the newline count, not its placement).
14771        let after_shift = {
14772            let output = runtime.render(window_id)?;
14773            let input = output
14774                .semantics
14775                .iter()
14776                .find(|node| node.role == SemanticsRole::TextInput)
14777                .expect("text area semantics present");
14778            match input.value.clone() {
14779                Some(SemanticsValue::Text(text)) => text,
14780                other => panic!("unexpected semantics value: {other:?}"),
14781            }
14782        };
14783        assert_eq!(
14784            after_shift.matches('\n').count(),
14785            1,
14786            "Shift+Enter inserts exactly one newline"
14787        );
14788
14789        // A plain Enter fires on_submit once with the current text (and does NOT insert another
14790        // newline — it is consumed).
14791        runtime.handle_event(
14792            window_id,
14793            Event::Keyboard(KeyboardEvent::new("Enter", KeyState::Pressed)),
14794        )?;
14795        assert_eq!(
14796            submits.borrow().as_slice(),
14797            std::slice::from_ref(&after_shift),
14798            "plain Enter submits the current text exactly once"
14799        );
14800
14801        // The submit consumed the Enter, so the value is unchanged (no extra newline).
14802        let output = runtime.render(window_id)?;
14803        let input = output
14804            .semantics
14805            .iter()
14806            .find(|node| node.role == SemanticsRole::TextInput)
14807            .expect("text area semantics present");
14808        assert_eq!(
14809            input.value,
14810            Some(SemanticsValue::Text(after_shift)),
14811            "plain Enter does not append a second newline"
14812        );
14813        Ok(())
14814    }
14815
14816    #[test]
14817    fn text_area_without_on_submit_inserts_newline_on_enter() -> Result<()> {
14818        let (mut runtime, window_id) = build_runtime(TextArea::new("Notes").value("a"));
14819        let _ = runtime.render(window_id)?;
14820        runtime.handle_event(
14821            window_id,
14822            primary_pointer(PointerEventKind::Down, Point::new(18.0, 18.0), true),
14823        )?;
14824        runtime.handle_event(
14825            window_id,
14826            Event::Keyboard(KeyboardEvent::new("Enter", KeyState::Pressed)),
14827        )?;
14828        let output = runtime.render(window_id)?;
14829        let input = output
14830            .semantics
14831            .iter()
14832            .find(|node| node.role == SemanticsRole::TextInput)
14833            .expect("text area semantics present");
14834        assert_eq!(
14835            input.value,
14836            Some(SemanticsValue::Text("a\n".to_string())),
14837            "with no on_submit, Enter inserts a newline (backward-compatible)"
14838        );
14839        Ok(())
14840    }
14841
14842    #[test]
14843    fn text_area_uses_shared_editor_commands_and_semantics() -> Result<()> {
14844        let changes = Rc::new(RefCell::new(Vec::new()));
14845        let on_change = Rc::clone(&changes);
14846        let (mut runtime, window_id) = build_runtime(
14847            TextArea::new("Notes")
14848                .value("alpha\nbeta")
14849                .on_change(move |value| on_change.borrow_mut().push(value)),
14850        );
14851
14852        let _ = runtime.render(window_id)?;
14853        runtime.handle_event(
14854            window_id,
14855            primary_pointer(PointerEventKind::Down, Point::new(18.0, 18.0), true),
14856        )?;
14857        runtime.handle_event(window_id, command_key("a"))?;
14858        runtime.handle_event(
14859            window_id,
14860            Event::Ime(ImeEvent::CompositionCommit {
14861                text: "gamma".to_string(),
14862            }),
14863        )?;
14864        runtime.handle_event(window_id, command_key("z"))?;
14865        runtime.handle_event(window_id, command_key("y"))?;
14866
14867        let output = runtime.render(window_id)?;
14868        let input = output
14869            .semantics
14870            .iter()
14871            .find(|node| node.role == SemanticsRole::TextInput)
14872            .expect("text area semantics present");
14873        assert_eq!(input.value, Some(SemanticsValue::Text("gamma".to_string())));
14874        let editable = input
14875            .editable_text
14876            .as_ref()
14877            .expect("text area should expose editable semantics");
14878        assert!(editable.multiline);
14879        assert_eq!(editable.caret_offset, "gamma".len());
14880        assert_eq!(
14881            editable.selection,
14882            SemanticsTextRange::new("gamma".len(), "gamma".len())
14883        );
14884        assert_eq!(changes.borrow().last().map(String::as_str), Some("gamma"));
14885        Ok(())
14886    }
14887
14888    #[test]
14889    fn select_can_choose_option_from_keyboard() -> Result<()> {
14890        let changes = Rc::new(RefCell::new(Vec::new()));
14891        let on_change = Rc::clone(&changes);
14892        let (mut runtime, window_id) = build_runtime(
14893            Select::new("Mode")
14894                .placeholder("Choose mode")
14895                .options(["Draft", "Final", "Review"])
14896                .on_change(move |_, value| on_change.borrow_mut().push(value)),
14897        );
14898
14899        let _ = runtime.render(window_id)?;
14900        runtime.handle_event(
14901            window_id,
14902            primary_pointer(PointerEventKind::Down, Point::new(20.0, 20.0), true),
14903        )?;
14904        runtime.handle_event(
14905            window_id,
14906            primary_pointer(PointerEventKind::Up, Point::new(20.0, 20.0), false),
14907        )?;
14908        runtime.handle_event(
14909            window_id,
14910            Event::Keyboard(KeyboardEvent::new("ArrowDown", KeyState::Pressed)),
14911        )?;
14912        runtime.handle_event(
14913            window_id,
14914            Event::Keyboard(KeyboardEvent::new("Enter", KeyState::Pressed)),
14915        )?;
14916
14917        assert_eq!(changes.borrow().as_slice(), &["Final".to_string()]);
14918
14919        let output = runtime.render(window_id)?;
14920        let select = output
14921            .semantics
14922            .iter()
14923            .find(|node| node.role == SemanticsRole::ComboBox)
14924            .expect("select semantics present");
14925        assert_eq!(
14926            select.value,
14927            Some(SemanticsValue::Text("Final".to_string()))
14928        );
14929        Ok(())
14930    }
14931
14932    #[test]
14933    fn select_selected_when_reads_external_selection() -> Result<()> {
14934        let selected = Rc::new(RefCell::new(Some(1usize)));
14935        let selected_reader = Rc::clone(&selected);
14936        let (mut runtime, window_id) = build_runtime(
14937            Select::new("Mode")
14938                .placeholder("Choose mode")
14939                .options(["Draft", "Final", "Review"])
14940                .selected_when(move || *selected_reader.borrow()),
14941        );
14942
14943        let output = runtime.render(window_id)?;
14944        let select = output
14945            .semantics
14946            .iter()
14947            .find(|node| node.role == SemanticsRole::ComboBox)
14948            .expect("select semantics present");
14949        assert_eq!(
14950            select.value,
14951            Some(SemanticsValue::Text("Final".to_string()))
14952        );
14953
14954        *selected.borrow_mut() = Some(2);
14955        runtime.handle_event(
14956            window_id,
14957            Event::Window(WindowEvent::Resized(Size::new(320.0, 80.0))),
14958        )?;
14959        let output = runtime.render(window_id)?;
14960        let select = output
14961            .semantics
14962            .iter()
14963            .find(|node| node.role == SemanticsRole::ComboBox)
14964            .expect("select semantics present after external selection changes");
14965        assert_eq!(
14966            select.value,
14967            Some(SemanticsValue::Text("Review".to_string()))
14968        );
14969
14970        *selected.borrow_mut() = None;
14971        runtime.handle_event(
14972            window_id,
14973            Event::Window(WindowEvent::Resized(Size::new(320.0, 80.0))),
14974        )?;
14975        let output = runtime.render(window_id)?;
14976        let select = output
14977            .semantics
14978            .iter()
14979            .find(|node| node.role == SemanticsRole::ComboBox)
14980            .expect("select semantics present after external selection clears");
14981        assert_eq!(
14982            select.value,
14983            Some(SemanticsValue::Text("Choose mode".to_string()))
14984        );
14985        Ok(())
14986    }
14987
14988    #[test]
14989    fn radio_group_selected_when_reads_external_selection() -> Result<()> {
14990        let selected = Rc::new(RefCell::new(Some(1usize)));
14991        let selected_reader = Rc::clone(&selected);
14992        let (mut runtime, window_id) = build_runtime(
14993            RadioGroup::new("Mode")
14994                .options(["Manual", "Automatic", "Scheduled"])
14995                .selected_when(move || *selected_reader.borrow()),
14996        );
14997
14998        let output = runtime.render(window_id)?;
14999        let group = output
15000            .semantics
15001            .iter()
15002            .find(|node| node.role == SemanticsRole::RadioGroup)
15003            .expect("radio group semantics present");
15004        assert_eq!(
15005            group.value,
15006            Some(SemanticsValue::Text("Automatic".to_string()))
15007        );
15008
15009        *selected.borrow_mut() = Some(2);
15010        runtime.handle_event(
15011            window_id,
15012            Event::Window(WindowEvent::Resized(Size::new(320.0, 120.0))),
15013        )?;
15014        let output = runtime.render(window_id)?;
15015        let group = output
15016            .semantics
15017            .iter()
15018            .find(|node| node.role == SemanticsRole::RadioGroup)
15019            .expect("radio group semantics present after external selection changes");
15020        assert_eq!(
15021            group.value,
15022            Some(SemanticsValue::Text("Scheduled".to_string()))
15023        );
15024
15025        *selected.borrow_mut() = None;
15026        runtime.handle_event(
15027            window_id,
15028            Event::Window(WindowEvent::Resized(Size::new(320.0, 120.0))),
15029        )?;
15030        let output = runtime.render(window_id)?;
15031        let group = output
15032            .semantics
15033            .iter()
15034            .find(|node| node.role == SemanticsRole::RadioGroup)
15035            .expect("radio group semantics present after external selection clears");
15036        assert_eq!(group.value, None);
15037        Ok(())
15038    }
15039
15040    #[test]
15041    fn select_clears_hover_state_after_pointer_moves_off_control() -> Result<()> {
15042        let (mut runtime, window_id) = build_runtime(crate::Padding::all(
15043            12.0,
15044            Select::new("Mode")
15045                .placeholder("Choose mode")
15046                .options(["Draft", "Final", "Review"]),
15047        ));
15048
15049        let _ = runtime.render(window_id)?;
15050        runtime.handle_event(
15051            window_id,
15052            primary_pointer(PointerEventKind::Move, Point::new(20.0, 20.0), false),
15053        )?;
15054        runtime.handle_event(
15055            window_id,
15056            primary_pointer(PointerEventKind::Move, Point::new(4.0, 4.0), false),
15057        )?;
15058
15059        let output = runtime.render(window_id)?;
15060        let select = output
15061            .semantics
15062            .iter()
15063            .find(|node| node.role == SemanticsRole::ComboBox)
15064            .expect("select semantics present");
15065        assert!(!select.state.hovered);
15066        Ok(())
15067    }
15068
15069    #[test]
15070    fn expanded_select_menu_uses_overlay_surface_layer_metadata() -> Result<()> {
15071        let (mut runtime, window_id) = build_runtime(crate::Padding::all(
15072            12.0,
15073            Select::new("Mode")
15074                .placeholder("Choose mode")
15075                .options(["Draft", "Final", "Review"]),
15076        ));
15077
15078        let _ = runtime.render(window_id)?;
15079        runtime.handle_event(
15080            window_id,
15081            primary_pointer(PointerEventKind::Down, Point::new(20.0, 20.0), true),
15082        )?;
15083        runtime.handle_event(
15084            window_id,
15085            primary_pointer(PointerEventKind::Up, Point::new(20.0, 20.0), false),
15086        )?;
15087
15088        let output = runtime.render(window_id)?;
15089        let select = output
15090            .semantics
15091            .iter()
15092            .find(|node| node.role == SemanticsRole::ComboBox)
15093            .expect("select semantics present");
15094        let descriptor =
15095            overlay_layer_descriptor(&output).expect("select menu overlay layer present");
15096
15097        assert_eq!(select.state.expanded, Some(true));
15098        assert_eq!(descriptor.composition_mode, LayerCompositionMode::Overlay);
15099        assert!(
15100            layer_descriptor_for(&output, select.id).is_none(),
15101            "the combobox trigger should not own the floating menu layer"
15102        );
15103        Ok(())
15104    }
15105
15106    #[test]
15107    fn expanded_select_menu_entrance_uses_theme_motion_layer_properties() -> Result<()> {
15108        let theme = slow_normal_motion_theme();
15109        let duration = theme.motion.entrance_duration();
15110        let (mut runtime, window_id) = build_runtime(crate::Padding::all(
15111            12.0,
15112            Select::new("Mode")
15113                .theme(theme)
15114                .placeholder("Choose mode")
15115                .options(["Draft", "Final", "Review"]),
15116        ));
15117
15118        let _ = runtime.render(window_id)?;
15119        runtime.handle_event(
15120            window_id,
15121            primary_pointer(PointerEventKind::Down, Point::new(20.0, 20.0), true),
15122        )?;
15123        runtime.handle_event(
15124            window_id,
15125            primary_pointer(PointerEventKind::Up, Point::new(20.0, 20.0), false),
15126        )?;
15127
15128        let start = runtime.render(window_id)?;
15129        let start_descriptor =
15130            overlay_layer_descriptor(&start).expect("select menu overlay layer present");
15131        let menu_owner = overlay_layer_owner(&start).expect("select menu overlay owner present");
15132        assert_eq!(start_descriptor.properties.opacity, 0.0);
15133        assert!(start_descriptor.properties.translation.y < 0.0);
15134
15135        runtime.tick(duration * 0.5);
15136        assert_eq!(handle_ready_events(&mut runtime)?, 1);
15137        let mid = runtime.render(window_id)?;
15138        let mid_descriptor =
15139            overlay_layer_descriptor(&mid).expect("select menu overlay layer still present");
15140        assert!(mid_descriptor.properties.opacity > 0.0);
15141        assert!(mid_descriptor.properties.opacity < 1.0);
15142        assert!(mid_descriptor.properties.translation.y < 0.0);
15143        assert!(
15144            mid_descriptor.properties.translation.y.abs()
15145                < start_descriptor.properties.translation.y.abs()
15146        );
15147        assert!(
15148            mid.frame.layer_updates.iter().any(|update| {
15149                update.owner == menu_owner
15150                    && matches!(
15151                        update.kind,
15152                        SceneLayerUpdateKind::Transform | SceneLayerUpdateKind::Effect
15153                    )
15154            }),
15155            "select menu entrance should update retained layer properties"
15156        );
15157        assert!(
15158            !mid.frame.layer_updates.iter().any(|update| {
15159                update.owner == menu_owner && update.kind == SceneLayerUpdateKind::Content
15160            }),
15161            "select menu entrance should not repaint option content"
15162        );
15163        assert!(runtime.next_wakeup_time(window_id)?.is_some());
15164
15165        runtime.tick(duration);
15166        assert_eq!(handle_ready_events(&mut runtime)?, 1);
15167        let settled = runtime.render(window_id)?;
15168        let settled_descriptor =
15169            overlay_layer_descriptor(&settled).expect("select menu overlay layer still present");
15170        assert_eq!(settled_descriptor.properties.opacity, 1.0);
15171        assert_eq!(settled_descriptor.properties.translation.y, 0.0);
15172        assert_eq!(runtime.next_wakeup_time(window_id)?, None);
15173        Ok(())
15174    }
15175
15176    #[test]
15177    fn expanded_select_does_not_reflow_following_widgets() -> Result<()> {
15178        let (mut runtime, window_id) = build_runtime(crate::Padding::all(
15179            12.0,
15180            crate::Stack::vertical()
15181                .spacing(10.0)
15182                .with_child(Select::new("Mode").placeholder("Choose mode").options([
15183                    "Automatic",
15184                    "Linear",
15185                    "Gamma",
15186                ]))
15187                .with_child(NumberInput::new("Gamma").value(1.4)),
15188        ));
15189
15190        let before = runtime.render(window_id)?;
15191        let spin_before = before
15192            .semantics
15193            .iter()
15194            .find(|node| node.role == SemanticsRole::SpinBox)
15195            .expect("spin box semantics present before expand")
15196            .bounds;
15197
15198        runtime.handle_event(
15199            window_id,
15200            primary_pointer(PointerEventKind::Down, Point::new(20.0, 20.0), true),
15201        )?;
15202        runtime.handle_event(
15203            window_id,
15204            primary_pointer(PointerEventKind::Up, Point::new(20.0, 20.0), false),
15205        )?;
15206
15207        let after = runtime.render(window_id)?;
15208        let spin_after = after
15209            .semantics
15210            .iter()
15211            .find(|node| node.role == SemanticsRole::SpinBox)
15212            .expect("spin box semantics present after expand")
15213            .bounds;
15214        let select = after
15215            .semantics
15216            .iter()
15217            .find(|node| node.role == SemanticsRole::ComboBox)
15218            .expect("select semantics present after expand");
15219        let descriptor =
15220            overlay_layer_descriptor(&after).expect("select menu overlay layer present");
15221
15222        assert_eq!(spin_before.y(), spin_after.y());
15223        assert!(descriptor.paint_bounds.max_y() > select.bounds.max_y());
15224        Ok(())
15225    }
15226
15227    #[test]
15228    fn expanded_select_accepts_pointer_selection_in_floating_menu() -> Result<()> {
15229        let changes = Rc::new(RefCell::new(Vec::new()));
15230        let on_change = Rc::clone(&changes);
15231        let (mut runtime, window_id) = build_runtime(crate::Padding::all(
15232            12.0,
15233            crate::Stack::vertical()
15234                .spacing(10.0)
15235                .with_child(
15236                    Select::new("Mode")
15237                        .placeholder("Choose mode")
15238                        .options(["Automatic", "Linear", "Gamma"])
15239                        .on_change(move |_, value| on_change.borrow_mut().push(value)),
15240                )
15241                .with_child(NumberInput::new("Gamma").value(1.4)),
15242        ));
15243
15244        let _ = runtime.render(window_id)?;
15245        runtime.handle_event(
15246            window_id,
15247            primary_pointer(PointerEventKind::Down, Point::new(20.0, 20.0), true),
15248        )?;
15249        runtime.handle_event(
15250            window_id,
15251            primary_pointer(PointerEventKind::Up, Point::new(20.0, 20.0), false),
15252        )?;
15253
15254        let expanded = runtime.render(window_id)?;
15255        let select = expanded
15256            .semantics
15257            .iter()
15258            .find(|node| node.role == SemanticsRole::ComboBox)
15259            .expect("select semantics present after expand");
15260        let menu = overlay_layer_descriptor(&expanded).expect("select menu overlay present");
15261        let option_point = Point::new(
15262            menu.bounds.x() + 20.0,
15263            menu.bounds.y() + (select.bounds.height() * 1.5),
15264        );
15265
15266        runtime.handle_event(
15267            window_id,
15268            primary_pointer(PointerEventKind::Down, option_point, true),
15269        )?;
15270        runtime.handle_event(
15271            window_id,
15272            primary_pointer(PointerEventKind::Up, option_point, false),
15273        )?;
15274
15275        assert_eq!(changes.borrow().as_slice(), &["Linear".to_string()]);
15276
15277        let output = runtime.render(window_id)?;
15278        let select = output
15279            .semantics
15280            .iter()
15281            .find(|node| node.role == SemanticsRole::ComboBox)
15282            .expect("select semantics present after pointer selection");
15283        assert_eq!(
15284            select.value,
15285            Some(SemanticsValue::Text("Linear".to_string()))
15286        );
15287        Ok(())
15288    }
15289
15290    #[test]
15291    fn expanded_select_flips_above_when_below_space_is_constrained() -> Result<()> {
15292        let changes = Rc::new(RefCell::new(Vec::new()));
15293        let on_change = Rc::clone(&changes);
15294        let (mut runtime, window_id) = build_runtime(
15295            SizedBox::new().size(Size::new(220.0, 180.0)).with_child(
15296                crate::Stack::vertical()
15297                    .with_child(SizedBox::new().height(128.0))
15298                    .with_child(
15299                        Select::new("Mode")
15300                            .placeholder("Choose mode")
15301                            .options(["Automatic", "Linear", "Gamma"])
15302                            .on_change(move |_, value| on_change.borrow_mut().push(value)),
15303                    ),
15304            ),
15305        );
15306
15307        let initial = runtime.render(window_id)?;
15308        let select_bounds = initial
15309            .semantics
15310            .iter()
15311            .find(|node| node.role == SemanticsRole::ComboBox)
15312            .expect("select semantics present before expand")
15313            .bounds;
15314        let header_point = Point::new(
15315            select_bounds.x() + 20.0,
15316            select_bounds.y() + (select_bounds.height() * 0.5),
15317        );
15318        runtime.handle_event(
15319            window_id,
15320            primary_pointer(PointerEventKind::Down, header_point, true),
15321        )?;
15322        runtime.handle_event(
15323            window_id,
15324            primary_pointer(PointerEventKind::Up, header_point, false),
15325        )?;
15326        runtime.tick(entrance_duration());
15327        assert_eq!(handle_ready_events(&mut runtime)?, 1);
15328
15329        let expanded = runtime.render(window_id)?;
15330        let select = expanded
15331            .semantics
15332            .iter()
15333            .find(|node| node.role == SemanticsRole::ComboBox)
15334            .expect("select semantics present after expand");
15335        let descriptor =
15336            overlay_layer_descriptor(&expanded).expect("select menu overlay layer present");
15337
15338        assert!(descriptor.paint_bounds.y() < select.bounds.y());
15339
15340        let option_point = Point::new(
15341            select.bounds.x() + 20.0,
15342            select.bounds.y() - super::SELECT_MENU_GAP - (select.bounds.height() * 1.5),
15343        );
15344        runtime.handle_event(
15345            window_id,
15346            primary_pointer(PointerEventKind::Down, option_point, true),
15347        )?;
15348        runtime.handle_event(
15349            window_id,
15350            primary_pointer(PointerEventKind::Up, option_point, false),
15351        )?;
15352
15353        assert_eq!(changes.borrow().as_slice(), &["Linear".to_string()]);
15354        Ok(())
15355    }
15356
15357    #[test]
15358    fn expanded_select_popover_paints_outside_layout_bounds() -> Result<()> {
15359        let root = crate::Background::new(
15360            Brush::Solid(Color::srgba(0.04, 0.045, 0.055, 1.0)),
15361            SizedBox::new().size(Size::new(220.0, 180.0)).with_child(
15362                crate::Stack::vertical()
15363                    .with_child(SizedBox::new().height(128.0))
15364                    .with_child(Select::new("Mode").placeholder("Choose mode").options([
15365                        "Automatic",
15366                        "Linear",
15367                        "Gamma",
15368                    ])),
15369            ),
15370        );
15371        let (mut runtime, window_id) = build_runtime(root);
15372        let mut renderer = WgpuRenderer::default().with_feathering_enabled(false);
15373
15374        let initial = runtime.render(window_id)?;
15375        renderer.render(&initial.frame)?;
15376        let select_bounds = initial
15377            .semantics
15378            .iter()
15379            .find(|node| node.role == SemanticsRole::ComboBox)
15380            .expect("select semantics present before expand")
15381            .bounds;
15382        let header_point = Point::new(
15383            select_bounds.x() + 20.0,
15384            select_bounds.y() + (select_bounds.height() * 0.5),
15385        );
15386        runtime.handle_event(
15387            window_id,
15388            primary_pointer(PointerEventKind::Down, header_point, true),
15389        )?;
15390        runtime.handle_event(
15391            window_id,
15392            primary_pointer(PointerEventKind::Up, header_point, false),
15393        )?;
15394        runtime.tick(entrance_duration());
15395        assert_eq!(handle_ready_events(&mut runtime)?, 1);
15396
15397        let expanded = runtime.render(window_id)?;
15398        let select = expanded
15399            .semantics
15400            .iter()
15401            .find(|node| node.role == SemanticsRole::ComboBox)
15402            .expect("select semantics present after expand");
15403        let descriptor =
15404            overlay_layer_descriptor(&expanded).expect("select menu overlay layer present");
15405        assert!(descriptor.paint_bounds.y() < select.bounds.y());
15406
15407        renderer.render(&expanded.frame)?;
15408        let image = renderer.capture_last_frame_rgba(window_id)?;
15409        let menu_probe = Rect::new(
15410            select.bounds.x() + 4.0,
15411            select.bounds.y() - super::SELECT_MENU_GAP - (select.bounds.height() * 3.0) + 4.0,
15412            select.bounds.width() - 8.0,
15413            (select.bounds.height() * 3.0) - 8.0,
15414        );
15415        let bright_pixels = bright_pixel_count(&image, menu_probe, 160);
15416
15417        assert!(
15418            bright_pixels > 200,
15419            "expanded select menu should paint outside layout bounds; bright_pixels={bright_pixels}, menu_probe={menu_probe:?}, select_bounds={:?}, paint_bounds={:?}",
15420            select.bounds,
15421            descriptor.paint_bounds
15422        );
15423        Ok(())
15424    }
15425
15426    #[test]
15427    fn select_header_text_visual_center_matches_control_center() {
15428        let output = render(Select::new("Mode").placeholder("Choose mode").options([
15429            "Automatic",
15430            "Linear",
15431            "Gamma",
15432        ]));
15433        let text = text_run_for(&output, "Choose mode");
15434        let layout = TextSystem::new()
15435            .shape_text_run(&text, &FontRegistry::new())
15436            .expect("select header text should shape");
15437        let line = layout
15438            .lines()
15439            .first()
15440            .expect("select header text should contain one line");
15441        let actual_visual_center =
15442            text.rect.y() + line.baseline + optical_visual_center(layout.measurement());
15443        let control_center = output.frame.viewport.height * 0.5;
15444
15445        assert!((actual_visual_center - control_center).abs() < 0.75);
15446    }
15447
15448    #[test]
15449    fn select_chevron_icon_centers_in_reserved_slot() {
15450        let output = render(
15451            SizedBox::new().width(220.0).with_child(
15452                Select::new("Mode")
15453                    .options(["Automatic", "Linear"])
15454                    .selected(0),
15455            ),
15456        );
15457        let select = output
15458            .semantics
15459            .iter()
15460            .find(|node| node.role == SemanticsRole::ComboBox)
15461            .expect("select semantics present");
15462        let slot = Rect::new(
15463            select.bounds.max_x() - super::SELECT_CHEVRON_SLOT_WIDTH,
15464            select.bounds.y(),
15465            super::SELECT_CHEVRON_SLOT_WIDTH,
15466            select.bounds.height(),
15467        );
15468        let chevron = lucide_strokes(&output)
15469            .into_iter()
15470            .map(|(bounds, _, stroke)| {
15471                let side = stroke.width * 12.0;
15472                Rect::new(
15473                    bounds.x() + (bounds.width() - side) * 0.5,
15474                    bounds.y() + (bounds.height() - side) * 0.5,
15475                    side,
15476                    side,
15477                )
15478            })
15479            .find(|rect| slot.contains(super::rect_center(*rect)))
15480            .expect("select chevron should paint as a native Lucide path");
15481
15482        assert!((super::rect_center(chevron).x - super::rect_center(slot).x).abs() < 0.75);
15483        assert!((super::rect_center(chevron).y - super::rect_center(slot).y).abs() < 0.75);
15484        assert!((chevron.width() - super::SELECT_CHEVRON_ICON_SIZE).abs() < 0.75);
15485        assert!((chevron.height() - super::SELECT_CHEVRON_ICON_SIZE).abs() < 0.75);
15486    }
15487
15488    #[test]
15489    fn select_header_placeholder_clips_before_chevron_slot() {
15490        let theme = DefaultTheme::default();
15491        let placeholder = "Choose an extremely detailed rendering pipeline preset";
15492        let output =
15493            render(SizedBox::new().width(180.0).with_child(
15494                Select::new("Mode").placeholder(placeholder).options([
15495                    "Automatic",
15496                    "Linear",
15497                    "Gamma",
15498                ]),
15499            ));
15500        let select = output
15501            .semantics
15502            .iter()
15503            .find(|node| node.role == SemanticsRole::ComboBox)
15504            .expect("select semantics present");
15505        let text = text_run_for(&output, placeholder);
15506        let clip = draw_clip_rect_for(&output, placeholder);
15507        let expected_clip_max_x = select.bounds.max_x()
15508            - theme.metrics.text_input_padding.right
15509            - super::SELECT_CHEVRON_SLOT_WIDTH;
15510
15511        assert_eq!(text.style.color, theme.placeholder_text_style().color);
15512        assert!((clip.max_x() - expected_clip_max_x).abs() < 0.75);
15513        assert!(clip.max_x() <= select.bounds.max_x() - super::SELECT_CHEVRON_SLOT_WIDTH + 0.75);
15514        assert!(
15515            (text_run_visual_center(&text) - (select.bounds.y() + select.bounds.height() * 0.5))
15516                .abs()
15517                < 0.75
15518        );
15519    }
15520
15521    #[test]
15522    fn select_header_and_options_preserve_tall_measurement_centering() -> Result<()> {
15523        let mut theme = DefaultTheme::default();
15524        theme.text.sm.size = 28.0;
15525        theme.text.sm.line_height = 10.0;
15526        theme.sync_derived_fields();
15527        theme.metrics.min_height = 52.0;
15528        let placeholder = "Choose mode";
15529        let option = "Automatic";
15530        let (mut runtime, window_id) = build_runtime(
15531            Select::new("Mode")
15532                .theme(theme)
15533                .placeholder(placeholder)
15534                .options([option, "Linear", "Gamma"]),
15535        );
15536
15537        let collapsed = runtime.render(window_id)?;
15538        let select = collapsed
15539            .semantics
15540            .iter()
15541            .find(|node| node.role == SemanticsRole::ComboBox)
15542            .expect("select semantics present");
15543        let placeholder_text = text_run_for(&collapsed, placeholder);
15544        let placeholder_layout = shaped_text_layout_for(&collapsed, placeholder);
15545        let placeholder_clip = draw_clip_rect_for(&collapsed, placeholder);
15546        let expected_clip_max_x = select.bounds.max_x()
15547            - theme.metrics.text_input_padding.right
15548            - super::SELECT_CHEVRON_SLOT_WIDTH;
15549
15550        assert_eq!(
15551            placeholder_text.style.font_size,
15552            theme.typography.body_font_size
15553        );
15554        assert_eq!(
15555            placeholder_text.style.line_height,
15556            theme.typography.body_line_height
15557        );
15558        assert_eq!(
15559            placeholder_text.style.color,
15560            theme.placeholder_text_style().color
15561        );
15562        assert!((placeholder_clip.max_x() - expected_clip_max_x).abs() < 0.75);
15563        assert!(
15564            (text_run_visual_center(&placeholder_text) - super::rect_center(select.bounds).y).abs()
15565                < 0.75,
15566            "select placeholder should visually center in the header; rect={:?}, bounds={:?}, measurement={:?}",
15567            placeholder_text.rect,
15568            select.bounds,
15569            placeholder_layout.measurement()
15570        );
15571
15572        let header_point = super::rect_center(select.bounds);
15573        runtime.handle_event(
15574            window_id,
15575            primary_pointer(PointerEventKind::Down, header_point, true),
15576        )?;
15577        runtime.handle_event(
15578            window_id,
15579            primary_pointer(PointerEventKind::Up, header_point, false),
15580        )?;
15581
15582        let expanded = runtime.render(window_id)?;
15583        let select = expanded
15584            .semantics
15585            .iter()
15586            .find(|node| node.role == SemanticsRole::ComboBox)
15587            .expect("select semantics present after expand");
15588        let option_text = text_run_for(&expanded, option);
15589        let option_layout = shaped_text_layout_for(&expanded, option);
15590        let option_clip = draw_clip_rect_for(&expanded, option);
15591        let menu = overlay_layer_descriptor(&expanded).expect("select menu overlay present");
15592        let row = Rect::new(
15593            menu.bounds.x(),
15594            menu.bounds.y(),
15595            menu.bounds.width(),
15596            select.bounds.height(),
15597        );
15598        let expected_option_clip =
15599            super::horizontal_text_inset_rect(row, theme.metrics.text_input_padding);
15600
15601        assert_eq!(option_text.style.font_size, theme.typography.body_font_size);
15602        assert_eq!(
15603            option_text.style.line_height,
15604            theme.typography.body_line_height
15605        );
15606        assert!((option_clip.x() - expected_option_clip.x()).abs() < 0.75);
15607        assert!((option_clip.max_x() - expected_option_clip.max_x()).abs() < 0.75);
15608        assert!(
15609            (text_run_visual_center(&option_text) - super::rect_center(row).y).abs() < 0.75,
15610            "select option should visually center in its row; rect={:?}, row={:?}, measurement={:?}",
15611            option_text.rect,
15612            row,
15613            option_layout.measurement()
15614        );
15615        Ok(())
15616    }
15617
15618    #[test]
15619    fn expanded_select_option_text_visual_center_matches_row_center() -> Result<()> {
15620        let (mut runtime, window_id) =
15621            build_runtime(Select::new("Mode").placeholder("Choose mode").options([
15622                "Automatic",
15623                "Linear",
15624                "Gamma",
15625            ]));
15626
15627        let _ = runtime.render(window_id)?;
15628        runtime.handle_event(
15629            window_id,
15630            primary_pointer(PointerEventKind::Down, Point::new(20.0, 20.0), true),
15631        )?;
15632        runtime.handle_event(
15633            window_id,
15634            primary_pointer(PointerEventKind::Up, Point::new(20.0, 20.0), false),
15635        )?;
15636
15637        let output = runtime.render(window_id)?;
15638        let select = output
15639            .semantics
15640            .iter()
15641            .find(|node| node.role == SemanticsRole::ComboBox)
15642            .expect("select semantics present");
15643        let text = text_run_for(&output, "Automatic");
15644        let layout = TextSystem::new()
15645            .shape_text_run(&text, &FontRegistry::new())
15646            .expect("select menu option text should shape");
15647        let line = layout
15648            .lines()
15649            .first()
15650            .expect("select menu option text should contain one line");
15651        let actual_visual_center =
15652            text.rect.y() + line.baseline + optical_visual_center(layout.measurement());
15653        let menu = overlay_layer_descriptor(&output).expect("select menu overlay present");
15654        let row_center = menu.bounds.y() + (select.bounds.height() * 0.5);
15655
15656        assert!((actual_visual_center - row_center).abs() < 0.75);
15657        Ok(())
15658    }
15659
15660    #[test]
15661    fn closed_select_does_not_block_immediate_clicks_before_next_render() -> Result<()> {
15662        let presses = Rc::new(RefCell::new(0usize));
15663        let on_press = Rc::clone(&presses);
15664        let (mut runtime, window_id) = build_runtime(crate::Padding::all(
15665            12.0,
15666            crate::Stack::vertical()
15667                .spacing(4.0)
15668                .with_child(Select::new("Mode").placeholder("Choose mode").options([
15669                    "Automatic",
15670                    "Linear",
15671                    "Gamma",
15672                    "Display P3",
15673                    "HDR",
15674                ]))
15675                .with_child(Button::new("Apply").on_press(move || {
15676                    *on_press.borrow_mut() += 1;
15677                })),
15678        ));
15679
15680        let _ = runtime.render(window_id)?;
15681        runtime.handle_event(
15682            window_id,
15683            primary_pointer(PointerEventKind::Down, Point::new(20.0, 20.0), true),
15684        )?;
15685        runtime.handle_event(
15686            window_id,
15687            primary_pointer(PointerEventKind::Up, Point::new(20.0, 20.0), false),
15688        )?;
15689
15690        let expanded = runtime.render(window_id)?;
15691        let button = expanded
15692            .semantics
15693            .iter()
15694            .find(|node| node.role == SemanticsRole::Button)
15695            .expect("button semantics present after expand")
15696            .bounds;
15697        let descriptor =
15698            overlay_layer_descriptor(&expanded).expect("select menu overlay layer present");
15699
15700        assert!(descriptor.paint_bounds.intersection(button).is_some());
15701
15702        runtime.handle_event(
15703            window_id,
15704            primary_pointer(PointerEventKind::Down, Point::new(20.0, 20.0), true),
15705        )?;
15706        runtime.handle_event(
15707            window_id,
15708            primary_pointer(PointerEventKind::Up, Point::new(20.0, 20.0), false),
15709        )?;
15710
15711        let button_center = Point::new(
15712            button.x() + (button.width() * 0.5),
15713            button.y() + (button.height() * 0.5),
15714        );
15715        runtime.handle_event(
15716            window_id,
15717            primary_pointer(PointerEventKind::Down, button_center, true),
15718        )?;
15719        runtime.handle_event(
15720            window_id,
15721            primary_pointer(PointerEventKind::Up, button_center, false),
15722        )?;
15723
15724        assert_eq!(*presses.borrow(), 1);
15725        Ok(())
15726    }
15727
15728    #[test]
15729    fn outside_click_closes_select_without_blocking_following_interactions() -> Result<()> {
15730        let presses = Rc::new(RefCell::new(0usize));
15731        let on_press = Rc::clone(&presses);
15732        let (mut runtime, window_id) = build_runtime(crate::Padding::all(
15733            12.0,
15734            crate::Stack::vertical()
15735                .spacing(4.0)
15736                .with_child(Select::new("Mode").placeholder("Choose mode").options([
15737                    "Automatic",
15738                    "Linear",
15739                    "Gamma",
15740                    "Display P3",
15741                    "HDR",
15742                ]))
15743                .with_child(Button::new("Apply").on_press(move || {
15744                    *on_press.borrow_mut() += 1;
15745                })),
15746        ));
15747
15748        let _ = runtime.render(window_id)?;
15749        runtime.handle_event(
15750            window_id,
15751            primary_pointer(PointerEventKind::Down, Point::new(20.0, 20.0), true),
15752        )?;
15753        runtime.handle_event(
15754            window_id,
15755            primary_pointer(PointerEventKind::Up, Point::new(20.0, 20.0), false),
15756        )?;
15757
15758        let expanded = runtime.render(window_id)?;
15759        let button = expanded
15760            .semantics
15761            .iter()
15762            .find(|node| node.role == SemanticsRole::Button)
15763            .expect("button semantics present after expand")
15764            .bounds;
15765        let outside_point = Point::new(
15766            button.x() + (button.width() * 0.5),
15767            button.y() + (button.height() * 0.5),
15768        );
15769
15770        runtime.handle_event(
15771            window_id,
15772            primary_pointer(PointerEventKind::Down, outside_point, true),
15773        )?;
15774        runtime.handle_event(
15775            window_id,
15776            primary_pointer(PointerEventKind::Up, outside_point, false),
15777        )?;
15778
15779        assert_eq!(*presses.borrow(), 0);
15780
15781        runtime.handle_event(
15782            window_id,
15783            primary_pointer(PointerEventKind::Down, outside_point, true),
15784        )?;
15785        runtime.handle_event(
15786            window_id,
15787            primary_pointer(PointerEventKind::Up, outside_point, false),
15788        )?;
15789
15790        assert_eq!(*presses.borrow(), 1);
15791        Ok(())
15792    }
15793
15794    #[test]
15795    fn select_retains_chevron_ink_when_feathering_is_enabled() {
15796        let root = crate::Padding::all(
15797            12.0,
15798            Select::new("Mode")
15799                .placeholder("Choose mode")
15800                .options(["Normal", "Multiply", "Screen"])
15801                .selected(0),
15802        );
15803
15804        let (feathered_output, feathered_image) = render_rgba(root, true);
15805        let select_bounds = feathered_output
15806            .semantics
15807            .iter()
15808            .find(|node| node.role == SemanticsRole::ComboBox)
15809            .map(|node| node.bounds)
15810            .expect("select semantics present");
15811
15812        let (_, hard_image) = render_rgba(
15813            crate::Padding::all(
15814                12.0,
15815                Select::new("Mode")
15816                    .placeholder("Choose mode")
15817                    .options(["Normal", "Multiply", "Screen"])
15818                    .selected(0),
15819            ),
15820            false,
15821        );
15822
15823        let chevron_crop = Rect::new(
15824            select_bounds.max_x() - 30.0,
15825            select_bounds.y(),
15826            30.0,
15827            select_bounds.height(),
15828        );
15829        let feathered_ink = dark_pixel_count(&feathered_image, chevron_crop, 224);
15830        let hard_ink = dark_pixel_count(&hard_image, chevron_crop, 224);
15831
15832        assert!(
15833            feathered_ink * 3 >= hard_ink * 2,
15834            "feathered select chevron lost too much dark ink (feathered={feathered_ink}, hard={hard_ink}, crop={chevron_crop:?})"
15835        );
15836    }
15837}