Struct rerun::external::eframe::egui::widgets::DragValue

pub struct DragValue<'a> {
    get_set_value: Box<dyn FnMut(Option<f64>) -> f64 + 'a>,
    speed: f64,
    prefix: String,
    suffix: String,
    range: RangeInclusive<f64>,
    clamp_existing_to_range: bool,
    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>>,
    update_while_editing: bool,
}

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

Fields

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

speed: f64

prefix: String

suffix: String

range: RangeInclusive<f64>

clamp_existing_to_range: bool

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

update_while_editing: bool

Implementations

impl<'a> DragValue<'a>

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

where Num: Numeric,

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

pub fn speed(self, speed: impl Into<f64>) -> DragValue<'a>

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

Should be finite and greater than zero.

pub fn clamp_range<Num>(self, range: RangeInclusive<Num>) -> DragValue<'a>

where Num: Numeric,

👎Deprecated: Use range instead

Sets valid range for 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 range<Num>(self, range: RangeInclusive<Num>) -> DragValue<'a>

where Num: Numeric,

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

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 clamp_to_range(self, clamp_to_range: bool) -> DragValue<'a>

👎Deprecated: Renamed clamp_existing_to_range

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

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

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

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

pub fn min_decimals(self, min_decimals: usize) -> DragValue<'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) -> DragValue<'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>) -> DragValue<'a>

pub fn fixed_decimals(self, num_decimals: usize) -> DragValue<'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 custom_formatter( self, formatter: impl Fn(f64, RangeInclusive<usize>) -> String + 'a ) -> DragValue<'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: 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 Fn(&str) -> Option<f64> + 'a ) -> DragValue<'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 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) -> DragValue<'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::DragValue::new(&mut my_i32).binary(64, false));

pub fn octal(self, min_width: usize, twos_complement: bool) -> DragValue<'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::DragValue::new(&mut my_i32).octal(22, false));

pub fn hexadecimal( self, min_width: usize, twos_complement: bool, upper: bool ) -> DragValue<'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::DragValue::new(&mut my_i32).hexadecimal(16, false, true));

pub fn update_while_editing(self, update: bool) -> DragValue<'a>

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.

Trait Implementations

impl<'a> Widget for DragValue<'a>

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

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