1use crate::capabilities::controls::slider::{SliderAxis, SliderSize};
2use crate::capabilities::foundation::theme::use_theme;
3use gpui::{prelude::*, *};
4use std::rc::Rc;
5
6#[derive(Copy, Clone, Debug, PartialEq, Eq)]
7enum ActiveThumb {
8 None,
9 Start,
10 End,
11}
12
13pub struct RangeSliderState {
14 min: f32,
15 max: f32,
16 start_value: f32,
17 end_value: f32,
18 step: f32,
19 focus_handle: FocusHandle,
20 active_thumb: ActiveThumb,
21 bounds: Bounds<Pixels>,
22}
23
24impl RangeSliderState {
25 pub fn new(cx: &mut Context<Self>) -> Self {
26 Self {
27 min: 0.0,
28 max: 100.0,
29 start_value: 25.0,
30 end_value: 75.0,
31 step: 1.0,
32 focus_handle: cx.focus_handle(),
33 active_thumb: ActiveThumb::None,
34 bounds: Bounds::default(),
35 }
36 }
37
38 pub fn min(&self) -> f32 {
39 self.min
40 }
41
42 pub fn set_min(&mut self, min: f32, cx: &mut Context<Self>) {
46 self.min = min;
47 self.max = self.max.max(self.min);
48 self.start_value = self.start_value.clamp(self.min, self.max);
49 self.end_value = self.end_value.clamp(self.start_value, self.max);
50 cx.notify();
51 }
52
53 pub fn max(&self) -> f32 {
54 self.max
55 }
56
57 pub fn set_max(&mut self, max: f32, cx: &mut Context<Self>) {
61 self.max = max;
62 self.min = self.min.min(self.max);
63 self.end_value = self.end_value.clamp(self.min, self.max);
64 self.start_value = self.start_value.clamp(self.min, self.end_value);
65 cx.notify();
66 }
67
68 pub fn start_value(&self) -> f32 {
69 self.start_value
70 }
71
72 pub fn end_value(&self) -> f32 {
73 self.end_value
74 }
75
76 pub fn range(&self) -> (f32, f32) {
77 (self.start_value, self.end_value)
78 }
79
80 pub fn set_start_value(&mut self, value: f32, cx: &mut Context<Self>) {
81 let clamped = value.clamp(self.min, self.end_value);
82 let stepped = ((clamped / self.step).round() * self.step).clamp(self.min, self.end_value);
83
84 if (self.start_value - stepped).abs() > f32::EPSILON {
85 self.start_value = stepped;
86 cx.notify();
87 }
88 }
89
90 pub fn set_end_value(&mut self, value: f32, cx: &mut Context<Self>) {
91 let clamped = value.clamp(self.start_value, self.max);
92 let stepped = ((clamped / self.step).round() * self.step).clamp(self.start_value, self.max);
93
94 if (self.end_value - stepped).abs() > f32::EPSILON {
95 self.end_value = stepped;
96 cx.notify();
97 }
98 }
99
100 pub fn set_range(&mut self, start: f32, end: f32, cx: &mut Context<Self>) {
101 let clamped_start = start.clamp(self.min, self.max);
102 let clamped_end = end.clamp(clamped_start, self.max);
103
104 let stepped_start =
105 ((clamped_start / self.step).round() * self.step).clamp(self.min, self.max);
106 let stepped_end =
107 ((clamped_end / self.step).round() * self.step).clamp(stepped_start, self.max);
108
109 let changed = (self.start_value - stepped_start).abs() > f32::EPSILON
110 || (self.end_value - stepped_end).abs() > f32::EPSILON;
111
112 if changed {
113 self.start_value = stepped_start;
114 self.end_value = stepped_end;
115 cx.notify();
116 }
117 }
118
119 pub fn step(&self) -> f32 {
120 self.step
121 }
122
123 pub fn set_step(&mut self, step: f32, cx: &mut Context<Self>) {
124 self.step = step;
125 cx.notify();
126 }
127
128 fn start_percentage(&self) -> f32 {
129 if self.max == self.min {
130 return 0.0;
131 }
132 ((self.start_value - self.min) / (self.max - self.min)).clamp(0.0, 1.0)
133 }
134
135 fn end_percentage(&self) -> f32 {
136 if self.max == self.min {
137 return 0.0;
138 }
139 ((self.end_value - self.min) / (self.max - self.min)).clamp(0.0, 1.0)
140 }
141
142 fn value_from_position(&self, position: Point<Pixels>) -> f32 {
143 let track_width = self.bounds.size.width;
144 if track_width <= px(0.0) {
145 return self.min;
146 }
147
148 let relative_x = (position.x - self.bounds.left()).clamp(px(0.0), track_width);
149 let percentage = (relative_x / track_width).clamp(0.0, 1.0);
150 self.min + percentage * (self.max - self.min)
151 }
152
153 fn value_from_position_vertical(&self, position: Point<Pixels>) -> f32 {
154 let track_height = self.bounds.size.height;
155 if track_height <= px(0.0) {
156 return self.min;
157 }
158
159 let relative_y = (position.y - self.bounds.top()).clamp(px(0.0), track_height);
160 let percentage = 1.0 - (relative_y / track_height).clamp(0.0, 1.0);
161 self.min + percentage * (self.max - self.min)
162 }
163
164 fn update_from_position(&mut self, position: Point<Pixels>, cx: &mut Context<Self>) {
165 let new_value = self.value_from_position(position);
166
167 match self.active_thumb {
168 ActiveThumb::Start => self.set_start_value(new_value, cx),
169 ActiveThumb::End => self.set_end_value(new_value, cx),
170 ActiveThumb::None => {
171 let start_dist = (new_value - self.start_value).abs();
172 let end_dist = (new_value - self.end_value).abs();
173
174 if start_dist <= end_dist {
175 self.active_thumb = ActiveThumb::Start;
176 self.set_start_value(new_value, cx);
177 } else {
178 self.active_thumb = ActiveThumb::End;
179 self.set_end_value(new_value, cx);
180 }
181 }
182 }
183 }
184
185 fn update_from_position_vertical(&mut self, position: Point<Pixels>, cx: &mut Context<Self>) {
186 let new_value = self.value_from_position_vertical(position);
187
188 match self.active_thumb {
189 ActiveThumb::Start => self.set_start_value(new_value, cx),
190 ActiveThumb::End => self.set_end_value(new_value, cx),
191 ActiveThumb::None => {
192 let start_dist = (new_value - self.start_value).abs();
193 let end_dist = (new_value - self.end_value).abs();
194
195 if start_dist <= end_dist {
196 self.active_thumb = ActiveThumb::Start;
197 self.set_start_value(new_value, cx);
198 } else {
199 self.active_thumb = ActiveThumb::End;
200 self.set_end_value(new_value, cx);
201 }
202 }
203 }
204 }
205}
206
207impl Focusable for RangeSliderState {
208 fn focus_handle(&self, _: &App) -> FocusHandle {
209 self.focus_handle.clone()
210 }
211}
212
213impl Render for RangeSliderState {
214 fn render(&mut self, _: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
215 div()
216 }
217}
218
219#[derive(IntoElement)]
220pub struct RangeSlider {
221 state: Entity<RangeSliderState>,
222 size: SliderSize,
223 axis: SliderAxis,
224 disabled: bool,
225 show_values: bool,
226 on_change: Option<Rc<dyn Fn(f32, f32, &mut Window, &mut App) + 'static>>,
227 style: StyleRefinement,
228}
229
230impl RangeSlider {
231 pub fn new(state: Entity<RangeSliderState>) -> Self {
232 Self {
233 state,
234 size: SliderSize::Md,
235 axis: SliderAxis::Horizontal,
236 disabled: false,
237 show_values: false,
238 on_change: None,
239 style: StyleRefinement::default(),
240 }
241 }
242
243 pub fn size(mut self, size: SliderSize) -> Self {
244 self.size = size;
245 self
246 }
247
248 pub fn horizontal(mut self) -> Self {
249 self.axis = SliderAxis::Horizontal;
250 self
251 }
252
253 pub fn vertical(mut self) -> Self {
254 self.axis = SliderAxis::Vertical;
255 self
256 }
257
258 pub fn disabled(mut self, disabled: bool) -> Self {
259 self.disabled = disabled;
260 self
261 }
262
263 pub fn show_values(mut self, show: bool) -> Self {
264 self.show_values = show;
265 self
266 }
267
268 pub fn on_change(
269 mut self,
270 handler: impl Fn(f32, f32, &mut Window, &mut App) + 'static,
271 ) -> Self {
272 self.on_change = Some(Rc::new(handler));
273 self
274 }
275}
276
277impl Styled for RangeSlider {
278 fn style(&mut self) -> &mut StyleRefinement {
279 &mut self.style
280 }
281}
282
283impl RangeSlider {
284 fn render_horizontal(
285 self,
286 window: &mut Window,
287 theme: crate::capabilities::foundation::theme::Theme,
288 focus_handle: FocusHandle,
289 is_focused: bool,
290 start_percentage: f32,
291 end_percentage: f32,
292 start_value: f32,
293 end_value: f32,
294 track_height: Pixels,
295 thumb_width: Pixels,
296 thumb_height: Pixels,
297 track_bg: Hsla,
298 active_bg: Hsla,
299 thumb_bg: Hsla,
300 focus_ring: BoxShadow,
301 user_style: StyleRefinement,
302 ) -> Div {
303 div()
304 .flex()
305 .items_center()
306 .gap_3()
307 .w_full()
308 .map(|this| {
309 let mut div = this;
310 div.style().refine(&user_style);
311 div
312 })
313 .when(self.show_values, |this| {
314 this.child(
315 div()
316 .min_w(px(40.0))
317 .text_center()
318 .text_sm()
319 .text_color(theme.tokens.foreground)
320 .child(format!("{:.0}", start_value)),
321 )
322 })
323 .child(
324 div()
325 .relative()
326 .flex_1()
327 .h(thumb_height)
328 .flex()
329 .items_center()
330 .when(!self.disabled, |this| {
331 this.track_focus(&focus_handle.tab_index(0).tab_stop(true))
332 })
333 .when(is_focused && !self.disabled, |this| {
334 this.shadow(smallvec::smallvec![focus_ring])
335 })
336 .rounded(theme.tokens.radius_md)
337 .when(!self.disabled, |this| {
338 let on_change_for_key = self.on_change.clone();
339 this.on_key_down(window.listener_for(
340 &self.state,
341 move |state, e: &KeyDownEvent, window, cx| {
342 let use_start = !matches!(state.active_thumb, ActiveThumb::End);
344 match (e.keystroke.key.as_str(), use_start) {
345 ("left" | "down", true) => {
346 state.set_start_value(state.start_value - state.step, cx)
347 }
348 ("left" | "down", false) => {
349 state.set_end_value(state.end_value - state.step, cx)
350 }
351 ("right" | "up", true) => {
352 state.set_start_value(state.start_value + state.step, cx)
353 }
354 ("right" | "up", false) => {
355 state.set_end_value(state.end_value + state.step, cx)
356 }
357 ("home", true) => state.set_start_value(state.min, cx),
358 ("home", false) => state.set_end_value(state.min, cx),
359 ("end", true) => state.set_start_value(state.max, cx),
360 ("end", false) => state.set_end_value(state.max, cx),
361 _ => return,
362 }
363 cx.stop_propagation();
364 if let Some(ref handler) = on_change_for_key {
365 handler(state.start_value, state.end_value, window, cx);
366 }
367 },
368 ))
369 })
370 .child(
371 canvas(
372 {
373 let state = self.state.clone();
374 move |bounds, _, cx| {
375 state.update(cx, |state, _| {
376 state.bounds = bounds;
377 });
378 }
379 },
380 |_, _, _, _| {},
381 )
382 .absolute()
383 .size_full(),
384 )
385 .child(
386 div()
387 .relative()
388 .w_full()
389 .h(track_height)
390 .rounded_full()
391 .bg(track_bg)
392 .overflow_hidden()
393 .child(
394 div()
395 .absolute()
396 .left(relative(start_percentage))
397 .top_0()
398 .h_full()
399 .w(relative(end_percentage - start_percentage))
400 .bg(active_bg),
401 ),
402 )
403 .child({
404 let state_clone = self.state.clone();
405 let on_change_thumb = self.on_change.clone();
406
407 div()
408 .absolute()
409 .left(relative(start_percentage))
410 .top_0()
411 .ml(-(thumb_width / 2.0))
412 .w(thumb_width)
413 .h(thumb_height)
414 .rounded(thumb_height / 2.0)
415 .bg(thumb_bg)
416 .border_2()
417 .border_color(theme.tokens.background)
418 .when(!self.disabled, {
419 let shadow = theme.tokens.shadow_sm.clone();
420 move |this| {
421 this.shadow(smallvec::smallvec![shadow])
422 .cursor(CursorStyle::PointingHand)
423 }
424 })
425 .when(!self.disabled, |this| {
426 this.on_mouse_down(
427 MouseButton::Left,
428 window.listener_for(
429 &state_clone,
430 move |state, e: &MouseDownEvent, window, cx| {
431 state.active_thumb = ActiveThumb::Start;
432 state.update_from_position(e.position, cx);
433
434 if let Some(ref handler) = on_change_thumb {
435 handler(
436 state.start_value,
437 state.end_value,
438 window,
439 cx,
440 );
441 }
442
443 cx.stop_propagation();
444 },
445 ),
446 )
447 })
448 })
449 .child({
450 let state_clone = self.state.clone();
451 let on_change_thumb = self.on_change.clone();
452
453 div()
454 .absolute()
455 .left(relative(end_percentage))
456 .top_0()
457 .ml(-(thumb_width / 2.0))
458 .w(thumb_width)
459 .h(thumb_height)
460 .rounded(thumb_height / 2.0)
461 .bg(thumb_bg)
462 .border_2()
463 .border_color(theme.tokens.background)
464 .when(!self.disabled, {
465 let shadow = theme.tokens.shadow_sm.clone();
466 move |this| {
467 this.shadow(smallvec::smallvec![shadow])
468 .cursor(CursorStyle::PointingHand)
469 }
470 })
471 .when(!self.disabled, |this| {
472 this.on_mouse_down(
473 MouseButton::Left,
474 window.listener_for(
475 &state_clone,
476 move |state, e: &MouseDownEvent, window, cx| {
477 state.active_thumb = ActiveThumb::End;
478 state.update_from_position(e.position, cx);
479
480 if let Some(ref handler) = on_change_thumb {
481 handler(
482 state.start_value,
483 state.end_value,
484 window,
485 cx,
486 );
487 }
488
489 cx.stop_propagation();
490 },
491 ),
492 )
493 })
494 })
495 .when(!self.disabled, |this| {
496 let state_bar = self.state.clone();
497 let on_change_bar = self.on_change.clone();
498
499 this.on_mouse_down(
500 MouseButton::Left,
501 window.listener_for(
502 &state_bar,
503 move |state, e: &MouseDownEvent, window, cx| {
504 state.update_from_position(e.position, cx);
505
506 if let Some(ref handler) = on_change_bar {
507 handler(state.start_value, state.end_value, window, cx);
508 }
509 },
510 ),
511 )
512 .on_mouse_move({
513 let state_move = self.state.clone();
514 let on_change_move = self.on_change.clone();
515
516 window.listener_for(
517 &state_move,
518 move |state, e: &MouseMoveEvent, window, cx| {
519 if state.active_thumb != ActiveThumb::None {
520 state.update_from_position(e.position, cx);
521
522 if let Some(ref handler) = on_change_move {
523 handler(state.start_value, state.end_value, window, cx);
524 }
525 }
526 },
527 )
528 })
529 .on_mouse_up(
530 MouseButton::Left,
531 window.listener_for(
532 &self.state,
533 move |state, _: &MouseUpEvent, _, _cx| {
534 state.active_thumb = ActiveThumb::None;
535 },
536 ),
537 )
538 .on_mouse_up_out(
539 MouseButton::Left,
540 window.listener_for(
541 &self.state,
542 move |state, _: &MouseUpEvent, _, _cx| {
543 state.active_thumb = ActiveThumb::None;
544 },
545 ),
546 )
547 }),
548 )
549 .when(self.show_values, |this| {
550 this.child(
551 div()
552 .min_w(px(40.0))
553 .text_center()
554 .text_sm()
555 .text_color(theme.tokens.foreground)
556 .child(format!("{:.0}", end_value)),
557 )
558 })
559 }
560
561 fn render_vertical(
562 self,
563 window: &mut Window,
564 theme: crate::capabilities::foundation::theme::Theme,
565 focus_handle: FocusHandle,
566 is_focused: bool,
567 start_percentage: f32,
568 end_percentage: f32,
569 start_value: f32,
570 end_value: f32,
571 track_height: Pixels,
572 thumb_width: Pixels,
573 thumb_height: Pixels,
574 track_bg: Hsla,
575 active_bg: Hsla,
576 thumb_bg: Hsla,
577 focus_ring: BoxShadow,
578 user_style: StyleRefinement,
579 ) -> Div {
580 div()
581 .flex()
582 .flex_col()
583 .items_center()
584 .gap_3()
585 .h_full()
586 .map(|this| {
587 let mut div = this;
588 div.style().refine(&user_style);
589 div
590 })
591 .when(self.show_values, |this| {
592 this.child(
593 div()
594 .min_h(px(24.0))
595 .text_center()
596 .text_sm()
597 .text_color(theme.tokens.foreground)
598 .child(format!("{:.0}", end_value)),
599 )
600 })
601 .child(
602 div()
603 .relative()
604 .flex_1()
605 .w(thumb_width)
606 .flex()
607 .items_center()
608 .justify_center()
609 .when(!self.disabled, |this| {
610 this.track_focus(&focus_handle.tab_index(0).tab_stop(true))
611 })
612 .when(is_focused && !self.disabled, |this| {
613 this.shadow(smallvec::smallvec![focus_ring])
614 })
615 .rounded(theme.tokens.radius_md)
616 .when(!self.disabled, |this| {
617 let on_change_for_key = self.on_change.clone();
618 this.on_key_down(window.listener_for(
619 &self.state,
620 move |state, e: &KeyDownEvent, window, cx| {
621 let use_start = !matches!(state.active_thumb, ActiveThumb::End);
623 match (e.keystroke.key.as_str(), use_start) {
624 ("left" | "down", true) => {
625 state.set_start_value(state.start_value - state.step, cx)
626 }
627 ("left" | "down", false) => {
628 state.set_end_value(state.end_value - state.step, cx)
629 }
630 ("right" | "up", true) => {
631 state.set_start_value(state.start_value + state.step, cx)
632 }
633 ("right" | "up", false) => {
634 state.set_end_value(state.end_value + state.step, cx)
635 }
636 ("home", true) => state.set_start_value(state.min, cx),
637 ("home", false) => state.set_end_value(state.min, cx),
638 ("end", true) => state.set_start_value(state.max, cx),
639 ("end", false) => state.set_end_value(state.max, cx),
640 _ => return,
641 }
642 cx.stop_propagation();
643 if let Some(ref handler) = on_change_for_key {
644 handler(state.start_value, state.end_value, window, cx);
645 }
646 },
647 ))
648 })
649 .child(
650 canvas(
651 {
652 let state = self.state.clone();
653 move |bounds, _, cx| {
654 state.update(cx, |state, _| {
655 state.bounds = bounds;
656 });
657 }
658 },
659 |_, _, _, _| {},
660 )
661 .absolute()
662 .size_full(),
663 )
664 .child(
665 div()
666 .relative()
667 .h_full()
668 .w(track_height)
669 .rounded_full()
670 .bg(track_bg)
671 .overflow_hidden()
672 .child(
673 div()
674 .absolute()
675 .left_0()
676 .bottom(relative(start_percentage))
677 .w_full()
678 .h(relative(end_percentage - start_percentage))
679 .bg(active_bg),
680 ),
681 )
682 .child({
683 let state_clone = self.state.clone();
684 let on_change_thumb = self.on_change.clone();
685
686 div()
687 .absolute()
688 .left_0()
689 .bottom(relative(start_percentage))
690 .mb(-(thumb_height / 2.0))
691 .w(thumb_width)
692 .h(thumb_height)
693 .rounded(thumb_width / 2.0)
694 .bg(thumb_bg)
695 .border_2()
696 .border_color(theme.tokens.background)
697 .when(!self.disabled, {
698 let shadow = theme.tokens.shadow_sm.clone();
699 move |this| {
700 this.shadow(smallvec::smallvec![shadow])
701 .cursor(CursorStyle::PointingHand)
702 }
703 })
704 .when(!self.disabled, |this| {
705 this.on_mouse_down(
706 MouseButton::Left,
707 window.listener_for(
708 &state_clone,
709 move |state, e: &MouseDownEvent, window, cx| {
710 state.active_thumb = ActiveThumb::Start;
711 state.update_from_position_vertical(e.position, cx);
712
713 if let Some(ref handler) = on_change_thumb {
714 handler(
715 state.start_value,
716 state.end_value,
717 window,
718 cx,
719 );
720 }
721
722 cx.stop_propagation();
723 },
724 ),
725 )
726 })
727 })
728 .child({
729 let state_clone = self.state.clone();
730 let on_change_thumb = self.on_change.clone();
731
732 div()
733 .absolute()
734 .left_0()
735 .bottom(relative(end_percentage))
736 .mb(-(thumb_height / 2.0))
737 .w(thumb_width)
738 .h(thumb_height)
739 .rounded(thumb_width / 2.0)
740 .bg(thumb_bg)
741 .border_2()
742 .border_color(theme.tokens.background)
743 .when(!self.disabled, {
744 let shadow = theme.tokens.shadow_sm.clone();
745 move |this| {
746 this.shadow(smallvec::smallvec![shadow])
747 .cursor(CursorStyle::PointingHand)
748 }
749 })
750 .when(!self.disabled, |this| {
751 this.on_mouse_down(
752 MouseButton::Left,
753 window.listener_for(
754 &state_clone,
755 move |state, e: &MouseDownEvent, window, cx| {
756 state.active_thumb = ActiveThumb::End;
757 state.update_from_position_vertical(e.position, cx);
758
759 if let Some(ref handler) = on_change_thumb {
760 handler(
761 state.start_value,
762 state.end_value,
763 window,
764 cx,
765 );
766 }
767
768 cx.stop_propagation();
769 },
770 ),
771 )
772 })
773 })
774 .when(!self.disabled, |this| {
775 let state_bar = self.state.clone();
776 let on_change_bar = self.on_change.clone();
777
778 this.on_mouse_down(
779 MouseButton::Left,
780 window.listener_for(
781 &state_bar,
782 move |state, e: &MouseDownEvent, window, cx| {
783 state.update_from_position_vertical(e.position, cx);
784
785 if let Some(ref handler) = on_change_bar {
786 handler(state.start_value, state.end_value, window, cx);
787 }
788 },
789 ),
790 )
791 .on_mouse_move({
792 let state_move = self.state.clone();
793 let on_change_move = self.on_change.clone();
794
795 window.listener_for(
796 &state_move,
797 move |state, e: &MouseMoveEvent, window, cx| {
798 if state.active_thumb != ActiveThumb::None {
799 state.update_from_position_vertical(e.position, cx);
800
801 if let Some(ref handler) = on_change_move {
802 handler(state.start_value, state.end_value, window, cx);
803 }
804 }
805 },
806 )
807 })
808 .on_mouse_up(
809 MouseButton::Left,
810 window.listener_for(
811 &self.state,
812 move |state, _: &MouseUpEvent, _, _cx| {
813 state.active_thumb = ActiveThumb::None;
814 },
815 ),
816 )
817 .on_mouse_up_out(
818 MouseButton::Left,
819 window.listener_for(
820 &self.state,
821 move |state, _: &MouseUpEvent, _, _cx| {
822 state.active_thumb = ActiveThumb::None;
823 },
824 ),
825 )
826 }),
827 )
828 .when(self.show_values, |this| {
829 this.child(
830 div()
831 .min_h(px(24.0))
832 .text_center()
833 .text_sm()
834 .text_color(theme.tokens.foreground)
835 .child(format!("{:.0}", start_value)),
836 )
837 })
838 }
839}
840
841impl RenderOnce for RangeSlider {
842 fn render(self, window: &mut Window, cx: &mut App) -> impl IntoElement {
843 let theme = use_theme(cx);
844 let state = self.state.read(cx);
845 let focus_handle = state.focus_handle(cx);
846 let is_focused = focus_handle.is_focused(window);
847 let start_percentage = state.start_percentage();
848 let end_percentage = state.end_percentage();
849 let start_value = state.start_value;
850 let end_value = state.end_value;
851
852 let track_height = self.size.track_height();
853 let thumb_width = self.size.thumb_width();
854 let thumb_height = self.size.thumb_height();
855
856 let (track_bg, active_bg, thumb_bg) = if self.disabled {
857 (
858 theme.tokens.muted.opacity(0.3),
859 theme.tokens.primary.opacity(0.3),
860 theme.tokens.primary.opacity(0.3),
861 )
862 } else {
863 (
864 theme.tokens.muted,
865 theme.tokens.primary,
866 theme.tokens.primary,
867 )
868 };
869
870 let focus_ring = theme.tokens.focus_ring_light();
871 let user_style = self.style.clone();
872
873 match self.axis {
874 SliderAxis::Horizontal => self.render_horizontal(
875 window,
876 theme,
877 focus_handle,
878 is_focused,
879 start_percentage,
880 end_percentage,
881 start_value,
882 end_value,
883 track_height,
884 thumb_width,
885 thumb_height,
886 track_bg,
887 active_bg,
888 thumb_bg,
889 focus_ring,
890 user_style,
891 ),
892 SliderAxis::Vertical => self.render_vertical(
893 window,
894 theme,
895 focus_handle,
896 is_focused,
897 start_percentage,
898 end_percentage,
899 start_value,
900 end_value,
901 track_height,
902 thumb_width,
903 thumb_height,
904 track_bg,
905 active_bg,
906 thumb_bg,
907 focus_ring,
908 user_style,
909 ),
910 }
911 }
912}
913
914#[cfg(test)]
915mod tests {
916 use super::*;
917
918 #[gpui::test]
919 fn set_min_above_current_max_preserves_range_ordering() {
920 let mut app = TestApp::new();
921 let slider = app.update(|cx| cx.new(RangeSliderState::new));
922
923 app.update(|cx| {
924 slider.update(cx, |state, cx| {
925 state.set_range(40.0, 60.0, cx);
926 state.set_min(110.0, cx);
928 assert!(state.min() <= state.max(), "min must never exceed max");
929 let (start, end) = state.range();
930 assert!(start <= end, "start {start} must not exceed end {end}");
931 assert!(state.min() <= start && end <= state.max());
932 assert_eq!((start, end), (110.0, 110.0));
933 });
934 });
935 }
936
937 #[gpui::test]
938 fn set_max_below_current_min_preserves_range_ordering() {
939 let mut app = TestApp::new();
940 let slider = app.update(|cx| cx.new(RangeSliderState::new));
941
942 app.update(|cx| {
943 slider.update(cx, |state, cx| {
944 state.set_range(40.0, 60.0, cx);
945 state.set_max(-20.0, cx);
947 assert!(state.min() <= state.max(), "min must never exceed max");
948 let (start, end) = state.range();
949 assert!(start <= end, "start {start} must not exceed end {end}");
950 assert_eq!(state.min(), -20.0);
951 assert_eq!((start, end), (-20.0, -20.0));
952 });
953 });
954 }
955}