Enum Value 

pub enum Value {
    Bool(bool),
    Number(f32),
    Choice(usize, String),
    Text(String),
}

A value carried by a UI event or stored in a menu item.

Variants

Bool(bool)

Checkbox state.

Number(f32)

Slider value.

Choice(usize, String)

Selected option of a choice: index and text.

Text(String)

Text field contents.

Implementations

impl Value

pub fn as_bool(&self) -> bool

The value as bool. Numbers are true when not zero, text when not empty.

pub fn as_f32(&self) -> f32

The value as number (choices give their index, text is parsed, bool gives 0 or 1).

Examples found in repository

examples/menus.rs (line 70)

    fn on_ui(&mut self, event: &UiEvent, ctx: &mut Context) {
        match event {
            UiEvent::Activated { menu, item } => match (menu.as_str(), item.as_str()) {
                ("main", "play") => {
                    let s = ctx.get::<Settings>().expect("settings exist");
                    let text = format!("Good luck, {}! (this is where your game would start)", s.name);
                    ctx.ui.message("intro", text);
                }
                ("main", "options") => {
                    let menu = options_menu(ctx.get::<Settings>().expect("settings exist"));
                    ctx.ui.open(menu);
                }
                ("main", "name") => ctx.ui.open(TextInput::new("name", "Enter your name").max_length(20).required()),
                ("main", "quit") => ctx.ui.open(Confirm::new("quit", "Do you really want to quit?").default_no()),
                ("options", "back") => ctx.ui.close(),
                _ => {}
            },
            UiEvent::Changed { menu, item, value } if menu == "options" => {
                let s = ctx.get_mut::<Settings>().expect("settings exist");
                match item.as_str() {
                    "volume" => s.volume = value.as_f32() / 100.0,
                    "difficulty" => s.difficulty = value.as_index(),
                    "name" => s.name = value.as_str().to_string(),
                    _ => {}
                }
                let volume = s.volume;
                ctx.audio.set_master_volume(volume);
            }
            UiEvent::TextSubmitted { id, text } if id == "name" => {
                ctx.get_mut::<Settings>().expect("settings exist").name = text.clone();
                ctx.speech.speak_queued(format!("Hello, {text}"));
            }
            UiEvent::Confirmed { id, yes: true } if id == "quit" => ctx.quit(),
            _ => {}
        }
    }

examples/bell_catcher.rs (line 136)

    fn on_ui(&mut self, event: &UiEvent, ctx: &mut Context) {
        match event {
            UiEvent::Activated { menu, item } if menu == "title" => match item.as_str() {
                "play" => {
                    ctx.ui.close_all();
                    ctx.switch_scene(Game::default());
                }
                "voice" => match voice_menu(ctx) {
                    Some(menu) => ctx.ui.open(menu),
                    None => ctx.ui.message(
                        "no voices",
                        "Your screen reader speaks with its own voice. Change it in the screen reader's settings.",
                    ),
                },
                "help" => ctx.ui.message(
                    "help",
                    "Bells fall in one of seven lanes in front of you. Listen where a bell rings, \
                     step under it with left and right, and catch it before it lands. \
                     The bell rings faster and higher the closer it gets. You have three lives. \
                     Press S for your score, Escape for the menu.",
                ),
                "quit" => ctx.quit(),
                _ => {}
            },
            UiEvent::Activated { menu, item } if menu == "voices" => {
                if item == "back" {
                    ctx.ui.close();
                    return;
                }
                if item == "default" {
                    ctx.speech.reset_voice();
                    ctx.storage.remove("voice");
                } else if let Some(voice) =
                    item.strip_prefix("voice").and_then(|i| i.parse::<usize>().ok()).and_then(|i| ctx.speech.voices().get(i).cloned())
                    && ctx.speech.set_voice(&voice.id)
                {
                    ctx.storage.set("voice", &voice.id);
                }
                ctx.ui.close();
                refresh_title(ctx, "voice");
                let name = ctx.speech.voice().map_or("Default voice".to_string(), |v| v.name.clone());
                ctx.speech.speak_queued(format!("{name}. This is how I sound now."));
            }
            UiEvent::Changed { menu, item, value } if menu == "title" && item == "rate" => {
                ctx.speech.set_rate(value.as_f32() / 100.0);
                ctx.storage.set("rate", value.as_f32());
            }
            _ => {}
        }
    }

