use std::{cell::RefCell, collections::HashMap, sync::Arc};
use super::{
names,
part_style::{FontFamily, Length, PartStyle},
recipe::{Case, Interaction, Name, Recipe, ResolvedPart, ResolvedRecipe},
shared::fading,
theme::{Themed, current_theme},
};
use crate::{
app::{
events::{DragEvent, KeyboardEvent, MouseButtonMask},
theme::{OpacityLevel, PaletteColor, RadiusSize, Theme},
},
components::{Row, Stack},
core::{ElementRef, Signal},
layout::stack_alignment::StackAlignment,
node::{CursorIcon, Element, border::Border, dimension::Dimension},
};
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum AngleSliderPart {
Root,
Value,
Handle,
}
names!(AngleSliderPart {
Root => "root",
Value => "value",
Handle => "handle",
});
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum AngleSliderState {
Disabled,
}
names!(AngleSliderState {
Disabled => "disabled",
});
pub type AngleSliderRenderer = Arc<dyn Fn(AngleSliderView) -> Element + Send + Sync>;
type Told = Arc<dyn Fn(f64) + Send + Sync>;
pub type AngleText = Arc<dyn Fn(f64) -> String + Send + Sync>;
pub struct AngleSlider {
value: f64,
bound: Option<Signal<f64>>,
on_change: Vec<Told>,
on_change_end: Vec<Told>,
min: f64,
max: f64,
step: f64,
page_step: Option<f64>,
wrap: bool,
label: Option<Arc<str>>,
value_text: Option<AngleText>,
locale: Option<crate::core::InputWords>,
disabled: bool,
states: Vec<Name>,
rules: Recipe,
forced: Option<Interaction>,
id: Option<Arc<str>>,
key: Option<Arc<str>>,
}
impl AngleSlider {
fn of(value: f64, bound: Option<Signal<f64>>) -> Self {
Self {
value,
bound,
on_change: Vec::new(),
on_change_end: Vec::new(),
min: 0.0,
max: 360.0,
step: 1.0,
page_step: None,
wrap: true,
label: None,
value_text: None,
locale: None,
disabled: false,
states: Vec::new(),
rules: Recipe::new(),
forced: None,
id: None,
key: None,
}
}
pub fn new(angle: Signal<f64>) -> Self {
Self::of(angle.get(), Some(angle))
}
pub fn controlled(angle: f64, on_change: impl Fn(f64) + Send + Sync + 'static) -> Self {
Self::of(angle, None).on_change(on_change)
}
pub fn min(mut self, min: impl Into<f64>) -> Self {
self.min = min.into();
self
}
pub fn max(mut self, max: impl Into<f64>) -> Self {
self.max = max.into();
self
}
pub fn step(mut self, step: impl Into<f64>) -> Self {
let step = step.into();
if step.is_finite() && step > 0.0 {
self.step = step;
}
self
}
pub fn page_step(mut self, step: impl Into<f64>) -> Self {
self.page_step = Some(step.into());
self
}
pub fn wrap(mut self, wrap: bool) -> Self {
self.wrap = wrap;
self
}
pub fn on_change(mut self, handler: impl Fn(f64) + Send + Sync + 'static) -> Self {
self.on_change.push(Arc::new(handler));
self
}
pub fn on_change_end(mut self, handler: impl Fn(f64) + Send + Sync + 'static) -> Self {
self.on_change_end.push(Arc::new(handler));
self
}
pub fn label(mut self, label: &str) -> Self {
self.label = Some(Arc::from(label));
self
}
pub fn value_text(mut self, text: impl Fn(f64) -> String + Send + Sync + 'static) -> Self {
self.value_text = Some(Arc::new(text));
self
}
pub fn locale(mut self, locale: &crate::core::Locale) -> Self {
self.locale = Some(locale.input.clone());
self
}
pub fn disabled(mut self, disabled: bool) -> Self {
self.disabled = disabled;
self
}
pub fn state(mut self, state: impl Into<Name>, on: bool) -> Self {
let state = state.into();
self.states.retain(|held| *held != state);
if on {
self.states.push(state);
}
self
}
pub fn style(mut self, part: impl Into<Name>, style: impl FnOnce(PartStyle) -> PartStyle) -> Self {
self.rules = self.rules.base(part, style);
self
}
pub fn rules(mut self, rules: &Recipe) -> Self {
self.rules = self.rules.extend(rules);
self
}
pub fn force(mut self, interaction: Option<Interaction>) -> Self {
self.forced = interaction;
self
}
pub fn id(mut self, id: impl Into<Arc<str>>) -> Self {
self.id = Some(id.into());
self
}
pub fn key(mut self, key: impl Into<Arc<str>>) -> Self {
self.key = Some(key.into());
self
}
pub fn build(self, theme: &Theme) -> Element {
let range = Range::new(self.min, self.max, self.step, self.page_step, self.wrap);
let angle = range.held(self.value);
let case = Case {
variant: None,
size: None,
density: None,
breakpoint: super::current_breakpoint(),
states: self.states.clone(),
}
.state(AngleSliderState::Disabled, self.disabled);
let view = AngleSliderView {
angle,
min: range.min,
max: range.max,
step: range.step,
wraps: range.wraps,
label: self.label.unwrap_or_else(|| match self.locale {
Some(words) => words.angle,
None => super::current_locale().input.angle.clone(),
}),
disabled: self.disabled,
recipe: theme
.resolve::<AngleSlider>(&case, Some(&self.rules))
.owned_by(self.id.as_ref()),
value_text: self.value_text.unwrap_or_else(|| {
let decimals = decimals_of(range.step);
Arc::new(move |angle| format!("{}°", number(angle, decimals)))
}),
model: Model {
range,
bound: self.bound,
given: angle,
on_change: self.on_change,
on_change_end: self.on_change_end,
root: ElementRef::new(),
},
forced: self.forced,
id: self.id,
key: self.key,
};
match theme.renderer::<AngleSlider>() {
Some(renderer) => renderer(view),
None => view.render(),
}
}
}
impl From<AngleSlider> for Element {
fn from(slider: AngleSlider) -> Self {
slider.build(¤t_theme())
}
}
fn decimals_of(step: f64) -> usize {
(0..3)
.find(|decimals| {
let scaled = step * 10f64.powi(*decimals as i32);
(scaled - scaled.round()).abs() < 1e-9
})
.unwrap_or(3)
}
fn number(angle: f64, decimals: usize) -> String {
let written = format!("{angle:.decimals$}");
let written = if written.contains('.') {
written.trim_end_matches('0').trim_end_matches('.').to_owned()
} else {
written
};
if written == "-0" { "0".to_owned() } else { written }
}
fn bearing(dx: f32, dy: f32) -> f64 {
let degrees = f64::from(dx).atan2(f64::from(-dy)).to_degrees();
degrees.rem_euclid(360.0)
}
fn turn(from: f64, to: f64) -> f64 {
let way = (to - from).rem_euclid(360.0);
if way > 180.0 { way - 360.0 } else { way }
}
#[derive(Clone, Copy, Debug)]
struct Range {
min: f64,
max: f64,
step: f64,
page: f64,
wraps: bool,
}
impl Range {
fn new(min: f64, max: f64, step: f64, page: Option<f64>, wrap: bool) -> Self {
let (min, max) = if min.is_finite() && max.is_finite() {
(min, max.max(min))
} else {
(0.0, 360.0)
};
let page = page.filter(|page| page.is_finite() && *page > 0.0).unwrap_or(15.0);
let page = ((page / step).round() * step).max(step);
Self {
min,
max,
step,
page,
wraps: wrap && ((max - min) - 360.0).abs() < 1e-9,
}
}
fn held(&self, angle: f64) -> f64 {
if !angle.is_finite() {
return self.min;
}
let snapped = self.min + ((angle - self.min) / self.step).round() * self.step;
let held = if self.wraps {
self.min + (snapped - self.min).rem_euclid(360.0)
} else {
snapped.clamp(self.min, self.max)
};
let held = if self.wraps && (held - self.max).abs() < 1e-9 {
self.min
} else {
held
};
let rounded = (held * 1e9).round() / 1e9;
if rounded == 0.0 { 0.0 } else { rounded }
}
fn greatest(&self) -> f64 {
if self.wraps {
self.held(self.max - self.step)
} else {
self.held(self.max - ((self.max - self.min) % self.step))
}
}
fn key(&self, angle: f64, key: &str) -> Option<f64> {
let next = match key {
"ArrowRight" | "ArrowUp" => angle + self.step,
"ArrowLeft" | "ArrowDown" => angle - self.step,
"PageUp" => angle + self.page,
"PageDown" => angle - self.page,
"Home" => return Some(self.min),
"End" => return Some(self.greatest()),
_ => return None,
};
Some(self.held(next))
}
fn pressed(&self, angle: f64, bearing: f64) -> f64 {
let at = angle + turn(angle.rem_euclid(360.0), bearing);
if self.wraps || (self.min..=self.max).contains(&at) {
return self.held(at);
}
for turns in [-1.0, 1.0, -2.0, 2.0] {
let other = at + 360.0 * turns;
if (self.min..=self.max).contains(&other) {
return self.held(other);
}
}
let from_least = turn(bearing, self.min.rem_euclid(360.0)).abs();
let from_greatest = turn(bearing, self.max.rem_euclid(360.0)).abs();
self.held(if from_least <= from_greatest {
self.min
} else {
self.max
})
}
fn dragged(&self, raw: f64, way: f64) -> f64 {
let next = raw + way;
if self.wraps {
self.min + (next - self.min).rem_euclid(360.0)
} else {
next.clamp(self.min - 180.0, self.max + 180.0)
}
}
}
#[derive(Clone, Copy, Debug)]
struct Drag {
start: f64,
raw: f64,
bearing: f64,
told: f64,
}
#[derive(Clone)]
struct Model {
range: Range,
bound: Option<Signal<f64>>,
given: f64,
on_change: Vec<Told>,
on_change_end: Vec<Told>,
root: ElementRef,
}
thread_local! {
static DRAGS: RefCell<HashMap<Option<u64>, Drag>> = RefCell::new(HashMap::new());
}
impl Model {
fn current(&self) -> f64 {
match &self.bound {
Some(signal) => self.range.held(signal.get_untracked()),
None => self.given,
}
}
fn set(&self, angle: f64, was: f64) {
if angle == was {
return;
}
if let Some(signal) = &self.bound {
signal.set(angle);
}
for handler in &self.on_change {
handler(angle);
}
}
fn end(&self, start: f64, now: f64) {
if now != start {
for handler in &self.on_change_end {
handler(now);
}
}
}
fn bearing(&self, x: f32, y: f32) -> Option<f64> {
let bounds = self.root.bounds();
let (dx, dy) = (
x - (bounds.x + bounds.width / 2.0),
y - (bounds.y + bounds.height / 2.0),
);
(dx.hypot(dy) >= 2.0).then(|| bearing(dx, dy))
}
fn press(&self, x: f32, y: f32, finger: Option<u64>) {
let start = self.current();
let Some(bearing) = self.bearing(x, y) else {
let drag = Drag {
start,
raw: start,
bearing: start.rem_euclid(360.0),
told: start,
};
DRAGS.with(|drags| drags.borrow_mut().insert(finger, drag));
return;
};
let angle = self.range.pressed(start, bearing);
let raw = angle + turn(angle.rem_euclid(360.0), bearing);
let drag = Drag {
start,
raw: self.range.dragged(raw, 0.0),
bearing,
told: angle,
};
DRAGS.with(|drags| drags.borrow_mut().insert(finger, drag));
self.set(angle, start);
}
fn moved(&self, x: f32, y: f32, finger: Option<u64>) {
let Some(bearing) = self.bearing(x, y) else {
return;
};
let moved = DRAGS.with(|drags| {
let mut drags = drags.borrow_mut();
let drag = drags.get_mut(&finger)?;
drag.raw = self.range.dragged(drag.raw, turn(drag.bearing, bearing));
drag.bearing = bearing;
let (angle, was) = (self.range.held(drag.raw), drag.told);
drag.told = angle;
Some((angle, was))
});
if let Some((angle, was)) = moved {
self.set(angle, was);
}
}
fn released(&self, finger: Option<u64>) {
if let Some(drag) = DRAGS.with(|drags| drags.borrow_mut().remove(&finger)) {
self.end(drag.start, drag.told);
}
}
}
pub struct AngleSliderView {
pub angle: f64,
pub min: f64,
pub max: f64,
pub step: f64,
pub wraps: bool,
pub label: Arc<str>,
pub disabled: bool,
pub recipe: ResolvedRecipe,
value_text: AngleText,
model: Model,
forced: Option<Interaction>,
id: Option<Arc<str>>,
key: Option<Arc<str>>,
}
impl AngleSliderView {
pub fn part(&self, part: impl Into<Name>) -> ResolvedPart {
self.recipe.part(part).forced(self.forced)
}
pub fn theme(&self) -> &Theme {
self.recipe.theme()
}
pub fn text(&self) -> String {
(self.value_text)(self.angle)
}
fn px(&self, length: Option<Length>, or: f32) -> f32 {
match length.and_then(|length| length.resolve(self.theme())) {
Some(Dimension::Px(px)) => px,
_ => or,
}
}
pub fn reach(&self) -> f32 {
let root = self.part(AngleSliderPart::Root).rest();
let side = self.px(root.width, 64.0);
let ring = root
.border
.as_ref()
.map_or(0.0, |border| border.width.resolve(&self.theme().border_sizes()));
let handle = self.px(self.part(AngleSliderPart::Handle).rest().width, 9.0);
side / 2.0 - ring - handle / 2.0
}
pub fn root(&self) -> Stack {
let text = self.text();
let mut root = Stack::new()
.stack_align(StackAlignment::Center)
.overflow_visible()
.part(&self.part(AngleSliderPart::Root))
.ref_element(self.model.root.clone())
.describe("a11y_role", "slider")
.describe("a11y_name", self.label.clone())
.describe("a11y_valuemin", number(self.min, 9))
.describe("a11y_valuemax", number(self.max, 9))
.describe("a11y_valuenow", number(self.angle, 9))
.describe("a11y_valuetext", text);
if self.disabled {
root = root.describe("a11y_disabled", "true");
} else {
let (press, drag, release, keys) = (
self.model.clone(),
self.model.clone(),
self.model.clone(),
self.model.clone(),
);
root = root
.tab_index(0)
.focuses(&self.model.root)
.start_drag_buttons(MouseButtonMask::LEFT)
.finger_drags(true)
.on_drag_start(move |event: DragEvent| press.press(event.x, event.y, None))
.on_drag_move(move |event: DragEvent| drag.moved(event.x, event.y, None))
.on_drag_end(move |_: DragEvent| release.released(None))
.on_key_down(move |event: KeyboardEvent| {
if !event.focus_within || event.ctrl || event.alt || event.meta || event.composing {
return;
}
let was = keys.current();
let Some(next) = keys.range.key(was, &event.key) else {
return;
};
event.prevent_default();
keys.set(next, was);
keys.end(was, next);
});
}
if let Some(id) = &self.id {
root = root.id(id.clone());
}
if let Some(key) = &self.key {
root = root.key(key.clone());
}
root
}
pub fn value(&self) -> Element {
let part = self.part(AngleSliderPart::Value);
part.text(&self.text()).pointer_events_none().into()
}
pub fn handle(&self) -> Element {
let radians = self.angle.to_radians() as f32;
let reach = self.reach();
Row::new()
.part(&self.part(AngleSliderPart::Handle))
.offset(reach * radians.sin(), -reach * radians.cos())
.pointer_events_none()
.into()
}
pub fn render(self) -> Element {
self.root().child(self.value()).child(self.handle()).into()
}
}
impl crate::ui::Styled for AngleSlider {
type Component = Self;
fn rules(self, rules: &crate::ui::Recipe) -> Self {
Self::rules(self, rules)
}
fn state(self, state: impl Into<crate::ui::Name>, on: bool) -> Self {
Self::state(self, state, on)
}
}
impl Themed for AngleSlider {
const NAME: &'static str = "angle_slider";
type Renderer = AngleSliderRenderer;
fn parts() -> crate::ui::Declared {
AngleSliderPart::declared()
}
fn states() -> crate::ui::Declared {
AngleSliderState::declared()
}
fn recipe() -> Recipe {
use AngleSliderPart::{Handle, Root, Value};
use PaletteColor::{Background, Foreground, Input, Primary};
Recipe::new()
.base(Root, |s| {
fading(
s.square(64.0)
.radius(RadiusSize::Full)
.background(Background)
.border(Border::inside(1.5, Input))
.cursor(CursorIcon::Pointer),
)
})
.base(Value, |s| {
s.font_family(FontFamily::Mono).font_size(13.0).foreground(Foreground)
})
.base(Handle, |s| s.square(9.0).radius(RadiusSize::Full).background(Primary))
.focus_visible(Root, |s| s.focus_ring())
.state(AngleSliderState::Disabled, Root, |s| {
s.opacity(OpacityLevel::Disabled).cursor(CursorIcon::Default)
})
}
}
impl super::FieldControl for AngleSlider {
fn in_field(mut self, field: &super::InField) -> Element {
if self.label.is_none() && !field.label.is_empty() {
self.label = Some(field.label.clone());
}
self.disabled |= field.disabled;
self.into()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_whole_turn_goes_round_and_a_part_of_one_stops_at_its_ends() {
let turn = Range::new(0.0, 360.0, 1.0, None, true);
assert!(turn.wraps);
assert_eq!(turn.held(360.0), 0.0);
assert_eq!(turn.held(-1.0), 359.0);
assert_eq!(turn.key(359.0, "ArrowRight"), Some(0.0));
assert_eq!(turn.key(0.0, "ArrowLeft"), Some(359.0));
assert_eq!(turn.key(350.0, "PageUp"), Some(5.0));
assert_eq!(turn.key(10.0, "End"), Some(359.0));
let held = Range::new(0.0, 360.0, 1.0, None, false);
assert_eq!(held.key(360.0, "ArrowRight"), Some(360.0));
assert_eq!(held.key(10.0, "End"), Some(360.0));
let half = Range::new(-90.0, 90.0, 15.0, None, true);
assert!(!half.wraps, "less than a turn does not go round");
assert_eq!(half.key(90.0, "ArrowRight"), Some(90.0));
assert_eq!(half.held(52.0), 45.0);
}
#[test]
fn a_press_goes_to_the_angle_under_it_and_a_drag_goes_on_round() {
let turn = Range::new(0.0, 360.0, 1.0, None, true);
assert_eq!(turn.pressed(10.0, 90.0), 90.0);
assert_eq!(turn.pressed(10.0, 300.4), 300.0);
assert_eq!(turn.dragged(350.0, 20.0), 10.0);
let held = Range::new(0.0, 360.0, 1.0, None, false);
assert_eq!(held.held(held.dragged(350.0, 20.0)), 360.0, "held at its end");
assert_eq!(held.dragged(350.0, 400.0), 540.0, "no more than half a turn past it");
let two = Range::new(0.0, 720.0, 1.0, None, true);
assert_eq!(two.pressed(400.0, 90.0), 450.0, "the turn nearer to the angle");
let half = Range::new(0.0, 180.0, 1.0, None, true);
assert_eq!(half.pressed(90.0, 200.0), 180.0, "past an end, the nearer end");
assert_eq!(half.pressed(90.0, 350.0), 0.0);
let signed = Range::new(-180.0, 180.0, 1.0, None, true);
assert_eq!(signed.pressed(0.0, 270.0), -90.0);
}
#[test]
fn bearings_are_a_compass_s() {
assert_eq!(bearing(0.0, -10.0), 0.0);
assert_eq!(bearing(10.0, 0.0), 90.0);
assert_eq!(bearing(0.0, 10.0), 180.0);
assert_eq!(bearing(-10.0, 0.0), 270.0);
assert_eq!(number(22.5, decimals_of(0.5)), "22.5");
assert_eq!(number(45.0, decimals_of(1.0)), "45");
}
}