Skip to main content

fc_ui/capabilities/controls/
range_slider.rs

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    /// Set the minimum. If `min` exceeds the current maximum, the maximum is
43    /// raised to `min`, so the ordering `min <= max` is always preserved. Both
44    /// thumbs are then re-clamped into range with `start <= end` preserved.
45    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    /// Set the maximum. If `max` is below the current minimum, the minimum is
58    /// lowered to `max`, so the ordering `min <= max` is always preserved. Both
59    /// thumbs are then re-clamped into range with `start <= end` preserved.
60    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                                // Keys move the most recently used thumb, defaulting to start.
343                                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                                // Keys move the most recently used thumb, defaulting to start.
622                                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                // 修复前:clamp(min, max) 因 min(110) > max(100) panic
927                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                // 修复前:end_value.clamp(min, max) 因 max(-20) < min(0) panic
946                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}