pub fn as_index(&self) -> usize

The value as index (for choices) or rounded number.

Examples found in repository

examples/menus.rs (line 71)

    fn on_ui(&mut self, event: &UiEvent, ctx: &mut Context) {
        match event {
            UiEvent::Activated { menu, item } => match (menu.as_str(), item.as_str()) {
                ("main", "play") => {
                    let s = ctx.get::<Settings>().expect("settings exist");
                    let text = format!("Good luck, {}! (this is where your game would start)", s.name);
                    ctx.ui.message("intro", text);
                }
                ("main", "options") => {
                    let menu = options_menu(ctx.get::<Settings>().expect("settings exist"));
                    ctx.ui.open(menu);
                }
                ("main", "name") => ctx.ui.open(TextInput::new("name", "Enter your name").max_length(20).required()),
                ("main", "quit") => ctx.ui.open(Confirm::new("quit", "Do you really want to quit?").default_no()),
                ("options", "back") => ctx.ui.close(),
                _ => {}
            },
            UiEvent::Changed { menu, item, value } if menu == "options" => {
                let s = ctx.get_mut::<Settings>().expect("settings exist");
                match item.as_str() {
                    "volume" => s.volume = value.as_f32() / 100.0,
                    "difficulty" => s.difficulty = value.as_index(),
                    "name" => s.name = value.as_str().to_string(),
                    _ => {}
                }
                let volume = s.volume;
                ctx.audio.set_master_volume(volume);
            }
            UiEvent::TextSubmitted { id, text } if id == "name" => {
                ctx.get_mut::<Settings>().expect("settings exist").name = text.clone();
                ctx.speech.speak_queued(format!("Hello, {text}"));
            }
            UiEvent::Confirmed { id, yes: true } if id == "quit" => ctx.quit(),
            _ => {}
        }
    }

pub fn as_str(&self) -> &str

The value as text.

Examples found in repository

examples/menus.rs (line 72)

    fn on_ui(&mut self, event: &UiEvent, ctx: &mut Context) {
        match event {
            UiEvent::Activated { menu, item } => match (menu.as_str(), item.as_str()) {
                ("main", "play") => {
                    let s = ctx.get::<Settings>().expect("settings exist");
                    let text = format!("Good luck, {}! (this is where your game would start)", s.name);
                    ctx.ui.message("intro", text);
                }
                ("main", "options") => {
                    let menu = options_menu(ctx.get::<Settings>().expect("settings exist"));
                    ctx.ui.open(menu);
                }
                ("main", "name") => ctx.ui.open(TextInput::new("name", "Enter your name").max_length(20).required()),
                ("main", "quit") => ctx.ui.open(Confirm::new("quit", "Do you really want to quit?").default_no()),
                ("options", "back") => ctx.ui.close(),
                _ => {}
            },
            UiEvent::Changed { menu, item, value } if menu == "options" => {
                let s = ctx.get_mut::<Settings>().expect("settings exist");
                match item.as_str() {
                    "volume" => s.volume = value.as_f32() / 100.0,
                    "difficulty" => s.difficulty = value.as_index(),
                    "name" => s.name = value.as_str().to_string(),
                    _ => {}
                }
                let volume = s.volume;
                ctx.audio.set_master_volume(volume);
            }
            UiEvent::TextSubmitted { id, text } if id == "name" => {
                ctx.get_mut::<Settings>().expect("settings exist").name = text.clone();
                ctx.speech.speak_queued(format!("Hello, {text}"));
            }
            UiEvent::Confirmed { id, yes: true } if id == "quit" => ctx.quit(),
            _ => {}
        }
    }

pub fn to_text(&self) -> String

The value formatted for speaking.

Trait Implementations

impl Clone for Value

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Value

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for Value

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Value