Struct egui::widgets::drag_value::DragValue

source ·
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,
}
Expand description

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§

source§

impl<'a> DragValue<'a>

source

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

source

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

source

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.

source

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

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

source

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.

source

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

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

👎Deprecated: Renamed clamp_existing_to_range
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 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 max_decimals_opt(self, max_decimals: Option<usize>) -> Self

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 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
        }
    }));
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 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
        }
    }));
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::DragValue::new(&mut my_i32).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::DragValue::new(&mut my_i32).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::DragValue::new(&mut my_i32).hexadecimal(16, false, true));
source

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.

Trait Implementations§

source§

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

source§

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

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

Auto Trait Implementations§

§

impl<'a> Freeze for DragValue<'a>

§

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

§

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

§

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

§

impl<'a> Unpin for DragValue<'a>

§

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

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where 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 T
where 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 T
where 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 T
where 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.