Skip to main content

gpui_base/
slider.rs

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