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