Struct rerun::external::eframe::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>

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>(value: &'a mut Num, range: RangeInclusive<Num>) -> Slider<'a>

where Num: Numeric,

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 FnMut(Option<f64>) -> f64 + 'a ) -> Slider<'a>

pub fn show_value(self, show_value: bool) -> Slider<'a>

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

pub fn prefix(self, prefix: impl ToString) -> Slider<'a>

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

pub fn suffix(self, suffix: impl ToString) -> Slider<'a>

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

pub fn text(self, text: impl Into<WidgetText>) -> Slider<'a>

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

pub fn text_color(self, text_color: Color32) -> Slider<'a>

pub fn orientation(self, orientation: SliderOrientation) -> Slider<'a>

Vertical or horizontal slider? The default is horizontal.

pub fn vertical(self) -> Slider<'a>

Make this a vertical slider.

pub fn logarithmic(self, logarithmic: bool) -> Slider<'a>

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) -> Slider<'a>

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) -> Slider<'a>

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) -> Slider<'a>

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) -> Slider<'a>

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

pub fn smart_aim(self, smart_aim: bool) -> Slider<'a>

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

pub fn step_by(self, step: f64) -> Slider<'a>

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) -> Slider<'a>

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) -> Slider<'a>

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) -> Slider<'a>

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>) -> Slider<'a>

pub fn fixed_decimals(self, num_decimals: usize) -> Slider<'a>

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) -> Slider<'a>

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) -> Slider<'a>

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 Fn(f64, RangeInclusive<usize>) -> String + 'a ) -> Slider<'a>

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 Fn(&str) -> Option<f64> + 'a ) -> Slider<'a>

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) -> Slider<'a>

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) -> Slider<'a>

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 ) -> Slider<'a>

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) -> Slider<'a>

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.

Trait Implementations

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

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

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