Struct comfy_wgpu::egui::DragValue

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

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

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

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

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

Clamp incoming and outgoing values to this 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.

See also: DragValue::custom_parser

ui.add(egui::DragValue::new(&mut my_i32)
    .clamp_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)
    .clamp_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));

Trait Implementations

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

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

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