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 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 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 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#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
533pub enum ButtonAppearance {
534 Filled,
536 #[default]
538 Tonal,
539 Outline,
541 Ghost,
543}
544
545#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
547pub enum FieldAppearance {
548 #[default]
550 Framed,
551 Bare,
553}
554
555#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
560pub enum ChoiceAppearance {
561 #[default]
564 Plain,
565 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 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 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 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 pub fn primary(label: impl Into<String>) -> Self {
2303 Self::new(label).primary_action()
2304 }
2305
2306 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 pub fn appearance(mut self, appearance: ButtonAppearance) -> Self {
2332 self.appearance = appearance;
2333 self
2334 }
2335
2336 pub fn tone(mut self, tone: SemanticTone) -> Self {
2339 self.tone = tone;
2340 self
2341 }
2342
2343 pub fn primary_action(mut self) -> Self {
2345 self.appearance = ButtonAppearance::Filled;
2346 self.tone = SemanticTone::Accent;
2347 self
2348 }
2349
2350 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 pub fn appearance(mut self, appearance: ChoiceAppearance) -> Self {
3120 self.appearance = appearance;
3121 self
3122 }
3123
3124 pub fn plain(self) -> Self {
3126 self.appearance(ChoiceAppearance::Plain)
3127 }
3128
3129 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 pub fn appearance(mut self, appearance: ChoiceAppearance) -> Self {
3523 self.appearance = appearance;
3524 self
3525 }
3526
3527 pub fn plain(self) -> Self {
3529 self.appearance(ChoiceAppearance::Plain)
3530 }
3531
3532 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 pub fn appearance(mut self, appearance: ChoiceAppearance) -> Self {
4061 self.appearance = appearance;
4062 self
4063 }
4064
4065 pub fn plain(self) -> Self {
4067 self.appearance(ChoiceAppearance::Plain)
4068 }
4069
4070 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 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 pub fn select_all(&mut self, ctx: &mut EventCtx) {
6209 self.execute_editor_command(ctx, EditorCommand::SelectAll);
6210 }
6211
6212 pub fn copy(&mut self, ctx: &mut EventCtx) {
6215 self.execute_editor_command(ctx, EditorCommand::Copy);
6216 }
6217
6218 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 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 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 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 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 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 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 pub fn select_all(&mut self, ctx: &mut EventCtx) {
8146 self.execute_editor_command(ctx, EditorCommand::SelectAll);
8147 }
8148
8149 pub fn copy(&mut self, ctx: &mut EventCtx) {
8152 self.execute_editor_command(ctx, EditorCommand::Copy);
8153 }
8154
8155 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 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 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 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 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
8885pub 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
9008pub 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
9341pub 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 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 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 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 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 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 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 runtime.handle_event(
14756 window_id,
14757 primary_pointer(PointerEventKind::Down, Point::new(18.0, 18.0), true),
14758 )?;
14759
14760 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 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 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 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}