Struct DragValue 

pub struct DragValue<'a> { /* private fields */ }

A numeric value that you can change by dragging the number. More compact than a crate::Slider.

ui.add(egui::DragValue::new(&mut my_f32).speed(0.1));

Implementations

impl<'a> DragValue<'a>

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

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

pub fn speed(self, speed: impl Into<f64>) -> Self

How much the value changes when dragged one point (logical pixel).

Should be finite and greater than zero.

pub fn range<Num: Numeric>(self, range: RangeInclusive<Num>) -> Self

Sets valid range for dragging the value.

By default all values are clamped to this range, even when not interacted with. You can change this behavior by passing false to Self::clamp_existing_to_range.

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

If set to true, existing values will be clamped to Self::range.

If false, only values entered by the user (via dragging or text editing) will be clamped to the range.

Without calling range

let mut my_value: f32 = 1337.0;
ui.add(egui::DragValue::new(&mut my_value));
assert_eq!(my_value, 1337.0, "No range, no clamp");

With .clamp_existing_to_range(true) (default)

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

With .clamp_existing_to_range(false)

let mut my_value: f32 = 1337.0;
let response = ui.add(
    egui::DragValue::new(&mut my_value).range(0.0..=1.0)
        .clamp_existing_to_range(false)
);
if response.dragged() {
    // The user edited the value, so it should be clamped to the range
    assert!(0.0 <= my_value && my_value <= 1.0);
} else {
    // The user didn't edit, so our original value should still be here:
    assert_eq!(my_value, 1337.0);
}

pub fn prefix(self, prefix: impl IntoAtoms<'a>) -> Self

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

pub fn suffix(self, suffix: impl IntoAtoms<'a>) -> Self

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

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 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: DragValue::custom_parser

ui.add(egui::DragValue::new(&mut my_i32)
    .range(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 a f64 if it was successfully parsed or None otherwise.

See also: DragValue::custom_formatter

ui.add(egui::DragValue::new(&mut my_i32)
    .range(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::DragValue::new(&mut my_i32).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::DragValue::new(&mut my_i32).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::DragValue::new(&mut my_i32).hexadecimal(16, false, true));

pub fn update_while_editing(self, update: bool) -> Self

Update the value on each key press when text-editing the value.

Default: true. If false, the value will only be updated when user presses enter or deselects the value.

pub fn atoms(&self) -> &Atoms<'a>

Output the DragValue’s Atoms.

This includes any images you have on the DragValue.

Trait Implementations

impl Widget for DragValue<'_>

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

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

fn boxed<'a>(self) -> BoxedWidget<'a>

where Self: Sized + 'a,

Box this widget for dynamic dispatch.