Struct egui::widgets::slider::Slider

source ·
pub struct Slider<'a> {
Show 17 fields get_set_value: Box<dyn FnMut(Option<f64>) -> f64 + 'a>, range: RangeInclusive<f64>, spec: SliderSpec, clamp_to_range: bool, 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>,
}
Expand description

Control a number with a slider.

The slider range defines the values you get when pulling the slider to the far edges. By default, the slider can still show values outside this range, and still allows users to enter values outside the range by clicking the slider value and editing it. If you want to clamp incoming and outgoing values, use 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§clamp_to_range: bool§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>

Implementations§

source§

impl<'a> Slider<'a>

source

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

Creates a new horizontal slider.

source

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

source

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

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

source

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

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

source

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

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

source

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

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

source

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

source

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

Vertical or horizontal slider? The default is horizontal.

source

pub fn vertical(self) -> Self

Make this a vertical slider.

source

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.

source

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.

source

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.

source

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

If set to true, all incoming and outgoing values will be clamped to the slider range. Default: true.

source

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.

source

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).

source

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.

source

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.

source

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.

source

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.

source

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 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 Visuals, the same as a ProgressBar.

source

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.

See also: DragValue::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
        }
    }));
source

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: DragValue::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
        }
    }));
source

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));
source

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));
source

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));
source

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.

source

fn get_value(&mut self) -> f64

source

fn set_value(&mut self, value: f64)

source

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

source

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

source

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

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

source

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

source§

impl<'a> Slider<'a>

source

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

Just the slider, no text

source

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

Just the slider, no text

source

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

source

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

source

fn position_range(&self, rect: &Rect) -> RangeInclusive<f32>

source

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

source

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

source

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

source

fn value_ui( &mut self, ui: &mut Ui, position_range: RangeInclusive<f32> ) -> Response

source

fn current_gradient(&mut self, position_range: &RangeInclusive<f32>) -> f64

delta(value) / delta(points)

source

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

Trait Implementations§

source§

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

source§

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

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

Auto Trait Implementations§

§

impl<'a> !RefUnwindSafe for Slider<'a>

§

impl<'a> !Send for Slider<'a>

§

impl<'a> !Sync for Slider<'a>

§

impl<'a> Unpin for Slider<'a>

§

impl<'a> !UnwindSafe for Slider<'a>

Blanket Implementations§

source§

impl<T> Any for Twhere T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for Twhere T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for Twhere T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for Twhere U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.