Struct egui::widgets::Slider

pub struct Slider<'a> {

    get_set_value: Box<dyn FnMut(Option<f64>) -> f64 + 'a>,
    range: RangeInclusive<f64>,
    spec: SliderSpec,
    clamping: SliderClamping,
    smart_aim: bool,
    show_value: bool,
    orientation: SliderOrientation,
    prefix: String,
    suffix: String,
    text: WidgetText,
    step: Option<f64>,
    drag_value_speed: Option<f64>,
    min_decimals: usize,
    max_decimals: Option<usize>,
    custom_formatter: Option<Box<dyn Fn(f64, RangeInclusive<usize>) -> String + 'a>>,
    custom_parser: Option<Box<dyn Fn(&str) -> Option<f64> + 'a>>,
    trailing_fill: Option<bool>,
    handle_shape: Option<HandleShape>,
}

Control a number with a slider.

The slider range defines the values you get when pulling the slider to the far edges. By default all values are clamped to this range, even when not interacted with. You can change this behavior by passing false to Slider::clamp_to_range.

The range can include any numbers, and go from low-to-high or from high-to-low.

The slider consists of three parts: a slider, a value display, and an optional text. The user can click the value display to edit its value. It can be turned off with .show_value(false).

ui.add(egui::Slider::new(&mut my_f32, 0.0..=100.0).text("My value"));

The default Slider size is set by crate::style::Spacing::slider_width.

Fields

get_set_value: Box<dyn FnMut(Option<f64>) -> f64 + 'a>

range: RangeInclusive<f64>

spec: SliderSpec

clamping: SliderClamping

smart_aim: bool

show_value: bool

orientation: SliderOrientation

prefix: String

suffix: String

text: WidgetText

step: Option<f64>

Sets the minimal step of the widget value

drag_value_speed: Option<f64>

min_decimals: usize

max_decimals: Option<usize>

custom_formatter: Option<Box<dyn Fn(f64, RangeInclusive<usize>) -> String + 'a>>

custom_parser: Option<Box<dyn Fn(&str) -> Option<f64> + 'a>>

trailing_fill: Option<bool>

handle_shape: Option<HandleShape>

Implementations

impl<'a> Slider<'a>

