Skip to main content

fc_ui/capabilities/controls/
range_slider.rs

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    /// Set the minimum. If `min` exceeds the current maximum, the maximum is
46    /// raised to `min`, so the ordering `min <= max` is always preserved. Both
47    /// thumbs are then re-clamped into range with `start <= end` preserved.
48    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    /// Set the maximum. If `max` is below the current minimum, the minimum is
61    /// lowered to `max`, so the ordering `min <= max` is always preserved. Both
62    /// thumbs are then re-clamped into range with `start <= end` preserved.
63    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                                // Keys move the most recently used thumb, defaulting to start.
330                                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                                // Keys move the most recently used thumb, defaulting to start.
609                                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                // 修复前:clamp(min, max) 因 min(110) > max(100) panic
914                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                // 修复前:end_value.clamp(min, max) 因 max(-20) < min(0) panic
933                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}