Struct ValText 

pub struct ValText<T, E> { /* private fields */ }

A mutable TextBuffer that will validate it’s contents when changed.
And check an input before adding it to the text.

The default validator will simply attempt to parse the text as T, but a custom validator function can be provided.

Usage

use egui_typed_input::ValText;

let mut alphabetical_order: ValText<Vec<char>, ()> = ValText::new(
    // parser
    (|str| Ok(str.chars().collect::<Vec<_>>())),
    // input validator
    (|current_text, input, index| {
        if input.chars().all(|c| c.is_ascii_alphabetic()) {
            input.chars().all(|c| {
                c.to_ascii_lowercase() >= current_text.chars().skip(index.saturating_sub(1)).take(1).last().unwrap_or('a')
            })
        } else { false }
    }),
);

ui.text_edit_singleline(&mut alphabetical_order);
println!("alphabetical_order: {:?}", alphabetical_order.get_val());

See hex color example (color_hex.rs) and number examples (number.rs) for more

Implementations

impl ValText<Color32, ParseHexColorError>

pub fn color_hex() -> Self

A hex color starting with #, parsed using Color32::from_hex.
Supports the 3, 4, 6, and 8-digit formats.

impl<T: FromStr> ValText<T, T::Err>

pub fn number() -> Self

Only allows (0,1,2,3,4,5,6,7,8,9,.) and (-,+) at the beginning

pub fn number_int() -> Self

Only allows (0,1,2,3,4,5,6,7,8,9) and (-,+) at the beginning

pub fn number_uint() -> Self

Only allows (0,1,2,3,4,5,6,7,8,9) and (+) at the beginning

impl ValText<f64, PercentageParseError>

pub fn percentage() -> Self

A numarical percentage in the range of 0-100.
Only allows (0,1,2,3,4,5,6,7,8,9,.) and (+) at the beginning

impl ValText<f32, PercentageParseError>

pub fn percentage() -> Self

A numarical percentage in the range of 0-100.
Only allows (0,1,2,3,4,5,6,7,8,9,.) and (+) at the beginning

impl ValText<u32, PercentageParseError>

pub fn percentage_uint() -> Self

A numarical percentage in the range of 0-100.
Only allows (0,1,2,3,4,5,6,7,8,9) and (+) at the beginning

impl<T, E> ValText<T, E>

pub fn new( value_parser: impl Fn(&str) -> Result<T, E> + 'static, input_validator: impl Fn(&str, &str, usize) -> bool + 'static, ) -> Self

pub fn new_box( value_parser: Box<dyn Fn(&str) -> Result<T, E>>, input_validator: Box<dyn Fn(&str, &str, usize) -> bool>, ) -> Self

pub fn with_parser(validator: impl Fn(&str) -> Result<T, E> + 'static) -> Self

pub fn with_parser_fixed_charset( parser: impl Fn(&str) -> Result<T, E> + 'static, charset: &'static [char], ) -> Self

Only chars in charset can be input

Usage

ValText::with_parser_fixed_charset(|str| Ok(str.to_owned()), &['a', 'c']);

Would allow ‘a’ and ‘c’ but no others.

pub const fn get_val(&self) -> Option<Result<&T, &E>>

ValText must be used before getting value

pub fn is_valid(&self) -> bool

impl<T: FromStr> ValText<Option<T>, T::Err>

pub fn option_parse() -> Self

impl<T: Display, E> ValText<T, E>

pub fn set_val(&mut self, val: T)

Trait Implementations

impl<T: FromStr> Default for ValText<T, T::Err>

fn default() -> Self

Parse the text using FromStr

impl<T: 'static, E> TextBuffer for ValText<T, E>

fn is_mutable(&self) -> bool

Can this text be edited?

fn as_str(&self) -> &str

Returns this buffer as a str.

fn insert_text(&mut self, text: &str, char_index: usize) -> usize

Inserts text text into this buffer at character index char_index.

fn delete_char_range(&mut self, char_range: Range<usize>)

Deletes a range of text char_range from this buffer.

fn clear(&mut self)

Clears all characters in this buffer

fn take(&mut self) -> String

Clears all characters in this buffer and returns a string of the contents.

fn type_id(&self) -> TypeId

Returns a unique identifier for the implementing type.

fn char_range(&self, char_range: Range<usize>) -> &str

Reads the given character range.

fn byte_index_from_char_index(&self, char_index: usize) -> usize

fn char_index_from_byte_index(&self, char_index: usize) -> usize

fn replace_with(&mut self, text: &str)

Replaces all contents of this string with text

fn insert_text_at( &mut self, ccursor: &mut CCursor, text_to_insert: &str, char_limit: usize, )

fn decrease_indentation(&mut self, ccursor: &mut CCursor)

fn delete_selected(&mut self, cursor_range: &CCursorRange) -> CCursor

fn delete_selected_ccursor_range(&mut self, _: [CCursor; 2]) -> CCursor

fn delete_previous_char(&mut self, ccursor: CCursor) -> CCursor

fn delete_next_char(&mut self, ccursor: CCursor) -> CCursor

fn delete_previous_word(&mut self, max_ccursor: CCursor) -> CCursor

fn delete_next_word(&mut self, min_ccursor: CCursor) -> CCursor

fn delete_paragraph_before_cursor( &mut self, galley: &Galley, cursor_range: &CCursorRange, ) -> CCursor

fn delete_paragraph_after_cursor( &mut self, galley: &Galley, cursor_range: &CCursorRange, ) -> CCursor