use std::{cell::Cell, rc::Rc};
use gpui::{
div, prelude::*, px, relative, App, Bounds, ElementId, MouseButton, Pixels, Point,
StyleRefinement, Window,
};
use super::direction::DirectionalStyled;
use super::{
interaction::{measure_bounds, track_drag},
overlay::child_id,
};
use crate::sx::SxStyled;
use crate::{
hooks::{use_keyed_state, EventHandler, State},
styles,
styles::ApplyStyleOverrides,
};
styles! {
SLIDER = {
root: { position: relative, display: flex, align: center, width: full, height: 4 },
interactive: { cursor: pointer },
inert: { opacity: 0.5 },
track: {
position: relative,
width: full,
height: 1.5,
radius: full,
overflow: hidden,
background: muted,
},
range: { position: absolute, top: 0, height: full, background: primary },
thumb: {
position: absolute,
margin_start: -2,
size: 4,
radius: full,
border: 1,
border_color: primary,
background: background,
shadow: sm,
},
thumb_interactive: { cursor: pointer, focus: { shadow: ring } },
}
}
#[derive(IntoElement)]
pub struct Slider {
id: ElementId,
values: Vec<f32>,
min: f32,
max: f32,
step: f32,
disabled: bool,
on_change: Option<EventHandler<Vec<f32>>>,
sx: crate::sx::Sx,
style_overrides: StyleRefinement,
}
crate::implement_style_overrides!(Slider);
impl Slider {
pub fn new(id: impl Into<ElementId>) -> Self {
Self {
id: id.into(),
values: vec![0.],
min: 0.,
max: 100.,
step: 1.,
disabled: false,
on_change: None,
sx: crate::sx::Sx::new(),
style_overrides: StyleRefinement::default(),
}
}
#[must_use]
pub fn value(mut self, value: f32) -> Self {
self.values = vec![value];
self
}
#[must_use]
pub fn range(mut self, start: f32, end: f32) -> Self {
self.values = vec![start.min(end), start.max(end)];
self
}
#[must_use]
pub fn min(mut self, min: f32) -> Self {
self.min = min;
self
}
#[must_use]
pub fn max(mut self, max: f32) -> Self {
self.max = max;
self
}
#[must_use]
pub fn step(mut self, step: f32) -> Self {
self.step = step;
self
}
#[must_use]
pub fn disabled(mut self, disabled: bool) -> Self {
self.disabled = disabled;
self
}
#[must_use]
pub fn on_change(
mut self,
handler: impl Fn(&Vec<f32>, &mut Window, &mut App) + 'static,
) -> Self {
self.on_change = Some(Rc::new(handler));
self
}
}
#[doc(hidden)]
#[must_use]
pub fn snap(value: f32, min: f32, max: f32, step: f32) -> f32 {
let snapped = if step > 0. {
min + ((value - min) / step).round() * step
} else {
value
};
snapped.clamp(min, max.max(min))
}
#[derive(Clone)]
struct SliderModel {
values: Vec<f32>,
rtl: bool,
min: f32,
max: f32,
step: f32,
on_change: Option<EventHandler<Vec<f32>>>,
}
impl SliderModel {
fn fraction(&self, value: f32) -> f32 {
let span = self.max - self.min;
if span <= 0. {
0.
} else {
((value - self.min) / span).clamp(0., 1.)
}
}
fn value_at(&self, position: Point<Pixels>, bounds: Bounds<Pixels>) -> f32 {
let width = bounds.size.width.max(px(1.));
let from_start = if self.rtl {
bounds.right() - position.x
} else {
position.x - bounds.left()
};
let fraction = (from_start / width).clamp(0., 1.);
snap(
self.min + fraction * (self.max - self.min),
self.min,
self.max,
self.step,
)
}
fn nearest_thumb(&self, value: f32) -> usize {
self.values
.iter()
.enumerate()
.min_by(|(_, a), (_, b)| {
(*a - value)
.abs()
.partial_cmp(&(*b - value).abs())
.unwrap_or(std::cmp::Ordering::Equal)
})
.map_or(0, |(index, _)| index)
}
fn set(&self, index: usize, value: f32, window: &mut Window, cx: &mut App) {
let lower = if index > 0 {
self.values[index - 1]
} else {
self.min
};
let upper = self.values.get(index + 1).copied().unwrap_or(self.max);
let value = value.clamp(lower, upper);
if (self.values[index] - value).abs() < f32::EPSILON {
return;
}
let mut next = self.values.clone();
next[index] = value;
if let Some(handler) = self.on_change.as_ref() {
handler(&next, window, cx);
}
}
}
struct SliderMemory {
bounds: Rc<Cell<Bounds<Pixels>>>,
dragging_thumb: Option<usize>,
}
impl RenderOnce for Slider {
fn render(self, window: &mut Window, cx: &mut App) -> impl IntoElement {
let memory: State<SliderMemory> =
use_keyed_state(child_id(&self.id, "slider"), window, cx, || SliderMemory {
bounds: Rc::new(Cell::new(Bounds::default())),
dragging_thumb: None,
});
let bounds = memory.read(cx).bounds.clone();
let dragging_thumb = memory.read(cx).dragging_thumb;
let model = SliderModel {
rtl: super::direction::is_rtl(),
values: self
.values
.iter()
.map(|value| value.clamp(self.min, self.max.max(self.min)))
.collect(),
min: self.min,
max: self.max,
step: self.step,
on_change: self.on_change,
};
let is_interactive = !self.disabled;
let (fill_start, fill_end) = match model.values.as_slice() {
[single] => (0., model.fraction(*single)),
[first, .., last] => (model.fraction(*first), model.fraction(*last)),
[] => (0., 0.),
};
let thumbs = model.values.iter().enumerate().map(|(index, value)| {
let key_model = model.clone();
let value = *value;
div()
.id(("slider-thumb", index))
.sx((
&SLIDER.thumb,
is_interactive.then_some(&SLIDER.thumb_interactive),
))
.inset_start(relative(model.fraction(value)))
.when(is_interactive, |thumb| {
thumb.tab_index(0).on_key_down(move |event, window, cx| {
let target = match event.keystroke.key.as_str() {
"up" => value + key_model.step,
"down" => value - key_model.step,
"right" if key_model.rtl => value - key_model.step,
"left" if key_model.rtl => value + key_model.step,
"right" => value + key_model.step,
"left" => value - key_model.step,
"pageup" => value + key_model.step * 10.,
"pagedown" => value - key_model.step * 10.,
"home" => key_model.min,
"end" => key_model.max,
_ => return,
};
cx.stop_propagation();
let target = snap(target, key_model.min, key_model.max, key_model.step);
key_model.set(index, target, window, cx);
})
})
});
let press_model = model.clone();
let press_bounds = bounds.clone();
let press_memory = memory.clone();
let move_model = model.clone();
let move_bounds = bounds.clone();
let end_memory = memory.clone();
div()
.id(self.id)
.sx((
&SLIDER.root,
if is_interactive {
&SLIDER.interactive
} else {
&SLIDER.inert
},
&self.sx,
))
.child(
div().sx(&SLIDER.track).child(measure_bounds(bounds)).child(
div()
.sx(&SLIDER.range)
.inset_start(relative(fill_start))
.w(relative(fill_end - fill_start)),
),
)
.children(thumbs)
.when(is_interactive, |slider| {
slider
.on_mouse_down(MouseButton::Left, move |event, window, cx| {
let value = press_model.value_at(event.position, press_bounds.get());
let thumb = press_model.nearest_thumb(value);
press_model.set(thumb, value, window, cx);
press_memory.update(cx, |memory| memory.dragging_thumb = Some(thumb));
})
.child(track_drag(
dragging_thumb.is_some(),
Rc::new(move |position, window, cx| {
if let Some(thumb) = dragging_thumb {
let value = move_model.value_at(position, move_bounds.get());
move_model.set(thumb, value, window, cx);
}
}),
Rc::new(move |_, cx| {
end_memory.update(cx, |memory| memory.dragging_thumb = None);
}),
))
})
.apply_style_overrides(&self.style_overrides)
}
}
#[cfg(test)]
#[allow(clippy::float_cmp)] mod tests {
use super::snap;
#[test]
fn snap_rounds_to_step_and_clamps() {
assert_eq!(snap(42.4, 0., 100., 5.), 40.);
assert_eq!(snap(42.6, 0., 100., 5.), 45.);
assert_eq!(snap(-3., 0., 100., 1.), 0.);
assert_eq!(snap(130., 0., 100., 1.), 100.);
assert_eq!(snap(0.33, 0., 1., 0.), 0.33);
assert_eq!(snap(7., 2., 12., 5.), 7.);
}
}