1use crate::TestSupportExt as _;
2use std::ops::Range;
3
4use gpui::{
5 AccessibleAction, Along, AnyElement, App, AppContext as _, Axis, Bounds, Context, Div,
6 DragMoveEvent, Empty, Entity, EntityId, EventEmitter, InteractiveElement, IntoElement,
7 MouseButton, MouseDownEvent, Orientation, ParentElement, Pixels, Point, Render, RenderOnce,
8 Role, StatefulInteractiveElement, StyleRefinement, Styled, Window, div,
9 prelude::FluentBuilder as _, px,
10};
11
12use crate::geometry::AxisExt;
13
14pub enum SliderEvent {
16 Change(SliderValue),
18 Release(SliderValue),
20}
21
22#[derive(Clone, Copy, Debug, PartialEq)]
29pub enum SliderValue {
30 Single(f32),
31 Range(f32, f32),
32}
33
34impl std::fmt::Display for SliderValue {
35 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
36 match self {
37 SliderValue::Single(value) => write!(f, "{}", value),
38 SliderValue::Range(start, end) => write!(f, "{}..{}", start, end),
39 }
40 }
41}
42
43impl From<f32> for SliderValue {
44 fn from(value: f32) -> Self {
45 SliderValue::Single(value)
46 }
47}
48
49impl From<(f32, f32)> for SliderValue {
50 fn from(value: (f32, f32)) -> Self {
51 SliderValue::Range(value.0, value.1)
52 }
53}
54
55impl From<Range<f32>> for SliderValue {
56 fn from(value: Range<f32>) -> Self {
57 SliderValue::Range(value.start, value.end)
58 }
59}
60
61impl Default for SliderValue {
62 fn default() -> Self {
63 SliderValue::Single(0.)
64 }
65}
66
67impl SliderValue {
68 pub fn clamp(self, min: f32, max: f32) -> Self {
70 match self {
71 SliderValue::Single(value) => SliderValue::Single(value.clamp(min, max)),
72 SliderValue::Range(start, end) => {
73 SliderValue::Range(start.clamp(min, max), end.clamp(min, max))
74 }
75 }
76 }
77
78 #[inline]
80 pub fn is_single(&self) -> bool {
81 matches!(self, SliderValue::Single(_))
82 }
83
84 #[inline]
86 pub fn is_range(&self) -> bool {
87 matches!(self, SliderValue::Range(_, _))
88 }
89
90 pub fn start(&self) -> f32 {
92 match self {
93 SliderValue::Single(value) => *value,
94 SliderValue::Range(start, _) => *start,
95 }
96 }
97
98 pub fn end(&self) -> f32 {
100 match self {
101 SliderValue::Single(value) => *value,
102 SliderValue::Range(_, end) => *end,
103 }
104 }
105
106 fn set_start(&mut self, value: f32) {
107 if let SliderValue::Range(_, end) = self {
108 *self = SliderValue::Range(value.min(*end), *end);
109 } else {
110 *self = SliderValue::Single(value);
111 }
112 }
113
114 fn set_end(&mut self, value: f32) {
115 if let SliderValue::Range(start, _) = self {
116 *self = SliderValue::Range(*start, value.max(*start));
117 } else {
118 *self = SliderValue::Single(value);
119 }
120 }
121}
122
123#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
125pub enum SliderScale {
126 #[default]
129 Linear,
130 Logarithmic,
155}
156
157impl SliderScale {
158 #[inline]
159 pub fn is_linear(&self) -> bool {
160 matches!(self, SliderScale::Linear)
161 }
162
163 #[inline]
164 pub fn is_logarithmic(&self) -> bool {
165 matches!(self, SliderScale::Logarithmic)
166 }
167}
168
169pub struct SliderState {
171 min: f32,
172 max: f32,
173 step: f32,
174 value: SliderValue,
175 percentage: Range<f32>,
177 bounds: Bounds<Pixels>,
179 scale: SliderScale,
180 dragging: bool,
183}
184
185impl SliderState {
186 pub fn new() -> Self {
188 Self {
189 min: 0.0,
190 max: 100.0,
191 step: 1.0,
192 value: SliderValue::default(),
193 percentage: (0.0..0.0),
194 bounds: Bounds::default(),
195 scale: SliderScale::default(),
196 dragging: false,
197 }
198 }
199
200 pub fn min(mut self, min: f32) -> Self {
202 if self.scale.is_logarithmic() {
203 assert!(
204 min > 0.0,
205 "`min` must be greater than 0 for SliderScale::Logarithmic"
206 );
207 assert!(
208 min < self.max,
209 "`min` must be less than `max` for Logarithmic scale"
210 );
211 }
212 self.min = min;
213 self.update_thumb_pos();
214 self
215 }
216
217 pub fn max(mut self, max: f32) -> Self {
219 if self.scale.is_logarithmic() {
220 assert!(
221 max > self.min,
222 "`max` must be greater than `min` for Logarithmic scale"
223 );
224 }
225 self.max = max;
226 self.update_thumb_pos();
227 self
228 }
229
230 pub fn step(mut self, step: f32) -> Self {
232 self.step = step;
233 self
234 }
235
236 pub fn scale(mut self, scale: SliderScale) -> Self {
238 if scale.is_logarithmic() {
239 assert!(
240 self.min > 0.0,
241 "`min` must be greater than 0 for Logarithmic scale"
242 );
243 assert!(
244 self.max > self.min,
245 "`max` must be greater than `min` for Logarithmic scale"
246 );
247 }
248 self.scale = scale;
249 self.update_thumb_pos();
250 self
251 }
252
253 pub fn default_value(mut self, value: impl Into<SliderValue>) -> Self {
255 self.value = value.into();
256 self.update_thumb_pos();
257 self
258 }
259
260 pub fn set_value(
262 &mut self,
263 value: impl Into<SliderValue>,
264 _: &mut Window,
265 cx: &mut Context<Self>,
266 ) {
267 self.value = value.into();
268 self.update_thumb_pos();
269 cx.notify();
270 }
271
272 pub fn value(&self) -> SliderValue {
274 self.value
275 }
276
277 pub fn min_value(&self) -> f32 {
279 self.min
280 }
281
282 pub fn max_value(&self) -> f32 {
284 self.max
285 }
286
287 pub fn step_value(&self) -> f32 {
289 self.step
290 }
291
292 fn percentage_to_value(&self, percentage: f32) -> f32 {
295 match self.scale {
296 SliderScale::Linear => self.min + (self.max - self.min) * percentage,
297 SliderScale::Logarithmic => {
298 let base = self.max / self.min;
302 (base.powf(percentage) * self.min).clamp(self.min, self.max)
303 }
304 }
305 }
306
307 fn value_to_percentage(&self, value: f32) -> f32 {
310 match self.scale {
311 SliderScale::Linear => {
312 let range = self.max - self.min;
313 if range <= 0.0 {
314 0.0
315 } else {
316 (value - self.min) / range
317 }
318 }
319 SliderScale::Logarithmic => {
320 let base = self.max / self.min;
321 (value / self.min).log(base).clamp(0.0, 1.0)
322 }
323 }
324 }
325
326 fn update_thumb_pos(&mut self) {
327 match self.value {
328 SliderValue::Single(value) => {
329 let percentage = self.value_to_percentage(value.clamp(self.min, self.max));
330 self.percentage = 0.0..percentage;
331 }
332 SliderValue::Range(start, end) => {
333 let clamped_start = start.clamp(self.min, self.max);
334 let clamped_end = end.clamp(self.min, self.max);
335 self.percentage =
336 self.value_to_percentage(clamped_start)..self.value_to_percentage(clamped_end);
337 }
338 }
339 }
340
341 #[doc(hidden)]
343 pub fn update_value_by_position(
344 &mut self,
345 axis: Axis,
346 position: Point<Pixels>,
347 is_start: bool,
348 _: &mut Window,
349 cx: &mut Context<Self>,
350 ) {
351 self.dragging = true;
352 let bounds = self.bounds;
353 let step = self.step;
354
355 let inner_pos = if axis.is_horizontal() {
356 position.x - bounds.left()
357 } else {
358 bounds.bottom() - position.y
359 };
360 let total_size = bounds.size.along(axis);
361 let percentage = inner_pos.clamp(px(0.), total_size) / total_size;
362
363 let percentage = if is_start {
364 percentage.clamp(0.0, self.percentage.end)
365 } else {
366 percentage.clamp(self.percentage.start, 1.0)
367 };
368
369 let value = self.percentage_to_value(percentage);
370 let value = (value / step).round() * step;
371
372 if is_start {
373 self.percentage.start = percentage;
374 self.value.set_start(value);
375 } else {
376 self.percentage.end = percentage;
377 self.value.set_end(value);
378 }
379 cx.emit(SliderEvent::Change(self.value));
380 cx.notify();
381 }
382
383 pub fn handle_release(&mut self, cx: &mut Context<Self>) {
385 if !self.dragging {
386 return;
387 }
388 self.dragging = false;
389 cx.emit(SliderEvent::Release(self.value));
390 }
391}
392
393#[derive(Clone)]
394struct DragThumb((EntityId, bool));
395
396impl Render for DragThumb {
397 fn render(&mut self, _: &mut Window, _: &mut Context<Self>) -> impl IntoElement {
398 Empty
399 }
400}
401
402#[derive(Clone)]
403struct DragSlider(EntityId);
404
405impl Render for DragSlider {
406 fn render(&mut self, _: &mut Window, _: &mut Context<Self>) -> impl IntoElement {
407 Empty
408 }
409}
410
411#[derive(IntoElement)]
415pub struct Slider {
416 state: Entity<SliderState>,
417 axis: Axis,
418 disabled: bool,
419 base: Div,
420 children: Vec<AnyElement>,
421}
422
423impl Slider {
424 pub fn new(state: &Entity<SliderState>) -> Self {
425 Self {
426 state: state.clone(),
427 axis: Axis::Horizontal,
428 disabled: false,
429 base: div(),
430 children: Vec::new(),
431 }
432 }
433
434 pub fn horizontal(mut self) -> Self {
435 self.axis = Axis::Horizontal;
436 self
437 }
438
439 pub fn vertical(mut self) -> Self {
440 self.axis = Axis::Vertical;
441 self
442 }
443
444 pub fn axis(mut self, axis: Axis) -> Self {
445 self.axis = axis;
446 self
447 }
448
449 pub fn disabled(mut self, disabled: bool) -> Self {
450 self.disabled = disabled;
451 self
452 }
453}
454
455impl ParentElement for Slider {
456 fn extend(&mut self, elements: impl IntoIterator<Item = AnyElement>) {
457 self.children.extend(elements);
458 }
459}
460
461impl Styled for Slider {
462 fn style(&mut self) -> &mut StyleRefinement {
463 self.base.style()
464 }
465}
466
467impl RenderOnce for Slider {
468 fn render(self, window: &mut Window, cx: &mut App) -> impl IntoElement {
469 let axis = self.axis;
470 let entity_id = self.state.entity_id();
471 let state = self.state.read(cx);
472 let slider_state = self.state.clone();
473
474 self.base
475 .id(("slider", entity_id))
476 .test_support()
477 .role(Role::Slider)
478 .aria_numeric_value(state.value().end() as f64)
479 .aria_min_numeric_value(state.min_value() as f64)
480 .aria_max_numeric_value(state.max_value() as f64)
481 .aria_numeric_value_step(state.step_value() as f64)
482 .aria_orientation(if axis.is_vertical() {
483 Orientation::Vertical
484 } else {
485 Orientation::Horizontal
486 })
487 .on_a11y_action(AccessibleAction::Increment, {
488 let state = slider_state.clone();
489 move |_, window, cx| {
490 state.update(cx, |state, cx| {
491 let value =
492 (state.value().end() + state.step_value()).min(state.max_value());
493 state.set_value(value, window, cx);
494 });
495 }
496 })
497 .on_a11y_action(AccessibleAction::Decrement, {
498 let state = slider_state.clone();
499 move |_, window, cx| {
500 state.update(cx, |state, cx| {
501 let value =
502 (state.value().end() - state.step_value()).max(state.min_value());
503 state.set_value(value, window, cx);
504 });
505 }
506 })
507 .when(!self.disabled, |this| {
508 this.on_mouse_up(
509 MouseButton::Left,
510 window.listener_for(&self.state, |state, _, _, cx| state.handle_release(cx)),
511 )
512 .on_mouse_up_out(
513 MouseButton::Left,
514 window.listener_for(&self.state, |state, _, _, cx| state.handle_release(cx)),
515 )
516 })
517 .children(self.children)
518 }
519}
520
521#[derive(IntoElement)]
523pub struct SliderTrack {
524 state: Entity<SliderState>,
525 axis: Axis,
526 disabled: bool,
527 base: Div,
528 children: Vec<AnyElement>,
529}
530
531impl SliderTrack {
532 pub fn new(state: &Entity<SliderState>) -> Self {
533 Self {
534 state: state.clone(),
535 axis: Axis::Horizontal,
536 disabled: false,
537 base: div(),
538 children: Vec::new(),
539 }
540 }
541
542 pub fn axis(mut self, axis: Axis) -> Self {
543 self.axis = axis;
544 self
545 }
546 pub fn disabled(mut self, disabled: bool) -> Self {
547 self.disabled = disabled;
548 self
549 }
550}
551
552impl ParentElement for SliderTrack {
553 fn extend(&mut self, elements: impl IntoIterator<Item = AnyElement>) {
554 self.children.extend(elements);
555 }
556}
557
558impl Styled for SliderTrack {
559 fn style(&mut self) -> &mut StyleRefinement {
560 self.base.style()
561 }
562}
563
564impl InteractiveElement for SliderTrack {
565 fn interactivity(&mut self) -> &mut gpui::Interactivity {
566 self.base.interactivity()
567 }
568}
569
570impl RenderOnce for SliderTrack {
571 fn render(self, window: &mut Window, cx: &mut App) -> impl IntoElement {
572 let axis = self.axis;
573 let entity_id = self.state.entity_id();
574 let state = self.state.read(cx);
575 let is_range = state.value().is_range();
576 let percentage = state.percentage();
577 self.base
578 .id("slider-bar-container")
579 .test_support()
580 .children(self.children)
581 .when(!self.disabled, |this| {
582 this.on_mouse_down(
583 MouseButton::Left,
584 window.listener_for(
585 &self.state,
586 move |state, event: &MouseDownEvent, window, cx| {
587 let is_start = if is_range {
588 let size = state.bounds().size.along(axis);
589 let position = if axis.is_horizontal() {
590 event.position.x - state.bounds().left()
591 } else {
592 state.bounds().bottom() - event.position.y
593 };
594 let center = ((percentage.end - percentage.start) / 2.
595 + percentage.start)
596 * size;
597 position < center
598 } else {
599 false
600 };
601 state.update_value_by_position(
602 axis,
603 event.position,
604 is_start,
605 window,
606 cx,
607 );
608 },
609 ),
610 )
611 .when(!is_range, |this| {
612 this.on_drag(DragSlider(entity_id), |drag, _, _, cx| {
613 cx.stop_propagation();
614 cx.new(|_| drag.clone())
615 })
616 .on_drag_move(window.listener_for(
617 &self.state,
618 move |state, event: &DragMoveEvent<DragSlider>, window, cx| {
619 let DragSlider(id) = event.drag(cx);
620 if *id == entity_id {
621 state.update_value_by_position(
622 axis,
623 event.event.position,
624 false,
625 window,
626 cx,
627 );
628 }
629 },
630 ))
631 })
632 })
633 }
634}
635
636#[derive(IntoElement)]
638pub struct SliderIndicator {
639 state: Entity<SliderState>,
640 base: Div,
641 children: Vec<AnyElement>,
642}
643
644impl SliderIndicator {
645 pub fn new(state: &Entity<SliderState>) -> Self {
646 Self {
647 state: state.clone(),
648 base: div(),
649 children: Vec::new(),
650 }
651 }
652}
653
654impl ParentElement for SliderIndicator {
655 fn extend(&mut self, elements: impl IntoIterator<Item = AnyElement>) {
656 self.children.extend(elements);
657 }
658}
659
660impl Styled for SliderIndicator {
661 fn style(&mut self) -> &mut StyleRefinement {
662 self.base.style()
663 }
664}
665
666impl InteractiveElement for SliderIndicator {
667 fn interactivity(&mut self) -> &mut gpui::Interactivity {
668 self.base.interactivity()
669 }
670}
671
672impl StatefulInteractiveElement for SliderIndicator {}
673
674impl RenderOnce for SliderIndicator {
675 fn render(self, _: &mut Window, _: &mut App) -> impl IntoElement {
676 crate::ElementExt::on_prepaint(self.base.id("slider-bar").children(self.children), {
677 let state = self.state;
678 move |bounds, _, cx| state.update(cx, |state, _| state.set_bounds(bounds))
679 })
680 }
681}
682
683#[derive(IntoElement)]
685pub struct SliderThumb {
686 state: Entity<SliderState>,
687 axis: Axis,
688 start: bool,
689 disabled: bool,
690 base: Div,
691 children: Vec<AnyElement>,
692}
693
694impl SliderThumb {
695 pub fn new(state: &Entity<SliderState>) -> Self {
696 Self {
697 state: state.clone(),
698 axis: Axis::Horizontal,
699 start: false,
700 disabled: false,
701 base: div(),
702 children: Vec::new(),
703 }
704 }
705
706 pub fn axis(mut self, axis: Axis) -> Self {
707 self.axis = axis;
708 self
709 }
710 pub fn start(mut self, start: bool) -> Self {
711 self.start = start;
712 self
713 }
714 pub fn disabled(mut self, disabled: bool) -> Self {
715 self.disabled = disabled;
716 self
717 }
718}
719
720impl ParentElement for SliderThumb {
721 fn extend(&mut self, elements: impl IntoIterator<Item = AnyElement>) {
722 self.children.extend(elements);
723 }
724}
725
726impl Styled for SliderThumb {
727 fn style(&mut self) -> &mut StyleRefinement {
728 self.base.style()
729 }
730}
731
732impl InteractiveElement for SliderThumb {
733 fn interactivity(&mut self) -> &mut gpui::Interactivity {
734 self.base.interactivity()
735 }
736}
737
738impl StatefulInteractiveElement for SliderThumb {}
739
740impl RenderOnce for SliderThumb {
741 fn render(self, window: &mut Window, _: &mut App) -> impl IntoElement {
742 let entity_id = self.state.entity_id();
743 let axis = self.axis;
744 let start = self.start;
745 self.base
746 .id(("slider-thumb", start as u32))
747 .test_support()
748 .children(self.children)
749 .when(!self.disabled, |this| {
750 this.on_mouse_down(MouseButton::Left, |_, _, cx| cx.stop_propagation())
751 .on_drag(DragThumb((entity_id, start)), |drag, _, _, cx| {
752 cx.stop_propagation();
753 cx.new(|_| drag.clone())
754 })
755 .on_drag_move(window.listener_for(
756 &self.state,
757 move |state, event: &DragMoveEvent<DragThumb>, window, cx| {
758 let DragThumb((id, start)) = event.drag(cx);
759 if *id == entity_id {
760 state.update_value_by_position(
761 axis,
762 event.event.position,
763 *start,
764 window,
765 cx,
766 );
767 }
768 },
769 ))
770 })
771 }
772}
773
774impl EventEmitter<SliderEvent> for SliderState {}
775
776impl SliderState {
777 #[doc(hidden)]
778 pub fn percentage(&self) -> Range<f32> {
779 self.percentage.clone()
780 }
781
782 #[doc(hidden)]
783 pub fn bounds(&self) -> Bounds<Pixels> {
784 self.bounds
785 }
786
787 #[doc(hidden)]
788 pub fn set_bounds(&mut self, bounds: Bounds<Pixels>) {
789 self.bounds = bounds;
790 }
791}
792
793#[cfg(test)]
794mod tests {
795 use super::*;
796
797 #[test]
798 fn legacy_value_conversions_and_clamping_are_preserved() {
799 assert_eq!(SliderValue::from(5.), SliderValue::Single(5.));
800 assert_eq!(SliderValue::from((2., 8.)), SliderValue::Range(2., 8.));
801 assert_eq!(SliderValue::from(2.0..8.0), SliderValue::Range(2., 8.));
802 assert_eq!(
803 SliderValue::Range(-1., 12.).clamp(0., 10.),
804 SliderValue::Range(0., 10.)
805 );
806 }
807
808 #[test]
809 fn legacy_linear_state_keeps_percentage_and_range_ordering() {
810 let state = SliderState::new()
811 .min(0.)
812 .max(200.)
813 .default_value((50., 150.));
814 assert_eq!(state.value(), SliderValue::Range(50., 150.));
815 assert_eq!(state.percentage(), 0.25..0.75);
816 }
817
818 #[test]
819 fn legacy_logarithmic_state_keeps_mapping() {
820 let state = SliderState::new()
821 .min(1.)
822 .max(1000.)
823 .scale(SliderScale::Logarithmic)
824 .default_value(10.);
825 let percentage = state.percentage().end;
826 assert!((percentage - (1. / 3.)).abs() < 0.0001);
827 }
828
829 #[test]
830 #[should_panic(expected = "`min` must be greater than 0")]
831 fn legacy_logarithmic_validation_is_preserved() {
832 let _ = SliderState::new().scale(SliderScale::Logarithmic);
833 }
834}