pub fn new<Num: Numeric>(value: &'a mut Num, range: RangeInclusive<Num>) -> Self

Creates a new horizontal slider.

The value given will be clamped to the range, unless you change this behavior with Self::clamping.

pub fn from_get_set( range: RangeInclusive<f64>, get_set_value: impl 'a + FnMut(Option<f64>) -> f64, ) -> Self

pub fn show_value(self, show_value: bool) -> Self

Control whether or not the slider shows the current value. Default: true.

pub fn prefix(self, prefix: impl ToString) -> Self

Show a prefix before the number, e.g. “x: “

pub fn suffix(self, suffix: impl ToString) -> Self

Add a suffix to the number, this can be e.g. a unit (“°” or “ m“)

pub fn text(self, text: impl Into<WidgetText>) -> Self

Show a text next to the slider (e.g. explaining what the slider controls).

pub fn text_color(self, text_color: Color32) -> Self

pub fn orientation(self, orientation: SliderOrientation) -> Self

Vertical or horizontal slider? The default is horizontal.

pub fn vertical(self) -> Self

Make this a vertical slider.

pub fn logarithmic(self, logarithmic: bool) -> Self

Make this a logarithmic slider. This is great for when the slider spans a huge range, e.g. from one to a million. The default is OFF.

pub fn smallest_positive(self, smallest_positive: f64) -> Self

For logarithmic sliders that includes zero: what is the smallest positive value you want to be able to select? The default is 1 for integer sliders and 1e-6 for real sliders.

pub fn largest_finite(self, largest_finite: f64) -> Self

For logarithmic sliders, the largest positive value we are interested in before the slider switches to INFINITY, if that is the higher end. Default: INFINITY.

pub fn clamping(self, clamping: SliderClamping) -> Self

Controls when the values will be clamped to the range.

With .clamping(SliderClamping::Always) (default)

let mut my_value: f32 = 1337.0;
ui.add(egui::Slider::new(&mut my_value, 0.0..=1.0));
assert!(0.0 <= my_value && my_value <= 1.0, "Existing value should be clamped");

With .clamping(SliderClamping::Edits)

let mut my_value: f32 = 1337.0;
let response = ui.add(
    egui::Slider::new(&mut my_value, 0.0..=1.0)
        .clamping(egui::SliderClamping::Edits)
);
if response.dragged() {
    // The user edited the value, so it should now be clamped to the range
    assert!(0.0 <= my_value && my_value <= 1.0);
}

With .clamping(SliderClamping::Never)

let mut my_value: f32 = 1337.0;
let response = ui.add(
    egui::Slider::new(&mut my_value, 0.0..=1.0)
        .clamping(egui::SliderClamping::Never)
);
// The user could have set the value to anything

pub fn clamp_to_range(self, clamp_to_range: bool) -> Self

👎Deprecated: Use `slider.clamping(…) instead

pub fn smart_aim(self, smart_aim: bool) -> Self

Turn smart aim on/off. Default is ON. There is almost no point in turning this off.

pub fn step_by(self, step: f64) -> Self

Sets the minimal change of the value.

Value 0.0 effectively disables the feature. If the new value is out of range and clamp_to_range is enabled, you would not have the ability to change the value.

Default: 0.0 (disabled).

pub fn drag_value_speed(self, drag_value_speed: f64) -> Self

When dragging the value, how fast does it move?

Unit: values per point (logical pixel). See also DragValue::speed.

By default this is the same speed as when dragging the slider, but you can change it here to for instance have a much finer control by dragging the slider value rather than the slider itself.

pub fn min_decimals(self, min_decimals: usize) -> Self

Set a minimum number of decimals to display.

Normally you don’t need to pick a precision, as the slider will intelligently pick a precision for you. Regardless of precision the slider will use “smart aim” to help the user select nice, round values.

pub fn max_decimals(self, max_decimals: usize) -> Self

Set a maximum number of decimals to display.

Values will also be rounded to this number of decimals. Normally you don’t need to pick a precision, as the slider will intelligently pick a precision for you. Regardless of precision the slider will use “smart aim” to help the user select nice, round values.

pub fn max_decimals_opt(self, max_decimals: Option<usize>) -> Self

pub fn fixed_decimals(self, num_decimals: usize) -> Self

Set an exact number of decimals to display.

Values will also be rounded to this number of decimals. Normally you don’t need to pick a precision, as the slider will intelligently pick a precision for you. Regardless of precision the slider will use “smart aim” to help the user select nice, round values.

pub fn trailing_fill(self, trailing_fill: bool) -> Self

Display trailing color behind the slider’s circle. Default is OFF.

This setting can be enabled globally for all sliders with crate::Visuals::slider_trailing_fill. Toggling it here will override the above setting ONLY for this individual slider.

The fill color will be taken from selection.bg_fill in your crate::Visuals, the same as a crate::ProgressBar.

pub fn handle_shape(self, handle_shape: HandleShape) -> Self

Change the shape of the slider handle

This setting can be enabled globally for all sliders with crate::Visuals::handle_shape. Changing it here will override the above setting ONLY for this individual slider.

pub fn custom_formatter( self, formatter: impl 'a + Fn(f64, RangeInclusive<usize>) -> String, ) -> Self

Set custom formatter defining how numbers are converted into text.

A custom formatter takes a f64 for the numeric value and a RangeInclusive<usize> representing the decimal range i.e. minimum and maximum number of decimal places shown.

The default formatter is crate::Style::number_formatter.

See also: Slider::custom_parser

ui.add(egui::Slider::new(&mut my_i32, 0..=((60 * 60 * 24) - 1))
    .custom_formatter(|n, _| {
        let n = n as i32;
        let hours = n / (60 * 60);
        let mins = (n / 60) % 60;
        let secs = n % 60;
        format!("{hours:02}:{mins:02}:{secs:02}")
    })
    .custom_parser(|s| {
        let parts: Vec<&str> = s.split(':').collect();
        if parts.len() == 3 {
            parts[0].parse::<i32>().and_then(|h| {
                parts[1].parse::<i32>().and_then(|m| {
                    parts[2].parse::<i32>().map(|s| {
                        ((h * 60 * 60) + (m * 60) + s) as f64
                    })
                })
            })
            .ok()
        } else {
            None
        }
    }));

pub fn custom_parser(self, parser: impl 'a + Fn(&str) -> Option<f64>) -> Self

Set custom parser defining how the text input is parsed into a number.

A custom parser takes an &str to parse into a number and returns Some if it was successfully parsed or None otherwise.

See also: Slider::custom_formatter

ui.add(egui::Slider::new(&mut my_i32, 0..=((60 * 60 * 24) - 1))
    .custom_formatter(|n, _| {
        let n = n as i32;
        let hours = n / (60 * 60);
        let mins = (n / 60) % 60;
        let secs = n % 60;
        format!("{hours:02}:{mins:02}:{secs:02}")
    })
    .custom_parser(|s| {
        let parts: Vec<&str> = s.split(':').collect();
        if parts.len() == 3 {
            parts[0].parse::<i32>().and_then(|h| {
                parts[1].parse::<i32>().and_then(|m| {
                    parts[2].parse::<i32>().map(|s| {
                        ((h * 60 * 60) + (m * 60) + s) as f64
                    })
                })
            })
            .ok()
        } else {
            None
        }
    }));

pub fn binary(self, min_width: usize, twos_complement: bool) -> Self

Set custom_formatter and custom_parser to display and parse numbers as binary integers. Floating point numbers are not supported.

min_width specifies the minimum number of displayed digits; if the number is shorter than this, it will be prefixed with additional 0s to match min_width.

If twos_complement is true, negative values will be displayed as the 2’s complement representation. Otherwise they will be prefixed with a ‘-’ sign.

Panics

Panics if min_width is 0.

ui.add(egui::Slider::new(&mut my_i32, -100..=100).binary(64, false));

pub fn octal(self, min_width: usize, twos_complement: bool) -> Self

Set custom_formatter and custom_parser to display and parse numbers as octal integers. Floating point numbers are not supported.

min_width specifies the minimum number of displayed digits; if the number is shorter than this, it will be prefixed with additional 0s to match min_width.

If twos_complement is true, negative values will be displayed as the 2’s complement representation. Otherwise they will be prefixed with a ‘-’ sign.

Panics

Panics if min_width is 0.

ui.add(egui::Slider::new(&mut my_i32, -100..=100).octal(22, false));

pub fn hexadecimal( self, min_width: usize, twos_complement: bool, upper: bool, ) -> Self

Set custom_formatter and custom_parser to display and parse numbers as hexadecimal integers. Floating point numbers are not supported.

min_width specifies the minimum number of displayed digits; if the number is shorter than this, it will be prefixed with additional 0s to match min_width.

If twos_complement is true, negative values will be displayed as the 2’s complement representation. Otherwise they will be prefixed with a ‘-’ sign.

Panics

Panics if min_width is 0.

ui.add(egui::Slider::new(&mut my_i32, -100..=100).hexadecimal(16, false, true));

pub fn integer(self) -> Self

Helper: equivalent to self.precision(0).smallest_positive(1.0). If you use one of the integer constructors (e.g. Slider::i32) this is called for you, but if you want to have a slider for picking integer values in an Slider::f64, use this.

fn get_value(&mut self) -> f64

fn set_value(&mut self, value: f64)

fn range(&self) -> RangeInclusive<f64>

fn value_from_position(&self, position: f32, position_range: Rangef) -> f64

For instance, position is the mouse position and position_range is the physical location of the slider on the screen.

fn position_from_value(&self, value: f64, position_range: Rangef) -> f32

impl<'a> Slider<'a>

fn allocate_slider_space(&self, ui: &mut Ui, thickness: f32) -> Response

Just the slider, no text

fn slider_ui(&mut self, ui: &Ui, response: &Response)

Just the slider, no text

fn marker_center(&self, position_1d: f32, rail_rect: &Rect) -> Pos2

fn pointer_position(&self, pointer_position_2d: Pos2) -> f32

fn position_range(&self, rect: &Rect, handle_shape: &HandleShape) -> Rangef

fn rail_rect(&self, rect: &Rect, radius: f32) -> Rect

fn handle_radius(&self, rect: &Rect) -> f32

fn value_ui(&mut self, ui: &mut Ui, position_range: Rangef) -> Response

fn current_gradient(&mut self, position_range: Rangef) -> f64

delta(value) / delta(points)

fn add_contents(&mut self, ui: &mut Ui) -> Response

Trait Implementations

impl<'a> Widget for Slider<'a>

fn ui(self, ui: &mut Ui) -> Response

Allocate space, interact, paint, and return a Response.