mod interaction;
use crate::animation::Reveal;
use crate::binding::Binding;
use crate::draw::{inset_rect, measure_text, mix_color, rect_center};
use crate::frame::draw_control_frame;
use crate::{
AnimationSpec, ControlMetrics, ControlPalette, DefaultTheme, GlowTone, HdrThemeMode,
Interpolate, Progress, ResolvedEffectStyle, ResolvedHdrStyle, SemanticTone, WidgetColorRole,
WidgetLuminanceRole, WidgetMaterialRole,
editable_text::{
CaretBlink, EditableTextController, EditableTextLineMode, TextChangeCallbacks,
keyboard_text, single_line_text,
},
editor::{EditorCommand, EditorCommandResult, selection_range},
frame::{
draw_control_shape, draw_focus_ring, physical_pixels, physical_pixels_at, snap_to_pixels,
},
overlay::{OverlayPlacement, OverlayPlacementRequest, place_overlay},
paint_theme_glow, paint_theme_shadow, resolve_luminance_role, resolve_widget_hdr_style,
selection::{SelectionChange, SelectionClipboardBehavior, SelectionOwnerId, SelectionScope},
text_align::{
HorizontalTextAlignmentMode, VerticalAlign, aligned_text_rect_for_layout,
aligned_text_rect_for_layout_with_mode, aligned_text_rect_for_text, alignment_fraction,
paint_text, paint_text_line, paragraph_origin,
},
text_command::TextCommand,
};
pub use interaction::InteractionPreview;
use interaction::PressInteraction;
use std::{cell::RefCell, ops::Range, rc::Rc, sync::Arc};
use sui_core::{
Color, DpiInfo, EditableTextSemantics, Event, ImeEvent, InvalidationKind, InvalidationRequest,
InvalidationTarget, KeyState, Path, PathBuilder, Point, PointerButton, PointerEventKind, Rect,
SemanticsAction, SemanticsActionRequest, SemanticsNode, SemanticsPopupKind, SemanticsRole,
SemanticsTextRange, SemanticsValue, Size, ToggleState, Vector, WidgetId,
};
use sui_layout::{Axis, Constraints, IntrinsicSize, Padding as Insets};
use sui_lucide::LucideIcon;
use sui_reactive::Observable;
use sui_runtime::{
ArrangeCtx, Command, EventCtx, EventPhase, FrameClock, LayerOptions, MeasureCtx,
OVERLAY_DISMISS_REQUEST, OutputColorRange, OverlayDismissPolicy, OverlayFocusBehavior,
OverlayKind, OverlayOptions, PaintBoundaryMode, PaintCtx, SemanticsCtx, SingleChild,
StackSurfaceOptions, Widget, WidgetPodMutVisitor, WidgetPodVisitor,
};
use sui_scene::{LayerCompositionMode, LayerProperties, StrokeStyle};
use sui_text::{
FontFeature, PersistentTextLayout, TextAlign, TextCursor, TextMeasurement, TextSelection,
TextStyle,
};
use unicode_segmentation::UnicodeSegmentation;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum IconGlyph {
Add,
Remove,
Check,
ChevronDown,
ChevronUp,
ChevronLeft,
ChevronRight,
Close,
Maximize,
Restore,
FitView,
ActualSize,
MoreHorizontal,
MoreVertical,
Search,
Undo,
Redo,
Brush,
Eraser,
PaintBucket,
Hand,
Lock,
Unlock,
Trash,
Download,
Sparkles,
Chat,
History,
Folder,
File,
FileText,
Link,
Send,
ArrowUp,
Stop,
Attach,
Hourglass,
Alert,
Storage,
AudioLines,
Mic,
MicOff,
Camera,
CameraOff,
Video,
VideoOff,
Phone,
PhoneOff,
Monitor,
ScreenShare,
Blocks,
Palette,
Type,
Languages,
FileCode,
Newspaper,
Sun,
LayoutDashboard,
Move,
PenTool,
Workflow,
}
impl IconGlyph {
pub const fn lucide_icon(self) -> LucideIcon {
match self {
Self::Add => LucideIcon::Plus,
Self::Remove => LucideIcon::Minus,
Self::Check => LucideIcon::Check,
Self::ChevronDown => LucideIcon::ChevronDown,
Self::ChevronUp => LucideIcon::ChevronUp,
Self::ChevronLeft => LucideIcon::ChevronLeft,
Self::ChevronRight => LucideIcon::ChevronRight,
Self::Close => LucideIcon::X,
Self::Maximize => LucideIcon::Maximize,
Self::Restore => LucideIcon::Copy,
Self::FitView => LucideIcon::ScanSearch,
Self::ActualSize => LucideIcon::Scan,
Self::MoreHorizontal => LucideIcon::Ellipsis,
Self::MoreVertical => LucideIcon::EllipsisVertical,
Self::Search => LucideIcon::Search,
Self::Undo => LucideIcon::Undo2,
Self::Redo => LucideIcon::Redo2,
Self::Brush => LucideIcon::Brush,
Self::Eraser => LucideIcon::Eraser,
Self::PaintBucket => LucideIcon::PaintBucket,
Self::Hand => LucideIcon::Hand,
Self::Lock => LucideIcon::Lock,
Self::Unlock => LucideIcon::LockOpen,
Self::Trash => LucideIcon::Trash2,
Self::Download => LucideIcon::Download,
Self::Sparkles => LucideIcon::Sparkles,
Self::Chat => LucideIcon::MessageSquare,
Self::History => LucideIcon::History,
Self::Folder => LucideIcon::Folder,
Self::File => LucideIcon::File,
Self::FileText => LucideIcon::FileText,
Self::Link => LucideIcon::Link,
Self::Send => LucideIcon::Send,
Self::ArrowUp => LucideIcon::ArrowUp,
Self::Stop => LucideIcon::Square,
Self::Attach => LucideIcon::Paperclip,
Self::Hourglass => LucideIcon::Hourglass,
Self::Alert => LucideIcon::TriangleAlert,
Self::Storage => LucideIcon::HardDrive,
Self::AudioLines => LucideIcon::AudioLines,
Self::Mic => LucideIcon::Mic,
Self::MicOff => LucideIcon::MicOff,
Self::Camera => LucideIcon::Camera,
Self::CameraOff => LucideIcon::CameraOff,
Self::Video => LucideIcon::Video,
Self::VideoOff => LucideIcon::VideoOff,
Self::Phone => LucideIcon::Phone,
Self::PhoneOff => LucideIcon::PhoneOff,
Self::Monitor => LucideIcon::Monitor,
Self::ScreenShare => LucideIcon::ScreenShare,
Self::Blocks => LucideIcon::Blocks,
Self::Palette => LucideIcon::Palette,
Self::Type => LucideIcon::Type,
Self::Languages => LucideIcon::Languages,
Self::FileCode => LucideIcon::FileCode,
Self::Newspaper => LucideIcon::Newspaper,
Self::Sun => LucideIcon::Sun,
Self::LayoutDashboard => LucideIcon::LayoutDashboard,
Self::Move => LucideIcon::Move,
Self::PenTool => LucideIcon::PenTool,
Self::Workflow => LucideIcon::Workflow,
}
}
}
pub const BUILTIN_ICON_GLYPHS: &[IconGlyph] = &[
IconGlyph::Add,
IconGlyph::Remove,
IconGlyph::Check,
IconGlyph::ChevronDown,
IconGlyph::ChevronUp,
IconGlyph::ChevronLeft,
IconGlyph::ChevronRight,
IconGlyph::Close,
IconGlyph::Maximize,
IconGlyph::Restore,
IconGlyph::FitView,
IconGlyph::ActualSize,
IconGlyph::MoreHorizontal,
IconGlyph::MoreVertical,
IconGlyph::Search,
IconGlyph::Undo,
IconGlyph::Redo,
IconGlyph::Brush,
IconGlyph::Eraser,
IconGlyph::PaintBucket,
IconGlyph::Hand,
IconGlyph::Lock,
IconGlyph::Unlock,
IconGlyph::Trash,
IconGlyph::Download,
IconGlyph::Sparkles,
IconGlyph::Chat,
IconGlyph::History,
IconGlyph::Folder,
IconGlyph::File,
IconGlyph::FileText,
IconGlyph::Link,
IconGlyph::Send,
IconGlyph::ArrowUp,
IconGlyph::Stop,
IconGlyph::Attach,
IconGlyph::Hourglass,
IconGlyph::Alert,
IconGlyph::Storage,
IconGlyph::AudioLines,
IconGlyph::Mic,
IconGlyph::MicOff,
IconGlyph::Camera,
IconGlyph::CameraOff,
IconGlyph::Video,
IconGlyph::VideoOff,
IconGlyph::Phone,
IconGlyph::PhoneOff,
IconGlyph::Monitor,
IconGlyph::ScreenShare,
IconGlyph::Blocks,
IconGlyph::Palette,
IconGlyph::Type,
IconGlyph::Languages,
IconGlyph::FileCode,
IconGlyph::Newspaper,
IconGlyph::Sun,
IconGlyph::LayoutDashboard,
IconGlyph::Move,
IconGlyph::PenTool,
IconGlyph::Workflow,
];
#[doc(alias = "Divider")]
pub struct Separator {
theme: Box<DefaultTheme>,
theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
axis: Axis,
name: Option<String>,
inset: f32,
thickness: Option<f32>,
length: Option<f32>,
}
impl Separator {
pub fn new(axis: Axis) -> Self {
Self {
theme: Box::new(DefaultTheme::default()),
theme_reader: None,
axis,
name: None,
inset: 0.0,
thickness: None,
length: None,
}
}
pub fn horizontal() -> Self {
Self::new(Axis::Horizontal)
}
pub fn vertical() -> Self {
Self::new(Axis::Vertical)
}
pub fn theme(mut self, theme: DefaultTheme) -> Self {
self.theme = Box::new(theme);
self.theme_reader = None;
self
}
pub fn theme_when<F>(mut self, theme: F) -> Self
where
F: Fn() -> DefaultTheme + 'static,
{
self.theme_reader = Some(Box::new(theme));
self
}
pub fn name(mut self, name: impl Into<String>) -> Self {
self.name = Some(name.into());
self
}
pub fn inset(mut self, inset: f32) -> Self {
self.inset = inset.max(0.0);
self
}
pub fn thickness(mut self, thickness: f32) -> Self {
self.thickness = Some(thickness.max(0.0));
self
}
pub fn length(mut self, length: f32) -> Self {
self.length = Some(length.max(0.0));
self
}
fn resolved_thickness(&self) -> f32 {
self.thickness
.unwrap_or(self.resolved_theme().metrics.separator_thickness)
.max(1.0)
}
fn resolved_theme(&self) -> DefaultTheme {
self.theme_reader
.as_ref()
.map(|reader| reader())
.unwrap_or_else(|| *self.theme)
}
}
impl Widget for Separator {
fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
let thickness = self.resolved_thickness();
let length = self.length.unwrap_or(64.0);
let size = match self.axis {
Axis::Horizontal => Size::new(length, thickness + (self.inset * 2.0)),
Axis::Vertical => Size::new(thickness + (self.inset * 2.0), length),
};
constraints.clamp(Size::new(
if self.axis == Axis::Horizontal && constraints.max.width.is_finite() {
constraints.max.width
} else {
size.width
},
if self.axis == Axis::Vertical && constraints.max.height.is_finite() {
constraints.max.height
} else {
size.height
},
))
}
fn paint(&self, ctx: &mut PaintCtx) {
let theme = self.resolved_theme();
let thickness = physical_pixels(ctx, self.resolved_thickness());
let line = match self.axis {
Axis::Horizontal => Rect::new(
ctx.bounds().x() + self.inset,
ctx.bounds().y() + ((ctx.bounds().height() - thickness) * 0.5),
(ctx.bounds().width() - (self.inset * 2.0)).max(0.0),
thickness,
),
Axis::Vertical => Rect::new(
ctx.bounds().x() + ((ctx.bounds().width() - thickness) * 0.5),
ctx.bounds().y() + self.inset,
thickness,
(ctx.bounds().height() - (self.inset * 2.0)).max(0.0),
),
};
ctx.fill(
Path::rounded_rect(line, thickness * 0.5),
theme.palette.border,
);
}
fn semantics(&self, ctx: &mut SemanticsCtx) {
let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::Separator, ctx.bounds());
node.name = self.name.clone();
ctx.push(node);
}
}
pub struct Icon {
theme: Box<DefaultTheme>,
theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
glyph: IconGlyph,
size: Option<f32>,
color: Option<Color>,
color_reader: Option<Box<dyn Fn() -> Color>>,
label: Option<String>,
}
impl Icon {
pub fn new(glyph: IconGlyph) -> Self {
Self {
theme: Box::new(DefaultTheme::default()),
theme_reader: None,
glyph,
size: None,
color: None,
color_reader: None,
label: None,
}
}
pub fn theme(mut self, theme: DefaultTheme) -> Self {
self.theme = Box::new(theme);
self.theme_reader = None;
self
}
pub fn theme_when<F>(mut self, theme: F) -> Self
where
F: Fn() -> DefaultTheme + 'static,
{
self.theme = Box::new(theme());
self.theme_reader = Some(Box::new(theme));
self
}
pub fn size(mut self, size: f32) -> Self {
self.size = Some(size.max(0.0));
self
}
pub fn color(mut self, color: Color) -> Self {
self.color = Some(color);
self.color_reader = None;
self
}
pub fn color_when<F>(mut self, color: F) -> Self
where
F: Fn() -> Color + 'static,
{
self.color_reader = Some(Box::new(color));
self
}
pub fn semantic_name(mut self, name: impl Into<String>) -> Self {
self.label = Some(name.into());
self
}
fn resolved_color(&self) -> Color {
self.color_reader
.as_ref()
.map(|reader| reader())
.or(self.color)
.unwrap_or(self.theme.palette.text)
}
fn resolved_size(&self) -> f32 {
self.size.unwrap_or(self.theme.metrics.icon_size)
}
}
impl Widget for Icon {
fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
if let Some(theme) = &self.theme_reader {
*self.theme = theme();
}
let side = self.resolved_size();
constraints.clamp(Size::new(side, side))
}
fn paint(&self, ctx: &mut PaintCtx) {
draw_icon_glyph(
ctx,
self.glyph,
center_square(ctx.bounds(), self.resolved_size()),
self.resolved_color(),
);
}
fn semantics(&self, ctx: &mut SemanticsCtx) {
if let Some(label) = &self.label {
let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::Image, ctx.bounds());
node.name = Some(label.clone());
ctx.push(node);
}
}
}
const CARET_BLINK_PERIOD_SECONDS: f64 = 1.0;
const SELECT_CHEVRON_SLOT_WIDTH: f32 = 28.0;
const SELECT_CHEVRON_ICON_SIZE: f32 = 20.0;
#[cfg(test)]
const SELECT_MENU_GAP: f32 = 6.0;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum SelectMenuPlacement {
Below,
Above,
}
type AnimatedScalar = Progress;
fn request_child_invalidation(ctx: &mut EventCtx, widget_id: WidgetId, kind: InvalidationKind) {
ctx.request(InvalidationRequest::new(
InvalidationTarget::Widget(widget_id),
kind,
));
}
fn set_animation_target(
animation: &mut AnimatedScalar,
target: f32,
duration: f64,
easing: crate::Easing,
ctx: &mut EventCtx,
) {
animation.animate(target, AnimationSpec::tween(duration, easing), ctx);
}
fn set_hover_animation_target(
animation: &mut AnimatedScalar,
target: f32,
theme: &DefaultTheme,
ctx: &mut EventCtx,
) {
set_animation_target(
animation,
target,
theme.motion.hover_duration(),
theme.motion.hover_easing(),
ctx,
);
}
fn set_press_animation_target(
animation: &mut AnimatedScalar,
target: f32,
theme: &DefaultTheme,
ctx: &mut EventCtx,
) {
set_animation_target(
animation,
target,
theme.motion.press_duration(),
theme.motion.press_easing(),
ctx,
);
}
fn set_toggle_animation_target(
animation: &mut AnimatedScalar,
target: f32,
theme: &DefaultTheme,
ctx: &mut EventCtx,
) {
set_animation_target(
animation,
target,
theme.motion.toggle_duration(),
theme.motion.toggle_easing(),
ctx,
);
}
fn set_focus_animation_target(
animation: &mut AnimatedScalar,
target: f32,
theme: &DefaultTheme,
ctx: &mut EventCtx,
) {
set_animation_target(
animation,
target,
theme.motion.focus_duration(),
theme.motion.focus_easing(),
ctx,
);
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum ButtonAppearance {
Filled,
#[default]
Tonal,
Outline,
Ghost,
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum FieldAppearance {
#[default]
Framed,
Bare,
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum ChoiceAppearance {
#[default]
Plain,
Framed,
}
#[derive(Clone, Copy, Debug, PartialEq)]
struct ChoiceFrameVisuals {
background: Color,
border: Color,
}
fn choice_frame_visuals(
theme: &DefaultTheme,
appearance: ChoiceAppearance,
framed_background: Color,
framed_border: Color,
hover_progress: f32,
press_progress: f32,
focus_progress: f32,
) -> ChoiceFrameVisuals {
if appearance == ChoiceAppearance::Framed {
return ChoiceFrameVisuals {
background: framed_background,
border: framed_border,
};
}
let hover_wash = theme.surfaces.hover;
let press_wash = theme
.palette
.text
.with_alpha(if theme.surfaces.dark { 0.10 } else { 0.07 });
let focus_wash =
theme
.palette
.focus
.with_alpha(if theme.surfaces.dark { 0.085 } else { 0.055 });
let background = composite_translucent_wash(
animated_translucent_wash(press_wash, press_progress),
composite_translucent_wash(
animated_translucent_wash(focus_wash, focus_progress),
animated_translucent_wash(hover_wash, hover_progress),
),
);
ChoiceFrameVisuals {
background,
border: Color::TRANSPARENT,
}
}
fn choice_indicator_colors(
palette: &ControlPalette,
hover: f32,
press: f32,
selected: f32,
) -> (Color, Color) {
let rest_fill = mix_color(palette.field, palette.button_hover, hover);
let rest_border = mix_color(palette.border_control, palette.text_muted, hover * 0.5);
let on = mix_color(
mix_color(palette.accent, palette.accent_hover, hover),
palette.accent_pressed,
press,
);
(
mix_color(rest_fill, on, selected),
mix_color(rest_border, on, selected),
)
}
fn framed_choice_colors(
palette: &ControlPalette,
hover: f32,
press: f32,
focus: f32,
) -> (Color, Color) {
let background = mix_color(
mix_color(palette.button, palette.button_hover, hover),
palette.button_pressed,
press,
);
let border = mix_color(
mix_color(palette.button_border, palette.border_hover, hover),
palette.border_focus,
focus,
);
(background, border)
}
fn animated_translucent_wash(color: Color, progress: f32) -> Color {
color.with_alpha(color.alpha * progress.clamp(0.0, 1.0))
}
fn composite_translucent_wash(foreground: Color, background: Color) -> Color {
let foreground_alpha = foreground.alpha.clamp(0.0, 1.0);
let background_alpha = background.alpha.clamp(0.0, 1.0);
let output_alpha = foreground_alpha + background_alpha * (1.0 - foreground_alpha);
if output_alpha <= f32::EPSILON {
return Color::TRANSPARENT;
}
let background_weight = background_alpha * (1.0 - foreground_alpha);
Color::new(
foreground.space,
(foreground.red * foreground_alpha + background.red * background_weight) / output_alpha,
(foreground.green * foreground_alpha + background.green * background_weight) / output_alpha,
(foreground.blue * foreground_alpha + background.blue * background_weight) / output_alpha,
output_alpha,
)
}
fn field_border(palette: &ControlPalette, hover: f32, focus: f32) -> Color {
mix_color(
mix_color(palette.button_border, palette.border_hover, hover),
palette.border_focus,
focus,
)
}
fn field_background(theme: &DefaultTheme, read_only: bool, focus_progress: f32) -> Color {
let palette = theme.palette;
let base = if read_only {
palette.surface
} else {
palette.field
};
mix_color(base, palette.surface_focus, focus_progress.clamp(0.0, 1.0))
}
#[derive(Clone, Copy, Debug, PartialEq)]
struct SemanticButtonVisuals {
background: Color,
border: Color,
content: Color,
}
fn semantic_button_visuals(
theme: &DefaultTheme,
appearance: ButtonAppearance,
tone: SemanticTone,
enabled: bool,
hover_progress: f32,
press_progress: f32,
) -> SemanticButtonVisuals {
let palette = theme.palette;
let interaction = theme.interaction;
let hover = if enabled {
hover_progress.clamp(0.0, 1.0) * interaction.hover_blend
} else {
0.0
};
let press = if enabled {
press_progress.clamp(0.0, 1.0) * interaction.pressed_blend
} else {
0.0
};
let roles = theme.tone_roles(tone);
let neutral = tone == SemanticTone::Neutral;
let wash = if neutral { palette.control } else { roles.soft };
let wash_pressed = if neutral {
palette.control_hover
} else {
mix_color(roles.soft, roles.solid, 0.16)
};
let ink = if neutral { palette.text } else { roles.text };
let (base, hovered, pressed, border, content) = match appearance {
ButtonAppearance::Filled | ButtonAppearance::Tonal if neutral => (
roles.solid,
roles.hover,
roles.pressed,
mix_color(roles.border, palette.border_hover, hover),
roles.on_solid,
),
ButtonAppearance::Filled => (
roles.solid,
roles.hover,
roles.pressed,
Color::TRANSPARENT,
roles.on_solid,
),
ButtonAppearance::Tonal => (
roles.soft,
mix_color(roles.soft, roles.solid, 0.12),
mix_color(roles.soft, roles.solid, 0.24),
roles.border,
roles.text,
),
ButtonAppearance::Outline => (
Color::TRANSPARENT,
wash,
wash_pressed,
if neutral {
mix_color(roles.border, palette.border_hover, hover)
} else {
roles.border
},
ink,
),
ButtonAppearance::Ghost => (
Color::TRANSPARENT,
wash,
wash_pressed,
Color::TRANSPARENT,
ink,
),
};
let background = mix_color(mix_color(base, hovered, hover), pressed, press);
let border = if appearance == ButtonAppearance::Filled && !neutral {
background
} else {
border
};
if enabled {
SemanticButtonVisuals {
background,
border,
content,
}
} else {
let background = if matches!(
appearance,
ButtonAppearance::Outline | ButtonAppearance::Ghost
) {
Color::TRANSPARENT
} else {
mix_color(background, palette.control, 0.72).with_alpha(interaction.disabled_opacity)
};
SemanticButtonVisuals {
background,
border: border.with_alpha(border.alpha * interaction.disabled_content_opacity),
content: palette.text_disabled,
}
}
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct IconButtonPaint {
pub appearance: ButtonAppearance,
pub tone: SemanticTone,
pub selected: bool,
pub enabled: bool,
pub hover_progress: f32,
pub press_progress: f32,
pub focus_progress: f32,
pub icon_size: Option<f32>,
}
impl IconButtonPaint {
pub const fn new() -> Self {
Self {
appearance: ButtonAppearance::Tonal,
tone: SemanticTone::Neutral,
selected: false,
enabled: true,
hover_progress: 0.0,
press_progress: 0.0,
focus_progress: 0.0,
icon_size: None,
}
}
pub const fn appearance(mut self, appearance: ButtonAppearance) -> Self {
self.appearance = appearance;
self
}
pub const fn tone(mut self, tone: SemanticTone) -> Self {
self.tone = tone;
self
}
pub const fn selected(mut self, selected: bool) -> Self {
self.selected = selected;
self
}
pub const fn enabled(mut self, enabled: bool) -> Self {
self.enabled = enabled;
self
}
pub const fn hovered(mut self, hovered: bool) -> Self {
self.hover_progress = if hovered { 1.0 } else { 0.0 };
self
}
pub const fn pressed(mut self, pressed: bool) -> Self {
self.press_progress = if pressed { 1.0 } else { 0.0 };
self
}
pub const fn focused(mut self, focused: bool) -> Self {
self.focus_progress = if focused { 1.0 } else { 0.0 };
self
}
pub fn hover_progress(mut self, progress: f32) -> Self {
self.hover_progress = progress;
self
}
pub fn press_progress(mut self, progress: f32) -> Self {
self.press_progress = progress;
self
}
pub fn focus_progress(mut self, progress: f32) -> Self {
self.focus_progress = progress;
self
}
pub const fn icon_size(mut self, icon_size: f32) -> Self {
self.icon_size = Some(icon_size);
self
}
}
impl Default for IconButtonPaint {
fn default() -> Self {
Self::new()
}
}
pub fn paint_icon_button(
ctx: &mut PaintCtx,
theme: &DefaultTheme,
rect: Rect,
icon: IconGlyph,
style: IconButtonPaint,
) {
if let Some((bounds, color)) = paint_icon_button_frame(ctx, theme, rect, style) {
draw_icon_glyph(ctx, icon, bounds, color);
}
}
fn paint_icon_button_frame(
ctx: &mut PaintCtx,
theme: &DefaultTheme,
rect: Rect,
style: IconButtonPaint,
) -> Option<(Rect, Color)> {
if rect.width() <= 0.0 || rect.height() <= 0.0 {
return None;
}
let palette = theme.palette;
let metrics = theme.metrics;
let interaction = theme.interaction;
let selected = style.selected;
let enabled = style.enabled;
let hover_progress = if enabled {
style.hover_progress.clamp(0.0, 1.0) * interaction.hover_blend
} else {
0.0
};
let press_progress = if enabled {
style.press_progress.clamp(0.0, 1.0) * interaction.pressed_blend
} else {
0.0
};
let focus_progress = if enabled {
style.focus_progress.clamp(0.0, 1.0)
} else {
0.0
};
let legacy_default =
style.appearance == ButtonAppearance::Tonal && style.tone == SemanticTone::Neutral;
let (background, border, icon_color) = if legacy_default {
let base_background = if selected {
palette.selection
} else {
palette.button
};
let hover_background = if selected {
mix_color(base_background, palette.control_hover, 0.35)
} else {
palette.button_hover
};
let press_background = if selected {
mix_color(base_background, palette.control_active, 0.45)
} else {
palette.button_pressed
};
let background = mix_color(
mix_color(base_background, hover_background, hover_progress),
press_background,
press_progress,
);
let border_base = if !enabled {
palette.border.with_alpha(0.55)
} else if selected {
palette.selection_border
} else {
mix_color(palette.button_border, palette.border_hover, hover_progress)
};
let border = if enabled && !selected {
mix_color(border_base, palette.border_focus, focus_progress)
} else {
border_base
};
let background = if enabled {
background
} else {
mix_color(background, palette.control, 0.72).with_alpha(interaction.disabled_opacity)
};
let icon_color = if !enabled {
palette.text_disabled
} else {
palette.text
};
(background, border, icon_color)
} else {
let mut visuals = semantic_button_visuals(
theme,
style.appearance,
style.tone,
enabled,
style.hover_progress,
style.press_progress,
);
if selected && enabled && style.appearance == ButtonAppearance::Filled {
let roles = theme.tone_roles(style.tone);
visuals.background = mix_color(
visuals.background,
roles.pressed,
interaction.selected_blend,
);
if style.tone != SemanticTone::Neutral {
visuals.border = visuals.background;
}
} else if selected && enabled {
let selection = if style.tone == SemanticTone::Neutral {
palette.text
} else {
theme.semantic_tone_color(style.tone)
};
visuals.background = if style.tone == SemanticTone::Neutral {
palette.selection
} else {
mix_color(visuals.background, selection, interaction.selected_blend)
};
visuals.border = if style.tone == SemanticTone::Neutral {
palette.selection_border
} else {
mix_color(visuals.border, selection, 0.72)
};
visuals.content = selection;
}
visuals.border = if enabled && !selected {
mix_color(visuals.border, palette.border_focus, focus_progress)
} else {
visuals.border
};
(visuals.background, visuals.border, visuals.content)
};
let icon_size = style
.icon_size
.unwrap_or(metrics.icon_size)
.min(rect.width().min(rect.height()))
.max(0.0);
draw_control_frame(
ctx,
rect,
metrics.corner_radius,
metrics,
background,
border,
(focus_progress > 0.0).then_some(
palette
.focus_ring
.with_alpha(palette.focus_ring.alpha * focus_progress),
),
);
Some((center_square(rect, icon_size), icon_color))
}
#[derive(Clone, Copy)]
enum ButtonIcon {
Glyph(IconGlyph),
Image(sui_core::ImageHandle),
}
pub struct IconButton {
theme: Box<DefaultTheme>,
theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
icon: ButtonIcon,
label: String,
semantic_description: Option<String>,
appearance: ButtonAppearance,
tone: SemanticTone,
size: Option<f32>,
icon_size: Option<f32>,
selected: bool,
selected_reader: Option<Box<dyn Fn() -> bool>>,
enabled: Binding<bool>,
interaction: PressInteraction,
focus_animation: AnimatedScalar,
on_press: Option<Box<dyn FnMut()>>,
on_press_with_ctx: Option<Box<dyn FnMut(&mut EventCtx)>>,
}
impl IconButton {
pub fn new(icon: IconGlyph, label: impl Into<String>) -> Self {
Self::with_icon(ButtonIcon::Glyph(icon), label.into())
}
pub fn from_image(icon: sui_core::ImageHandle, label: impl Into<String>) -> Self {
Self::with_icon(ButtonIcon::Image(icon), label.into())
}
fn with_icon(icon: ButtonIcon, label: String) -> Self {
Self {
theme: Box::new(DefaultTheme::default()),
theme_reader: None,
icon,
label,
semantic_description: None,
appearance: ButtonAppearance::Tonal,
tone: SemanticTone::Neutral,
size: None,
icon_size: None,
selected: false,
selected_reader: None,
enabled: Binding::new(true),
interaction: PressInteraction::default(),
focus_animation: AnimatedScalar::new(0.0),
on_press: None,
on_press_with_ctx: None,
}
}
pub fn theme(mut self, theme: DefaultTheme) -> Self {
self.theme = Box::new(theme);
self.theme_reader = None;
self
}
pub fn description(mut self, description: impl Into<String>) -> Self {
self.semantic_description = Some(description.into());
self
}
pub fn appearance(mut self, appearance: ButtonAppearance) -> Self {
self.appearance = appearance;
self
}
pub fn tone(mut self, tone: SemanticTone) -> Self {
self.tone = tone;
self
}
pub fn theme_when<F>(mut self, theme: F) -> Self
where
F: Fn() -> DefaultTheme + 'static,
{
self.theme_reader = Some(Box::new(theme));
self
}
pub fn size(mut self, size: f32) -> Self {
self.size = Some(size.max(0.0));
self
}
pub fn icon_size(mut self, icon_size: f32) -> Self {
self.icon_size = Some(icon_size.max(0.0));
self
}
pub fn selected(mut self, selected: bool) -> Self {
self.selected = selected;
self.selected_reader = None;
self
}
pub fn selected_when<F>(mut self, selected: F) -> Self
where
F: Fn() -> bool + 'static,
{
self.selected_reader = Some(Box::new(selected));
self
}
pub fn enabled(mut self, enabled: bool) -> Self {
self.enabled.set(enabled);
self
}
pub fn enabled_when<F>(mut self, enabled: F) -> Self
where
F: Fn() -> bool + 'static,
{
self.enabled.set_when(enabled);
self
}
pub fn enabled_from<O>(mut self, enabled: O) -> Self
where
O: Observable<bool> + 'static,
{
self.enabled.set_from(enabled);
self
}
pub fn interaction_preview(mut self, preview: InteractionPreview) -> Self {
self.interaction.preview = preview;
self
}
pub fn focus_on_press(mut self, focus: bool) -> Self {
self.interaction.focus_on_press = focus;
self
}
pub fn on_press<F>(mut self, on_press: F) -> Self
where
F: FnMut() + 'static,
{
self.on_press = Some(Box::new(on_press));
self
}
pub fn on_press_with_ctx<F>(mut self, on_press: F) -> Self
where
F: FnMut(&mut EventCtx) + 'static,
{
self.on_press_with_ctx = Some(Box::new(on_press));
self
}
fn resolved_theme(&self) -> DefaultTheme {
self.theme_reader
.as_ref()
.map(|theme| theme())
.unwrap_or(*self.theme)
}
fn resolved_size(&self) -> f32 {
let theme = self.resolved_theme();
self.size
.unwrap_or(theme.metrics.icon_button_size)
.max(theme.metrics.min_height)
}
fn resolved_icon_size(&self) -> f32 {
let theme = self.resolved_theme();
self.icon_size
.unwrap_or(theme.metrics.icon_size)
.min(self.resolved_size())
.max(0.0)
}
fn is_selected(&self) -> bool {
self.selected_reader
.as_ref()
.map(|selected| selected())
.unwrap_or(self.selected)
}
pub fn is_enabled(&self) -> bool {
self.enabled.get()
}
fn observe_enabled<T>(&self, observe: impl FnOnce(&dyn Observable<bool>) -> T) {
self.enabled.observe(|source| {
observe(source);
});
}
fn activate(&mut self, ctx: &mut EventCtx) {
if !self.is_enabled() {
return;
}
if let Some(on_press) = &mut self.on_press {
on_press();
}
if let Some(on_press) = &mut self.on_press_with_ctx {
on_press(ctx);
}
}
}
impl Widget for IconButton {
fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
let enabled = self.is_enabled();
let theme = &self.theme;
let reader = &self.theme_reader;
let activate = self.interaction.event(ctx, event, enabled, || {
reader.as_ref().map(|read| read()).unwrap_or(**theme)
});
if activate {
self.activate(ctx);
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
}
fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
let side = self.resolved_size();
constraints.clamp(Size::new(side, side))
}
fn paint(&self, ctx: &mut PaintCtx) {
self.observe_enabled(|source| ctx.observe(source));
let theme = self.resolved_theme();
let style = IconButtonPaint::new()
.appearance(self.appearance)
.tone(self.tone)
.selected(self.is_selected())
.enabled(self.is_enabled())
.hover_progress(self.interaction.hover_progress(ctx))
.press_progress(self.interaction.press_progress(ctx))
.focus_progress(
self.focus_animation
.get(ctx)
.max(self.interaction.preview.focus()),
)
.icon_size(self.resolved_icon_size());
match self.icon {
ButtonIcon::Glyph(icon) => paint_icon_button(ctx, &theme, ctx.bounds(), icon, style),
ButtonIcon::Image(icon) => {
if let Some((bounds, color)) =
paint_icon_button_frame(ctx, &theme, ctx.bounds(), style)
{
ctx.draw_image_source(
bounds,
sui_scene::ImageSource::new(icon).with_tint(color),
);
}
}
}
}
fn semantics(&self, ctx: &mut SemanticsCtx) {
self.observe_enabled(|source| ctx.observe(source));
let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::Button, ctx.bounds());
node.name = Some(self.label.clone());
node.description = self.semantic_description.clone();
node.state.focused = ctx.is_focused();
node.state.hovered = self.interaction.hovered && self.is_enabled();
node.state.selected = self.is_selected();
node.state.disabled = !self.is_enabled();
node.actions = if self.is_enabled() {
vec![SemanticsAction::Focus, SemanticsAction::Activate]
} else {
Vec::new()
};
ctx.push(node);
}
fn accepts_focus(&self) -> bool {
self.is_enabled()
}
fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
let theme = self.resolved_theme();
set_focus_animation_target(&mut self.focus_animation, focused as u8 as f32, &theme, ctx);
ctx.request_paint();
ctx.request_semantics();
}
}
mod text_display;
pub use text_display::{Label, Link};
pub struct Button {
theme: Box<DefaultTheme>,
theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
label: String,
label_reader: Option<Box<dyn Fn() -> String>>,
semantic_name: Option<String>,
semantic_description: Option<String>,
appearance: ButtonAppearance,
tone: SemanticTone,
text_style: Option<TextStyle>,
icon: Option<IconGlyph>,
icon_size: Option<f32>,
icon_gap: Option<f32>,
padding: Option<Insets>,
min_width: Option<f32>,
min_width_metric: Option<fn(&DefaultTheme) -> f32>,
min_height: Option<f32>,
interaction: PressInteraction,
focus_animation: AnimatedScalar,
label_measurement: Option<TextMeasurement>,
label_layout: Option<PersistentTextLayout>,
enabled: Binding<bool>,
glow: bool,
on_press: Option<Box<dyn FnMut()>>,
on_press_with_ctx: Option<Box<dyn FnMut(&mut EventCtx)>>,
}
#[derive(Debug, Clone, Copy, PartialEq)]
struct ButtonVisuals {
background: Color,
border: Color,
focus_ring: Option<Color>,
label_color: Color,
label_peak_lift: f32,
chrome_style: Option<ResolvedHdrStyle>,
}
impl Button {
pub fn new(label: impl Into<String>) -> Self {
Self {
theme: Box::new(DefaultTheme::default()),
theme_reader: None,
label: label.into(),
label_reader: None,
semantic_name: None,
semantic_description: None,
appearance: ButtonAppearance::Tonal,
tone: SemanticTone::Neutral,
text_style: None,
icon: None,
icon_size: None,
icon_gap: None,
padding: None,
min_width: None,
min_width_metric: None,
min_height: None,
interaction: PressInteraction::default(),
focus_animation: AnimatedScalar::new(0.0),
label_measurement: None,
label_layout: None,
enabled: Binding::new(true),
glow: true,
on_press: None,
on_press_with_ctx: None,
}
}
pub fn primary(label: impl Into<String>) -> Self {
Self::new(label).primary_action()
}
pub fn danger(label: impl Into<String>) -> Self {
Self::new(label).danger_action()
}
pub fn current_label(&self) -> &str {
&self.label
}
pub fn set_label(&mut self, label: impl Into<String>) {
self.label = label.into();
}
pub fn semantic_name(mut self, name: impl Into<String>) -> Self {
self.semantic_name = Some(name.into());
self
}
pub fn description(mut self, description: impl Into<String>) -> Self {
self.semantic_description = Some(description.into());
self
}
pub fn appearance(mut self, appearance: ButtonAppearance) -> Self {
self.appearance = appearance;
self
}
pub fn tone(mut self, tone: SemanticTone) -> Self {
self.tone = tone;
self
}
pub fn primary_action(mut self) -> Self {
self.appearance = ButtonAppearance::Filled;
self.tone = SemanticTone::Accent;
self
}
pub fn danger_action(mut self) -> Self {
self.appearance = ButtonAppearance::Filled;
self.tone = SemanticTone::Danger;
self
}
pub fn theme(mut self, theme: DefaultTheme) -> Self {
self.theme = Box::new(theme);
self.theme_reader = None;
self
}
pub fn theme_when<F>(mut self, theme: F) -> Self
where
F: Fn() -> DefaultTheme + 'static,
{
self.theme_reader = Some(Box::new(theme));
self
}
pub fn text_style(mut self, text_style: TextStyle) -> Self {
self.text_style = Some(text_style);
self
}
pub fn icon(mut self, icon: IconGlyph) -> Self {
self.icon = Some(icon);
self
}
pub fn without_icon(mut self) -> Self {
self.icon = None;
self
}
pub fn icon_size(mut self, icon_size: f32) -> Self {
self.icon_size = Some(icon_size.max(0.0));
self
}
pub fn icon_gap(mut self, icon_gap: f32) -> Self {
self.icon_gap = Some(icon_gap.max(0.0));
self
}
pub fn min_width(mut self, width: f32) -> Self {
self.min_width = Some(width.max(0.0));
self.min_width_metric = None;
self
}
pub(crate) fn min_width_from_theme(mut self, metric: fn(&DefaultTheme) -> f32) -> Self {
self.min_width = None;
self.min_width_metric = Some(metric);
self
}
pub fn min_height(mut self, height: f32) -> Self {
self.min_height = Some(height.max(0.0));
self
}
pub fn padding(mut self, padding: Insets) -> Self {
self.padding = Some(padding);
self
}
pub fn enabled(mut self, enabled: bool) -> Self {
self.enabled.set(enabled);
self
}
pub fn enabled_when<F>(mut self, enabled: F) -> Self
where
F: Fn() -> bool + 'static,
{
self.enabled.set_when(enabled);
self
}
pub fn enabled_from<O>(mut self, enabled: O) -> Self
where
O: Observable<bool> + 'static,
{
self.enabled.set_from(enabled);
self
}
pub fn interaction_preview(mut self, preview: InteractionPreview) -> Self {
self.interaction.preview = preview;
self
}
pub fn focus_on_press(mut self, focus: bool) -> Self {
self.interaction.focus_on_press = focus;
self
}
pub fn on_press<F>(mut self, on_press: F) -> Self
where
F: FnMut() + 'static,
{
self.on_press = Some(Box::new(on_press));
self
}
pub fn on_press_with_ctx<F>(mut self, on_press: F) -> Self
where
F: FnMut(&mut EventCtx) + 'static,
{
self.on_press_with_ctx = Some(Box::new(on_press));
self
}
fn activate(&mut self, ctx: &mut EventCtx) {
if !self.is_enabled() {
return;
}
if let Some(on_press) = &mut self.on_press {
on_press();
}
if let Some(on_press) = &mut self.on_press_with_ctx {
on_press(ctx);
}
}
pub fn is_enabled(&self) -> bool {
self.enabled.get()
}
fn observe_enabled<T>(&self, observe: impl FnOnce(&dyn Observable<bool>) -> T) {
self.enabled.observe(|source| {
observe(source);
});
}
fn resolved_theme(&self) -> DefaultTheme {
self.theme_reader
.as_ref()
.map(|theme| theme())
.unwrap_or(*self.theme)
}
fn resolved_text_style(&self) -> TextStyle {
self.text_style
.clone()
.unwrap_or_else(|| self.resolved_theme().button_text_style())
}
fn resolved_padding(&self) -> Insets {
self.padding
.unwrap_or(self.resolved_theme().metrics.button_padding)
}
fn resolved_icon_size(&self) -> f32 {
self.icon_size
.unwrap_or(self.resolved_theme().metrics.icon_size)
.max(0.0)
}
fn resolved_icon_gap(&self) -> f32 {
self.icon_gap
.unwrap_or(self.resolved_theme().metrics.icon_label_gap)
.max(0.0)
}
fn icon_extent(&self) -> Option<(f32, f32)> {
self.icon.map(|_| {
let icon_size = self.resolved_icon_size();
let gap = if self.label.is_empty() {
0.0
} else {
self.resolved_icon_gap()
};
(icon_size, gap)
})
}
fn resolved_min_size(&self) -> Size {
let theme = self.resolved_theme();
Size::new(
self.min_width
.or_else(|| self.min_width_metric.map(|metric| metric(&theme).max(0.0)))
.unwrap_or(theme.metrics.button_min_width),
self.min_height.unwrap_or(theme.metrics.min_height),
)
}
pub fn glow(mut self, glow: bool) -> Self {
self.glow = glow;
self
}
fn glows(&self) -> bool {
self.glow
&& self.is_enabled()
&& self.appearance == ButtonAppearance::Filled
&& self.tone == SemanticTone::Accent
}
#[cfg(test)]
fn resolved_visuals(&self, focused: bool) -> ButtonVisuals {
self.resolved_visuals_with_focus_progress(focused as u8 as f32, &0.0, None)
}
fn resolved_visuals_with_focus_progress(
&self,
focus_progress: f32,
clock: &impl FrameClock,
output: Option<OutputColorRange>,
) -> ButtonVisuals {
let mut theme = self.resolved_theme();
theme.hdr = theme.hdr.limited_to(output);
let palette = theme.palette;
let interaction = theme.interaction;
let enabled = self.is_enabled();
let focus_progress = if enabled {
focus_progress.clamp(0.0, 1.0)
} else {
0.0
};
let hover_progress = if enabled {
self.interaction.hover_progress(clock) * interaction.hover_blend
} else {
0.0
};
let press_progress = if enabled {
self.interaction.press_progress(clock) * interaction.pressed_blend
} else {
0.0
};
let legacy_default =
self.appearance == ButtonAppearance::Filled && self.tone == SemanticTone::Accent;
if !legacy_default {
let semantic = semantic_button_visuals(
&theme,
self.appearance,
self.tone,
enabled,
self.interaction.hover_progress(clock),
self.interaction.press_progress(clock),
);
let label_peak_lift = resolve_luminance_role(&theme.hdr, WidgetLuminanceRole::Standard);
let label_color = if enabled {
apply_hdr_policy_cap(
self.text_style
.as_ref()
.map(|style| style.color)
.unwrap_or(semantic.content),
label_peak_lift,
)
} else {
apply_hdr_policy_cap(semantic.content, label_peak_lift)
};
return ButtonVisuals {
background: semantic.background,
border: if enabled {
mix_color(semantic.border, palette.border_focus, focus_progress)
} else {
semantic.border
},
focus_ring: (focus_progress > 0.0).then_some(
palette
.focus_ring
.with_alpha(palette.focus_ring.alpha * focus_progress),
),
label_color,
label_peak_lift,
chrome_style: None,
};
}
let background = if !enabled {
mix_color(palette.control, palette.accent, 0.08)
.with_alpha(interaction.disabled_opacity)
} else {
mix_color(
mix_color(palette.accent, palette.accent_hover, hover_progress),
palette.accent_pressed,
press_progress,
)
};
let border = background;
let label_peak_lift = resolve_luminance_role(&theme.hdr, WidgetLuminanceRole::Standard);
let label_color = if enabled {
apply_hdr_policy_cap(self.resolved_text_style().color, label_peak_lift)
} else {
apply_hdr_policy_cap(palette.text_muted, label_peak_lift)
};
if matches!(theme.hdr.mode, HdrThemeMode::Disabled) {
return ButtonVisuals {
background,
border,
focus_ring: (focus_progress > 0.0).then_some(
palette
.focus_ring
.with_alpha(palette.focus_ring.alpha * focus_progress),
),
label_color,
label_peak_lift,
chrome_style: None,
};
}
let chrome_style = cap_resolved_hdr_style(resolve_widget_hdr_style(
&theme.hdr,
WidgetColorRole::Accent,
WidgetLuminanceRole::SemanticAccent,
WidgetMaterialRole::Flat,
None,
));
let focus_style = cap_resolved_hdr_style(resolve_widget_hdr_style(
&theme.hdr,
WidgetColorRole::Accent,
WidgetLuminanceRole::Focused,
WidgetMaterialRole::Flat,
None,
));
let hdr_background = if !enabled {
background
} else {
mix_color(
mix_color(chrome_style.color, palette.accent_hover, hover_progress),
palette.accent_pressed,
press_progress,
)
};
let hdr_border = hdr_background;
ButtonVisuals {
background: hdr_background,
border: hdr_border,
focus_ring: (focus_progress > 0.0).then_some(
focus_style
.color
.with_alpha(palette.focus_ring.alpha * focus_progress),
),
label_color,
label_peak_lift,
chrome_style: Some(chrome_style),
}
}
fn button_content_rects(
&self,
bounds: Rect,
padding: Insets,
) -> (Option<Rect>, Rect, TextAlign) {
let content = inset_rect(bounds, padding);
let Some((icon_size, icon_gap)) = self.icon_extent() else {
return (None, content, TextAlign::Center);
};
let measurement = self.label_measurement;
let natural_label_width = measurement.map(|value| value.width).unwrap_or(0.0);
let icon_size = icon_size
.min(content.width())
.min(content.height())
.max(0.0);
let gap = if icon_size > 0.0 && natural_label_width > 0.0 {
icon_gap.min(content.width())
} else {
0.0
};
let label_width = natural_label_width.min((content.width() - icon_size - gap).max(0.0));
let group_width = icon_size + gap + label_width;
let start_x = content.x() + ((content.width() - group_width).max(0.0) * 0.5);
let icon_rect = Rect::new(
start_x,
content.y() + ((content.height() - icon_size) * 0.5),
icon_size,
icon_size,
);
let label_base = Rect::new(
start_x + icon_size + gap,
content.y(),
label_width,
content.height(),
);
(Some(icon_rect), label_base, TextAlign::Start)
}
}
impl Button {
pub fn label_when<F>(mut self, reader: F) -> Self
where
F: Fn() -> String + 'static,
{
self.label = reader();
self.label_reader = Some(Box::new(reader));
self
}
fn sync_label_reader(&mut self) {
if let Some(reader) = &self.label_reader {
let label = reader();
if label != self.label {
self.label = label;
}
}
}
}
impl Widget for Button {
fn supports_output_reuse(&self) -> bool {
self.theme_reader.is_none() && !self.enabled.is_live()
}
fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
self.sync_label_reader();
let enabled = self.is_enabled();
let theme = &self.theme;
let reader = &self.theme_reader;
let activate = self.interaction.event(ctx, event, enabled, || {
reader.as_ref().map(|read| read()).unwrap_or(**theme)
});
if activate {
self.activate(ctx);
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
}
fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
self.sync_label_reader();
let text_style = self.resolved_text_style();
let padding = self.resolved_padding();
let min_size = self.resolved_min_size();
let label_layout = ctx
.layout()
.layout_document_persistent(
self.label_layout.as_ref().map(|layout| layout.handle()),
sui_text::TextLayoutRequest::new(sui_text::TextDocument::from_plain_text(
self.label.clone(),
text_style.clone(),
)),
)
.ok();
let measurement = label_layout
.as_ref()
.map(|layout| layout.measurement())
.unwrap_or(TextMeasurement {
width: 0.0,
height: text_style.line_height,
bounds: Rect::new(0.0, 0.0, 0.0, text_style.line_height),
ascent: text_style.font_size,
descent: 0.0,
cap_height: Some(text_style.font_size),
});
self.label_measurement = Some(measurement);
self.label_layout = label_layout;
let (icon_size, icon_gap) = self.icon_extent().unwrap_or((0.0, 0.0));
let content_width = icon_size + icon_gap + measurement.width;
let content_height = measurement
.height
.max(text_style.line_height)
.max(icon_size);
let width = (content_width + padding.left + padding.right).max(min_size.width);
let height = (content_height + padding.top + padding.bottom).max(min_size.height);
constraints.clamp(Size::new(width, height))
}
fn paint(&self, ctx: &mut PaintCtx) {
self.observe_enabled(|source| ctx.observe(source));
let theme = self.resolved_theme();
let metrics = theme.metrics;
let text_style = self.resolved_text_style();
let padding = self.resolved_padding();
let visuals = self.resolved_visuals_with_focus_progress(
self.focus_animation
.get(ctx)
.max(self.interaction.preview.focus()),
ctx,
ctx.output_color_range(),
);
if self.glows() {
let glow = theme.glow_for_output(GlowTone::Accent, ctx.output_color_range());
paint_theme_glow(ctx, ctx.bounds(), [metrics.corner_radius; 4], &glow);
}
draw_control_frame(
ctx,
ctx.bounds(),
metrics.corner_radius,
metrics,
visuals.background,
visuals.border,
visuals.focus_ring,
);
let (icon_rect, label_slot, label_alignment) =
self.button_content_rects(ctx.bounds(), padding);
if let (Some(icon), Some(icon_rect)) = (self.icon, icon_rect) {
draw_icon_glyph(ctx, icon, icon_rect, visuals.label_color);
}
ctx.push_clip_rect(label_slot);
if self.is_enabled()
&& let Some(layout) = &self.label_layout
{
let layout_rect = aligned_text_rect_for_layout_with_mode(
ctx,
label_slot,
layout.layout(),
text_style.line_height,
alignment_fraction(label_alignment),
HorizontalTextAlignmentMode::Optical,
);
let layout_bounds = layout.measurement().bounds;
ctx.draw_persistent_text_layout_with_color(
Point::new(layout_rect.x() - layout_bounds.x(), layout_rect.y()),
layout,
visuals.label_color,
);
ctx.pop_clip();
return;
}
let paint_style = TextStyle {
color: visuals.label_color,
..text_style
};
paint_text(ctx, label_slot, &self.label, &paint_style, label_alignment);
ctx.pop_clip();
}
fn semantics(&self, ctx: &mut SemanticsCtx) {
self.observe_enabled(|source| ctx.observe(source));
let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::Button, ctx.bounds());
node.name = Some(
self.semantic_name
.clone()
.unwrap_or_else(|| self.label.clone()),
);
node.description = self.semantic_description.clone();
node.state.focused = ctx.is_focused();
node.state.hovered = self.interaction.hovered && self.is_enabled();
node.state.disabled = !self.is_enabled();
node.actions = if self.is_enabled() {
vec![SemanticsAction::Focus, SemanticsAction::Activate]
} else {
Vec::new()
};
ctx.push(node);
}
fn accepts_focus(&self) -> bool {
self.is_enabled()
}
fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
let theme = self.resolved_theme();
set_focus_animation_target(&mut self.focus_animation, focused as u8 as f32, &theme, ctx);
ctx.request_paint();
ctx.request_semantics();
}
}
pub struct Checkbox {
theme: Box<DefaultTheme>,
theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
label: String,
label_reader: Option<Box<dyn Fn() -> String>>,
enabled: Binding<bool>,
semantic_name: Option<String>,
checked: bool,
checked_reader: Option<Box<dyn Fn() -> bool>>,
checked_source: Option<Arc<dyn Observable<bool>>>,
appearance: ChoiceAppearance,
text_style: Option<TextStyle>,
padding: Option<Insets>,
indicator_size: Option<f32>,
gap: Option<f32>,
hovered: bool,
pressed: bool,
hover_animation: AnimatedScalar,
press_animation: AnimatedScalar,
toggle_animation: AnimatedScalar,
focus_animation: AnimatedScalar,
label_measurement: Option<TextMeasurement>,
on_change: Option<Box<dyn FnMut(bool)>>,
on_change_with_ctx: Option<Box<dyn FnMut(&mut EventCtx, bool)>>,
preview: InteractionPreview,
}
#[derive(Clone, Copy, Debug, Default, PartialEq)]
pub struct CheckboxIndicatorState {
pub checked: bool,
pub hovered: bool,
pub pressed: bool,
pub focused: bool,
}
impl CheckboxIndicatorState {
pub fn new(checked: bool) -> Self {
Self {
checked,
hovered: false,
pressed: false,
focused: false,
}
}
pub fn hovered(mut self, hovered: bool) -> Self {
self.hovered = hovered;
self
}
pub fn pressed(mut self, pressed: bool) -> Self {
self.pressed = pressed;
self
}
pub fn focused(mut self, focused: bool) -> Self {
self.focused = focused;
self
}
}
#[derive(Clone, Copy, Debug, Default)]
struct CheckboxIndicatorVisual {
hover_progress: f32,
press_progress: f32,
toggle_progress: f32,
}
pub fn paint_checkbox_indicator(
ctx: &mut PaintCtx,
theme: &DefaultTheme,
rect: Rect,
state: CheckboxIndicatorState,
) {
paint_checkbox_indicator_visual(
ctx,
theme,
rect,
CheckboxIndicatorVisual {
hover_progress: state.hovered as u8 as f32,
press_progress: state.pressed as u8 as f32,
toggle_progress: state.checked as u8 as f32,
},
);
}
fn paint_checkbox_indicator_visual(
ctx: &mut PaintCtx,
theme: &DefaultTheme,
rect: Rect,
visual: CheckboxIndicatorVisual,
) {
if rect.width() <= 0.0 || rect.height() <= 0.0 {
return;
}
let palette = theme.palette;
let metrics = theme.metrics;
let interaction = theme.interaction;
let (indicator_background, indicator_border) = choice_indicator_colors(
&palette,
visual.hover_progress * interaction.hover_blend,
visual.press_progress * interaction.pressed_blend,
visual.toggle_progress,
);
draw_control_shape(
ctx,
rect,
metrics.indicator_corner_radius,
physical_pixels(ctx, metrics.border_width),
indicator_background,
indicator_border,
);
if visual.toggle_progress > 0.0 {
let check_color = palette.accent_text.with_alpha(visual.toggle_progress);
ctx.stroke(
checkmark_path(rect.inflate(-4.0, -4.0)),
check_color,
StrokeStyle::new(physical_pixels(ctx, interaction.active_indicator_thickness)),
);
}
}
impl Checkbox {
pub fn new(label: impl Into<String>) -> Self {
Self {
theme: Box::new(DefaultTheme::default()),
theme_reader: None,
label: label.into(),
label_reader: None,
enabled: Binding::new(true),
semantic_name: None,
checked: false,
checked_reader: None,
checked_source: None,
appearance: ChoiceAppearance::Plain,
text_style: None,
padding: None,
indicator_size: None,
gap: None,
hovered: false,
pressed: false,
hover_animation: AnimatedScalar::new(0.0),
press_animation: AnimatedScalar::new(0.0),
toggle_animation: AnimatedScalar::new(0.0),
focus_animation: AnimatedScalar::new(0.0),
preview: InteractionPreview::None,
label_measurement: None,
on_change: None,
on_change_with_ctx: None,
}
}
pub fn checked(mut self, checked: bool) -> Self {
self.checked = checked;
self.toggle_animation = AnimatedScalar::new(checked as u8 as f32);
self
}
pub fn semantic_name(mut self, name: impl Into<String>) -> Self {
self.semantic_name = Some(name.into());
self
}
pub fn checked_when<F>(mut self, checked: F) -> Self
where
F: Fn() -> bool + 'static,
{
let current = checked();
self.checked_reader = Some(Box::new(checked));
self.checked_source = None;
self.checked(current)
}
pub fn checked_from<O>(mut self, checked: O) -> Self
where
O: Observable<bool> + 'static,
{
let current = checked.get();
self.checked_source = Some(Arc::new(checked));
self.checked_reader = None;
self.checked(current)
}
pub fn enabled(mut self, enabled: bool) -> Self {
self.enabled.set(enabled);
self
}
pub fn enabled_when<F>(mut self, enabled: F) -> Self
where
F: Fn() -> bool + 'static,
{
self.enabled.set_when(enabled);
self
}
pub fn enabled_from<O>(mut self, enabled: O) -> Self
where
O: Observable<bool> + 'static,
{
self.enabled.set_from(enabled);
self
}
pub fn is_enabled(&self) -> bool {
self.enabled.get()
}
fn paint_theme(&self) -> DefaultTheme {
let theme = self.resolved_theme();
if self.enabled.get() {
theme
} else {
theme.for_disabled_control()
}
}
fn current_checked(&self) -> bool {
if let Some(source) = &self.checked_source {
return source.get();
}
self.checked_reader
.as_ref()
.map_or(self.checked, |checked| checked())
}
fn observe_checked<T>(&self, observe: impl FnOnce(&dyn Observable<bool>) -> T) {
if let Some(source) = &self.checked_source {
observe(source.as_ref());
}
}
fn sync_checked(&mut self) -> bool {
let current = self.current_checked();
if current == self.checked {
return false;
}
self.checked = current;
self.toggle_animation.jump_to(current as u8 as f32);
true
}
pub fn is_checked(&self) -> bool {
self.current_checked()
}
pub fn appearance(mut self, appearance: ChoiceAppearance) -> Self {
self.appearance = appearance;
self
}
pub fn plain(self) -> Self {
self.appearance(ChoiceAppearance::Plain)
}
pub fn framed(self) -> Self {
self.appearance(ChoiceAppearance::Framed)
}
pub fn theme(mut self, theme: DefaultTheme) -> Self {
self.theme = Box::new(theme);
self.theme_reader = None;
self
}
pub fn theme_when<F>(mut self, theme: F) -> Self
where
F: Fn() -> DefaultTheme + 'static,
{
self.theme_reader = Some(Box::new(theme));
self
}
pub fn text_style(mut self, text_style: TextStyle) -> Self {
self.text_style = Some(text_style);
self
}
pub fn padding(mut self, padding: Insets) -> Self {
self.padding = Some(padding);
self
}
pub fn indicator_size(mut self, indicator_size: f32) -> Self {
self.indicator_size = Some(indicator_size.max(0.0));
self
}
pub fn gap(mut self, gap: f32) -> Self {
self.gap = Some(gap.max(0.0));
self
}
pub fn set_checked(&mut self, checked: bool) {
self.checked = checked;
self.toggle_animation = AnimatedScalar::new(checked as u8 as f32);
}
pub fn interaction_preview(mut self, preview: InteractionPreview) -> Self {
self.preview = preview;
self
}
pub fn on_change<F>(mut self, on_change: F) -> Self
where
F: FnMut(bool) + 'static,
{
self.on_change = Some(Box::new(on_change));
self
}
pub fn on_change_with_ctx<F>(mut self, on_change: F) -> Self
where
F: FnMut(&mut EventCtx, bool) + 'static,
{
self.on_change_with_ctx = Some(Box::new(on_change));
self
}
fn toggle(&mut self, ctx: &mut EventCtx) {
self.checked = !self.current_checked();
if let Some(on_change) = &mut self.on_change {
on_change(self.checked);
}
if let Some(on_change) = &mut self.on_change_with_ctx {
on_change(ctx, self.checked);
}
}
fn set_hovered(&mut self, hovered: bool, ctx: &mut EventCtx) {
if self.hovered != hovered {
let theme = self.resolved_theme();
self.hovered = hovered;
set_hover_animation_target(
&mut self.hover_animation,
hovered as u8 as f32,
&theme,
ctx,
);
ctx.request_paint();
ctx.request_semantics();
}
}
fn resolved_text_style(&self) -> TextStyle {
self.text_style
.clone()
.unwrap_or_else(|| self.resolved_theme().body_text_style())
}
fn resolved_padding(&self) -> Insets {
self.padding
.unwrap_or(self.resolved_theme().metrics.checkbox_padding)
}
fn resolved_indicator_size(&self) -> f32 {
self.indicator_size
.unwrap_or(self.resolved_theme().metrics.checkbox_indicator_size)
}
fn resolved_gap(&self) -> f32 {
self.gap
.unwrap_or(self.resolved_theme().metrics.checkbox_gap)
}
fn resolved_theme(&self) -> DefaultTheme {
self.theme_reader
.as_ref()
.map(|theme| theme())
.unwrap_or(*self.theme)
}
fn hover_value(&self, clock: &impl FrameClock) -> f32 {
if !self.enabled.get() {
return 0.0;
}
self.hover_animation.get(clock).max(self.preview.hover())
}
fn press_value(&self, clock: &impl FrameClock) -> f32 {
if !self.enabled.get() {
return 0.0;
}
self.press_animation.get(clock).max(self.preview.press())
}
fn focus_value(&self, clock: &impl FrameClock) -> f32 {
if !self.enabled.get() {
return 0.0;
}
self.focus_animation.get(clock).max(self.preview.focus())
}
}
impl Checkbox {
pub fn label_when<F>(mut self, reader: F) -> Self
where
F: Fn() -> String + 'static,
{
self.label = reader();
self.label_reader = Some(Box::new(reader));
self
}
fn sync_label_reader(&mut self) {
if let Some(reader) = &self.label_reader {
let label = reader();
if label != self.label {
self.label = label;
}
}
}
}
impl Widget for Checkbox {
fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
self.sync_label_reader();
if self.sync_checked() {
ctx.request_paint();
ctx.request_semantics();
}
if !self.enabled.get() {
if let Event::Pointer(pointer) = event
&& pointer.kind == PointerEventKind::Up
&& self.pressed
{
self.pressed = false;
ctx.release_pointer_capture(pointer.pointer_id);
ctx.request_paint();
}
return;
}
match event {
Event::Pointer(pointer) if pointer.kind == PointerEventKind::Move => {
self.set_hovered(ctx.bounds().contains(pointer.position), ctx);
}
Event::Pointer(_pointer) if matches!(_pointer.kind, PointerEventKind::Enter) => {
self.set_hovered(true, ctx);
}
Event::Pointer(_pointer) if matches!(_pointer.kind, PointerEventKind::Leave) => {
self.set_hovered(false, ctx);
}
Event::Pointer(pointer)
if pointer.kind == PointerEventKind::Down
&& pointer.button == Some(PointerButton::Primary) =>
{
let theme = self.resolved_theme();
self.pressed = true;
self.hovered = true;
set_hover_animation_target(&mut self.hover_animation, 1.0, &theme, ctx);
set_press_animation_target(&mut self.press_animation, 1.0, &theme, ctx);
ctx.request_pointer_capture(pointer.pointer_id);
ctx.request_focus();
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
Event::Pointer(pointer)
if pointer.kind == PointerEventKind::Up
&& pointer.button == Some(PointerButton::Primary) =>
{
let theme = self.resolved_theme();
let hovered = ctx.bounds().contains(pointer.position);
let toggle = self.pressed && hovered;
self.pressed = false;
self.hovered = hovered;
set_hover_animation_target(
&mut self.hover_animation,
hovered as u8 as f32,
&theme,
ctx,
);
set_press_animation_target(&mut self.press_animation, 0.0, &theme, ctx);
ctx.release_pointer_capture(pointer.pointer_id);
if toggle {
self.toggle(ctx);
set_toggle_animation_target(
&mut self.toggle_animation,
self.checked as u8 as f32,
&theme,
ctx,
);
}
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
Event::Pointer(pointer) if pointer.kind == PointerEventKind::Cancel => {
if self.pressed {
let theme = self.resolved_theme();
self.pressed = false;
self.hovered = false;
set_hover_animation_target(&mut self.hover_animation, 0.0, &theme, ctx);
set_press_animation_target(&mut self.press_animation, 0.0, &theme, ctx);
ctx.release_pointer_capture(pointer.pointer_id);
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
}
Event::Keyboard(key)
if key.state == KeyState::Pressed
&& ctx.is_focused()
&& matches!(key.key.as_str(), "Enter" | " ") =>
{
let theme = self.resolved_theme();
self.toggle(ctx);
set_toggle_animation_target(
&mut self.toggle_animation,
self.checked as u8 as f32,
&theme,
ctx,
);
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
_ => {}
}
}
fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
self.sync_label_reader();
let theme = self.resolved_theme();
let text_style = self.resolved_text_style();
let padding = self.resolved_padding();
let indicator_size = self.resolved_indicator_size();
let gap = self.resolved_gap();
let measurement = measure_text(ctx, &self.label, &text_style);
self.label_measurement = Some(measurement);
let width = padding.left + indicator_size + gap + measurement.width + padding.right;
let content_height = indicator_size.max(measurement.height.max(text_style.line_height));
let height = choice_control_height(
content_height,
padding,
default_form_control_height(&theme),
self.padding.is_some(),
);
constraints.clamp(Size::new(width, height))
}
fn paint(&self, ctx: &mut PaintCtx) {
self.observe_checked(|source| ctx.observe(source));
self.enabled.observe(|source| {
ctx.observe(source);
});
let theme = self.paint_theme();
let palette = theme.palette;
let metrics = theme.metrics;
let interaction = theme.interaction;
let mut text_style = self.resolved_text_style();
if !self.enabled.get() {
text_style.color = theme.palette.text_disabled;
}
let padding = self.resolved_padding();
let indicator_size = self.resolved_indicator_size();
let gap = self.resolved_gap();
let hover_progress = self.hover_value(ctx) * interaction.hover_blend;
let press_progress = self.press_value(ctx) * interaction.pressed_blend;
let checked = self.current_checked();
let toggle_progress = if checked == (self.toggle_animation.target() > 0.5) {
self.toggle_animation.get(ctx)
} else {
checked as u8 as f32
};
let focus_progress = self.focus_value(ctx);
let (framed_background, framed_border) =
framed_choice_colors(&palette, hover_progress, press_progress, focus_progress);
let frame_visuals = choice_frame_visuals(
&theme,
self.appearance,
framed_background,
framed_border,
hover_progress,
press_progress,
focus_progress,
);
let layout_padding = choice_control_layout_padding(padding, self.padding.is_some());
let indicator = indicator_rect(ctx.bounds(), layout_padding, indicator_size);
let label_rect = checkbox_label_rect(ctx.bounds(), layout_padding, indicator_size, gap);
draw_choice_control_frame(
ctx,
ctx.bounds(),
metrics.corner_radius,
metrics,
self.appearance,
frame_visuals,
(focus_progress > 0.0).then_some(
palette
.focus_ring
.with_alpha(palette.focus_ring.alpha * focus_progress),
),
);
paint_checkbox_indicator_visual(
ctx,
&theme,
indicator,
CheckboxIndicatorVisual {
hover_progress: self.hover_value(ctx),
press_progress: self.press_value(ctx),
toggle_progress,
},
);
paint_text(ctx, label_rect, &self.label, &text_style, TextAlign::Start);
}
fn semantics(&self, ctx: &mut SemanticsCtx) {
self.observe_checked(|source| ctx.observe(source));
self.enabled.observe(|source| {
ctx.observe(source);
});
let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::CheckBox, ctx.bounds());
node.name = Some(
self.semantic_name
.clone()
.unwrap_or_else(|| self.label.clone()),
);
node.state.focused = ctx.is_focused();
node.state.hovered = self.hovered;
node.state.checked = Some(if self.current_checked() {
ToggleState::Checked
} else {
ToggleState::Unchecked
});
node.state.disabled = !self.enabled.get();
node.actions = if self.enabled.get() {
vec![SemanticsAction::Focus, SemanticsAction::Activate]
} else {
Vec::new()
};
ctx.push(node);
}
fn accepts_focus(&self) -> bool {
self.enabled.get()
}
fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
let theme = self.resolved_theme();
set_focus_animation_target(&mut self.focus_animation, focused as u8 as f32, &theme, ctx);
ctx.request_paint();
ctx.request_semantics();
}
}
pub struct Switch {
theme: Box<DefaultTheme>,
theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
label: String,
label_reader: Option<Box<dyn Fn() -> String>>,
enabled: Binding<bool>,
semantic_name: Option<String>,
checked: bool,
checked_reader: Option<Box<dyn Fn() -> bool>>,
checked_source: Option<Arc<dyn Observable<bool>>>,
appearance: ChoiceAppearance,
text_style: Option<TextStyle>,
padding: Option<Insets>,
gap: Option<f32>,
hovered: bool,
pressed: bool,
hover_animation: AnimatedScalar,
press_animation: AnimatedScalar,
toggle_animation: AnimatedScalar,
focus_animation: AnimatedScalar,
label_measurement: Option<TextMeasurement>,
on_change: Option<Box<dyn FnMut(bool)>>,
on_change_with_ctx: Option<Box<dyn FnMut(&mut EventCtx, bool)>>,
preview: InteractionPreview,
}
#[derive(Debug, Clone, Copy, PartialEq)]
struct SwitchVisuals {
frame_background: Color,
frame_border: Color,
track_color: Color,
track_border: Color,
thumb_color: Color,
label_color: Color,
label_peak_lift: f32,
indicator_style: Option<ResolvedHdrStyle>,
}
impl Switch {
pub fn new(label: impl Into<String>) -> Self {
Self {
theme: Box::new(DefaultTheme::default()),
theme_reader: None,
label: label.into(),
label_reader: None,
enabled: Binding::new(true),
semantic_name: None,
checked: false,
checked_reader: None,
checked_source: None,
appearance: ChoiceAppearance::Plain,
text_style: None,
padding: None,
gap: None,
hovered: false,
pressed: false,
hover_animation: AnimatedScalar::new(0.0),
press_animation: AnimatedScalar::new(0.0),
toggle_animation: AnimatedScalar::new(0.0),
focus_animation: AnimatedScalar::new(0.0),
preview: InteractionPreview::None,
label_measurement: None,
on_change: None,
on_change_with_ctx: None,
}
}
pub fn checked(mut self, checked: bool) -> Self {
self.checked = checked;
self.toggle_animation = AnimatedScalar::new(checked as u8 as f32);
self
}
pub fn semantic_name(mut self, name: impl Into<String>) -> Self {
self.semantic_name = Some(name.into());
self
}
pub fn checked_when<F>(mut self, checked: F) -> Self
where
F: Fn() -> bool + 'static,
{
let current = checked();
self.checked_reader = Some(Box::new(checked));
self.checked_source = None;
self.checked(current)
}
pub fn checked_from<O>(mut self, checked: O) -> Self
where
O: Observable<bool> + 'static,
{
let current = checked.get();
self.checked_source = Some(Arc::new(checked));
self.checked_reader = None;
self.checked(current)
}
pub fn enabled(mut self, enabled: bool) -> Self {
self.enabled.set(enabled);
self
}
pub fn enabled_when<F>(mut self, enabled: F) -> Self
where
F: Fn() -> bool + 'static,
{
self.enabled.set_when(enabled);
self
}
pub fn enabled_from<O>(mut self, enabled: O) -> Self
where
O: Observable<bool> + 'static,
{
self.enabled.set_from(enabled);
self
}
pub fn is_enabled(&self) -> bool {
self.enabled.get()
}
fn paint_theme(&self) -> DefaultTheme {
let theme = self.resolved_theme();
if self.enabled.get() {
theme
} else {
theme.for_disabled_control()
}
}
fn current_checked(&self) -> bool {
if let Some(source) = &self.checked_source {
return source.get();
}
self.checked_reader
.as_ref()
.map_or(self.checked, |checked| checked())
}
fn observe_checked<T>(&self, observe: impl FnOnce(&dyn Observable<bool>) -> T) {
if let Some(source) = &self.checked_source {
observe(source.as_ref());
}
}
fn sync_checked(&mut self) -> bool {
let current = self.current_checked();
if current == self.checked {
return false;
}
self.checked = current;
self.toggle_animation.jump_to(current as u8 as f32);
true
}
pub fn is_checked(&self) -> bool {
self.current_checked()
}
pub fn appearance(mut self, appearance: ChoiceAppearance) -> Self {
self.appearance = appearance;
self
}
pub fn plain(self) -> Self {
self.appearance(ChoiceAppearance::Plain)
}
pub fn framed(self) -> Self {
self.appearance(ChoiceAppearance::Framed)
}
pub fn set_checked(&mut self, checked: bool) {
self.checked = checked;
self.toggle_animation = AnimatedScalar::new(checked as u8 as f32);
}
pub fn theme(mut self, theme: DefaultTheme) -> Self {
self.theme = Box::new(theme);
self.theme_reader = None;
self
}
pub fn theme_when<F>(mut self, theme: F) -> Self
where
F: Fn() -> DefaultTheme + 'static,
{
self.theme_reader = Some(Box::new(theme));
self
}
pub fn text_style(mut self, text_style: TextStyle) -> Self {
self.text_style = Some(text_style);
self
}
pub fn padding(mut self, padding: Insets) -> Self {
self.padding = Some(padding);
self
}
pub fn gap(mut self, gap: f32) -> Self {
self.gap = Some(gap.max(0.0));
self
}
pub fn interaction_preview(mut self, preview: InteractionPreview) -> Self {
self.preview = preview;
self
}
pub fn on_change<F>(mut self, on_change: F) -> Self
where
F: FnMut(bool) + 'static,
{
self.on_change = Some(Box::new(on_change));
self
}
pub fn on_change_with_ctx<F>(mut self, on_change: F) -> Self
where
F: FnMut(&mut EventCtx, bool) + 'static,
{
self.on_change_with_ctx = Some(Box::new(on_change));
self
}
fn resolved_text_style(&self) -> TextStyle {
self.text_style
.clone()
.unwrap_or_else(|| self.resolved_theme().body_text_style())
}
fn resolved_padding(&self) -> Insets {
self.padding
.unwrap_or(self.resolved_theme().metrics.checkbox_padding)
}
fn resolved_gap(&self) -> f32 {
self.gap
.unwrap_or(self.resolved_theme().metrics.checkbox_gap)
}
fn resolved_theme(&self) -> DefaultTheme {
self.theme_reader
.as_ref()
.map(|theme| theme())
.unwrap_or(*self.theme)
}
fn toggle(&mut self, ctx: &mut EventCtx) {
self.checked = !self.current_checked();
if let Some(on_change) = &mut self.on_change {
on_change(self.checked);
}
if let Some(on_change) = &mut self.on_change_with_ctx {
on_change(ctx, self.checked);
}
}
fn set_hovered(&mut self, hovered: bool, ctx: &mut EventCtx) {
if self.hovered != hovered {
let theme = self.resolved_theme();
self.hovered = hovered;
set_hover_animation_target(
&mut self.hover_animation,
hovered as u8 as f32,
&theme,
ctx,
);
ctx.request_paint();
ctx.request_semantics();
}
}
fn resolved_visuals_for_state(
&self,
on: bool,
focused: bool,
clock: &impl FrameClock,
output: Option<OutputColorRange>,
) -> SwitchVisuals {
let mut theme = self.paint_theme();
theme.hdr = theme.hdr.limited_to(output);
let palette = theme.palette;
let interaction = theme.interaction;
let hover_t = self.hover_value(clock) * interaction.hover_blend;
let press_t = self.press_value(clock) * interaction.pressed_blend;
let (framed_background, framed_border) = framed_choice_colors(
&palette,
self.hover_value(clock),
press_t,
focused as u8 as f32,
);
let frame_visuals = choice_frame_visuals(
&theme,
self.appearance,
framed_background,
framed_border,
hover_t,
press_t,
focused as u8 as f32,
);
let (baseline_track_color, baseline_track_border) =
choice_indicator_colors(&palette, hover_t, press_t, on as u8 as f32);
let thumb_color = if on {
palette.accent_text
} else {
mix_color(palette.border_control, palette.text_muted, hover_t * 0.5)
};
let label_peak_lift = resolve_luminance_role(&theme.hdr, WidgetLuminanceRole::Standard);
let label_color = if self.enabled.get() {
apply_hdr_policy_cap(self.resolved_text_style().color, label_peak_lift)
} else {
palette.text_disabled
};
if matches!(theme.hdr.mode, HdrThemeMode::Disabled) || !on {
return SwitchVisuals {
frame_background: frame_visuals.background,
frame_border: frame_visuals.border,
track_color: baseline_track_color,
track_border: baseline_track_border,
thumb_color,
label_color,
label_peak_lift,
indicator_style: None,
};
}
let indicator_style = cap_resolved_hdr_style(resolve_widget_hdr_style(
&theme.hdr,
WidgetColorRole::Accent,
WidgetLuminanceRole::EmissiveIndicator,
WidgetMaterialRole::Flat,
None,
));
SwitchVisuals {
frame_background: frame_visuals.background,
frame_border: frame_visuals.border,
track_color: mix_color(
mix_color(indicator_style.color, palette.accent_hover, hover_t),
palette.accent_pressed,
press_t,
),
track_border: mix_color(
mix_color(indicator_style.color, palette.accent_hover, hover_t),
palette.accent_pressed,
press_t,
),
thumb_color,
label_color,
label_peak_lift,
indicator_style: Some(indicator_style),
}
}
#[cfg(test)]
fn resolved_visuals(&self, focused: bool) -> SwitchVisuals {
self.resolved_visuals_for_state(self.current_checked(), focused, &0.0, None)
}
fn hover_value(&self, clock: &impl FrameClock) -> f32 {
if !self.enabled.get() {
return 0.0;
}
self.hover_animation.get(clock).max(self.preview.hover())
}
fn press_value(&self, clock: &impl FrameClock) -> f32 {
if !self.enabled.get() {
return 0.0;
}
self.press_animation.get(clock).max(self.preview.press())
}
fn focus_value(&self, clock: &impl FrameClock) -> f32 {
if !self.enabled.get() {
return 0.0;
}
self.focus_animation.get(clock).max(self.preview.focus())
}
}
impl Switch {
pub fn label_when<F>(mut self, reader: F) -> Self
where
F: Fn() -> String + 'static,
{
self.label = reader();
self.label_reader = Some(Box::new(reader));
self
}
fn sync_label_reader(&mut self) {
if let Some(reader) = &self.label_reader {
let label = reader();
if label != self.label {
self.label = label;
}
}
}
}
impl Widget for Switch {
fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
self.sync_label_reader();
if self.sync_checked() {
ctx.request_paint();
ctx.request_semantics();
}
if !self.enabled.get() {
if let Event::Pointer(pointer) = event
&& pointer.kind == PointerEventKind::Up
&& self.pressed
{
self.pressed = false;
ctx.release_pointer_capture(pointer.pointer_id);
ctx.request_paint();
}
return;
}
match event {
Event::Pointer(pointer) if pointer.kind == PointerEventKind::Move => {
self.set_hovered(ctx.bounds().contains(pointer.position), ctx);
}
Event::Pointer(_pointer) if matches!(_pointer.kind, PointerEventKind::Enter) => {
self.set_hovered(true, ctx);
}
Event::Pointer(_pointer) if matches!(_pointer.kind, PointerEventKind::Leave) => {
self.set_hovered(false, ctx);
}
Event::Pointer(pointer)
if pointer.kind == PointerEventKind::Down
&& pointer.button == Some(PointerButton::Primary) =>
{
let theme = self.resolved_theme();
self.pressed = true;
self.hovered = true;
set_hover_animation_target(&mut self.hover_animation, 1.0, &theme, ctx);
set_press_animation_target(&mut self.press_animation, 1.0, &theme, ctx);
ctx.request_pointer_capture(pointer.pointer_id);
ctx.request_focus();
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
Event::Pointer(pointer)
if pointer.kind == PointerEventKind::Up
&& pointer.button == Some(PointerButton::Primary) =>
{
let theme = self.resolved_theme();
let hovered = ctx.bounds().contains(pointer.position);
let toggle = self.pressed && hovered;
self.pressed = false;
self.hovered = hovered;
set_hover_animation_target(
&mut self.hover_animation,
hovered as u8 as f32,
&theme,
ctx,
);
set_press_animation_target(&mut self.press_animation, 0.0, &theme, ctx);
ctx.release_pointer_capture(pointer.pointer_id);
if toggle {
self.toggle(ctx);
set_toggle_animation_target(
&mut self.toggle_animation,
self.checked as u8 as f32,
&theme,
ctx,
);
}
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
Event::Pointer(pointer) if pointer.kind == PointerEventKind::Cancel => {
if self.pressed {
let theme = self.resolved_theme();
self.pressed = false;
self.hovered = false;
set_hover_animation_target(&mut self.hover_animation, 0.0, &theme, ctx);
set_press_animation_target(&mut self.press_animation, 0.0, &theme, ctx);
ctx.release_pointer_capture(pointer.pointer_id);
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
}
Event::Keyboard(key)
if key.state == KeyState::Pressed
&& ctx.is_focused()
&& matches!(key.key.as_str(), "Enter" | " ") =>
{
let theme = self.resolved_theme();
self.toggle(ctx);
set_toggle_animation_target(
&mut self.toggle_animation,
self.checked as u8 as f32,
&theme,
ctx,
);
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
_ => {}
}
}
fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
self.sync_label_reader();
let theme = self.resolved_theme();
let text_style = self.resolved_text_style();
let padding = self.resolved_padding();
let gap = self.resolved_gap();
let measurement = measure_text(ctx, &self.label, &text_style);
self.label_measurement = Some(measurement);
let track_width = theme.metrics.switch_track_width;
let track_height = theme.metrics.switch_track_height;
let content_height = track_height.max(measurement.height.max(text_style.line_height));
constraints.clamp(Size::new(
padding.left + track_width + gap + measurement.width + padding.right,
choice_control_height(
content_height,
padding,
default_form_control_height(&theme),
self.padding.is_some(),
),
))
}
fn paint(&self, ctx: &mut PaintCtx) {
self.observe_checked(|source| ctx.observe(source));
self.enabled.observe(|source| {
ctx.observe(source);
});
let theme = self.paint_theme();
let metrics = theme.metrics;
let palette = theme.palette;
let interaction = theme.interaction;
let mut text_style = self.resolved_text_style();
if !self.enabled.get() {
text_style.color = theme.palette.text_disabled;
}
let padding = self.resolved_padding();
let gap = self.resolved_gap();
let track = switch_track_rect(ctx.bounds(), padding, metrics);
let label_rect = switch_label_rect(ctx.bounds(), padding, metrics, gap);
let focused = ctx.is_focused() || self.preview.is_focused();
let output = ctx.output_color_range();
let visuals =
self.resolved_visuals_for_state(self.current_checked(), focused, &0.0, output);
let off_visuals = self.resolved_visuals_for_state(false, focused, ctx, output);
let on_visuals = self.resolved_visuals_for_state(true, focused, ctx, output);
let hover_progress = self.hover_value(ctx) * interaction.hover_blend;
let press_progress = self.press_value(ctx) * interaction.pressed_blend;
let on = self.current_checked();
let toggle_progress = if on == self.checked {
self.toggle_animation.get(ctx)
} else {
on as u8 as f32
};
let focus_progress = self.focus_value(ctx);
let (framed_background, framed_border) =
framed_choice_colors(&palette, hover_progress, press_progress, focus_progress);
let frame_visuals = choice_frame_visuals(
&theme,
self.appearance,
framed_background,
framed_border,
hover_progress,
press_progress,
focus_progress,
);
draw_choice_control_frame(
ctx,
ctx.bounds(),
metrics.corner_radius,
metrics,
self.appearance,
frame_visuals,
(focus_progress > 0.0).then_some(
palette
.focus_ring
.with_alpha(palette.focus_ring.alpha * focus_progress),
),
);
let thumb_inset = metrics.switch_thumb_inset;
let thumb_size = (track.height() - (thumb_inset * 2.0)).max(0.0);
let thumb_x_off = track.x() + thumb_inset;
let thumb_x_on = track.max_x() - thumb_size - thumb_inset;
let thumb = Rect::new(
f32::interpolate(thumb_x_off, thumb_x_on, toggle_progress),
track.y() + thumb_inset,
thumb_size,
thumb_size,
);
let track_color = if toggle_progress <= f32::EPSILON {
off_visuals.track_color
} else if (1.0 - toggle_progress) <= f32::EPSILON {
on_visuals.track_color
} else {
mix_color(
off_visuals.track_color,
on_visuals.track_color,
toggle_progress,
)
};
let track_border = if toggle_progress <= f32::EPSILON {
off_visuals.track_border
} else if (1.0 - toggle_progress) <= f32::EPSILON {
on_visuals.track_border
} else {
mix_color(
off_visuals.track_border,
on_visuals.track_border,
toggle_progress,
)
};
draw_control_shape(
ctx,
track,
track.height() * 0.5,
physical_pixels(ctx, metrics.border_width),
track_color,
track_border,
);
let thumb_color = if toggle_progress <= f32::EPSILON {
off_visuals.thumb_color
} else if (1.0 - toggle_progress) <= f32::EPSILON {
on_visuals.thumb_color
} else {
mix_color(
off_visuals.thumb_color,
on_visuals.thumb_color,
toggle_progress,
)
};
ctx.fill(
Path::circle(rect_center(thumb), thumb.width() * 0.5),
thumb_color,
);
let text_style = TextStyle {
color: visuals.label_color,
..text_style
};
paint_text(ctx, label_rect, &self.label, &text_style, TextAlign::Start);
}
fn semantics(&self, ctx: &mut SemanticsCtx) {
self.observe_checked(|source| ctx.observe(source));
self.enabled.observe(|source| {
ctx.observe(source);
});
let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::Switch, ctx.bounds());
node.name = Some(
self.semantic_name
.clone()
.unwrap_or_else(|| self.label.clone()),
);
node.state.focused = ctx.is_focused();
node.state.hovered = self.hovered;
node.state.checked = Some(if self.current_checked() {
ToggleState::Checked
} else {
ToggleState::Unchecked
});
node.state.disabled = !self.enabled.get();
node.actions = if self.enabled.get() {
vec![SemanticsAction::Focus, SemanticsAction::Activate]
} else {
Vec::new()
};
ctx.push(node);
}
fn accepts_focus(&self) -> bool {
self.enabled.get()
}
fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
let theme = self.resolved_theme();
set_focus_animation_target(&mut self.focus_animation, focused as u8 as f32, &theme, ctx);
ctx.request_paint();
ctx.request_semantics();
}
}
pub struct RadioButton {
theme: Box<DefaultTheme>,
theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
label: String,
label_reader: Option<Box<dyn Fn() -> String>>,
semantic_name: Option<String>,
enabled: Binding<bool>,
checked: bool,
checked_reader: Option<Box<dyn Fn() -> bool>>,
checked_source: Option<Arc<dyn Observable<bool>>>,
appearance: ChoiceAppearance,
text_style: Option<TextStyle>,
padding: Option<Insets>,
indicator_size: Option<f32>,
gap: Option<f32>,
hovered: bool,
pressed: bool,
hover_animation: AnimatedScalar,
press_animation: AnimatedScalar,
toggle_animation: AnimatedScalar,
focus_animation: AnimatedScalar,
label_measurement: Option<TextMeasurement>,
on_change: Option<Box<dyn FnMut(bool)>>,
on_change_with_ctx: Option<Box<dyn FnMut(&mut EventCtx, bool)>>,
preview: InteractionPreview,
}
impl RadioButton {
pub fn new(label: impl Into<String>) -> Self {
Self {
theme: Box::new(DefaultTheme::default()),
theme_reader: None,
label: label.into(),
label_reader: None,
semantic_name: None,
enabled: Binding::new(true),
checked: false,
checked_reader: None,
checked_source: None,
appearance: ChoiceAppearance::Plain,
text_style: None,
padding: None,
indicator_size: None,
gap: None,
hovered: false,
pressed: false,
hover_animation: AnimatedScalar::new(0.0),
press_animation: AnimatedScalar::new(0.0),
toggle_animation: AnimatedScalar::new(0.0),
focus_animation: AnimatedScalar::new(0.0),
preview: InteractionPreview::None,
label_measurement: None,
on_change: None,
on_change_with_ctx: None,
}
}
pub fn semantic_name(mut self, name: impl Into<String>) -> Self {
self.semantic_name = Some(name.into());
self
}
pub fn checked(mut self, checked: bool) -> Self {
self.checked = checked;
self.toggle_animation = AnimatedScalar::new(checked as u8 as f32);
self
}
pub fn checked_when<F>(mut self, checked: F) -> Self
where
F: Fn() -> bool + 'static,
{
let current = checked();
self.checked_reader = Some(Box::new(checked));
self.checked_source = None;
self.checked(current)
}
pub fn checked_from<O>(mut self, checked: O) -> Self
where
O: Observable<bool> + 'static,
{
let current = checked.get();
self.checked_source = Some(Arc::new(checked));
self.checked_reader = None;
self.checked(current)
}
pub fn enabled(mut self, enabled: bool) -> Self {
self.enabled.set(enabled);
self
}
pub fn enabled_when<F>(mut self, enabled: F) -> Self
where
F: Fn() -> bool + 'static,
{
self.enabled.set_when(enabled);
self
}
pub fn enabled_from<O>(mut self, enabled: O) -> Self
where
O: Observable<bool> + 'static,
{
self.enabled.set_from(enabled);
self
}
pub fn is_enabled(&self) -> bool {
self.enabled.get()
}
fn paint_theme(&self) -> DefaultTheme {
let theme = self.resolved_theme();
if self.enabled.get() {
theme
} else {
theme.for_disabled_control()
}
}
pub fn is_checked(&self) -> bool {
self.current_checked()
}
fn current_checked(&self) -> bool {
if let Some(source) = &self.checked_source {
return source.get();
}
self.checked_reader
.as_ref()
.map_or(self.checked, |checked| checked())
}
fn observe_checked<T>(&self, observe: impl FnOnce(&dyn Observable<bool>) -> T) {
if let Some(source) = &self.checked_source {
observe(source.as_ref());
}
}
fn sync_checked(&mut self) -> bool {
let current = self.current_checked();
if current == self.checked {
return false;
}
self.checked = current;
self.toggle_animation.jump_to(current as u8 as f32);
true
}
pub fn appearance(mut self, appearance: ChoiceAppearance) -> Self {
self.appearance = appearance;
self
}
pub fn plain(self) -> Self {
self.appearance(ChoiceAppearance::Plain)
}
pub fn framed(self) -> Self {
self.appearance(ChoiceAppearance::Framed)
}
pub fn set_checked(&mut self, checked: bool) {
self.checked = checked;
self.toggle_animation = AnimatedScalar::new(checked as u8 as f32);
}
pub fn theme(mut self, theme: DefaultTheme) -> Self {
self.theme = Box::new(theme);
self.theme_reader = None;
self
}
pub fn theme_when<F>(mut self, theme: F) -> Self
where
F: Fn() -> DefaultTheme + 'static,
{
self.theme_reader = Some(Box::new(theme));
self
}
pub fn text_style(mut self, text_style: TextStyle) -> Self {
self.text_style = Some(text_style);
self
}
pub fn padding(mut self, padding: Insets) -> Self {
self.padding = Some(padding);
self
}
pub fn indicator_size(mut self, indicator_size: f32) -> Self {
self.indicator_size = Some(indicator_size.max(0.0));
self
}
pub fn gap(mut self, gap: f32) -> Self {
self.gap = Some(gap.max(0.0));
self
}
pub fn interaction_preview(mut self, preview: InteractionPreview) -> Self {
self.preview = preview;
self
}
pub fn on_change<F>(mut self, on_change: F) -> Self
where
F: FnMut(bool) + 'static,
{
self.on_change = Some(Box::new(on_change));
self
}
pub fn on_change_with_ctx<F>(mut self, on_change: F) -> Self
where
F: FnMut(&mut EventCtx, bool) + 'static,
{
self.on_change_with_ctx = Some(Box::new(on_change));
self
}
fn resolved_text_style(&self) -> TextStyle {
self.text_style
.clone()
.unwrap_or_else(|| self.resolved_theme().body_text_style())
}
fn resolved_padding(&self) -> Insets {
self.padding
.unwrap_or(self.resolved_theme().metrics.checkbox_padding)
}
fn resolved_indicator_size(&self) -> f32 {
self.indicator_size
.unwrap_or(self.resolved_theme().metrics.checkbox_indicator_size)
}
fn resolved_gap(&self) -> f32 {
self.gap
.unwrap_or(self.resolved_theme().metrics.checkbox_gap)
}
fn resolved_theme(&self) -> DefaultTheme {
self.theme_reader
.as_ref()
.map(|theme| theme())
.unwrap_or(*self.theme)
}
fn activate(&mut self, ctx: &mut EventCtx) {
let theme = self.resolved_theme();
let changed = !self.current_checked();
self.checked = true;
if changed {
set_toggle_animation_target(&mut self.toggle_animation, 1.0, &theme, ctx);
if let Some(on_change) = &mut self.on_change {
on_change(true);
}
if let Some(on_change) = &mut self.on_change_with_ctx {
on_change(ctx, true);
}
}
}
fn set_hovered(&mut self, hovered: bool, ctx: &mut EventCtx) {
if self.hovered != hovered {
let theme = self.resolved_theme();
self.hovered = hovered;
set_hover_animation_target(
&mut self.hover_animation,
hovered as u8 as f32,
&theme,
ctx,
);
ctx.request_paint();
ctx.request_semantics();
}
}
fn hover_value(&self, clock: &impl FrameClock) -> f32 {
if !self.enabled.get() {
return 0.0;
}
self.hover_animation.get(clock).max(self.preview.hover())
}
fn press_value(&self, clock: &impl FrameClock) -> f32 {
if !self.enabled.get() {
return 0.0;
}
self.press_animation.get(clock).max(self.preview.press())
}
fn focus_value(&self, clock: &impl FrameClock) -> f32 {
if !self.enabled.get() {
return 0.0;
}
self.focus_animation.get(clock).max(self.preview.focus())
}
}
impl RadioButton {
pub fn label_when<F>(mut self, reader: F) -> Self
where
F: Fn() -> String + 'static,
{
self.label = reader();
self.label_reader = Some(Box::new(reader));
self
}
fn sync_label_reader(&mut self) {
if let Some(reader) = &self.label_reader {
let label = reader();
if label != self.label {
self.label = label;
}
}
}
}
impl Widget for RadioButton {
fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
self.sync_label_reader();
if self.sync_checked() {
ctx.request_paint();
ctx.request_semantics();
}
if !self.enabled.get() {
if let Event::Pointer(pointer) = event
&& pointer.kind == PointerEventKind::Up
&& self.pressed
{
self.pressed = false;
ctx.release_pointer_capture(pointer.pointer_id);
ctx.request_paint();
}
return;
}
match event {
Event::Pointer(pointer) if pointer.kind == PointerEventKind::Move => {
self.set_hovered(ctx.bounds().contains(pointer.position), ctx);
}
Event::Pointer(_pointer) if matches!(_pointer.kind, PointerEventKind::Enter) => {
self.set_hovered(true, ctx);
}
Event::Pointer(_pointer) if matches!(_pointer.kind, PointerEventKind::Leave) => {
self.set_hovered(false, ctx);
}
Event::Pointer(pointer)
if pointer.kind == PointerEventKind::Down
&& pointer.button == Some(PointerButton::Primary) =>
{
let theme = self.resolved_theme();
self.pressed = true;
self.hovered = true;
set_hover_animation_target(&mut self.hover_animation, 1.0, &theme, ctx);
set_press_animation_target(&mut self.press_animation, 1.0, &theme, ctx);
ctx.request_pointer_capture(pointer.pointer_id);
ctx.request_focus();
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
Event::Pointer(pointer)
if pointer.kind == PointerEventKind::Up
&& pointer.button == Some(PointerButton::Primary) =>
{
let theme = self.resolved_theme();
let hovered = ctx.bounds().contains(pointer.position);
let activate = self.pressed && hovered;
self.pressed = false;
self.hovered = hovered;
set_hover_animation_target(
&mut self.hover_animation,
hovered as u8 as f32,
&theme,
ctx,
);
set_press_animation_target(&mut self.press_animation, 0.0, &theme, ctx);
ctx.release_pointer_capture(pointer.pointer_id);
if activate {
self.activate(ctx);
}
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
Event::Pointer(pointer) if pointer.kind == PointerEventKind::Cancel => {
if self.pressed {
let theme = self.resolved_theme();
self.pressed = false;
self.hovered = false;
set_hover_animation_target(&mut self.hover_animation, 0.0, &theme, ctx);
set_press_animation_target(&mut self.press_animation, 0.0, &theme, ctx);
ctx.release_pointer_capture(pointer.pointer_id);
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
}
Event::Keyboard(key)
if key.state == KeyState::Pressed
&& ctx.is_focused()
&& matches!(key.key.as_str(), "Enter" | " ") =>
{
self.activate(ctx);
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
_ => {}
}
}
fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
self.sync_label_reader();
let text_style = self.resolved_text_style();
let padding = self.resolved_padding();
let indicator_size = self.resolved_indicator_size();
let gap = self.resolved_gap();
let measurement = measure_text(ctx, &self.label, &text_style);
self.label_measurement = Some(measurement);
let theme = self.resolved_theme();
let content_height = indicator_size.max(measurement.height.max(text_style.line_height));
constraints.clamp(Size::new(
padding.left + indicator_size + gap + measurement.width + padding.right,
choice_control_height(
content_height,
padding,
default_form_control_height(&theme),
self.padding.is_some(),
),
))
}
fn paint(&self, ctx: &mut PaintCtx) {
self.observe_checked(|source| ctx.observe(source));
self.enabled.observe(|source| {
ctx.observe(source);
});
let theme = self.paint_theme();
let palette = theme.palette;
let metrics = theme.metrics;
let interaction = theme.interaction;
let mut text_style = self.resolved_text_style();
if !self.enabled.get() {
text_style.color = theme.palette.text_disabled;
}
let padding = self.resolved_padding();
let indicator_size = self.resolved_indicator_size();
let gap = self.resolved_gap();
let hover_progress = self.hover_value(ctx) * interaction.hover_blend;
let press_progress = self.press_value(ctx) * interaction.pressed_blend;
let checked = self.current_checked();
let toggle_progress = if checked == (self.toggle_animation.target() > 0.5) {
self.toggle_animation.get(ctx)
} else {
checked as u8 as f32
};
let focus_progress = self.focus_value(ctx);
let layout_padding = choice_control_layout_padding(padding, self.padding.is_some());
let indicator = indicator_rect(ctx.bounds(), layout_padding, indicator_size);
let label_rect = checkbox_label_rect(ctx.bounds(), layout_padding, indicator_size, gap);
let (framed_background, framed_border) =
framed_choice_colors(&palette, hover_progress, press_progress, focus_progress);
let frame_visuals = choice_frame_visuals(
&theme,
self.appearance,
framed_background,
framed_border,
hover_progress,
press_progress,
focus_progress,
);
draw_choice_control_frame(
ctx,
ctx.bounds(),
metrics.corner_radius,
metrics,
self.appearance,
frame_visuals,
(focus_progress > 0.0).then_some(
palette
.focus_ring
.with_alpha(palette.focus_ring.alpha * focus_progress),
),
);
let (indicator_fill, indicator_border) =
choice_indicator_colors(&palette, hover_progress, press_progress, toggle_progress);
ctx.fill(
Path::circle(rect_center(indicator), indicator.width() * 0.5),
indicator_fill,
);
ctx.stroke(
Path::circle(rect_center(indicator), (indicator.width() * 0.5) - 0.5),
indicator_border,
StrokeStyle::new(physical_pixels(ctx, metrics.border_width)),
);
if toggle_progress > 0.0 {
ctx.fill(
Path::circle(
rect_center(indicator),
indicator.width() * 0.22 * toggle_progress,
),
palette.accent_text.with_alpha(toggle_progress),
);
}
paint_text(ctx, label_rect, &self.label, &text_style, TextAlign::Start);
}
fn semantics(&self, ctx: &mut SemanticsCtx) {
self.observe_checked(|source| ctx.observe(source));
self.enabled.observe(|source| {
ctx.observe(source);
});
let mut node =
SemanticsNode::new(ctx.widget_id(), SemanticsRole::RadioButton, ctx.bounds());
node.name = Some(
self.semantic_name
.clone()
.unwrap_or_else(|| self.label.clone()),
);
node.state.focused = ctx.is_focused();
node.state.hovered = self.hovered;
node.state.selected = self.current_checked();
node.state.disabled = !self.enabled.get();
node.actions = if self.enabled.get() {
vec![SemanticsAction::Focus, SemanticsAction::Activate]
} else {
Vec::new()
};
ctx.push(node);
}
fn accepts_focus(&self) -> bool {
true
}
fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
let theme = self.resolved_theme();
set_focus_animation_target(&mut self.focus_animation, focused as u8 as f32, &theme, ctx);
ctx.request_paint();
ctx.request_semantics();
}
}
pub struct RadioGroup {
theme: Box<DefaultTheme>,
theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
enabled: Binding<bool>,
name: String,
options: Vec<String>,
selected: Option<usize>,
selected_reader: Option<Box<dyn Fn() -> Option<usize>>>,
hovered: Option<usize>,
pressed: Option<usize>,
hover_visual: Option<usize>,
press_visual: Option<usize>,
selected_visual: Option<usize>,
hover_animation: AnimatedScalar,
press_animation: AnimatedScalar,
selection_animation: AnimatedScalar,
focus_animation: AnimatedScalar,
label_measurements: Vec<TextMeasurement>,
spacing: f32,
on_change: Option<Box<dyn FnMut(usize, String)>>,
on_change_with_ctx: Option<Box<dyn FnMut(&mut EventCtx, usize, String)>>,
}
impl RadioGroup {
pub fn new(name: impl Into<String>) -> Self {
Self {
theme: Box::new(DefaultTheme::default()),
theme_reader: None,
enabled: Binding::new(true),
name: name.into(),
options: Vec::new(),
selected: None,
selected_reader: None,
hovered: None,
pressed: None,
hover_visual: None,
press_visual: None,
selected_visual: None,
hover_animation: AnimatedScalar::new(0.0),
press_animation: AnimatedScalar::new(0.0),
selection_animation: AnimatedScalar::new(0.0),
focus_animation: AnimatedScalar::new(0.0),
label_measurements: Vec::new(),
spacing: 6.0,
on_change: None,
on_change_with_ctx: None,
}
}
pub fn theme(mut self, theme: DefaultTheme) -> Self {
self.theme = Box::new(theme);
self.theme_reader = None;
self
}
pub fn theme_when<F>(mut self, theme: F) -> Self
where
F: Fn() -> DefaultTheme + 'static,
{
self.theme_reader = Some(Box::new(theme));
self
}
pub fn enabled(mut self, enabled: bool) -> Self {
self.enabled.set(enabled);
self
}
pub fn enabled_when<F>(mut self, enabled: F) -> Self
where
F: Fn() -> bool + 'static,
{
self.enabled.set_when(enabled);
self
}
pub fn enabled_from<O>(mut self, enabled: O) -> Self
where
O: Observable<bool> + 'static,
{
self.enabled.set_from(enabled);
self
}
pub fn is_enabled(&self) -> bool {
self.enabled.get()
}
fn paint_theme(&self) -> DefaultTheme {
let theme = self.resolved_theme();
if self.enabled.get() {
theme
} else {
theme.for_disabled_control()
}
}
pub fn option(mut self, option: impl Into<String>) -> Self {
self.options.push(option.into());
self
}
pub fn options<I, S>(mut self, options: I) -> Self
where
I: IntoIterator<Item = S>,
S: Into<String>,
{
self.options.extend(options.into_iter().map(Into::into));
self
}
pub fn selected(mut self, selected: impl Into<Option<usize>>) -> Self {
let selected = selected.into();
self.selected = selected;
self.selected_reader = None;
self.selected_visual = selected;
self.selection_animation = AnimatedScalar::new(1.0);
self
}
pub const fn selected_index(&self) -> Option<usize> {
self.selected
}
pub fn selected_when<F>(mut self, selected: F) -> Self
where
F: Fn() -> Option<usize> + 'static,
{
self.selected_reader = Some(Box::new(selected));
self
}
pub fn on_change<F>(mut self, on_change: F) -> Self
where
F: FnMut(usize, String) + 'static,
{
self.on_change = Some(Box::new(on_change));
self
}
pub fn on_change_with_ctx<F>(mut self, on_change: F) -> Self
where
F: FnMut(&mut EventCtx, usize, String) + 'static,
{
self.on_change_with_ctx = Some(Box::new(on_change));
self
}
fn row_height(&self) -> f32 {
default_form_control_height(&self.resolved_theme())
}
fn row_rect(&self, bounds: Rect, index: usize) -> Rect {
let y = bounds.y() + (index as f32 * (self.row_height() + self.spacing));
Rect::new(bounds.x(), y, bounds.width(), self.row_height())
}
fn option_at(&self, bounds: Rect, position: Point) -> Option<usize> {
self.options.iter().enumerate().find_map(|(index, _)| {
self.row_rect(bounds, index)
.contains(position)
.then_some(index)
})
}
fn current_selected_index(&self) -> Option<usize> {
self.selected_reader
.as_ref()
.map(|reader| reader())
.unwrap_or(self.selected)
.filter(|index| *index < self.options.len())
}
fn select(&mut self, index: usize, ctx: &mut EventCtx) {
if self.options.is_empty() {
return;
}
let selected = index.min(self.options.len().saturating_sub(1));
let changed = self.current_selected_index() != Some(selected);
self.selected = Some(selected);
if changed || self.selected_visual != Some(selected) {
let theme = self.resolved_theme();
self.selected_visual = Some(selected);
self.selection_animation = AnimatedScalar::new(0.0);
set_toggle_animation_target(&mut self.selection_animation, 1.0, &theme, ctx);
}
if let Some(on_change) = &mut self.on_change {
on_change(selected, self.options[selected].clone());
}
if let Some(on_change) = &mut self.on_change_with_ctx {
on_change(ctx, selected, self.options[selected].clone());
}
}
fn resolved_theme(&self) -> DefaultTheme {
self.theme_reader
.as_ref()
.map(|theme| theme())
.unwrap_or(*self.theme)
}
fn set_hovered(&mut self, hovered: Option<usize>, ctx: &mut EventCtx) {
if self.hovered == hovered && self.hover_visual == hovered {
return;
}
let theme = self.resolved_theme();
self.hovered = hovered;
match hovered {
Some(index) => {
if self.hover_visual != Some(index) {
self.hover_visual = Some(index);
self.hover_animation = AnimatedScalar::new(0.0);
}
set_hover_animation_target(&mut self.hover_animation, 1.0, &theme, ctx);
}
None => {
set_hover_animation_target(&mut self.hover_animation, 0.0, &theme, ctx);
}
}
ctx.request_paint();
ctx.request_semantics();
}
fn set_pressed(&mut self, pressed: Option<usize>, ctx: &mut EventCtx) {
if self.pressed == pressed && self.press_visual == pressed {
return;
}
let theme = self.resolved_theme();
self.pressed = pressed;
match pressed {
Some(index) => {
if self.press_visual != Some(index) {
self.press_visual = Some(index);
self.press_animation = AnimatedScalar::new(0.0);
}
set_press_animation_target(&mut self.press_animation, 1.0, &theme, ctx);
}
None => {
set_press_animation_target(&mut self.press_animation, 0.0, &theme, ctx);
}
}
ctx.request_paint();
ctx.request_semantics();
}
fn hover_progress_for(&self, index: usize, clock: &impl FrameClock) -> f32 {
if self.hover_visual == Some(index) {
self.hover_animation.get(clock)
} else {
0.0
}
}
fn press_progress_for(&self, index: usize, clock: &impl FrameClock) -> f32 {
if self.press_visual == Some(index) {
self.press_animation.get(clock)
} else {
0.0
}
}
fn selection_progress_for(&self, index: usize, clock: &impl FrameClock) -> f32 {
let selected = self.current_selected_index();
if selected == Some(index) && self.selected_visual == Some(index) {
self.selection_animation.get(clock)
} else if selected == Some(index) {
1.0
} else {
0.0
}
}
}
impl Widget for RadioGroup {
fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
if !self.enabled.get() {
if let Event::Pointer(pointer) = event
&& pointer.kind == PointerEventKind::Up
{
ctx.release_pointer_capture(pointer.pointer_id);
}
return;
}
match event {
Event::Pointer(pointer) if pointer.kind == PointerEventKind::Move => {
self.set_hovered(self.option_at(ctx.bounds(), pointer.position), ctx);
}
Event::Pointer(pointer) if matches!(pointer.kind, PointerEventKind::Enter) => {
self.set_hovered(self.option_at(ctx.bounds(), pointer.position), ctx);
}
Event::Pointer(_pointer) if matches!(_pointer.kind, PointerEventKind::Leave) => {
self.set_hovered(None, ctx);
}
Event::Pointer(pointer)
if pointer.kind == PointerEventKind::Down
&& pointer.button == Some(PointerButton::Primary) =>
{
let hovered = self.option_at(ctx.bounds(), pointer.position);
self.set_hovered(hovered, ctx);
self.set_pressed(hovered, ctx);
ctx.request_focus();
ctx.request_pointer_capture(pointer.pointer_id);
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
Event::Pointer(pointer)
if pointer.kind == PointerEventKind::Up
&& pointer.button == Some(PointerButton::Primary) =>
{
let hovered = self.option_at(ctx.bounds(), pointer.position);
let activate = self
.pressed
.zip(hovered)
.filter(|(pressed, hovered)| pressed == hovered);
self.set_hovered(hovered, ctx);
self.set_pressed(None, ctx);
ctx.release_pointer_capture(pointer.pointer_id);
if let Some((index, _)) = activate {
self.select(index, ctx);
}
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
Event::Pointer(pointer) if pointer.kind == PointerEventKind::Cancel => {
if self.pressed.is_some() {
self.set_pressed(None, ctx);
ctx.release_pointer_capture(pointer.pointer_id);
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
}
Event::Semantics(semantics) if semantics.target == ctx.widget_id() => {
let SemanticsActionRequest::SetValue(SemanticsValue::Text(value)) =
&semantics.action
else {
return;
};
let Some(index) = self.options.iter().position(|option| option == value) else {
return;
};
self.set_hovered(Some(index), ctx);
self.select(index, ctx);
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
Event::Keyboard(key) if ctx.is_focused() && key.state == KeyState::Pressed => {
if self.options.is_empty() {
return;
}
let current = self
.current_selected_index()
.unwrap_or(0)
.min(self.options.len() - 1);
let next = match key.key.as_str() {
"ArrowUp" | "ArrowLeft" => Some(current.saturating_sub(1)),
"ArrowDown" | "ArrowRight" => Some((current + 1).min(self.options.len() - 1)),
"Home" => Some(0),
"End" => Some(self.options.len() - 1),
"Enter" | " " => Some(current),
_ => None,
};
if let Some(next) = next {
self.set_hovered(Some(next), ctx);
self.select(next, ctx);
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
}
_ => {}
}
}
fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
let theme = self.resolved_theme();
let text_style = theme.body_text_style();
let padding = theme.metrics.checkbox_padding;
let indicator = theme.metrics.checkbox_indicator_size;
let gap = theme.metrics.checkbox_gap;
let mut width: f32 = 0.0;
self.label_measurements.clear();
for option in &self.options {
let measurement = measure_text(ctx, option, &text_style);
self.label_measurements.push(measurement);
width = width.max(padding.left + indicator + gap + measurement.width + padding.right);
}
let count = self.options.len() as f32;
let height = if self.options.is_empty() {
self.row_height()
} else {
(count * self.row_height()) + ((count - 1.0) * self.spacing.max(0.0))
};
constraints.clamp(Size::new(width.max(theme.metrics.button_min_width), height))
}
fn paint(&self, ctx: &mut PaintCtx) {
self.enabled.observe(|source| {
ctx.observe(source);
});
let theme = self.paint_theme();
let palette = theme.palette;
let metrics = theme.metrics;
let interaction = theme.interaction;
let focus_progress = self.focus_animation.get(ctx);
let row_padding = Insets {
top: 0.0,
bottom: 0.0,
..metrics.checkbox_padding
};
if focus_progress > AnimatedScalar::EPSILON {
draw_focus_ring(
ctx,
ctx.bounds(),
metrics.corner_radius,
metrics,
palette
.focus_ring
.with_alpha(palette.focus_ring.alpha * focus_progress),
);
}
for (index, option) in self.options.iter().enumerate() {
let row = self.row_rect(ctx.bounds(), index);
let indicator = indicator_rect(row, row_padding, metrics.checkbox_indicator_size);
let label_rect = checkbox_label_rect(
row,
row_padding,
metrics.checkbox_indicator_size,
metrics.checkbox_gap,
);
let hover_progress = self.hover_progress_for(index, ctx);
let press_progress = self.press_progress_for(index, ctx);
let selection_progress = self.selection_progress_for(index, ctx);
let hover_amount = hover_progress * interaction.hover_blend;
let press_amount = press_progress * interaction.pressed_blend;
let (background, row_border) =
framed_choice_colors(&palette, hover_amount, press_amount, 0.0);
let border = mix_color(row_border, palette.selection_border, selection_progress);
let (indicator_fill, indicator_border) =
choice_indicator_colors(&palette, hover_amount, press_amount, selection_progress);
draw_control_shape(
ctx,
row,
metrics.corner_radius,
physical_pixels(ctx, metrics.border_width),
background,
border,
);
ctx.fill(
Path::circle(rect_center(indicator), indicator.width() * 0.5),
indicator_fill,
);
ctx.stroke(
Path::circle(rect_center(indicator), (indicator.width() * 0.5) - 0.5),
indicator_border,
StrokeStyle::new(physical_pixels(ctx, metrics.border_width)),
);
if selection_progress > AnimatedScalar::EPSILON {
ctx.fill(
Path::circle(
rect_center(indicator),
indicator.width() * 0.22 * selection_progress,
),
palette.accent_text.with_alpha(selection_progress),
);
}
let text_style = theme.body_text_style();
paint_text(ctx, label_rect, option, &text_style, TextAlign::Start);
}
}
fn semantics(&self, ctx: &mut SemanticsCtx) {
self.enabled.observe(|source| {
ctx.observe(source);
});
let enabled = self.enabled.get();
let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::RadioGroup, ctx.bounds());
node.name = Some(self.name.clone());
node.value = self
.current_selected_index()
.and_then(|index| self.options.get(index).cloned())
.map(SemanticsValue::Text);
node.state.focused = ctx.is_focused();
node.actions = vec![SemanticsAction::Focus, SemanticsAction::SetValue];
if !enabled {
node.state.disabled = true;
node.actions.clear();
}
ctx.push(node);
}
fn accepts_focus(&self) -> bool {
self.enabled.get()
}
fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
let theme = self.resolved_theme();
set_focus_animation_target(&mut self.focus_animation, focused as u8 as f32, &theme, ctx);
ctx.request_paint();
ctx.request_semantics();
}
}
pub struct Slider {
theme: Box<DefaultTheme>,
theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
name: String,
enabled: Binding<bool>,
min: f64,
max: f64,
step: f64,
value: f64,
value_reader: Option<Box<dyn Fn() -> f64>>,
hovered: bool,
dragging: bool,
hover_animation: AnimatedScalar,
drag_animation: AnimatedScalar,
focus_animation: AnimatedScalar,
on_change: Option<Box<dyn FnMut(f64)>>,
on_change_with_ctx: Option<Box<dyn FnMut(&mut EventCtx, f64)>>,
preview: InteractionPreview,
}
impl Slider {
pub fn new(name: impl Into<String>) -> Self {
Self {
theme: Box::new(DefaultTheme::default()),
theme_reader: None,
name: name.into(),
enabled: Binding::new(true),
min: 0.0,
max: 1.0,
step: 0.01,
value: 0.0,
value_reader: None,
hovered: false,
dragging: false,
hover_animation: AnimatedScalar::new(0.0),
drag_animation: AnimatedScalar::new(0.0),
focus_animation: AnimatedScalar::new(0.0),
preview: InteractionPreview::None,
on_change: None,
on_change_with_ctx: None,
}
}
pub fn theme(mut self, theme: DefaultTheme) -> Self {
self.theme = Box::new(theme);
self.theme_reader = None;
self
}
pub fn theme_when<F>(mut self, theme: F) -> Self
where
F: Fn() -> DefaultTheme + 'static,
{
self.theme_reader = Some(Box::new(theme));
self
}
pub fn enabled(mut self, enabled: bool) -> Self {
self.enabled.set(enabled);
self
}
pub fn enabled_when<F>(mut self, enabled: F) -> Self
where
F: Fn() -> bool + 'static,
{
self.enabled.set_when(enabled);
self
}
pub fn enabled_from<O>(mut self, enabled: O) -> Self
where
O: Observable<bool> + 'static,
{
self.enabled.set_from(enabled);
self
}
pub fn is_enabled(&self) -> bool {
self.enabled.get()
}
fn paint_theme(&self) -> DefaultTheme {
let theme = self.resolved_theme();
if self.enabled.get() {
theme
} else {
theme.for_disabled_control()
}
}
pub fn range(mut self, min: f64, max: f64) -> Self {
self.min = min.min(max);
self.max = max.max(min);
self.value = clamp_and_snap_value(self.value, self.min, self.max, self.step);
self
}
pub fn step(mut self, step: f64) -> Self {
self.step = step.abs();
self.value = clamp_and_snap_value(self.value, self.min, self.max, self.step);
self
}
pub fn value(mut self, value: f64) -> Self {
self.value = clamp_and_snap_value(value, self.min, self.max, self.step);
self.value_reader = None;
self
}
pub fn value_when<F>(mut self, value: F) -> Self
where
F: Fn() -> f64 + 'static,
{
self.value_reader = Some(Box::new(value));
self
}
pub const fn current_value(&self) -> f64 {
self.value
}
pub fn interaction_preview(mut self, preview: InteractionPreview) -> Self {
self.preview = preview;
self
}
pub fn on_change<F>(mut self, on_change: F) -> Self
where
F: FnMut(f64) + 'static,
{
self.on_change = Some(Box::new(on_change));
self
}
pub fn on_change_with_ctx<F>(mut self, on_change: F) -> Self
where
F: FnMut(&mut EventCtx, f64) + 'static,
{
self.on_change_with_ctx = Some(Box::new(on_change));
self
}
fn resolved_value(&self) -> f64 {
if self.dragging {
return self.value;
}
self.value_reader
.as_ref()
.map(|reader| clamp_and_snap_value(reader(), self.min, self.max, self.step))
.unwrap_or(self.value)
}
fn fraction_for(&self, value: f64) -> f32 {
if (self.max - self.min).abs() <= f64::EPSILON {
return 0.0;
}
((value - self.min) / (self.max - self.min)).clamp(0.0, 1.0) as f32
}
fn sync_external_value(&mut self) {
if self.dragging {
return;
}
let Some(reader) = &self.value_reader else {
return;
};
self.value = clamp_and_snap_value(reader(), self.min, self.max, self.step);
}
fn resolved_theme(&self) -> DefaultTheme {
self.theme_reader
.as_ref()
.map(|theme| theme())
.unwrap_or(*self.theme)
}
fn track_rect(&self, bounds: Rect) -> Rect {
let theme = self.resolved_theme();
let padding = theme.metrics.slider_padding;
let height = theme.metrics.slider_track_height.max(1.0);
Rect::new(
bounds.x() + padding.left,
bounds.y() + ((bounds.height() - height) * 0.5),
(bounds.width() - padding.left - padding.right).max(0.0),
height,
)
}
fn thumb_rect_for(&self, bounds: Rect, value: f64) -> Rect {
let track = self.track_rect(bounds);
let theme = self.resolved_theme();
let thumb = theme.metrics.slider_thumb_size;
Rect::new(
track.x() + (track.width() * self.fraction_for(value)) - (thumb * 0.5),
bounds.y() + ((bounds.height() - thumb) * 0.5),
thumb,
thumb,
)
}
fn emit_change(&mut self, ctx: &mut EventCtx) {
if let Some(on_change) = &mut self.on_change {
on_change(self.value);
}
if let Some(on_change_with_ctx) = &mut self.on_change_with_ctx {
on_change_with_ctx(ctx, self.value);
}
}
fn set_from_position(&mut self, ctx: &mut EventCtx, bounds: Rect, position: Point) {
let track = self.track_rect(bounds);
if track.width() <= 0.0 {
return;
}
let fraction = ((position.x - track.x()) / track.width()).clamp(0.0, 1.0);
let raw = self.min + ((self.max - self.min) * f64::from(fraction));
let next = clamp_and_snap_value(raw, self.min, self.max, self.step);
if (next - self.value).abs() > f64::EPSILON {
self.value = next;
self.emit_change(ctx);
}
}
fn set_hovered(&mut self, hovered: bool, ctx: &mut EventCtx) {
if self.hovered != hovered {
let theme = self.resolved_theme();
self.hovered = hovered;
set_hover_animation_target(
&mut self.hover_animation,
hovered as u8 as f32,
&theme,
ctx,
);
ctx.request_paint();
ctx.request_semantics();
}
}
fn hover_value(&self, clock: &impl FrameClock) -> f32 {
if !self.enabled.get() {
return 0.0;
}
self.hover_animation.get(clock).max(self.preview.hover())
}
fn drag_value(&self, clock: &impl FrameClock) -> f32 {
if !self.enabled.get() {
return 0.0;
}
self.drag_animation.get(clock).max(self.preview.press())
}
fn focus_value(&self, clock: &impl FrameClock) -> f32 {
if !self.enabled.get() {
return 0.0;
}
self.focus_animation.get(clock).max(self.preview.focus())
}
}
impl Widget for Slider {
fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
self.sync_external_value();
if !self.enabled.get() {
if let Event::Pointer(pointer) = event
&& pointer.kind == PointerEventKind::Up
{
ctx.release_pointer_capture(pointer.pointer_id);
}
return;
}
match event {
Event::Pointer(pointer) if pointer.kind == PointerEventKind::Move => {
let hovered = ctx.bounds().contains(pointer.position);
self.set_hovered(hovered, ctx);
if self.dragging {
let previous = self.value;
self.set_from_position(ctx, ctx.bounds(), pointer.position);
if (self.value - previous).abs() > f64::EPSILON {
ctx.request_paint();
ctx.request_semantics();
}
}
}
Event::Pointer(_pointer) if matches!(_pointer.kind, PointerEventKind::Enter) => {
self.set_hovered(true, ctx);
}
Event::Pointer(_pointer) if matches!(_pointer.kind, PointerEventKind::Leave) => {
self.set_hovered(false, ctx);
}
Event::Pointer(pointer)
if pointer.kind == PointerEventKind::Down
&& pointer.button == Some(PointerButton::Primary) =>
{
let theme = self.resolved_theme();
self.dragging = true;
self.hovered = true;
set_hover_animation_target(&mut self.hover_animation, 1.0, &theme, ctx);
set_press_animation_target(&mut self.drag_animation, 1.0, &theme, ctx);
self.set_from_position(ctx, ctx.bounds(), pointer.position);
ctx.request_pointer_capture(pointer.pointer_id);
ctx.request_focus();
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
Event::Pointer(pointer)
if pointer.kind == PointerEventKind::Up
&& pointer.button == Some(PointerButton::Primary) =>
{
let theme = self.resolved_theme();
self.dragging = false;
self.hovered = ctx.bounds().contains(pointer.position);
set_hover_animation_target(
&mut self.hover_animation,
self.hovered as u8 as f32,
&theme,
ctx,
);
set_press_animation_target(&mut self.drag_animation, 0.0, &theme, ctx);
self.set_from_position(ctx, ctx.bounds(), pointer.position);
ctx.release_pointer_capture(pointer.pointer_id);
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
Event::Pointer(pointer) if pointer.kind == PointerEventKind::Cancel => {
if self.dragging {
let theme = self.resolved_theme();
self.dragging = false;
self.hovered = false;
set_hover_animation_target(&mut self.hover_animation, 0.0, &theme, ctx);
set_press_animation_target(&mut self.drag_animation, 0.0, &theme, ctx);
ctx.release_pointer_capture(pointer.pointer_id);
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
}
Event::Semantics(semantics) if semantics.target == ctx.widget_id() => {
let next = match &semantics.action {
SemanticsActionRequest::Increment => Some(self.value + self.step.max(0.01)),
SemanticsActionRequest::Decrement => Some(self.value - self.step.max(0.01)),
SemanticsActionRequest::SetValue(SemanticsValue::Number(value)) => Some(*value),
SemanticsActionRequest::SetValue(SemanticsValue::Range { value, .. }) => {
Some(*value)
}
_ => None,
};
let Some(next) = next.filter(|value| value.is_finite()) else {
return;
};
let clamped = clamp_and_snap_value(next, self.min, self.max, self.step);
if (clamped - self.value).abs() > f64::EPSILON {
self.value = clamped;
self.emit_change(ctx);
}
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
Event::Keyboard(key) if ctx.is_focused() && key.state == KeyState::Pressed => {
let next = match key.key.as_str() {
"ArrowLeft" | "ArrowDown" => Some(self.value - self.step.max(0.01)),
"ArrowRight" | "ArrowUp" => Some(self.value + self.step.max(0.01)),
"Home" => Some(self.min),
"End" => Some(self.max),
_ => None,
};
if let Some(next) = next {
let clamped = clamp_and_snap_value(next, self.min, self.max, self.step);
if (clamped - self.value).abs() > f64::EPSILON {
self.value = clamped;
self.emit_change(ctx);
}
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
}
_ => {}
}
}
fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
self.sync_external_value();
let theme = self.resolved_theme();
constraints.clamp(Size::new(
theme.metrics.slider_min_width,
default_form_control_height(&theme),
))
}
fn paint(&self, ctx: &mut PaintCtx) {
self.enabled.observe(|source| {
ctx.observe(source);
});
let theme = self.paint_theme();
let palette = theme.palette;
let metrics = theme.metrics;
let hover_progress = self.hover_value(ctx);
let drag_progress = self.drag_value(ctx);
let focus_progress = self.focus_value(ctx);
let value = self.resolved_value();
let track = self.track_rect(ctx.bounds());
let active = Rect::new(
track.x(),
track.y(),
track.width() * self.fraction_for(value),
track.height(),
);
let thumb = self.thumb_rect_for(ctx.bounds(), value);
draw_control_focus_ring(
ctx,
ctx.bounds(),
metrics.corner_radius,
metrics,
(focus_progress > 0.0).then_some(
palette
.focus_ring
.with_alpha(palette.focus_ring.alpha * focus_progress),
),
);
ctx.fill(
Path::rounded_rect(track, track.height() * 0.5),
palette.control_active,
);
ctx.fill(
Path::rounded_rect(active, track.height() * 0.5),
palette.accent,
);
ctx.fill(
Path::circle(rect_center(thumb), thumb.width() * 0.5),
mix_color(
mix_color(palette.accent, palette.accent_hover, hover_progress),
palette.accent_pressed,
drag_progress,
),
);
}
fn semantics(&self, ctx: &mut SemanticsCtx) {
self.enabled.observe(|source| {
ctx.observe(source);
});
let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::Slider, ctx.bounds());
node.name = Some(self.name.clone());
node.value = Some(SemanticsValue::Range {
value: self.resolved_value(),
min: self.min,
max: self.max,
});
node.numeric_step = Some(self.step.max(0.01));
node.state.focused = ctx.is_focused();
node.state.hovered = self.hovered;
node.state.disabled = !self.enabled.get();
node.actions = if self.enabled.get() {
vec![
SemanticsAction::Focus,
SemanticsAction::Increment,
SemanticsAction::Decrement,
SemanticsAction::SetValue,
]
} else {
Vec::new()
};
ctx.push(node);
}
fn accepts_focus(&self) -> bool {
self.enabled.get()
}
fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
let theme = self.resolved_theme();
set_focus_animation_target(&mut self.focus_animation, focused as u8 as f32, &theme, ctx);
ctx.request_paint();
ctx.request_semantics();
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum NumberInputStepperPart {
Increment,
Decrement,
}
#[doc(alias = "SpinBox")]
pub struct NumberInput {
theme: Box<DefaultTheme>,
theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
name: String,
enabled: Binding<bool>,
value: f64,
min: f64,
max: f64,
step: f64,
precision: usize,
buffer: String,
hovered: bool,
hovered_stepper: Option<NumberInputStepperPart>,
pressed_stepper: Option<NumberInputStepperPart>,
hover_animation: AnimatedScalar,
stepper_hover_animation: AnimatedScalar,
press_animation: AnimatedScalar,
focus_animation: AnimatedScalar,
editing: bool,
value_reader: Option<Box<dyn Fn() -> f64>>,
on_change: Option<Box<dyn FnMut(f64)>>,
on_change_with_ctx: Option<Box<dyn FnMut(&mut EventCtx, f64)>>,
preview: InteractionPreview,
}
impl NumberInput {
pub fn new(name: impl Into<String>) -> Self {
let value = 0.0;
Self {
theme: Box::new(DefaultTheme::default()),
theme_reader: None,
name: name.into(),
enabled: Binding::new(true),
value,
min: f64::NEG_INFINITY,
max: f64::INFINITY,
step: 1.0,
precision: 2,
buffer: format_number(value, 2),
hovered: false,
hovered_stepper: None,
pressed_stepper: None,
hover_animation: AnimatedScalar::new(0.0),
stepper_hover_animation: AnimatedScalar::new(0.0),
press_animation: AnimatedScalar::new(0.0),
focus_animation: AnimatedScalar::new(0.0),
preview: InteractionPreview::None,
editing: false,
value_reader: None,
on_change: None,
on_change_with_ctx: None,
}
}
pub fn theme(mut self, theme: DefaultTheme) -> Self {
self.theme = Box::new(theme);
self.theme_reader = None;
self
}
pub fn theme_when<F>(mut self, theme: F) -> Self
where
F: Fn() -> DefaultTheme + 'static,
{
self.theme_reader = Some(Box::new(theme));
self
}
pub fn enabled(mut self, enabled: bool) -> Self {
self.enabled.set(enabled);
self
}
pub fn enabled_when<F>(mut self, enabled: F) -> Self
where
F: Fn() -> bool + 'static,
{
self.enabled.set_when(enabled);
self
}
pub fn enabled_from<O>(mut self, enabled: O) -> Self
where
O: Observable<bool> + 'static,
{
self.enabled.set_from(enabled);
self
}
pub fn is_enabled(&self) -> bool {
self.enabled.get()
}
fn paint_theme(&self) -> DefaultTheme {
let theme = self.resolved_theme();
if self.enabled.get() {
theme
} else {
theme.for_disabled_control()
}
}
pub fn range(mut self, min: f64, max: f64) -> Self {
self.min = min.min(max);
self.max = max.max(min);
self.value = clamp_and_snap_value(self.value, self.min, self.max, self.step);
self.buffer = format_number(self.value, self.precision);
self
}
pub fn step(mut self, step: f64) -> Self {
self.step = step.abs().max(f64::EPSILON);
self.value = clamp_and_snap_value(self.value, self.min, self.max, self.step);
self.buffer = format_number(self.value, self.precision);
self
}
pub fn precision(mut self, precision: usize) -> Self {
self.precision = precision;
self.buffer = format_number(self.value, self.precision);
self
}
pub fn value(mut self, value: f64) -> Self {
self.value = clamp_and_snap_value(value, self.min, self.max, self.step);
self.buffer = format_number(self.value, self.precision);
self.value_reader = None;
self
}
pub fn value_when<F>(mut self, value: F) -> Self
where
F: Fn() -> f64 + 'static,
{
self.value_reader = Some(Box::new(value));
self
}
pub const fn current_value(&self) -> f64 {
self.value
}
pub fn interaction_preview(mut self, preview: InteractionPreview) -> Self {
self.preview = preview;
self
}
pub fn on_change<F>(mut self, on_change: F) -> Self
where
F: FnMut(f64) + 'static,
{
self.on_change = Some(Box::new(on_change));
self
}
pub fn on_change_with_ctx<F>(mut self, on_change: F) -> Self
where
F: FnMut(&mut EventCtx, f64) + 'static,
{
self.on_change_with_ctx = Some(Box::new(on_change));
self
}
fn resolved_theme(&self) -> DefaultTheme {
self.theme_reader
.as_ref()
.map(|theme| theme())
.unwrap_or(*self.theme)
}
fn text_style(&self) -> TextStyle {
numeric_text_style(self.resolved_theme().body_text_style())
}
fn sync_external_value(&mut self) {
if self.editing {
return;
}
let Some(reader) = &self.value_reader else {
return;
};
let next = clamp_and_snap_value(reader(), self.min, self.max, self.step);
if (next - self.value).abs() > f64::EPSILON {
self.value = next;
self.buffer = format_number(self.value, self.precision);
}
}
fn resolved_value(&self) -> f64 {
if !self.editing
&& let Some(reader) = &self.value_reader
{
return clamp_and_snap_value(reader(), self.min, self.max, self.step);
}
self.value
}
fn display_buffer(&self) -> String {
if !self.editing && self.value_reader.is_some() {
format_number(self.resolved_value(), self.precision)
} else {
self.buffer.clone()
}
}
fn commit_buffer(&mut self, ctx: &mut EventCtx) {
if let Ok(parsed) = self.buffer.trim().parse::<f64>() {
let next = clamp_and_snap_value(parsed, self.min, self.max, self.step);
if (next - self.value).abs() > f64::EPSILON {
self.value = next;
if let Some(on_change) = &mut self.on_change {
on_change(self.value);
}
if let Some(on_change) = &mut self.on_change_with_ctx {
on_change(ctx, self.value);
}
}
self.buffer = format_number(self.value, self.precision);
}
}
fn apply_edit_buffer(&mut self, ctx: &mut EventCtx) {
let Ok(parsed) = self.buffer.trim().parse::<f64>() else {
return;
};
if !parsed.is_finite() || parsed < self.min || parsed > self.max {
return;
}
if (parsed - self.value).abs() > f64::EPSILON {
self.value = parsed;
if let Some(on_change) = &mut self.on_change {
on_change(self.value);
}
if let Some(on_change) = &mut self.on_change_with_ctx {
on_change(ctx, self.value);
}
}
}
fn nudge(&mut self, ctx: &mut EventCtx, delta: f64) {
let next = clamp_and_snap_value(self.value + delta, self.min, self.max, self.step);
if (next - self.value).abs() > f64::EPSILON {
self.value = next;
self.buffer = format_number(self.value, self.precision);
if let Some(on_change) = &mut self.on_change {
on_change(self.value);
}
if let Some(on_change) = &mut self.on_change_with_ctx {
on_change(ctx, self.value);
}
}
}
fn set_hover_state(
&mut self,
hovered: bool,
hovered_stepper: Option<NumberInputStepperPart>,
ctx: &mut EventCtx,
) {
if self.hovered != hovered || self.hovered_stepper != hovered_stepper {
let theme = self.resolved_theme();
self.hovered = hovered;
self.hovered_stepper = hovered_stepper;
set_hover_animation_target(
&mut self.hover_animation,
hovered as u8 as f32,
&theme,
ctx,
);
set_hover_animation_target(
&mut self.stepper_hover_animation,
hovered_stepper.is_some() as u8 as f32,
&theme,
ctx,
);
ctx.request_paint();
ctx.request_semantics();
}
}
fn set_pressed_stepper(
&mut self,
pressed_stepper: Option<NumberInputStepperPart>,
ctx: &mut EventCtx,
) {
if self.pressed_stepper != pressed_stepper {
let theme = self.resolved_theme();
self.pressed_stepper = pressed_stepper;
set_press_animation_target(
&mut self.press_animation,
pressed_stepper.is_some() as u8 as f32,
&theme,
ctx,
);
ctx.request_paint();
ctx.request_semantics();
}
}
fn hover_value(&self, clock: &impl FrameClock) -> f32 {
if !self.enabled.get() {
return 0.0;
}
self.hover_animation.get(clock).max(self.preview.hover())
}
fn press_value(&self, clock: &impl FrameClock) -> f32 {
if !self.enabled.get() {
return 0.0;
}
self.press_animation.get(clock).max(self.preview.press())
}
fn focus_value(&self, clock: &impl FrameClock) -> f32 {
if !self.enabled.get() {
return 0.0;
}
self.focus_animation.get(clock).max(self.preview.focus())
}
}
impl Widget for NumberInput {
fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
self.sync_external_value();
if !self.enabled.get() {
if let Event::Pointer(pointer) = event
&& pointer.kind == PointerEventKind::Up
{
ctx.release_pointer_capture(pointer.pointer_id);
}
return;
}
match event {
Event::Pointer(pointer) if pointer.kind == PointerEventKind::Move => {
let theme = self.resolved_theme();
self.set_hover_state(
ctx.bounds().contains(pointer.position),
number_input_stepper_part(ctx.bounds(), theme.metrics, pointer.position),
ctx,
);
}
Event::Pointer(pointer) if matches!(pointer.kind, PointerEventKind::Enter) => {
let theme = self.resolved_theme();
self.set_hover_state(
ctx.bounds().contains(pointer.position),
number_input_stepper_part(ctx.bounds(), theme.metrics, pointer.position),
ctx,
);
}
Event::Pointer(_pointer) if matches!(_pointer.kind, PointerEventKind::Leave) => {
self.set_hover_state(false, None, ctx);
}
Event::Pointer(pointer)
if pointer.kind == PointerEventKind::Down
&& pointer.button == Some(PointerButton::Primary) =>
{
let theme = self.resolved_theme();
let stepper_part =
number_input_stepper_part(ctx.bounds(), theme.metrics, pointer.position);
self.set_hover_state(ctx.bounds().contains(pointer.position), stepper_part, ctx);
self.set_pressed_stepper(stepper_part, ctx);
ctx.request_focus();
ctx.request_pointer_capture(pointer.pointer_id);
match stepper_part {
Some(NumberInputStepperPart::Increment) => self.nudge(ctx, self.step),
Some(NumberInputStepperPart::Decrement) => self.nudge(ctx, -self.step),
None => {}
}
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
Event::Pointer(pointer)
if pointer.kind == PointerEventKind::Up
&& pointer.button == Some(PointerButton::Primary) =>
{
let theme = self.resolved_theme();
self.set_hover_state(
ctx.bounds().contains(pointer.position),
number_input_stepper_part(ctx.bounds(), theme.metrics, pointer.position),
ctx,
);
self.set_pressed_stepper(None, ctx);
ctx.release_pointer_capture(pointer.pointer_id);
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
Event::Pointer(pointer) if pointer.kind == PointerEventKind::Cancel => {
if self.pressed_stepper.is_some() {
self.set_pressed_stepper(None, ctx);
ctx.release_pointer_capture(pointer.pointer_id);
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
}
Event::Semantics(semantics) if semantics.target == ctx.widget_id() => {
let next = match &semantics.action {
SemanticsActionRequest::Increment => Some(self.value + self.step),
SemanticsActionRequest::Decrement => Some(self.value - self.step),
SemanticsActionRequest::SetValue(SemanticsValue::Number(value)) => Some(*value),
SemanticsActionRequest::SetValue(SemanticsValue::Range { value, .. }) => {
Some(*value)
}
_ => None,
};
let Some(next) = next.filter(|value| value.is_finite()) else {
return;
};
let next = clamp_and_snap_value(next, self.min, self.max, self.step);
if (next - self.value).abs() > f64::EPSILON {
self.value = next;
self.buffer = format_number(self.value, self.precision);
if let Some(on_change) = &mut self.on_change {
on_change(self.value);
}
if let Some(on_change) = &mut self.on_change_with_ctx {
on_change(ctx, self.value);
}
}
ctx.request_measure();
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
Event::Keyboard(key) if ctx.is_focused() && key.state == KeyState::Pressed => {
match key.key.as_str() {
"ArrowUp" => self.nudge(ctx, self.step),
"ArrowDown" => self.nudge(ctx, -self.step),
"Enter" => self.commit_buffer(ctx),
"Escape" => self.buffer = format_number(self.value, self.precision),
"Backspace" => {
self.buffer.pop();
self.apply_edit_buffer(ctx);
}
_ => {
if let Some(text) = keyboard_text(key)
&& text.chars().all(is_numeric_input_char)
{
self.buffer.push_str(text);
self.apply_edit_buffer(ctx);
}
}
}
ctx.request_measure();
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
_ => {}
}
}
fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
self.sync_external_value();
let buffer = self.display_buffer();
let text_style = self.text_style();
let measurement = measure_text(ctx, &buffer, &text_style);
let theme = self.resolved_theme();
let padding = theme.metrics.text_input_padding;
let height =
(measurement.height.max(text_style.line_height) + padding.top + padding.bottom)
.max(theme.metrics.min_height);
constraints.clamp(Size::new(
(measurement.width
+ padding.left
+ padding.right
+ theme.metrics.number_input_stepper_width)
.max(theme.metrics.button_min_width + 60.0),
height,
))
}
fn paint(&self, ctx: &mut PaintCtx) {
self.enabled.observe(|source| {
ctx.observe(source);
});
let theme = self.paint_theme();
let palette = theme.palette;
let metrics = theme.metrics;
let interaction = theme.interaction;
let content = number_input_text_rect(ctx.bounds(), metrics);
let stepper = number_input_stepper_rect(ctx.bounds(), metrics);
let mut text_style = self.text_style();
if !self.enabled.get() {
text_style.color = theme.palette.text_disabled;
}
let buffer = self.display_buffer();
let stepper_hover_progress =
self.stepper_hover_animation.get(ctx) * interaction.hover_blend;
let press_progress = self.press_value(ctx) * interaction.pressed_blend;
let focus_progress = self.focus_value(ctx);
draw_control_frame(
ctx,
ctx.bounds(),
metrics.corner_radius,
metrics,
mix_color(palette.field, palette.surface_focus, focus_progress),
field_border(&palette, self.hover_value(ctx), focus_progress),
(focus_progress > 0.0).then_some(
palette
.focus_ring
.with_alpha(palette.focus_ring.alpha * focus_progress),
),
);
paint_text(ctx, content, &buffer, &text_style, TextAlign::End);
ctx.stroke(
line_path(
Point::new(stepper.x(), ctx.bounds().y() + 6.0),
Point::new(stepper.x(), ctx.bounds().max_y() - 6.0),
),
palette.border,
StrokeStyle::new(physical_pixels(ctx, metrics.border_width)),
);
for (part, rect) in [
(
NumberInputStepperPart::Increment,
Rect::new(
stepper.x(),
stepper.y(),
stepper.width(),
stepper.height() * 0.5,
),
),
(
NumberInputStepperPart::Decrement,
Rect::new(
stepper.x(),
stepper.y() + (stepper.height() * 0.5),
stepper.width(),
stepper.height() * 0.5,
),
),
] {
let hover_amount = if self.hovered_stepper == Some(part) {
stepper_hover_progress
} else {
0.0
};
let press_amount = if self.pressed_stepper == Some(part) {
press_progress
} else {
0.0
};
if hover_amount > 0.0 || press_amount > 0.0 {
let fill = mix_color(
mix_color(palette.control, palette.control_hover, hover_amount),
palette.control_active,
press_amount,
);
ctx.fill(
Path::rounded_rect(rect.inflate(-2.0, -2.0), metrics.corner_radius - 2.0),
fill,
);
}
}
let increment_offset = if self.pressed_stepper == Some(NumberInputStepperPart::Increment) {
Vector::new(0.0, self.press_value(ctx) * interaction.pressed_offset)
} else {
Vector::ZERO
};
let decrement_offset = if self.pressed_stepper == Some(NumberInputStepperPart::Decrement) {
Vector::new(0.0, self.press_value(ctx) * interaction.pressed_offset)
} else {
Vector::ZERO
};
draw_icon_glyph(
ctx,
IconGlyph::ChevronUp,
Rect::new(
stepper.x(),
stepper.y(),
stepper.width(),
stepper.height() * 0.5,
)
.translate(increment_offset),
palette.text,
);
draw_icon_glyph(
ctx,
IconGlyph::ChevronDown,
Rect::new(
stepper.x(),
stepper.y() + (stepper.height() * 0.5),
stepper.width(),
stepper.height() * 0.5,
)
.translate(decrement_offset),
palette.text,
);
if ctx.is_focused() {
let caret_x = content.max_x();
let caret_width = physical_pixels(ctx, metrics.caret_width);
let caret = Rect::new(
caret_x.min((content.max_x() - caret_width).max(content.x())),
content.y(),
caret_width,
content.height(),
);
ctx.set_ime_composition_rect(caret);
ctx.fill(Path::rounded_rect(caret, caret_width * 0.5), palette.caret);
}
}
fn semantics(&self, ctx: &mut SemanticsCtx) {
self.enabled.observe(|source| {
ctx.observe(source);
});
let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::SpinBox, ctx.bounds());
node.name = Some(self.name.clone());
node.value = Some(SemanticsValue::Range {
value: self.resolved_value(),
min: self.min,
max: self.max,
});
node.numeric_step = Some(self.step);
node.state.focused = ctx.is_focused();
node.state.hovered = self.hovered;
node.state.disabled = !self.enabled.get();
node.actions = if self.enabled.get() {
vec![
SemanticsAction::Focus,
SemanticsAction::Increment,
SemanticsAction::Decrement,
SemanticsAction::SetValue,
]
} else {
Vec::new()
};
ctx.push(node);
}
fn accepts_focus(&self) -> bool {
self.enabled.get()
}
fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
if focused {
self.sync_external_value();
}
self.editing = focused;
if !focused {
self.commit_buffer(ctx);
self.sync_external_value();
}
let theme = self.resolved_theme();
set_focus_animation_target(&mut self.focus_animation, focused as u8 as f32, &theme, ctx);
ctx.request_paint();
ctx.request_semantics();
}
}
#[doc(alias = "MultilineTextInput")]
pub struct TextArea {
theme: Box<DefaultTheme>,
theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
name: String,
enabled: Binding<bool>,
editor: EditableTextController,
placeholder: String,
read_only: bool,
appearance: FieldAppearance,
text_style: Option<TextStyle>,
padding: Option<Insets>,
min_width: Option<f32>,
min_height: Option<f32>,
hovered: bool,
focused: bool,
dragging_selection: bool,
hover_animation: AnimatedScalar,
focus_animation: AnimatedScalar,
caret: CaretBlink,
display_layout: Option<PersistentTextLayout>,
input_layout: Option<PersistentTextLayout>,
changes: TextChangeCallbacks,
on_submit: Option<Box<dyn FnMut(&str)>>,
on_submit_with_ctx: Option<Box<dyn FnMut(&mut EventCtx, &str)>>,
on_focus_change: Option<Box<dyn FnMut(bool)>>,
on_focus_change_with_ctx: Option<Box<dyn FnMut(&mut EventCtx, bool)>>,
preview: InteractionPreview,
}
impl TextArea {
pub fn new(name: impl Into<String>) -> Self {
Self {
theme: Box::new(DefaultTheme::default()),
theme_reader: None,
name: name.into(),
enabled: Binding::new(true),
editor: EditableTextController::new(),
placeholder: String::new(),
read_only: false,
appearance: FieldAppearance::Framed,
text_style: None,
padding: None,
min_width: None,
min_height: None,
hovered: false,
focused: false,
dragging_selection: false,
hover_animation: AnimatedScalar::new(0.0),
focus_animation: AnimatedScalar::new(0.0),
preview: InteractionPreview::None,
caret: CaretBlink::new(CARET_BLINK_PERIOD_SECONDS),
display_layout: None,
input_layout: None,
changes: TextChangeCallbacks::default(),
on_submit: None,
on_submit_with_ctx: None,
on_focus_change: None,
on_focus_change_with_ctx: None,
}
}
pub fn theme(mut self, theme: DefaultTheme) -> Self {
self.theme = Box::new(theme);
self.theme_reader = None;
self
}
pub fn theme_when<F>(mut self, theme: F) -> Self
where
F: Fn() -> DefaultTheme + 'static,
{
self.theme_reader = Some(Box::new(theme));
self
}
pub fn enabled(mut self, enabled: bool) -> Self {
self.enabled.set(enabled);
self
}
pub fn enabled_when<F>(mut self, enabled: F) -> Self
where
F: Fn() -> bool + 'static,
{
self.enabled.set_when(enabled);
self
}
pub fn enabled_from<O>(mut self, enabled: O) -> Self
where
O: Observable<bool> + 'static,
{
self.enabled.set_from(enabled);
self
}
pub fn is_enabled(&self) -> bool {
self.enabled.get()
}
fn paint_theme(&self) -> DefaultTheme {
let theme = self.resolved_theme();
if self.enabled.get() {
theme
} else {
theme.for_disabled_control()
}
}
pub fn text_style(mut self, text_style: TextStyle) -> Self {
self.text_style = Some(text_style);
self
}
pub fn appearance(mut self, appearance: FieldAppearance) -> Self {
self.appearance = appearance;
self
}
pub fn bare(mut self) -> Self {
self.appearance = FieldAppearance::Bare;
self
}
pub fn padding(mut self, padding: Insets) -> Self {
self.padding = Some(padding);
self
}
pub fn min_width(mut self, width: f32) -> Self {
self.min_width = Some(width.max(0.0));
self
}
pub fn min_height(mut self, height: f32) -> Self {
self.min_height = Some(height.max(0.0));
self
}
pub fn placeholder(mut self, placeholder: impl Into<String>) -> Self {
self.placeholder = placeholder.into();
self
}
pub fn read_only(mut self, read_only: bool) -> Self {
self.read_only = read_only;
self
}
pub fn is_read_only(&self) -> bool {
self.read_only
}
pub fn selectable(mut self, selection_scope: SelectionScope) -> Self {
self.editor.selectable(selection_scope);
self
}
pub fn selection_scope(mut self, selection_scope: SelectionScope) -> Self {
self.editor.selection_scope(selection_scope);
self
}
pub fn clipboard_behavior(mut self, behavior: SelectionClipboardBehavior) -> Self {
self.editor.clipboard_behavior(behavior);
self
}
pub fn copy_to_clipboard(self, enabled: bool) -> Self {
self.clipboard_behavior(if enabled {
SelectionClipboardBehavior::WidgetManaged
} else {
SelectionClipboardBehavior::AppManaged
})
}
pub fn value(mut self, value: impl Into<String>) -> Self {
self.editor.set_text(value);
self
}
pub fn current_value(&self) -> &str {
self.editor.document().text()
}
pub fn set_value(&mut self, value: impl Into<String>) {
self.editor.set_text(value);
}
pub fn interaction_preview(mut self, preview: InteractionPreview) -> Self {
self.preview = preview;
self
}
pub fn on_change<F>(mut self, on_change: F) -> Self
where
F: FnMut(String) + 'static,
{
self.changes.value = Some(Box::new(on_change));
self
}
pub fn on_change_with_ctx<F>(mut self, on_change: F) -> Self
where
F: FnMut(&mut EventCtx, String) + 'static,
{
self.changes.with_ctx = Some(Box::new(on_change));
self
}
pub fn on_submit<F>(mut self, on_submit: F) -> Self
where
F: FnMut(&str) + 'static,
{
self.on_submit = Some(Box::new(on_submit));
self
}
pub fn on_submit_with_ctx<F>(mut self, on_submit: F) -> Self
where
F: FnMut(&mut EventCtx, &str) + 'static,
{
self.on_submit_with_ctx = Some(Box::new(on_submit));
self
}
pub fn on_focus_change<F>(mut self, on_focus_change: F) -> Self
where
F: FnMut(bool) + 'static,
{
self.on_focus_change = Some(Box::new(on_focus_change));
self
}
pub fn on_focus_change_with_ctx<F>(mut self, on_focus_change: F) -> Self
where
F: FnMut(&mut EventCtx, bool) + 'static,
{
self.on_focus_change_with_ctx = Some(Box::new(on_focus_change));
self
}
fn input_text(&self) -> String {
self.editor.display_text()
}
fn display_text(&self) -> String {
let input = self.input_text();
if input.is_empty() {
self.placeholder.clone()
} else {
input
}
}
fn resolved_text_style(&self) -> TextStyle {
self.text_style
.clone()
.unwrap_or_else(|| self.resolved_theme().body_text_style())
}
fn display_text_style(&self) -> TextStyle {
let theme = self.resolved_theme();
if self.input_text().is_empty() {
theme.placeholder_text_style()
} else if self.read_only {
theme.text_style(theme.palette.text_muted)
} else {
self.resolved_text_style()
}
}
fn resolved_padding(&self) -> Insets {
self.padding
.unwrap_or(self.resolved_theme().metrics.text_input_padding)
}
fn resolved_min_size(&self) -> Size {
let theme = self.resolved_theme();
Size::new(
self.min_width.unwrap_or(theme.metrics.text_input_min_width),
self.min_height
.unwrap_or(theme.metrics.text_area_min_height),
)
}
fn resolved_theme(&self) -> DefaultTheme {
self.theme_reader
.as_ref()
.map(|theme| theme())
.unwrap_or(*self.theme)
}
fn apply_editor_result(&mut self, ctx: &mut EventCtx, result: EditorCommandResult) {
self.editor.apply_field_result(
ctx,
result,
&mut self.changes,
&mut self.caret,
self.focused,
self.read_only,
);
}
fn execute_editor_command(&mut self, ctx: &mut EventCtx, command: EditorCommand) {
let result = self.editor.execute(command);
self.apply_editor_result(ctx, result);
}
pub fn select_all(&mut self, ctx: &mut EventCtx) {
self.apply_text_command(ctx, TextCommand::SelectAll);
}
pub fn copy(&mut self, ctx: &mut EventCtx) {
self.apply_text_command(ctx, TextCommand::Copy);
}
pub fn cut(&mut self, ctx: &mut EventCtx) {
self.apply_text_command(ctx, TextCommand::Cut);
}
pub fn paste(&mut self, ctx: &mut EventCtx) {
self.apply_text_command(ctx, TextCommand::Paste);
}
pub fn selected_text(&self) -> &str {
self.editor.selected_text()
}
fn apply_text_command(&mut self, ctx: &mut EventCtx, command: TextCommand) {
if let Some(command) = self.editor.text_command(
ctx,
command,
self.read_only,
EditableTextLineMode::MultiLine,
) {
self.execute_editor_command(ctx, command);
}
}
fn text_offset_at_position(&self, bounds: Rect, position: Point) -> usize {
let content = inset_rect(bounds, self.resolved_padding());
self.input_layout
.as_ref()
.map(|layout| {
layout
.hit_test_point(Point::new(
position.x - content.x(),
position.y - content.y(),
))
.utf8_offset
})
.unwrap_or(self.editor.document().len())
}
fn set_caret_from_position(
&mut self,
bounds: Rect,
position: Point,
extend: bool,
ctx: &mut EventCtx,
) {
let offset = self.text_offset_at_position(bounds, position);
let command = if extend {
EditorCommand::SetSelection {
anchor: self.editor.selection().anchor.utf8_offset,
focus: offset,
}
} else {
EditorCommand::MoveTo {
offset,
extend: false,
}
};
let result = self.editor.execute(command);
self.apply_editor_result(ctx, result);
}
fn set_hovered(&mut self, hovered: bool, ctx: &mut EventCtx) {
if self.hovered != hovered {
let theme = self.resolved_theme();
self.hovered = hovered;
set_hover_animation_target(
&mut self.hover_animation,
hovered as u8 as f32,
&theme,
ctx,
);
ctx.request_paint();
ctx.request_semantics();
}
}
fn hover_value(&self, clock: &impl FrameClock) -> f32 {
if !self.enabled.get() {
return 0.0;
}
self.hover_animation.get(clock).max(self.preview.hover())
}
fn focus_value(&self, clock: &impl FrameClock) -> f32 {
if !self.enabled.get() {
return 0.0;
}
self.focus_animation.get(clock).max(self.preview.focus())
}
}
impl Widget for TextArea {
fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
if !self.enabled.get() {
if let Event::Pointer(pointer) = event
&& pointer.kind == PointerEventKind::Up
{
ctx.release_pointer_capture(pointer.pointer_id);
}
return;
}
match event {
Event::Pointer(pointer) if pointer.kind == PointerEventKind::Move => {
self.set_hovered(ctx.bounds().contains(pointer.position), ctx);
if self.dragging_selection
&& ctx.phase() != EventPhase::Capture
&& pointer.buttons.contains(PointerButton::Primary)
{
let offset = self.text_offset_at_position(ctx.bounds(), pointer.position);
let anchor = self.editor.selection().anchor.utf8_offset;
let result = self.editor.execute(EditorCommand::SetSelection {
anchor,
focus: offset,
});
self.apply_editor_result(ctx, result);
}
}
Event::Pointer(pointer) if pointer.kind == PointerEventKind::Enter => {
self.set_hovered(ctx.bounds().contains(pointer.position), ctx);
}
Event::Pointer(_pointer) if matches!(_pointer.kind, PointerEventKind::Leave) => {
self.set_hovered(false, ctx);
}
Event::Pointer(pointer)
if pointer.kind == PointerEventKind::Down
&& pointer.button == Some(PointerButton::Primary) =>
{
self.set_hovered(true, ctx);
if self.focused {
self.caret.reset(ctx, self.focused, self.read_only);
}
self.set_caret_from_position(
ctx.bounds(),
pointer.position,
pointer.modifiers.shift,
ctx,
);
self.dragging_selection = true;
ctx.request_pointer_capture(pointer.pointer_id);
ctx.request_focus();
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
Event::Pointer(pointer)
if pointer.kind == PointerEventKind::Up
&& pointer.button == Some(PointerButton::Primary)
&& self.dragging_selection =>
{
self.dragging_selection = false;
ctx.release_pointer_capture(pointer.pointer_id);
ctx.set_handled();
}
Event::Pointer(pointer) if pointer.kind == PointerEventKind::Cancel => {
if self.dragging_selection {
self.dragging_selection = false;
ctx.release_pointer_capture(pointer.pointer_id);
}
}
Event::Pointer(pointer)
if pointer.kind == PointerEventKind::Down
&& pointer.button == Some(PointerButton::Secondary)
&& ctx.phase() != EventPhase::Capture
&& ctx.bounds().contains(pointer.position) =>
{
self.set_hovered(true, ctx);
if !ctx.is_focused() {
ctx.request_focus();
ctx.request_paint();
ctx.request_semantics();
}
}
Event::Semantics(semantics) if semantics.target == ctx.widget_id() => {
if let Some(commands) = self.editor.semantics_commands(
ctx,
&semantics.action,
self.read_only,
EditableTextLineMode::MultiLine,
) {
for command in commands {
self.execute_editor_command(ctx, command);
}
}
}
Event::Ime(ImeEvent::CompositionStart) if ctx.is_focused() => {
if !self.read_only {
self.execute_editor_command(ctx, EditorCommand::StartComposition);
}
}
Event::Ime(ImeEvent::CompositionUpdate { text, cursor_range }) if ctx.is_focused() => {
if !self.read_only {
self.execute_editor_command(
ctx,
EditorCommand::UpdateComposition {
text: text.clone(),
cursor_range: cursor_range.clone(),
},
);
}
}
Event::Ime(ImeEvent::CompositionCommit { text }) if ctx.is_focused() => {
if !self.read_only {
self.execute_editor_command(
ctx,
EditorCommand::CommitComposition(text.clone()),
);
}
}
Event::Ime(ImeEvent::CompositionEnd) if ctx.is_focused() => {
if !self.read_only {
self.execute_editor_command(ctx, EditorCommand::EndComposition);
}
}
Event::Keyboard(key)
if key.state == KeyState::Pressed && ctx.is_focused() && key.key == "Enter" =>
{
let plain_enter =
!key.modifiers.shift && !key.modifiers.control && !key.modifiers.meta;
let has_submit = self.on_submit.is_some() || self.on_submit_with_ctx.is_some();
if has_submit && plain_enter {
let text = self.current_value().to_string();
if let Some(on_submit) = &mut self.on_submit {
on_submit(&text);
}
if let Some(on_submit) = &mut self.on_submit_with_ctx {
on_submit(ctx, &text);
}
ctx.set_handled();
} else if let Some(command) = self.editor.keyboard_command(
ctx,
key,
self.read_only,
EditableTextLineMode::MultiLine,
) {
self.execute_editor_command(ctx, command);
}
}
Event::Keyboard(key) if key.state == KeyState::Pressed && ctx.is_focused() => {
if let Some(command) = self.editor.keyboard_command(
ctx,
key,
self.read_only,
EditableTextLineMode::MultiLine,
) {
self.execute_editor_command(ctx, command);
}
}
Event::Wake(sui_core::WakeEvent::Timer { token, .. }) if self.caret.matches(*token) => {
self.caret.tick(ctx, self.focused);
}
_ => {}
}
}
fn command(&mut self, ctx: &mut EventCtx, command: &Command<'_>) {
let Some(command) = TextCommand::from_command(command) else {
return;
};
if !ctx.is_focused() {
ctx.request_focus();
}
self.apply_text_command(ctx, command);
}
fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
let text_style = self.resolved_text_style();
let padding = self.resolved_padding();
let min_size = self.resolved_min_size();
let content_width = if constraints.max.width.is_finite() {
(constraints.max.width - padding.left - padding.right).max(0.0)
} else {
(min_size.width - padding.left - padding.right).max(0.0)
};
let display_text = self.display_text();
let input_text = self.input_text();
let display_style = self.display_text_style();
let display_min_height = display_style.line_height.max(1.0);
let input_min_height = text_style.line_height.max(1.0);
let display_box = Size::new(content_width.max(1.0), display_min_height);
let input_box = Size::new(content_width.max(1.0), input_min_height);
let mut display_layout = ctx
.layout()
.shape_text_persistent(
self.display_layout.as_ref().map(|layout| layout.handle()),
display_text.clone(),
display_box,
display_style.clone(),
)
.ok();
if let Some(required_height) = display_layout
.as_ref()
.map(|layout| layout.measurement().height.max(display_min_height).max(1.0))
.filter(|height| *height > display_box.height + 0.01)
&& let Ok(layout) = ctx.layout().shape_text_persistent(
self.display_layout.as_ref().map(|layout| layout.handle()),
display_text,
Size::new(content_width.max(1.0), required_height),
display_style.clone(),
)
{
display_layout = Some(layout);
}
let mut input_layout = ctx
.layout()
.shape_text_persistent(
self.input_layout.as_ref().map(|layout| layout.handle()),
input_text.clone(),
input_box,
text_style.clone(),
)
.ok();
if let Some(required_height) = input_layout
.as_ref()
.map(|layout| layout.measurement().height.max(input_min_height).max(1.0))
.filter(|height| *height > input_box.height + 0.01)
&& let Ok(layout) = ctx.layout().shape_text_persistent(
self.input_layout.as_ref().map(|layout| layout.handle()),
input_text,
Size::new(content_width.max(1.0), required_height),
text_style.clone(),
)
{
input_layout = Some(layout);
}
let measured_height = display_layout
.as_ref()
.map(|layout| layout.measurement().height.max(display_style.line_height))
.unwrap_or(display_style.line_height);
self.display_layout = display_layout;
self.input_layout = input_layout;
constraints.clamp(Size::new(
min_size
.width
.max(content_width + padding.left + padding.right),
min_size
.height
.max(measured_height + padding.top + padding.bottom),
))
}
fn paint(&self, ctx: &mut PaintCtx) {
self.enabled.observe(|source| {
ctx.observe(source);
});
let theme = self.paint_theme();
let palette = theme.palette;
let metrics = theme.metrics;
let padding = self.resolved_padding();
let content = inset_rect(ctx.bounds(), padding);
let focus_progress = self.focus_value(ctx);
let background = field_background(&theme, self.read_only, focus_progress);
if self.appearance == FieldAppearance::Framed {
draw_control_frame(
ctx,
ctx.bounds(),
metrics.corner_radius,
metrics,
background,
field_border(&palette, self.hover_value(ctx), focus_progress),
(focus_progress > 0.0).then_some(
palette
.focus_ring
.with_alpha(palette.focus_ring.alpha * focus_progress),
),
);
}
if let Some(layout) = &self.display_layout {
ctx.push_clip_rect(content);
let input_text = self.input_text();
let selection = selection_range(&self.editor.display_selection(), input_text.len());
if !selection.is_empty() {
for rect in layout.selection_rects(selection) {
ctx.fill_rect(
rect.translate(content.origin.to_vector()),
palette.selection,
);
}
}
if self.enabled.get() {
ctx.draw_persistent_text_layout(content.origin, layout);
} else {
ctx.draw_persistent_text_layout_with_color(
content.origin,
layout,
theme.palette.text_disabled,
);
}
ctx.pop_clip();
}
if self.focused && !self.read_only {
let text_style = self.resolved_text_style();
let caret_width = physical_pixels(ctx, metrics.caret_width);
let fallback_caret = Rect::new(
content.x(),
content.y(),
caret_width,
text_style.line_height.max(1.0),
);
let caret = self
.input_layout
.as_ref()
.and_then(|layout| {
let caret = layout
.caret_rect(self.editor.display_selection().focus.utf8_offset)
.translate(content.origin.to_vector());
rect_is_finite(caret).then_some(caret)
})
.unwrap_or(fallback_caret);
let caret = Rect::new(
caret
.x()
.min((content.max_x() - caret_width).max(content.x()))
.max(content.x()),
caret.y(),
caret_width,
caret.height().max(text_style.line_height).max(1.0),
);
ctx.set_ime_composition_rect(caret);
if self.caret.visible {
ctx.fill(Path::rounded_rect(caret, caret_width * 0.5), palette.caret);
}
}
}
fn semantics(&self, ctx: &mut SemanticsCtx) {
self.enabled.observe(|source| {
ctx.observe(source);
});
let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::TextInput, ctx.bounds());
let display_text = self.input_text();
let display_selection = self.editor.display_selection();
let selection = selection_range(&display_selection, display_text.len());
node.name = Some(self.name.clone());
node.value = Some(SemanticsValue::Text(display_text));
node.state.focused = ctx.is_focused();
node.state.hovered = self.hovered;
node.editable_text = Some(EditableTextSemantics {
caret_offset: display_selection.focus.utf8_offset,
selection: SemanticsTextRange::new(selection.start, selection.end),
multiline: true,
password: false,
readonly: self.read_only,
scroll_x: 0.0,
scroll_y: 0.0,
});
node.state.disabled = !self.enabled.get();
node.actions = if self.enabled.get() {
self.editor.semantic_actions(self.read_only)
} else {
Vec::new()
};
ctx.push(node);
}
fn accepts_focus(&self) -> bool {
self.enabled.get()
}
fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
self.focused = focused;
if !focused {
let result = self.editor.execute(EditorCommand::ClearComposition);
if result.layout_changed() {
ctx.request_measure();
}
}
if focused {
self.caret.reset(ctx, self.focused, self.read_only);
} else {
self.caret.stop(ctx);
}
let theme = self.resolved_theme();
set_focus_animation_target(&mut self.focus_animation, focused as u8 as f32, &theme, ctx);
if let Some(on_focus_change) = &mut self.on_focus_change {
on_focus_change(focused);
}
if let Some(on_focus_change) = &mut self.on_focus_change_with_ctx {
on_focus_change(ctx, focused);
}
ctx.request_paint();
ctx.request_semantics();
}
}
#[derive(Debug, Clone)]
struct SelectMenuPresentationState {
theme: DefaultTheme,
options: Vec<String>,
selected: Option<usize>,
hovered: Option<usize>,
hover_visual: Option<usize>,
hover_animation: Progress,
placement: SelectMenuPlacement,
menu_bounds: Rect,
reveal: Reveal,
inline: bool,
}
impl SelectMenuPresentationState {
fn new() -> Self {
Self {
theme: DefaultTheme::default(),
options: Vec::new(),
selected: None,
hovered: None,
hover_visual: None,
hover_animation: Progress::new(0.0),
placement: SelectMenuPlacement::Below,
menu_bounds: Rect::ZERO,
reveal: Reveal::new(0.0),
inline: false,
}
}
fn is_presented(&self) -> bool {
self.reveal.is_presented()
}
fn row_rect(&self, index: usize, bounds: Rect) -> Rect {
select_option_rect(&self.theme, bounds, index)
}
fn set_hovered(
&mut self,
hovered: Option<usize>,
ctx: &mut EventCtx,
surface: WidgetId,
) -> bool {
if self.hovered == hovered && self.hover_visual == hovered {
return false;
}
self.hovered = hovered;
let spec = self.theme.motion.hover_spec();
if let Some(index) = hovered
&& self.hover_visual != Some(index)
{
self.hover_visual = Some(index);
self.hover_animation = Progress::new(0.0);
}
self.hover_animation
.animate_for(hovered.is_some() as u8 as f32, spec, ctx, surface);
true
}
fn sync_hovered_without_animation(&mut self, hovered: Option<usize>) -> bool {
if self.hovered == hovered && self.hover_visual == hovered {
return false;
}
self.hovered = hovered;
self.hover_visual = hovered;
self.hover_animation = Progress::new(hovered.is_some() as u8 as f32);
true
}
fn hover_progress_for(&self, index: usize, clock: &impl FrameClock) -> f32 {
if self.hover_visual == Some(index) {
self.hover_animation.get(clock)
} else {
0.0
}
}
fn layer_properties_at(&self, time: f64) -> LayerProperties {
let (direction, anchor) = match self.placement {
SelectMenuPlacement::Below => (-1.0, Vector::new(0.5, 0.0)),
SelectMenuPlacement::Above => (1.0, Vector::new(0.5, 1.0)),
};
let reveal = self.reveal.at(time);
LayerProperties::new(
reveal,
Vector::new(
0.0,
self.theme.metrics.popover_reveal_offset
* sui_runtime::motion_policy().entrance_offset(reveal)
* direction,
),
)
.with_scale(crate::animation::entrance_scale(reveal))
.with_scale_anchor(anchor)
}
}
struct SelectMenuSurface {
state: Rc<RefCell<SelectMenuPresentationState>>,
}
impl SelectMenuSurface {
fn new(state: Rc<RefCell<SelectMenuPresentationState>>) -> Self {
Self { state }
}
}
impl Widget for SelectMenuSurface {
fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
match event {
Event::Pointer(pointer)
if matches!(
pointer.kind,
PointerEventKind::Move | PointerEventKind::Enter
) =>
{
let mut state = self.state.borrow_mut();
let bounds = state.menu_bounds;
let hovered = bounds.contains(pointer.position).then(|| {
state.options.iter().enumerate().find_map(|(index, _)| {
state
.row_rect(index, bounds)
.contains(pointer.position)
.then_some(index)
})
});
let surface = ctx.widget_id();
let changed = state.set_hovered(hovered.flatten(), ctx, surface);
drop(state);
if changed {
ctx.request_paint();
}
}
Event::Pointer(pointer) if pointer.kind == PointerEventKind::Leave => {
let mut state = self.state.borrow_mut();
let surface = ctx.widget_id();
let changed = state.set_hovered(None, ctx, surface);
drop(state);
if changed {
ctx.request_paint();
}
}
_ => {}
}
}
fn measure(&mut self, _ctx: &mut MeasureCtx, _constraints: Constraints) -> Size {
let state = self.state.borrow();
if state.is_presented() {
state.menu_bounds.size
} else {
Size::ZERO
}
}
fn paint(&self, ctx: &mut PaintCtx) {
let state = self.state.borrow();
if !state.is_presented() {
return;
}
let menu = ctx.bounds();
let theme = state.theme;
let metrics = theme.metrics;
let palette = theme.palette;
let menu_radius = metrics.corner_radius + 2.0;
paint_theme_shadow(ctx, menu, [menu_radius; 4], &theme.shadows.box_shadow.lg);
draw_control_shape(
ctx,
menu,
menu_radius,
physical_pixels(ctx, metrics.border_width),
palette.surface_raised,
palette.border,
);
ctx.push_clip_rect(menu);
for (index, option) in state.options.iter().enumerate() {
let row = state.row_rect(index, menu);
let selected = state.selected == Some(index);
let hover_progress = state.hover_progress_for(index, ctx);
let text_style = theme.body_text_style();
if hover_progress > AnimatedScalar::EPSILON || selected {
let background = if selected {
mix_color(
palette.selection,
palette.control_hover,
hover_progress * theme.interaction.hover_blend,
)
} else {
mix_color(
palette.surface_raised,
palette.control_hover,
hover_progress,
)
};
ctx.fill(
Path::rounded_rect(row.inflate(-2.0, -2.0), metrics.corner_radius - 2.0),
background,
);
}
let text_slot = horizontal_text_inset_rect(row, metrics.menu_item_padding);
ctx.push_clip_rect(text_slot);
paint_text(ctx, text_slot, option, &text_style, TextAlign::Start);
ctx.pop_clip();
}
ctx.pop_clip();
}
fn layer_options(&self) -> LayerOptions {
let state = self.state.borrow();
LayerOptions {
paint_boundary: PaintBoundaryMode::Explicit,
composition_mode: if state.is_presented() && !state.inline {
LayerCompositionMode::Overlay
} else {
LayerCompositionMode::Normal
},
}
}
fn layer_properties_at(&self, frame_time: f64) -> LayerProperties {
self.state.borrow().layer_properties_at(frame_time)
}
fn stack_surface_options(&self) -> Option<StackSurfaceOptions> {
let state = self.state.borrow();
(state.is_presented() && !state.inline).then_some(StackSurfaceOptions {
transient: true,
..StackSurfaceOptions::default()
})
}
}
#[doc(alias = "ComboBox")]
pub struct Select {
theme: Box<DefaultTheme>,
theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
name: String,
enabled: Binding<bool>,
options: Vec<String>,
selected: Option<usize>,
selected_reader: Option<Box<dyn Fn() -> Option<usize>>>,
placeholder: String,
expanded: bool,
open_binding: Binding<bool>,
hovered_option: Option<usize>,
hovered_header: bool,
pressed_header: bool,
hover_animation: AnimatedScalar,
press_animation: AnimatedScalar,
focus_animation: AnimatedScalar,
menu_surface: SingleChild,
menu_state: Rc<RefCell<SelectMenuPresentationState>>,
inline: bool,
on_change: Option<Box<dyn FnMut(usize, String)>>,
on_change_with_ctx: Option<Box<dyn FnMut(&mut EventCtx, usize, String)>>,
on_open_change: Option<Box<dyn FnMut(bool)>>,
on_open_change_with_ctx: Option<Box<dyn FnMut(&mut EventCtx, bool)>>,
preview: InteractionPreview,
}
impl Select {
pub fn new(name: impl Into<String>) -> Self {
let menu_state = Rc::new(RefCell::new(SelectMenuPresentationState::new()));
Self {
theme: Box::new(DefaultTheme::default()),
theme_reader: None,
name: name.into(),
enabled: Binding::new(true),
options: Vec::new(),
selected: None,
selected_reader: None,
placeholder: String::new(),
expanded: false,
open_binding: Binding::new(false),
hovered_option: None,
hovered_header: false,
pressed_header: false,
hover_animation: AnimatedScalar::new(0.0),
press_animation: AnimatedScalar::new(0.0),
focus_animation: AnimatedScalar::new(0.0),
preview: InteractionPreview::None,
menu_surface: SingleChild::new(SelectMenuSurface::new(Rc::clone(&menu_state))),
menu_state,
inline: false,
on_change: None,
on_change_with_ctx: None,
on_open_change: None,
on_open_change_with_ctx: None,
}
}
pub fn theme(mut self, theme: DefaultTheme) -> Self {
self.theme = Box::new(theme);
self.theme_reader = None;
self
}
pub fn theme_when<F>(mut self, theme: F) -> Self
where
F: Fn() -> DefaultTheme + 'static,
{
self.theme_reader = Some(Box::new(theme));
self
}
pub fn enabled(mut self, enabled: bool) -> Self {
self.enabled.set(enabled);
self
}
pub fn enabled_when<F>(mut self, enabled: F) -> Self
where
F: Fn() -> bool + 'static,
{
self.enabled.set_when(enabled);
self
}
pub fn enabled_from<O>(mut self, enabled: O) -> Self
where
O: Observable<bool> + 'static,
{
self.enabled.set_from(enabled);
self
}
pub fn is_enabled(&self) -> bool {
self.enabled.get()
}
fn paint_theme(&self) -> DefaultTheme {
let theme = self.resolved_theme();
if self.enabled.get() {
theme
} else {
theme.for_disabled_control()
}
}
pub fn placeholder(mut self, placeholder: impl Into<String>) -> Self {
self.placeholder = placeholder.into();
self
}
pub fn option(mut self, option: impl Into<String>) -> Self {
self.options.push(option.into());
self
}
pub fn options<I, S>(mut self, options: I) -> Self
where
I: IntoIterator<Item = S>,
S: Into<String>,
{
self.options.extend(options.into_iter().map(Into::into));
self
}
pub fn selected(mut self, index: impl Into<Option<usize>>) -> Self {
let index = index.into();
self.selected = index;
self.selected_reader = None;
self
}
pub fn open(mut self, open: bool) -> Self {
self.open_binding.set(open);
self.jump_open(open);
self
}
pub fn open_when<F>(mut self, open: F) -> Self
where
F: Fn() -> bool + 'static,
{
self.open_binding.set_when(open);
self.sync_open();
self
}
pub fn open_from<O>(mut self, open: O) -> Self
where
O: Observable<bool> + 'static,
{
self.open_binding.set_from(open);
self.sync_open();
self
}
pub fn is_open(&self) -> bool {
self.expanded
}
pub fn on_open_change<F>(mut self, on_open_change: F) -> Self
where
F: FnMut(bool) + 'static,
{
self.on_open_change = Some(Box::new(on_open_change));
self
}
pub fn on_open_change_with_ctx<F>(mut self, on_open_change: F) -> Self
where
F: FnMut(&mut EventCtx, bool) + 'static,
{
self.on_open_change_with_ctx = Some(Box::new(on_open_change));
self
}
fn jump_open(&mut self, open: bool) {
self.expanded = open;
if open {
self.hovered_option = self.current_selected_index().or(Some(0));
} else {
self.hovered_option = None;
}
self.menu_state
.borrow_mut()
.reveal
.jump_to(open as u8 as f32);
}
fn sync_open(&mut self) {
if let Some(open) = self.open_binding.live()
&& open != self.expanded
&& !self.is_inline()
{
self.jump_open(open);
}
}
pub fn selected_when<F>(mut self, selected: F) -> Self
where
F: Fn() -> Option<usize> + 'static,
{
self.selected_reader = Some(Box::new(selected));
self
}
pub fn show_inline(mut self) -> Self {
self.inline = true;
self.menu_state.borrow_mut().inline = true;
self.open(true)
}
fn is_inline(&self) -> bool {
self.inline
}
pub const fn selected_index(&self) -> Option<usize> {
self.selected
}
pub fn current_value(&self) -> Option<&str> {
self.current_selected_index()
.and_then(|index| self.options.get(index).map(String::as_str))
}
pub fn interaction_preview(mut self, preview: InteractionPreview) -> Self {
self.preview = preview;
self
}
pub fn on_change<F>(mut self, on_change: F) -> Self
where
F: FnMut(usize, String) + 'static,
{
self.on_change = Some(Box::new(on_change));
self
}
pub fn on_change_with_ctx<F>(mut self, on_change: F) -> Self
where
F: FnMut(&mut EventCtx, usize, String) + 'static,
{
self.on_change_with_ctx = Some(Box::new(on_change));
self
}
fn resolved_theme(&self) -> DefaultTheme {
self.theme_reader
.as_ref()
.map(|theme| theme())
.unwrap_or(*self.theme)
}
fn header_height(&self) -> f32 {
default_form_control_height(&self.resolved_theme())
}
fn current_label(&self) -> String {
self.current_value()
.map(str::to_string)
.unwrap_or_else(|| self.placeholder.clone())
}
fn current_selected_index(&self) -> Option<usize> {
self.selected_reader
.as_ref()
.map(|reader| reader())
.unwrap_or(self.selected)
.filter(|index| *index < self.options.len())
}
fn header_rect(&self, bounds: Rect) -> Rect {
if self.is_inline() {
return Rect::new(bounds.x(), bounds.y(), bounds.width(), self.header_height());
}
let height = self.header_height().min(bounds.height()).max(0.0);
Rect::new(
bounds.x(),
bounds.y() + ((bounds.height() - height) * 0.5).max(0.0),
bounds.width(),
height,
)
}
fn menu_height(&self) -> f32 {
let metrics = self.resolved_theme().metrics;
(metrics.menu_padding.top
+ metrics.menu_padding.bottom
+ self.options.len() as f32 * metrics.menu_row_height)
.min(metrics.select_menu_max_height)
}
fn menu_layout(&self, bounds: Rect, viewport: Size) -> (SelectMenuPlacement, Rect) {
let theme = self.resolved_theme();
if self.is_inline() {
let header = self.header_rect(bounds);
return (
SelectMenuPlacement::Below,
Rect::new(
header.x(),
header.max_y() + theme.metrics.select_menu_gap,
header.width(),
self.menu_height(),
),
);
}
let viewport = if viewport.width.is_finite()
&& viewport.height.is_finite()
&& viewport.width > 0.0
&& viewport.height > 0.0
{
Rect::from_origin_size(Point::ZERO, viewport)
} else {
Rect::new(0.0, 0.0, f32::MAX / 4.0, f32::MAX / 4.0)
};
let result = place_overlay(
&OverlayPlacementRequest::new(
self.header_rect(bounds),
Size::new(bounds.width(), self.menu_height()),
viewport,
OverlayPlacement::BOTTOM_START,
)
.fallbacks([OverlayPlacement::TOP_START])
.gap(theme.metrics.select_menu_gap)
.margin(theme.metrics.select_menu_edge_padding),
);
let placement = if result.placement == OverlayPlacement::TOP_START {
SelectMenuPlacement::Above
} else {
SelectMenuPlacement::Below
};
(placement, result.bounds)
}
fn menu_placement(&self, bounds: Rect, viewport: Size) -> SelectMenuPlacement {
self.menu_layout(bounds, viewport).0
}
fn menu_rect(&self, bounds: Rect, viewport: Size) -> Rect {
self.menu_layout(bounds, viewport).1
}
fn option_rect(&self, bounds: Rect, viewport: Size, index: usize) -> Rect {
select_option_rect(
&self.resolved_theme(),
self.menu_rect(bounds, viewport),
index,
)
}
fn option_at(&self, bounds: Rect, viewport: Size, position: Point) -> Option<usize> {
if !self.expanded {
return None;
}
let menu = self.menu_rect(bounds, viewport);
if !menu.contains(position) {
return None;
}
self.options.iter().enumerate().find_map(|(index, _)| {
self.option_rect(bounds, viewport, index)
.contains(position)
.then_some(index)
})
}
fn select_index(&mut self, ctx: &mut EventCtx, index: usize) {
if self.options.is_empty() {
return;
}
let index = index.min(self.options.len().saturating_sub(1));
self.selected = Some(index);
let value = self.options[index].clone();
if let Some(on_change) = &mut self.on_change {
on_change(index, value.clone());
}
if let Some(on_change_with_ctx) = &mut self.on_change_with_ctx {
on_change_with_ctx(ctx, index, value);
}
self.refresh_menu_interaction_state(ctx);
}
fn sync_menu_state(&self, bounds: Rect, viewport: Size) {
let mut state = self.menu_state.borrow_mut();
state.theme = self.resolved_theme();
state.options = self.options.clone();
state.selected = self.current_selected_index();
if state.hovered != self.hovered_option {
state.sync_hovered_without_animation(self.hovered_option);
}
state.placement = self.menu_placement(bounds, viewport);
state.menu_bounds = self.menu_rect(bounds, viewport);
}
fn refresh_menu_interaction_state(&self, ctx: &mut EventCtx) {
let selected = self.current_selected_index();
let hovered = self.hovered_option;
let surface_id = self.menu_surface.child().id();
let mut state = self.menu_state.borrow_mut();
let selected_changed = state.selected != selected;
state.selected = selected;
let hover_changed = state.set_hovered(hovered, ctx, surface_id);
let changed = selected_changed || hover_changed;
let presented = state.is_presented();
drop(state);
if changed && presented {
request_child_invalidation(ctx, surface_id, InvalidationKind::Paint);
}
}
fn set_expanded(&mut self, ctx: &mut EventCtx, expanded: bool) {
if self.expanded == expanded || self.is_inline() {
return;
}
self.expanded = expanded;
self.hovered_option = if expanded {
self.current_selected_index().or(Some(0))
} else {
None
};
if let Some(on_open_change) = &mut self.on_open_change {
on_open_change(expanded);
}
if let Some(on_open_change) = &mut self.on_open_change_with_ctx {
on_open_change(ctx, expanded);
}
let surface_id = self.menu_surface.child().id();
let theme = self.resolved_theme();
let mut state = self.menu_state.borrow_mut();
state.theme = theme;
let was_presented = state.is_presented();
state.sync_hovered_without_animation(self.hovered_option);
let until = if expanded {
state
.reveal
.start(1.0, ctx.current_time(), theme.motion.entrance_spec())
} else {
state.reveal.jump_to(0.0);
None
};
let reveal = state.reveal;
let is_presented = state.is_presented();
drop(state);
reveal.track(ctx, &[surface_id], until, &Reveal::LAYER);
if expanded || was_presented != is_presented {
ctx.request_measure();
request_child_invalidation(ctx, surface_id, InvalidationKind::Visibility);
}
ctx.request_paint();
ctx.request_semantics();
}
fn set_hover_state(
&mut self,
hovered_header: bool,
hovered_option: Option<usize>,
ctx: &mut EventCtx,
) {
if self.hovered_header != hovered_header || self.hovered_option != hovered_option {
let theme = self.resolved_theme();
self.hovered_header = hovered_header;
self.hovered_option = hovered_option;
set_hover_animation_target(
&mut self.hover_animation,
hovered_header as u8 as f32,
&theme,
ctx,
);
let surface_id = self.menu_surface.child().id();
let mut state = self.menu_state.borrow_mut();
state.theme = theme;
state.set_hovered(hovered_option, ctx, surface_id);
let presented = state.is_presented();
drop(state);
if presented {
request_child_invalidation(ctx, surface_id, InvalidationKind::Paint);
}
ctx.request_paint();
ctx.request_semantics();
}
}
fn set_pressed_header(&mut self, pressed: bool, ctx: &mut EventCtx) {
if self.pressed_header != pressed {
let theme = self.resolved_theme();
self.pressed_header = pressed;
set_press_animation_target(
&mut self.press_animation,
pressed as u8 as f32,
&theme,
ctx,
);
ctx.request_paint();
ctx.request_semantics();
}
}
fn hover_value(&self, clock: &impl FrameClock) -> f32 {
if !self.enabled.get() {
return 0.0;
}
self.hover_animation.get(clock).max(self.preview.hover())
}
fn press_value(&self, clock: &impl FrameClock) -> f32 {
if !self.enabled.get() {
return 0.0;
}
self.press_animation.get(clock).max(self.preview.press())
}
fn focus_value(&self, clock: &impl FrameClock) -> f32 {
if !self.enabled.get() {
return 0.0;
}
self.focus_animation.get(clock).max(self.preview.focus())
}
}
impl Widget for Select {
fn command(&mut self, ctx: &mut EventCtx, command: &Command<'_>) {
if command.get(OVERLAY_DISMISS_REQUEST).is_some() && self.expanded {
self.set_expanded(ctx, false);
ctx.set_handled();
}
}
fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
if !self.enabled.get() {
if self.expanded {
self.set_expanded(ctx, false);
}
if let Event::Pointer(pointer) = event
&& pointer.kind == PointerEventKind::Up
{
ctx.release_pointer_capture(pointer.pointer_id);
}
return;
}
match event {
Event::Pointer(pointer) if pointer.kind == PointerEventKind::Move => {
self.set_hover_state(
self.header_rect(ctx.bounds()).contains(pointer.position),
self.option_at(ctx.bounds(), ctx.dpi().viewport, pointer.position),
ctx,
);
}
Event::Pointer(pointer) if matches!(pointer.kind, PointerEventKind::Enter) => {
self.set_hover_state(
self.header_rect(ctx.bounds()).contains(pointer.position),
self.option_at(ctx.bounds(), ctx.dpi().viewport, pointer.position),
ctx,
);
}
Event::Pointer(pointer) if matches!(pointer.kind, PointerEventKind::Leave) => {
self.set_hover_state(
false,
self.option_at(ctx.bounds(), ctx.dpi().viewport, pointer.position),
ctx,
);
}
Event::Pointer(pointer)
if pointer.kind == PointerEventKind::Down
&& pointer.button == Some(PointerButton::Primary) =>
{
let hovered_header = self.header_rect(ctx.bounds()).contains(pointer.position);
let hovered_option =
self.option_at(ctx.bounds(), ctx.dpi().viewport, pointer.position);
self.set_hover_state(hovered_header, hovered_option, ctx);
self.set_pressed_header(hovered_header, ctx);
ctx.request_focus();
ctx.request_pointer_capture(pointer.pointer_id);
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
Event::Pointer(pointer)
if pointer.kind == PointerEventKind::Up
&& pointer.button == Some(PointerButton::Primary) =>
{
let hovered_header = self.header_rect(ctx.bounds()).contains(pointer.position);
let hovered_option =
self.option_at(ctx.bounds(), ctx.dpi().viewport, pointer.position);
let was_pressed_header = self.pressed_header;
if was_pressed_header && hovered_header {
self.set_expanded(ctx, !self.expanded);
} else if let Some(index) = hovered_option {
self.select_index(ctx, index);
self.set_expanded(ctx, false);
} else {
self.set_expanded(ctx, false);
}
self.set_pressed_header(false, ctx);
self.set_hover_state(
hovered_header,
if self.expanded {
self.hovered_option
} else {
None
},
ctx,
);
ctx.release_pointer_capture(pointer.pointer_id);
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
Event::Pointer(pointer) if pointer.kind == PointerEventKind::Cancel => {
if self.pressed_header {
self.set_pressed_header(false, ctx);
self.set_hover_state(false, None, ctx);
ctx.release_pointer_capture(pointer.pointer_id);
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
}
Event::Keyboard(key) if ctx.is_focused() && key.state == KeyState::Pressed => {
if self.options.is_empty() {
return;
}
match key.key.as_str() {
"Enter" | " " => {
if self.expanded {
if let Some(index) = self
.hovered_option
.or_else(|| self.current_selected_index())
{
self.select_index(ctx, index);
}
self.set_expanded(ctx, false);
} else {
self.set_expanded(ctx, true);
}
}
"Escape" => self.set_expanded(ctx, false),
"ArrowDown" => {
if self.expanded {
let next = self
.hovered_option
.unwrap_or_else(|| self.current_selected_index().unwrap_or(0))
.saturating_add(1)
.min(self.options.len() - 1);
self.set_hover_state(self.hovered_header, Some(next), ctx);
} else {
let next = self
.current_selected_index()
.unwrap_or(0)
.saturating_add(1)
.min(self.options.len() - 1);
self.select_index(ctx, next);
}
}
"ArrowUp" => {
if self.expanded {
let next = self
.hovered_option
.unwrap_or_else(|| self.current_selected_index().unwrap_or(0))
.saturating_sub(1);
self.set_hover_state(self.hovered_header, Some(next), ctx);
} else {
let next = self.current_selected_index().unwrap_or(0).saturating_sub(1);
self.select_index(ctx, next);
}
}
"Home" => self.select_index(ctx, 0),
"End" => self.select_index(ctx, self.options.len() - 1),
_ => {}
}
self.refresh_menu_interaction_state(ctx);
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
Event::Semantics(semantics) if semantics.target == ctx.widget_id() => {
match &semantics.action {
SemanticsActionRequest::SetValue(SemanticsValue::Text(value)) => {
let Some(index) = self.options.iter().position(|option| option == value)
else {
return;
};
self.select_index(ctx, index);
self.set_expanded(ctx, false);
}
SemanticsActionRequest::Expand => self.set_expanded(ctx, true),
SemanticsActionRequest::Collapse => self.set_expanded(ctx, false),
_ => return,
}
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
_ => {}
}
}
fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
self.open_binding.observe(|open| {
ctx.observe::<bool, _>(open);
});
self.sync_open();
let theme = self.resolved_theme();
let padding = theme.metrics.text_input_padding;
let text_style = theme.body_text_style();
let widest_option = self
.options
.iter()
.map(|label| measure_text(ctx, label, &text_style).width)
.fold(0.0, f32::max);
let placeholder_width =
measure_text(ctx, &self.placeholder, &theme.placeholder_text_style()).width;
let widest = widest_option.max(placeholder_width);
let width = (widest + padding.left + padding.right + SELECT_CHEVRON_SLOT_WIDTH)
.max(theme.metrics.button_min_width + SELECT_CHEVRON_SLOT_WIDTH + padding.right);
let height = self.header_height();
let presented = self.menu_state.borrow().is_presented();
if presented {
let menu_size = Size::new(width, self.menu_height());
{
let mut state = self.menu_state.borrow_mut();
state.theme = theme;
state.options = self.options.clone();
state.selected = self.current_selected_index();
if state.hovered != self.hovered_option {
state.sync_hovered_without_animation(self.hovered_option);
}
state.menu_bounds = Rect::from_origin_size(Point::ZERO, menu_size);
}
self.menu_surface
.measure(ctx, Constraints::tight(menu_size));
if self.is_inline() {
return constraints.clamp(Size::new(
width,
height + theme.metrics.select_menu_gap + menu_size.height,
));
}
}
constraints.clamp(Size::new(width, height))
}
fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
self.sync_menu_state(bounds, ctx.dpi().viewport);
let state = self.menu_state.borrow();
let surface_bounds = if state.is_presented() {
state.menu_bounds
} else {
Rect::from_origin_size(bounds.origin, Size::ZERO)
};
drop(state);
self.menu_surface.arrange(ctx, surface_bounds);
}
fn paint(&self, ctx: &mut PaintCtx) {
self.enabled.observe(|source| {
ctx.observe(source);
});
let theme = self.paint_theme();
let palette = theme.palette;
let metrics = theme.metrics;
let interaction = theme.interaction;
let header = self.header_rect(ctx.bounds());
let label = self.current_label();
let placeholder = self.current_value().is_none();
let hover_progress = self.hover_value(ctx) * interaction.hover_blend;
let press_progress = self.press_value(ctx) * interaction.pressed_blend;
let focus_progress = self.focus_value(ctx);
let content_offset = Vector::new(0.0, self.press_value(ctx) * interaction.pressed_offset);
let text_style = if placeholder {
theme.placeholder_text_style()
} else {
theme.body_text_style()
};
let text_slot = Rect::new(
header.x() + metrics.text_input_padding.left,
header.y(),
(header.width()
- metrics.text_input_padding.left
- metrics.text_input_padding.right
- SELECT_CHEVRON_SLOT_WIDTH)
.max(0.0),
header.height(),
);
draw_control_frame(
ctx,
header,
metrics.corner_radius,
metrics,
mix_color(
mix_color(palette.field, palette.button_pressed, press_progress * 0.5),
palette.surface_focus,
focus_progress,
),
field_border(
&palette,
self.hover_value(ctx).max(hover_progress),
focus_progress,
),
(focus_progress > 0.0).then_some(
palette
.focus_ring
.with_alpha(palette.focus_ring.alpha * focus_progress),
),
);
ctx.push_clip_rect(text_slot);
paint_text_line(
ctx,
text_slot.translate(content_offset),
&label,
&text_style,
TextAlign::Start,
);
ctx.pop_clip();
draw_icon_glyph(
ctx,
if self.expanded {
IconGlyph::ChevronUp
} else {
IconGlyph::ChevronDown
},
select_chevron_icon_rect(header).translate(content_offset),
palette.text,
);
if self.menu_state.borrow().is_presented() {
self.menu_surface.paint(ctx);
}
}
fn semantics(&self, ctx: &mut SemanticsCtx) {
self.enabled.observe(|source| {
ctx.observe(source);
});
let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::ComboBox, ctx.bounds());
node.name = Some(self.name.clone());
node.value = Some(SemanticsValue::Text(self.current_label()));
node.state.focused = ctx.is_focused();
node.state.hovered = self.hovered_header || self.menu_state.borrow().hovered.is_some();
node.state.expanded = Some(self.expanded);
node.popup = Some(SemanticsPopupKind::ListBox);
node.state.disabled = !self.enabled.get();
node.actions = if self.enabled.get() {
vec![
SemanticsAction::Focus,
SemanticsAction::Expand,
SemanticsAction::Collapse,
SemanticsAction::SetValue,
]
} else {
Vec::new()
};
ctx.push(node);
}
fn accepts_focus(&self) -> bool {
self.enabled.get()
}
fn overlay_options(&self) -> Option<OverlayOptions> {
if self.is_inline() {
return None;
}
(self.expanded || self.menu_state.borrow().is_presented()).then_some(
OverlayOptions::new(OverlayKind::Menu)
.dismiss(if self.expanded {
OverlayDismissPolicy::TRANSIENT
} else {
OverlayDismissPolicy::NONE
})
.focus(OverlayFocusBehavior::NONE),
)
}
fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
if !focused && self.expanded {
self.set_expanded(ctx, false);
}
let theme = self.resolved_theme();
set_focus_animation_target(&mut self.focus_animation, focused as u8 as f32, &theme, ctx);
ctx.request_paint();
ctx.request_semantics();
}
fn visit_children(&self, visitor: &mut dyn WidgetPodVisitor) {
if self.menu_state.borrow().is_presented() {
self.menu_surface.visit_children(visitor);
}
}
fn visit_children_mut(&mut self, visitor: &mut dyn WidgetPodMutVisitor) {
if self.menu_state.borrow().is_presented() {
self.menu_surface.visit_children_mut(visitor);
}
}
}
const PASSWORD_MASK: &str = "•";
pub struct TextInput {
theme: Box<DefaultTheme>,
theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
name: String,
enabled: Binding<bool>,
editor: EditableTextController,
password: bool,
placeholder: String,
leading_icon: Option<IconGlyph>,
read_only: bool,
appearance: FieldAppearance,
text_style: Option<TextStyle>,
padding: Option<Insets>,
min_width: Option<f32>,
min_height: Option<f32>,
hovered: bool,
focused: bool,
dragging_selection: bool,
reveal_caret: bool,
hover_animation: AnimatedScalar,
focus_animation: AnimatedScalar,
caret: CaretBlink,
visible_measurement: Option<TextMeasurement>,
input_measurement: Option<TextMeasurement>,
display_layout: Option<PersistentTextLayout>,
input_layout: Option<PersistentTextLayout>,
changes: TextChangeCallbacks,
on_submit: Option<Box<dyn FnMut(&str)>>,
on_submit_with_ctx: Option<Box<dyn FnMut(&mut EventCtx, &str)>>,
on_focus_change: Option<Box<dyn FnMut(bool)>>,
on_focus_change_with_ctx: Option<Box<dyn FnMut(&mut EventCtx, bool)>>,
preview: InteractionPreview,
}
impl TextInput {
pub fn new(name: impl Into<String>) -> Self {
Self {
theme: Box::new(DefaultTheme::default()),
theme_reader: None,
name: name.into(),
enabled: Binding::new(true),
editor: EditableTextController::new(),
password: false,
placeholder: String::new(),
leading_icon: None,
read_only: false,
appearance: FieldAppearance::Framed,
text_style: None,
padding: None,
min_width: None,
min_height: None,
hovered: false,
focused: false,
dragging_selection: false,
reveal_caret: false,
hover_animation: AnimatedScalar::new(0.0),
focus_animation: AnimatedScalar::new(0.0),
preview: InteractionPreview::None,
caret: CaretBlink::new(CARET_BLINK_PERIOD_SECONDS),
visible_measurement: None,
input_measurement: None,
display_layout: None,
input_layout: None,
changes: TextChangeCallbacks::default(),
on_submit: None,
on_submit_with_ctx: None,
on_focus_change: None,
on_focus_change_with_ctx: None,
}
}
pub fn accessible_name(&self) -> &str {
&self.name
}
pub fn theme(mut self, theme: DefaultTheme) -> Self {
self.theme = Box::new(theme);
self.theme_reader = None;
self
}
pub fn theme_when<F>(mut self, theme: F) -> Self
where
F: Fn() -> DefaultTheme + 'static,
{
self.theme_reader = Some(Box::new(theme));
self
}
pub fn enabled(mut self, enabled: bool) -> Self {
self.enabled.set(enabled);
self
}
pub fn enabled_when<F>(mut self, enabled: F) -> Self
where
F: Fn() -> bool + 'static,
{
self.enabled.set_when(enabled);
self
}
pub fn enabled_from<O>(mut self, enabled: O) -> Self
where
O: Observable<bool> + 'static,
{
self.enabled.set_from(enabled);
self
}
pub fn is_enabled(&self) -> bool {
self.enabled.get()
}
fn paint_theme(&self) -> DefaultTheme {
let theme = self.resolved_theme();
if self.enabled.get() {
theme
} else {
theme.for_disabled_control()
}
}
pub fn text_style(mut self, text_style: TextStyle) -> Self {
self.text_style = Some(text_style);
self
}
pub fn appearance(mut self, appearance: FieldAppearance) -> Self {
self.appearance = appearance;
self
}
pub fn bare(mut self) -> Self {
self.appearance = FieldAppearance::Bare;
self
}
pub fn padding(mut self, padding: Insets) -> Self {
self.padding = Some(padding);
self
}
pub fn min_width(mut self, width: f32) -> Self {
self.min_width = Some(width.max(0.0));
self
}
pub fn min_height(mut self, height: f32) -> Self {
self.min_height = Some(height.max(0.0));
self
}
pub fn placeholder(mut self, placeholder: impl Into<String>) -> Self {
self.placeholder = placeholder.into();
self
}
pub fn leading_icon(mut self, icon: IconGlyph) -> Self {
self.leading_icon = Some(icon);
self
}
pub fn read_only(mut self, read_only: bool) -> Self {
self.read_only = read_only;
self
}
pub fn is_read_only(&self) -> bool {
self.read_only
}
pub fn selectable(mut self, selection_scope: SelectionScope) -> Self {
self.editor.selectable(selection_scope);
self
}
pub fn selection_scope(mut self, selection_scope: SelectionScope) -> Self {
self.editor.selection_scope(selection_scope);
self
}
pub fn clipboard_behavior(mut self, behavior: SelectionClipboardBehavior) -> Self {
self.editor.clipboard_behavior(behavior);
self
}
pub fn copy_to_clipboard(self, enabled: bool) -> Self {
self.clipboard_behavior(if enabled {
SelectionClipboardBehavior::WidgetManaged
} else {
SelectionClipboardBehavior::AppManaged
})
}
pub fn value(mut self, value: impl Into<String>) -> Self {
self.editor.set_text(single_line_text(value.into()));
self
}
fn password(mut self) -> Self {
self.password = true;
self
}
pub fn current_value(&self) -> &str {
self.editor.document().text()
}
pub fn set_value(&mut self, value: impl Into<String>) {
self.editor.set_text(single_line_text(value.into()));
}
pub fn interaction_preview(mut self, preview: InteractionPreview) -> Self {
self.preview = preview;
self
}
pub fn on_change<F>(mut self, on_change: F) -> Self
where
F: FnMut(String) + 'static,
{
self.changes.value = Some(Box::new(on_change));
self
}
pub fn on_change_with_ctx<F>(mut self, on_change: F) -> Self
where
F: FnMut(&mut EventCtx, String) + 'static,
{
self.changes.with_ctx = Some(Box::new(on_change));
self
}
pub fn on_submit<F>(mut self, on_submit: F) -> Self
where
F: FnMut(&str) + 'static,
{
self.on_submit = Some(Box::new(on_submit));
self
}
pub fn on_submit_with_ctx<F>(mut self, on_submit: F) -> Self
where
F: FnMut(&mut EventCtx, &str) + 'static,
{
self.on_submit_with_ctx = Some(Box::new(on_submit));
self
}
pub fn on_focus_change<F>(mut self, on_focus_change: F) -> Self
where
F: FnMut(bool) + 'static,
{
self.on_focus_change = Some(Box::new(on_focus_change));
self
}
pub fn on_focus_change_with_ctx<F>(mut self, on_focus_change: F) -> Self
where
F: FnMut(&mut EventCtx, bool) + 'static,
{
self.on_focus_change_with_ctx = Some(Box::new(on_focus_change));
self
}
fn input_text(&self) -> String {
self.editor.display_text()
}
fn rendered_input_text(&self) -> String {
let input = self.input_text();
if self.password {
PASSWORD_MASK.repeat(input.graphemes(true).count())
} else {
input
}
}
fn rendered_offset(&self, input: &str, editor_offset: usize) -> usize {
if !self.password {
return editor_offset.min(input.len());
}
input
.grapheme_indices(true)
.take_while(|(offset, _)| *offset < editor_offset.min(input.len()))
.count()
* PASSWORD_MASK.len()
}
fn editor_offset(&self, input: &str, rendered_offset: usize) -> usize {
if !self.password {
return rendered_offset.min(input.len());
}
let grapheme_index = rendered_offset / PASSWORD_MASK.len();
input
.grapheme_indices(true)
.nth(grapheme_index)
.map(|(offset, _)| offset)
.unwrap_or(input.len())
}
fn rendered_selection_range(&self, input: &str) -> Range<usize> {
let selection = selection_range(&self.editor.display_selection(), input.len());
self.rendered_offset(input, selection.start)..self.rendered_offset(input, selection.end)
}
fn display_caret_offset(&self) -> usize {
let input = self.input_text();
self.rendered_offset(&input, self.editor.display_selection().focus.utf8_offset)
}
fn visible_text(&self) -> String {
let input = self.rendered_input_text();
if input.is_empty() {
self.placeholder.clone()
} else {
input
}
}
fn display_text_style(&self) -> TextStyle {
let theme = self.resolved_theme();
if self.input_text().is_empty() {
theme.placeholder_text_style()
} else if self.read_only {
self.read_only_text_style(&theme)
} else {
self.resolved_text_style()
}
}
fn read_only_text_style(&self, theme: &DefaultTheme) -> TextStyle {
TextStyle {
color: theme.palette.text_muted,
..self.resolved_text_style()
}
}
fn apply_editor_result(&mut self, ctx: &mut EventCtx, result: EditorCommandResult) {
let moved = result.text_changed || result.selection_changed || result.composition_changed;
let reshaped = result.layout_changed();
self.editor.apply_field_result(
ctx,
result,
&mut self.changes,
&mut self.caret,
self.focused,
self.read_only,
);
if moved && reshaped {
self.reveal_caret = true;
} else if moved {
self.scroll_caret_into_view(ctx);
}
}
fn scroll_caret_into_view(&mut self, ctx: &mut EventCtx) {
if !self.reveal_caret && self.update_scroll(ctx.bounds(), ctx.dpi(), true) {
ctx.request_paint();
ctx.request_semantics();
}
}
fn execute_editor_command(&mut self, ctx: &mut EventCtx, command: EditorCommand) {
let result = self.editor.execute(command);
self.apply_editor_result(ctx, result);
}
pub fn select_all(&mut self, ctx: &mut EventCtx) {
self.apply_text_command(ctx, TextCommand::SelectAll);
}
pub fn copy(&mut self, ctx: &mut EventCtx) {
self.apply_text_command(ctx, TextCommand::Copy);
}
pub fn cut(&mut self, ctx: &mut EventCtx) {
self.apply_text_command(ctx, TextCommand::Cut);
}
pub fn paste(&mut self, ctx: &mut EventCtx) {
self.apply_text_command(ctx, TextCommand::Paste);
}
pub fn selected_text(&self) -> &str {
self.editor.selected_text()
}
fn apply_text_command(&mut self, ctx: &mut EventCtx, command: TextCommand) {
if let Some(command) = self.editor.text_command(
ctx,
command,
self.read_only,
EditableTextLineMode::SingleLine,
) {
self.execute_editor_command(ctx, command);
}
}
fn text_offset_at_position(&self, bounds: Rect, position: Point) -> usize {
let content = self.text_content_rect(bounds);
let rendered_offset = self
.input_layout
.as_ref()
.map(|layout| {
layout
.hit_test_point(Point::new(
position.x - self.text_x(content),
position.y - content.y(),
))
.utf8_offset
})
.unwrap_or(self.rendered_input_text().len());
self.editor_offset(&self.input_text(), rendered_offset)
}
fn text_x(&self, content: Rect) -> f32 {
content.x() - self.editor.scroll_x()
}
fn caret_width(&self, dpi: DpiInfo) -> f32 {
physical_pixels_at(dpi, self.resolved_theme().metrics.caret_width)
}
fn update_scroll(&mut self, bounds: Rect, dpi: DpiInfo, reveal_caret: bool) -> bool {
let previous = self.editor.scroll_x();
let viewport = self.text_content_rect(bounds).width();
let caret_width = self.caret_width(dpi);
let (text_width, caret_x) = self.input_layout.as_ref().map_or((0.0, 0.0), |layout| {
(
layout.measurement().width,
layout.caret_rect(self.display_caret_offset()).x(),
)
});
let mut scroll = previous;
if reveal_caret {
if caret_x + caret_width > scroll + viewport {
scroll = caret_x + caret_width - viewport;
}
if caret_x < scroll {
scroll = caret_x;
}
}
let max_scroll = (text_width + caret_width - viewport).max(0.0);
self.editor.set_scroll(scroll.clamp(0.0, max_scroll), 0.0);
self.editor.scroll_x() != previous
}
fn set_caret_from_position(
&mut self,
bounds: Rect,
position: Point,
extend: bool,
ctx: &mut EventCtx,
) {
let offset = self.text_offset_at_position(bounds, position);
let command = if extend {
EditorCommand::SetSelection {
anchor: self.editor.selection().anchor.utf8_offset,
focus: offset,
}
} else {
EditorCommand::MoveTo {
offset,
extend: false,
}
};
let result = self.editor.execute(command);
self.apply_editor_result(ctx, result);
self.caret.reset(ctx, self.focused, self.read_only);
}
fn set_hovered(&mut self, hovered: bool, ctx: &mut EventCtx) {
if self.hovered != hovered {
let theme = self.resolved_theme();
self.hovered = hovered;
set_hover_animation_target(
&mut self.hover_animation,
hovered as u8 as f32,
&theme,
ctx,
);
ctx.request_paint();
ctx.request_semantics();
}
}
fn resolved_text_style(&self) -> TextStyle {
self.text_style
.clone()
.unwrap_or_else(|| self.resolved_theme().body_text_style())
}
fn resolved_padding(&self) -> Insets {
self.padding
.unwrap_or(self.resolved_theme().metrics.text_input_padding)
}
fn leading_icon_advance(&self) -> f32 {
if self.leading_icon.is_some() {
24.0
} else {
0.0
}
}
fn text_content_rect(&self, bounds: Rect) -> Rect {
let content = inset_rect(bounds, self.resolved_padding());
let leading = self.leading_icon_advance();
Rect::new(
(content.x() + leading).min(content.max_x()),
content.y(),
(content.width() - leading).max(0.0),
content.height(),
)
}
fn resolved_min_size(&self) -> Size {
let theme = self.resolved_theme();
Size::new(
self.min_width.unwrap_or(theme.metrics.text_input_min_width),
self.min_height.unwrap_or(theme.metrics.min_height),
)
}
fn resolved_theme(&self) -> DefaultTheme {
self.theme_reader
.as_ref()
.map(|theme| theme())
.unwrap_or(*self.theme)
}
fn single_line_layout_rect(
&self,
ctx: &PaintCtx,
content: Rect,
layout: &PersistentTextLayout,
line_height: f32,
) -> Rect {
aligned_text_rect_for_layout(ctx, content, layout.layout(), line_height, 0.0)
}
fn single_line_text_rect(
&self,
ctx: &PaintCtx,
content: Rect,
text: &str,
style: &TextStyle,
line_height: f32,
) -> Rect {
aligned_text_rect_for_text(ctx, content, text, style, line_height, 0.0)
}
fn hover_value(&self, clock: &impl FrameClock) -> f32 {
if !self.enabled.get() {
return 0.0;
}
self.hover_animation.get(clock).max(self.preview.hover())
}
fn focus_value(&self, clock: &impl FrameClock) -> f32 {
if !self.enabled.get() {
return 0.0;
}
self.focus_animation.get(clock).max(self.preview.focus())
}
}
impl Widget for TextInput {
fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
if !self.enabled.get() {
if let Event::Pointer(pointer) = event
&& pointer.kind == PointerEventKind::Up
{
ctx.release_pointer_capture(pointer.pointer_id);
}
return;
}
match event {
Event::Pointer(pointer) if pointer.kind == PointerEventKind::Move => {
self.set_hovered(ctx.bounds().contains(pointer.position), ctx);
if self.dragging_selection
&& ctx.phase() != EventPhase::Capture
&& pointer.buttons.contains(PointerButton::Primary)
{
let offset = self.text_offset_at_position(ctx.bounds(), pointer.position);
let anchor = self.editor.selection().anchor.utf8_offset;
let result = self.editor.execute(EditorCommand::SetSelection {
anchor,
focus: offset,
});
self.apply_editor_result(ctx, result);
}
}
Event::Pointer(_pointer) if matches!(_pointer.kind, PointerEventKind::Enter) => {
self.set_hovered(true, ctx);
}
Event::Pointer(_pointer) if matches!(_pointer.kind, PointerEventKind::Leave) => {
self.set_hovered(false, ctx);
}
Event::Pointer(pointer)
if pointer.kind == PointerEventKind::Down
&& pointer.button == Some(PointerButton::Primary) =>
{
self.set_hovered(true, ctx);
self.set_caret_from_position(
ctx.bounds(),
pointer.position,
pointer.modifiers.shift,
ctx,
);
self.dragging_selection = true;
ctx.request_pointer_capture(pointer.pointer_id);
ctx.request_focus();
ctx.request_paint();
ctx.request_semantics();
ctx.set_handled();
}
Event::Pointer(pointer)
if pointer.kind == PointerEventKind::Up
&& pointer.button == Some(PointerButton::Primary)
&& self.dragging_selection =>
{
self.dragging_selection = false;
ctx.release_pointer_capture(pointer.pointer_id);
ctx.set_handled();
}
Event::Pointer(pointer) if pointer.kind == PointerEventKind::Cancel => {
if self.dragging_selection {
self.dragging_selection = false;
ctx.release_pointer_capture(pointer.pointer_id);
}
}
Event::Pointer(pointer)
if pointer.kind == PointerEventKind::Down
&& pointer.button == Some(PointerButton::Secondary)
&& ctx.phase() != EventPhase::Capture
&& ctx.bounds().contains(pointer.position) =>
{
self.set_hovered(true, ctx);
if !ctx.is_focused() {
ctx.request_focus();
ctx.request_paint();
ctx.request_semantics();
}
}
Event::Semantics(semantics) if semantics.target == ctx.widget_id() => {
if let Some(commands) = self.editor.semantics_commands(
ctx,
&semantics.action,
self.read_only,
EditableTextLineMode::SingleLine,
) {
for command in commands {
self.execute_editor_command(ctx, command);
}
}
}
Event::Ime(ImeEvent::CompositionStart) if ctx.is_focused() => {
if !self.read_only {
self.execute_editor_command(ctx, EditorCommand::StartComposition);
}
}
Event::Ime(ImeEvent::CompositionUpdate { text, cursor_range }) if ctx.is_focused() => {
if !self.read_only {
self.execute_editor_command(
ctx,
EditorCommand::UpdateComposition {
text: single_line_text(text.clone()),
cursor_range: cursor_range.clone(),
},
);
}
}
Event::Ime(ImeEvent::CompositionCommit { text }) if ctx.is_focused() => {
if !self.read_only {
self.execute_editor_command(
ctx,
EditorCommand::CommitComposition(single_line_text(text.clone())),
);
}
}
Event::Ime(ImeEvent::CompositionEnd) if ctx.is_focused() => {
if !self.read_only {
self.execute_editor_command(ctx, EditorCommand::EndComposition);
}
}
Event::Keyboard(key)
if key.state == KeyState::Pressed
&& ctx.is_focused()
&& key.key == "Enter"
&& !key.modifiers.shift
&& !key.modifiers.control
&& !key.modifiers.meta
&& (self.on_submit.is_some() || self.on_submit_with_ctx.is_some()) =>
{
let text = self.current_value().to_string();
if let Some(on_submit) = &mut self.on_submit {
on_submit(&text);
}
if let Some(on_submit) = &mut self.on_submit_with_ctx {
on_submit(ctx, &text);
}
ctx.set_handled();
}
Event::Keyboard(key) if key.state == KeyState::Pressed && ctx.is_focused() => {
if let Some(command) = self.editor.keyboard_command(
ctx,
key,
self.read_only,
EditableTextLineMode::SingleLine,
) {
self.execute_editor_command(ctx, command);
}
}
Event::Wake(sui_core::WakeEvent::Timer { token, .. }) if self.caret.matches(*token) => {
self.caret.tick(ctx, self.focused);
}
_ => {}
}
}
fn command(&mut self, ctx: &mut EventCtx, command: &Command<'_>) {
let Some(command) = TextCommand::from_command(command) else {
return;
};
if !ctx.is_focused() {
ctx.request_focus();
}
self.apply_text_command(ctx, command);
}
fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
let text_style = self.resolved_text_style();
let padding = self.resolved_padding();
let min_size = self.resolved_min_size();
let visible_text = self.visible_text();
let input_text = self.rendered_input_text();
let display_style = self.display_text_style();
let measured_visible = measure_text(ctx, &visible_text, &display_style);
let measured_input = if input_text.is_empty() {
TextMeasurement {
width: 0.0,
height: measured_visible.height,
bounds: Rect::new(0.0, 0.0, 0.0, measured_visible.height),
ascent: measured_visible.ascent,
descent: measured_visible.descent,
cap_height: measured_visible.cap_height,
}
} else {
measure_text(ctx, &input_text, &text_style)
};
let display_line_height = display_style
.line_height
.max(measured_visible.height)
.max(1.0);
let input_line_height = text_style.line_height.max(measured_input.height).max(1.0);
let display_line_box = Size::new(f32::INFINITY, display_line_height);
let input_line_box = Size::new(f32::INFINITY, input_line_height);
let display_layout = ctx
.layout()
.shape_text_persistent(
self.display_layout.as_ref().map(|layout| layout.handle()),
visible_text.clone(),
display_line_box,
display_style.clone(),
)
.ok();
let input_layout = ctx
.layout()
.shape_text_persistent(
self.input_layout.as_ref().map(|layout| layout.handle()),
input_text.clone(),
input_line_box,
text_style.clone(),
)
.ok();
let visible_measurement = display_layout
.as_ref()
.map(|layout| layout.measurement())
.unwrap_or(measured_visible);
let input_measurement = input_layout
.as_ref()
.map(|layout| layout.measurement())
.unwrap_or(measured_input);
self.visible_measurement = Some(visible_measurement);
self.input_measurement = Some(input_measurement);
self.display_layout = display_layout;
self.input_layout = input_layout;
let width = (visible_measurement.width
+ self.leading_icon_advance()
+ padding.left
+ padding.right)
.max(min_size.width);
let height = (visible_measurement.height.max(display_style.line_height)
+ padding.top
+ padding.bottom)
.max(min_size.height);
constraints.clamp(Size::new(width, height))
}
fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
let reveal_caret = std::mem::take(&mut self.reveal_caret) || self.focused;
if self.update_scroll(bounds, ctx.dpi(), reveal_caret) {
ctx.request_paint();
ctx.request_semantics();
}
}
fn paint(&self, ctx: &mut PaintCtx) {
self.enabled.observe(|source| {
ctx.observe(source);
});
let theme = self.paint_theme();
let palette = theme.palette;
let metrics = theme.metrics;
let mut text_style = self.resolved_text_style();
if !self.enabled.get() {
text_style.color = theme.palette.text_disabled;
}
let padding = self.resolved_padding();
let focus_progress = self.focus_value(ctx);
let background = field_background(&theme, self.read_only, focus_progress);
let border = field_border(&palette, self.hover_value(ctx), focus_progress);
let full_content_rect = inset_rect(ctx.bounds(), padding);
let content_rect = self.text_content_rect(ctx.bounds());
let display_text = self.visible_text();
let placeholder = self.input_text().is_empty();
if self.appearance == FieldAppearance::Framed {
draw_control_frame(
ctx,
ctx.bounds(),
metrics.corner_radius,
metrics,
background,
border,
(focus_progress > 0.0).then_some(
palette
.focus_ring
.with_alpha(palette.focus_ring.alpha * focus_progress),
),
);
}
if let Some(icon) = self.leading_icon {
let icon_color = if self.read_only || placeholder {
palette.text_muted
} else {
palette.text
};
let icon_side = 15.0;
let icon_rect = Rect::new(
full_content_rect.x() + 1.0,
full_content_rect.y() + (full_content_rect.height() - icon_side) * 0.5,
icon_side,
icon_side,
);
draw_icon_glyph(ctx, icon, icon_rect, icon_color);
}
ctx.push_clip_rect(content_rect);
if let Some(layout) = &self.display_layout {
let layout_rect =
self.single_line_layout_rect(ctx, content_rect, layout, layout.style().line_height);
let layout_x = if placeholder {
layout_rect.x() - layout.measurement().bounds.x()
} else {
self.text_x(content_rect)
};
let layout_origin = Point::new(layout_x, layout_rect.y());
if !placeholder {
let input = self.input_text();
let selection = self.rendered_selection_range(&input);
if !selection.is_empty() {
for rect in layout.selection_rects(selection) {
ctx.fill_rect(rect.translate(layout_origin.to_vector()), palette.selection);
}
}
}
if self.enabled.get() {
ctx.draw_persistent_text_layout(layout_origin, layout);
} else {
ctx.draw_persistent_text_layout_with_color(
layout_origin,
layout,
theme.palette.text_disabled,
);
}
} else {
let display_style = if placeholder {
theme.placeholder_text_style()
} else if self.read_only {
self.read_only_text_style(&theme)
} else {
text_style.clone()
};
paint_text(
ctx,
content_rect,
&display_text,
&display_style,
TextAlign::Start,
);
}
ctx.pop_clip();
if self.focused && !self.read_only {
let caret_width = self.caret_width(ctx.dpi());
let input_text = self.rendered_input_text();
let input_text_rect = self
.input_layout
.as_ref()
.map(|layout| {
self.single_line_layout_rect(ctx, content_rect, layout, text_style.line_height)
})
.unwrap_or_else(|| {
self.single_line_text_rect(
ctx,
content_rect,
&input_text,
&text_style,
text_style.line_height,
)
});
let caret_rect = self
.input_layout
.as_ref()
.map(|layout| {
layout
.caret_rect(self.display_caret_offset())
.translate(Vector::new(self.text_x(content_rect), input_text_rect.y()))
})
.unwrap_or(Rect::new(
input_text_rect.x()
+ self
.input_measurement
.map(|measurement| measurement.width)
.unwrap_or(0.0),
input_text_rect.y(),
caret_width,
input_text_rect.height().max(text_style.line_height),
));
let caret_rect = Rect::new(
caret_rect.x(),
caret_rect.y(),
caret_width,
caret_rect.height().max(text_style.line_height),
);
ctx.set_ime_composition_rect(caret_rect);
if self.caret.visible {
ctx.fill(
Path::rounded_rect(caret_rect, caret_width * 0.5),
palette.caret,
);
}
}
}
fn semantics(&self, ctx: &mut SemanticsCtx) {
self.enabled.observe(|source| {
ctx.observe(source);
});
let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::TextInput, ctx.bounds());
let display_text = self.input_text();
let display_selection = self.editor.display_selection();
let selection = selection_range(&display_selection, display_text.len());
node.name = Some(self.name.clone());
node.value = Some(SemanticsValue::Text(display_text));
node.state.focused = ctx.is_focused();
node.state.hovered = self.hovered;
node.editable_text = Some(EditableTextSemantics {
caret_offset: display_selection.focus.utf8_offset,
selection: SemanticsTextRange::new(selection.start, selection.end),
multiline: false,
password: self.password,
readonly: self.read_only,
scroll_x: self.editor.scroll_x(),
scroll_y: 0.0,
});
node.state.disabled = !self.enabled.get();
node.actions = if self.enabled.get() {
self.editor.semantic_actions(self.read_only)
} else {
Vec::new()
};
ctx.push(node);
}
fn accepts_focus(&self) -> bool {
self.enabled.get()
}
fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
self.focused = focused;
if !focused {
let result = self.editor.execute(EditorCommand::ClearComposition);
if result.layout_changed() {
ctx.request_measure();
}
}
if focused {
self.caret.reset(ctx, self.focused, self.read_only);
self.scroll_caret_into_view(ctx);
} else {
self.caret.stop(ctx);
}
let theme = self.resolved_theme();
set_focus_animation_target(&mut self.focus_animation, focused as u8 as f32, &theme, ctx);
if let Some(on_focus_change) = &mut self.on_focus_change {
on_focus_change(focused);
}
if let Some(on_focus_change) = &mut self.on_focus_change_with_ctx {
on_focus_change(ctx, focused);
}
ctx.request_paint();
ctx.request_semantics();
}
}
pub struct PasswordInput {
inner: TextInput,
}
impl PasswordInput {
pub fn new(name: impl Into<String>) -> Self {
Self {
inner: TextInput::new(name).password(),
}
}
pub fn theme(mut self, theme: DefaultTheme) -> Self {
self.inner = self.inner.theme(theme);
self
}
pub fn theme_when<F>(mut self, theme: F) -> Self
where
F: Fn() -> DefaultTheme + 'static,
{
self.inner = self.inner.theme_when(theme);
self
}
pub fn placeholder(mut self, placeholder: impl Into<String>) -> Self {
self.inner = self.inner.placeholder(placeholder);
self
}
pub fn value(mut self, value: impl Into<String>) -> Self {
self.inner = self.inner.value(value);
self
}
pub fn min_width(mut self, width: f32) -> Self {
self.inner = self.inner.min_width(width);
self
}
pub fn read_only(mut self, read_only: bool) -> Self {
self.inner = self.inner.read_only(read_only);
self
}
pub fn is_read_only(&self) -> bool {
self.inner.is_read_only()
}
pub fn enabled(mut self, enabled: bool) -> Self {
self.inner = self.inner.enabled(enabled);
self
}
pub fn enabled_when<F>(mut self, enabled: F) -> Self
where
F: Fn() -> bool + 'static,
{
self.inner = self.inner.enabled_when(enabled);
self
}
pub fn enabled_from<O>(mut self, enabled: O) -> Self
where
O: Observable<bool> + 'static,
{
self.inner = self.inner.enabled_from(enabled);
self
}
pub fn is_enabled(&self) -> bool {
self.inner.is_enabled()
}
pub fn interaction_preview(mut self, preview: InteractionPreview) -> Self {
self.inner = self.inner.interaction_preview(preview);
self
}
pub fn selectable(mut self, selection_scope: SelectionScope) -> Self {
self.inner = self.inner.selectable(selection_scope);
self
}
pub fn clipboard_behavior(mut self, behavior: SelectionClipboardBehavior) -> Self {
self.inner = self.inner.clipboard_behavior(behavior);
self
}
pub fn copy_to_clipboard(mut self, enabled: bool) -> Self {
self.inner = self.inner.copy_to_clipboard(enabled);
self
}
pub fn text_style(mut self, text_style: TextStyle) -> Self {
self.inner = self.inner.text_style(text_style);
self
}
pub fn appearance(mut self, appearance: FieldAppearance) -> Self {
self.inner = self.inner.appearance(appearance);
self
}
pub fn on_change<F>(mut self, on_change: F) -> Self
where
F: FnMut(String) + 'static,
{
self.inner = self.inner.on_change(on_change);
self
}
pub fn on_change_with_ctx<F>(mut self, on_change: F) -> Self
where
F: FnMut(&mut EventCtx, String) + 'static,
{
self.inner = self.inner.on_change_with_ctx(on_change);
self
}
pub fn on_submit<F>(mut self, on_submit: F) -> Self
where
F: FnMut(&str) + 'static,
{
self.inner = self.inner.on_submit(on_submit);
self
}
pub fn on_submit_with_ctx<F>(mut self, on_submit: F) -> Self
where
F: FnMut(&mut EventCtx, &str) + 'static,
{
self.inner = self.inner.on_submit_with_ctx(on_submit);
self
}
pub fn on_focus_change<F>(mut self, on_focus_change: F) -> Self
where
F: FnMut(bool) + 'static,
{
self.inner = self.inner.on_focus_change(on_focus_change);
self
}
pub fn on_focus_change_with_ctx<F>(mut self, on_focus_change: F) -> Self
where
F: FnMut(&mut EventCtx, bool) + 'static,
{
self.inner = self.inner.on_focus_change_with_ctx(on_focus_change);
self
}
pub fn current_value(&self) -> &str {
self.inner.current_value()
}
pub fn set_value(&mut self, value: impl Into<String>) {
self.inner.set_value(value);
}
pub fn selected_text(&self) -> &str {
self.inner.selected_text()
}
pub fn select_all(&mut self, ctx: &mut EventCtx) {
self.inner.select_all(ctx);
}
pub fn copy(&mut self, ctx: &mut EventCtx) {
self.inner.copy(ctx);
}
pub fn cut(&mut self, ctx: &mut EventCtx) {
self.inner.cut(ctx);
}
pub fn paste(&mut self, ctx: &mut EventCtx) {
self.inner.paste(ctx);
}
}
impl Widget for PasswordInput {
fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
self.inner.event(ctx, event);
}
fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
self.inner.measure(ctx, constraints)
}
fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
self.inner.arrange(ctx, bounds);
}
fn paint(&self, ctx: &mut PaintCtx) {
self.inner.paint(ctx);
}
fn semantics(&self, ctx: &mut SemanticsCtx) {
self.inner.semantics(ctx);
}
fn accepts_focus(&self) -> bool {
self.inner.accepts_focus()
}
fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
self.inner.focus_changed(ctx, focused);
}
}
pub struct DateTimeInput {
inner: TextInput,
}
impl DateTimeInput {
pub fn new(name: impl Into<String>) -> Self {
Self {
inner: TextInput::new(name).placeholder("YYYY-MM-DD HH:MM"),
}
}
pub fn theme(mut self, theme: DefaultTheme) -> Self {
self.inner = self.inner.theme(theme);
self
}
pub fn theme_when<F>(mut self, theme: F) -> Self
where
F: Fn() -> DefaultTheme + 'static,
{
self.inner = self.inner.theme_when(theme);
self
}
pub fn placeholder(mut self, placeholder: impl Into<String>) -> Self {
self.inner = self.inner.placeholder(placeholder);
self
}
pub fn value(mut self, value: impl Into<String>) -> Self {
self.inner = self.inner.value(value);
self
}
pub fn min_width(mut self, width: f32) -> Self {
self.inner = self.inner.min_width(width);
self
}
pub fn read_only(mut self, read_only: bool) -> Self {
self.inner = self.inner.read_only(read_only);
self
}
pub fn is_read_only(&self) -> bool {
self.inner.is_read_only()
}
pub fn enabled(mut self, enabled: bool) -> Self {
self.inner = self.inner.enabled(enabled);
self
}
pub fn enabled_when<F>(mut self, enabled: F) -> Self
where
F: Fn() -> bool + 'static,
{
self.inner = self.inner.enabled_when(enabled);
self
}
pub fn enabled_from<O>(mut self, enabled: O) -> Self
where
O: Observable<bool> + 'static,
{
self.inner = self.inner.enabled_from(enabled);
self
}
pub fn is_enabled(&self) -> bool {
self.inner.is_enabled()
}
pub fn interaction_preview(mut self, preview: InteractionPreview) -> Self {
self.inner = self.inner.interaction_preview(preview);
self
}
pub fn selectable(mut self, selection_scope: SelectionScope) -> Self {
self.inner = self.inner.selectable(selection_scope);
self
}
pub fn clipboard_behavior(mut self, behavior: SelectionClipboardBehavior) -> Self {
self.inner = self.inner.clipboard_behavior(behavior);
self
}
pub fn copy_to_clipboard(mut self, enabled: bool) -> Self {
self.inner = self.inner.copy_to_clipboard(enabled);
self
}
pub fn text_style(mut self, text_style: TextStyle) -> Self {
self.inner = self.inner.text_style(text_style);
self
}
pub fn appearance(mut self, appearance: FieldAppearance) -> Self {
self.inner = self.inner.appearance(appearance);
self
}
pub fn on_change<F>(mut self, on_change: F) -> Self
where
F: FnMut(String) + 'static,
{
self.inner = self.inner.on_change(on_change);
self
}
pub fn on_change_with_ctx<F>(mut self, on_change: F) -> Self
where
F: FnMut(&mut EventCtx, String) + 'static,
{
self.inner = self.inner.on_change_with_ctx(on_change);
self
}
pub fn on_submit<F>(mut self, on_submit: F) -> Self
where
F: FnMut(&str) + 'static,
{
self.inner = self.inner.on_submit(on_submit);
self
}
pub fn on_submit_with_ctx<F>(mut self, on_submit: F) -> Self
where
F: FnMut(&mut EventCtx, &str) + 'static,
{
self.inner = self.inner.on_submit_with_ctx(on_submit);
self
}
pub fn on_focus_change<F>(mut self, on_focus_change: F) -> Self
where
F: FnMut(bool) + 'static,
{
self.inner = self.inner.on_focus_change(on_focus_change);
self
}
pub fn on_focus_change_with_ctx<F>(mut self, on_focus_change: F) -> Self
where
F: FnMut(&mut EventCtx, bool) + 'static,
{
self.inner = self.inner.on_focus_change_with_ctx(on_focus_change);
self
}
pub fn current_value(&self) -> &str {
self.inner.current_value()
}
pub fn set_value(&mut self, value: impl Into<String>) {
self.inner.set_value(value);
}
pub fn selected_text(&self) -> &str {
self.inner.selected_text()
}
pub fn select_all(&mut self, ctx: &mut EventCtx) {
self.inner.select_all(ctx);
}
pub fn copy(&mut self, ctx: &mut EventCtx) {
self.inner.copy(ctx);
}
pub fn cut(&mut self, ctx: &mut EventCtx) {
self.inner.cut(ctx);
}
pub fn paste(&mut self, ctx: &mut EventCtx) {
self.inner.paste(ctx);
}
}
impl Widget for DateTimeInput {
fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
self.inner.event(ctx, event);
}
fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
self.inner.measure(ctx, constraints)
}
fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
self.inner.arrange(ctx, bounds);
}
fn paint(&self, ctx: &mut PaintCtx) {
self.inner.paint(ctx);
}
fn semantics(&self, ctx: &mut SemanticsCtx) {
self.inner.semantics(ctx);
}
fn accepts_focus(&self) -> bool {
self.inner.accepts_focus()
}
fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
self.inner.focus_changed(ctx, focused);
}
}
fn measure_text_size(ctx: &mut MeasureCtx, text: &str, style: &TextStyle) -> Size {
ctx.layout()
.measure_text_size(text.to_owned(), style.clone())
.unwrap_or(Size::new(0.0, style.line_height))
}
fn numeric_text_style(mut style: TextStyle) -> TextStyle {
style.features.enable(FontFeature::TABULAR_FIGURES);
style
}
fn center_square(bounds: Rect, side: f32) -> Rect {
let side = side.min(bounds.width()).min(bounds.height()).max(0.0);
Rect::new(
bounds.x() + ((bounds.width() - side) * 0.5),
bounds.y() + ((bounds.height() - side) * 0.5),
side,
side,
)
}
fn switch_track_rect(bounds: Rect, padding: Insets, metrics: ControlMetrics) -> Rect {
Rect::new(
bounds.x() + padding.left,
bounds.y() + ((bounds.height() - metrics.switch_track_height) * 0.5),
metrics.switch_track_width,
metrics.switch_track_height,
)
}
fn switch_label_rect(bounds: Rect, padding: Insets, metrics: ControlMetrics, gap: f32) -> Rect {
let x = bounds.x() + padding.left + metrics.switch_track_width + gap;
Rect::new(
x,
bounds.y(),
(bounds.width() - (x - bounds.x()) - padding.right).max(0.0),
bounds.height(),
)
}
fn select_option_rect(theme: &DefaultTheme, menu: Rect, index: usize) -> Rect {
let padding = theme.metrics.menu_padding;
let row_height = theme.metrics.menu_row_height;
Rect::new(
menu.x() + padding.left,
menu.y() + padding.top + index as f32 * row_height,
(menu.width() - padding.left - padding.right).max(0.0),
row_height,
)
}
fn horizontal_text_inset_rect(bounds: Rect, padding: Insets) -> Rect {
Rect::new(
bounds.x() + padding.left,
bounds.y(),
(bounds.width() - padding.left - padding.right).max(0.0),
bounds.height(),
)
}
fn select_chevron_icon_rect(header: Rect) -> Rect {
let x = header.max_x() - SELECT_CHEVRON_SLOT_WIDTH
+ ((SELECT_CHEVRON_SLOT_WIDTH - SELECT_CHEVRON_ICON_SIZE).max(0.0) * 0.5);
Rect::new(x, header.y(), SELECT_CHEVRON_ICON_SIZE, header.height())
}
fn number_input_stepper_rect(bounds: Rect, metrics: ControlMetrics) -> Rect {
Rect::new(
bounds.max_x() - metrics.number_input_stepper_width,
bounds.y(),
metrics.number_input_stepper_width,
bounds.height(),
)
}
fn number_input_stepper_part(
bounds: Rect,
metrics: ControlMetrics,
position: Point,
) -> Option<NumberInputStepperPart> {
let stepper = number_input_stepper_rect(bounds, metrics);
if !stepper.contains(position) {
return None;
}
if position.y < stepper.y() + (stepper.height() * 0.5) {
Some(NumberInputStepperPart::Increment)
} else {
Some(NumberInputStepperPart::Decrement)
}
}
fn number_input_text_rect(bounds: Rect, metrics: ControlMetrics) -> Rect {
let padding = metrics.text_input_padding;
Rect::new(
bounds.x() + padding.left,
bounds.y(),
(bounds.width() - padding.left - padding.right - metrics.number_input_stepper_width)
.max(0.0),
bounds.height(),
)
}
fn clamp_and_snap_value(value: f64, min: f64, max: f64, step: f64) -> f64 {
let clamped = value.clamp(min, max);
if !step.is_finite() || step <= f64::EPSILON {
return clamped;
}
let snapped = (clamped / step).round() * step;
snapped.clamp(min, max)
}
fn format_number(value: f64, precision: usize) -> String {
let mut text = format!("{value:.precision$}");
if precision > 0 && text.contains('.') {
while text.ends_with('0') {
text.pop();
}
if text.ends_with('.') {
text.pop();
}
}
if text == "-0" { "0".to_string() } else { text }
}
fn is_numeric_input_char(ch: char) -> bool {
ch.is_ascii_digit() || matches!(ch, '.' | '-' | '+')
}
pub fn draw_glyph(ctx: &mut PaintCtx, glyph: IconGlyph, bounds: Rect, color: Color) {
draw_icon_glyph(ctx, glyph, bounds, color);
}
pub(crate) fn draw_icon_glyph(ctx: &mut PaintCtx, glyph: IconGlyph, bounds: Rect, color: Color) {
glyph.lucide_icon().paint(ctx, bounds, color);
}
fn line_path(start: Point, end: Point) -> Path {
let mut builder = PathBuilder::new();
builder.move_to(start).line_to(end);
builder.build()
}
pub(crate) fn apply_hdr_policy_cap(color: Color, peak_lift: f32) -> Color {
let cap = if peak_lift.is_finite() {
peak_lift.max(0.0)
} else {
return color;
};
Color {
red: color.red.clamp(0.0, cap),
green: color.green.clamp(0.0, cap),
blue: color.blue.clamp(0.0, cap),
..color
}
}
pub(crate) fn cap_resolved_hdr_style(style: ResolvedHdrStyle) -> ResolvedHdrStyle {
ResolvedHdrStyle {
color: apply_hdr_policy_cap(style.color, style.peak_lift),
effect: style.effect.map(|effect| ResolvedEffectStyle {
color: apply_hdr_policy_cap(effect.color, style.peak_lift),
..effect
}),
..style
}
}
fn draw_choice_control_frame(
ctx: &mut PaintCtx,
bounds: Rect,
radius: f32,
metrics: ControlMetrics,
appearance: ChoiceAppearance,
visuals: ChoiceFrameVisuals,
focus_ring: Option<Color>,
) {
if appearance == ChoiceAppearance::Framed {
draw_control_frame(
ctx,
bounds,
radius,
metrics,
visuals.background,
visuals.border,
focus_ring,
);
return;
}
if visuals.background.alpha > f32::EPSILON {
ctx.fill(
Path::rounded_rect(snap_to_pixels(ctx, bounds), radius),
visuals.background,
);
}
draw_control_focus_ring(ctx, bounds, radius, metrics, focus_ring);
}
fn draw_control_focus_ring(
ctx: &mut PaintCtx,
bounds: Rect,
radius: f32,
metrics: ControlMetrics,
focus_ring: Option<Color>,
) {
if let Some(focus_ring) = focus_ring {
draw_focus_ring(ctx, bounds, radius, metrics, focus_ring);
}
}
fn checkmark_path(rect: Rect) -> Path {
let mut builder = PathBuilder::new();
builder
.move_to(Point::new(
rect.x() + (rect.width() * 0.18),
rect.y() + (rect.height() * 0.54),
))
.line_to(Point::new(
rect.x() + (rect.width() * 0.42),
rect.y() + (rect.height() * 0.76),
))
.line_to(Point::new(
rect.x() + (rect.width() * 0.82),
rect.y() + (rect.height() * 0.28),
));
builder.build()
}
fn choice_control_height(
content_height: f32,
padding: Insets,
baseline_height: f32,
has_explicit_padding: bool,
) -> f32 {
let padding_height = if has_explicit_padding {
padding.top + padding.bottom
} else {
0.0
};
(content_height + padding_height).max(baseline_height)
}
fn default_form_control_height(theme: &DefaultTheme) -> f32 {
let style = theme.body_text_style();
let padding = theme.metrics.text_input_padding;
(style.line_height + padding.top + padding.bottom).max(theme.metrics.min_height)
}
fn choice_control_layout_padding(padding: Insets, has_explicit_padding: bool) -> Insets {
if has_explicit_padding {
padding
} else {
Insets {
top: 0.0,
bottom: 0.0,
..padding
}
}
}
fn indicator_rect(bounds: Rect, padding: Insets, indicator_size: f32) -> Rect {
let x = bounds.x() + padding.left;
let content = inset_rect(bounds, padding);
let y = content.y() + ((content.height() - indicator_size) * 0.5);
Rect::new(x, y, indicator_size, indicator_size)
}
fn checkbox_label_rect(bounds: Rect, padding: Insets, indicator_size: f32, gap: f32) -> Rect {
let x = bounds.x() + padding.left + indicator_size + gap;
let width = (bounds.width() - padding.left - padding.right - indicator_size - gap).max(0.0);
let content = inset_rect(bounds, padding);
Rect::new(x, content.y(), width, content.height())
}
fn rect_is_finite(rect: Rect) -> bool {
rect.x().is_finite()
&& rect.y().is_finite()
&& rect.width().is_finite()
&& rect.height().is_finite()
}
fn request_selection_change(ctx: &mut EventCtx, change: SelectionChange) {
for owner in change.affected_owners() {
let widget_id = WidgetId::new(owner.get());
ctx.request(InvalidationRequest::new(
InvalidationTarget::Widget(widget_id),
InvalidationKind::Paint,
));
ctx.request(InvalidationRequest::new(
InvalidationTarget::Widget(widget_id),
InvalidationKind::Semantics,
));
}
}
#[cfg(test)]
mod tests;