Enum Button 

#[repr(u8)]
pub enum Button {
    B0 = 0,
    B1 = 1,
    B2 = 2,
    B3 = 3,
    B4 = 4,
    B5 = 5,
    B6 = 6,
    B7 = 7,
    B8 = 8,
    B9 = 9,
}

One of the 10 top buttons.

Button 0 is the top left. 4 is the top right. 5 is the bottom left and 9 is the bottom right. (English lexographical order).

Represented visually:

0 1 2 3 4
5 6 7 8 9

Variants

B0 = 0

Row::Top, Column::C0

B1 = 1

Row::Top, Column::C1

B2 = 2

Row::Top, Column::C2

B3 = 3

Row::Top, Column::C3

B4 = 4

Row::Top, Column::C4

B5 = 5

Row::Bottom, Column::C0

B6 = 6

Row::Bottom, Column::C1

B7 = 7

Row::Bottom, Column::C2

B8 = 8

Row::Bottom, Column::C3

B9 = 9

Row::Bottom, Column::C4

Implementations

impl Button

pub const COUNT: usize = 10

The number of light-up buttons on top of Boppo.

pub const fn from_index(index: usize) -> Button

Converts an index to its corresponding Button.

Panics

This function will panic if index >= Button::COUNT.

Examples

let button = Button::from_index(6);
assert_eq!(button, Button::B6);

// Panic!
let button = Button::from_index(100);

pub const fn from_row_col(row: Row, col: Column) -> Button

Returns the Button at row, col.

pub fn random() -> Button

Returns a random Button.

See also Buttons::choose_n_randomly() and Buttons::choose_one_randomly().

pub const fn index(self) -> usize

Returns this button’s index.

Examples found in repository

examples/features.rs (line 136)

fn print_event(event: ButtonEvent) {
    let action = if event.is_pressed() {
        "pressed"
    } else {
        "released"
    };
    println!("tablet event: button {} {action}", event.button().index());
}

pub const fn row(self) -> Row

Returns this button’s Row.

pub const fn col(self) -> Column

Returns this button’s Column.

pub const fn next_clockwise(self) -> Button

Return the button clockwise of this button

Examples

assert_eq!(Button::B3.next_clockwise(), Button::B4);
assert_eq!(Button::B4.next_clockwise(), Button::B9);
assert_eq!(Button::B5.next_clockwise(), Button::B0);
assert_eq!(Button::B9.next_clockwise(), Button::B8);

pub const fn next_counterclockwise(self) -> Button

Return the button counterclockwise of this button

Examples

assert_eq!(Button::B1.next_counterclockwise(), Button::B0);
assert_eq!(Button::B8.next_counterclockwise(), Button::B9);
assert_eq!(Button::B0.next_counterclockwise(), Button::B5);
assert_eq!(Button::B9.next_counterclockwise(), Button::B4);

pub const fn above(self) -> Option<Button>

The button above this one (if any)

pub const fn below(self) -> Option<Button>

The button below this one (if any)

pub const fn left(self) -> Option<Button>

The button to the left of this one (if any)

pub const fn right(self) -> Option<Button>

The button to the right of this one (if any)

pub const fn rotate_180(self) -> Button

Return the button where this button would be if Boppo is rotated 180 degrees around its center

pub const fn to_buttons(self) -> Buttons

Returns a Buttons with only this button selected.

pub const fn to_lights(self) -> Lights

Returns a Lights with only this button’s lights selected.

pub fn set_color(self, color: Rgb<u8>)

Sets this button’s lights to color.

This function sets the lights immediately, if you want to modify many lights’ or buttons’ colors at once, consider using Framebuffer.

Examples found in repository

examples/simple.rs (line 25)

async fn main() {
    if env::args().len() != 3 {
        panic!("usage: simple <hostname> <password>");
    }
    let url = env::args().nth(1).unwrap();
    let password = env::args().nth(2).unwrap();
    connect_and_setup_globals(&url, &password)
        .await
        .expect("failed to connect");

    let mut button_events = ButtonEvents::subscribe();
    loop {
        let event = button_events.next().await;
        if event.is_pressed() {
            event.button().set_color(color::BLUE);
            stop_all_sounds().await.ok();
            play("/effects/snare.qoa").await.ok();
        } else {
            event.button().set_color(color::OFF);
        }
    }
}

examples/features.rs (line 36)

async fn main() {
    if env::args().len() != 3 {
        panic!("usage: features <hostname> <password>");
    }
    let url = env::args().nth(1).unwrap();
    let password = env::args().nth(2).unwrap();
    println!("Connecting to {url:?} ...");
    connect_and_setup_globals(&url, &password)
        .await
        .expect("failed to connect");
    println!("Connected!");

    const FLASH_BUTTON: Button = Button::B0;
    const PRESS_LIGHT_BUTTON: Button = Button::B1;
    const SFX_SIMPLE_BUTTON: Button = Button::B5;
    const SFX_WAIT_BUTTON: Button = Button::B6;
    const SFX_ERROR_BUTTON: Button = Button::B7;
    const STOP_ALL_SOUNDS_BUTTON: Button = Button::B8;
    const SLEEP_BUTTON: Button = Button::B9;

    const PAUSE_BUTTON: Button = Button::B2;
    const SPEED_CHANGE_BUTTON: Button = Button::B3;
    const VOLUME_CHANGE_BUTTON: Button = Button::B4;

    SFX_SIMPLE_BUTTON.set_color(color::ORANGE);
    SFX_WAIT_BUTTON.set_color(color::ORANGE);
    SFX_ERROR_BUTTON.set_color(color::RED);
    PAUSE_BUTTON.set_color(color::GREEN);
    SPEED_CHANGE_BUTTON.set_color(color::PURPLE);
    VOLUME_CHANGE_BUTTON.set_color(color::YELLOW);
    STOP_ALL_SOUNDS_BUTTON.set_color(color::WHITE);
    SLEEP_BUTTON.set_color(color::GREY);

    tokio::spawn(async move {
        let mut button_events = ButtonEvents::subscribe();
        let music_controller =
            play_with_controller(SoundBuilder::file("music/Being_Me.mp3").repeat_forever())
                .await
                .unwrap();

        music_controller.set_paused(true);

        let mut paused = true;
        let mut volume = 1.0;
        let mut speed = 1.0;

        loop {
            let event = button_events.next().await;
            print_event(event);
            let button = event.button();
            if event.is_released() && button != PRESS_LIGHT_BUTTON {
                continue;
            }
            match button {
                PRESS_LIGHT_BUTTON => {
                    let color = if event.is_pressed() {
                        color::RED
                    } else {
                        color::OFF
                    };
                    PRESS_LIGHT_BUTTON.set_color(color);
                }
                SFX_SIMPLE_BUTTON => {
                    play("/effects/success.qoa").await.ok();
                }
                SFX_ERROR_BUTTON => {
                    play("/effects/MISSING_SOUND_FOR_ERROR.qoa").await.ok();
                }
                SFX_WAIT_BUTTON => {
                    let controller = play_with_controller("music/add_music_instructions.mp3")
                        .await
                        .unwrap();
                    SFX_WAIT_BUTTON.set_color(color::BLUE);
                    tokio::spawn(async move {
                        controller.wait_until_finished().await;
                        SFX_WAIT_BUTTON.set_color(color::ORANGE);
                    });
                }
                PAUSE_BUTTON => {
                    paused = !paused;
                    let color = if paused { color::GREEN } else { color::RED };
                    PAUSE_BUTTON.set_color(color);
                    music_controller.set_paused(paused);
                }
                VOLUME_CHANGE_BUTTON => {
                    volume = match volume {
                        1.0 => 0.5,
                        _ => 1.0,
                    };
                    music_controller.set_volume(volume);
                }
                SPEED_CHANGE_BUTTON => {
                    speed = match speed {
                        1.0 => 2.0,
                        2.0 => 0.5,
                        _ => 1.0,
                    };
                    music_controller.set_speed(speed);
                }
                STOP_ALL_SOUNDS_BUTTON => {
                    stop_all_sounds().await.ok();
                }
                SLEEP_BUTTON => {
                    execute_command("sleep").await.ok();
                }
                _ => {}
            }
        }
    });

    loop {
        FLASH_BUTTON.set_color(color::RED);
        tokio::time::sleep(tokio::time::Duration::from_millis(500)).await;
        FLASH_BUTTON.set_color(color::OFF);
        tokio::time::sleep(tokio::time::Duration::from_millis(500)).await;
    }
}

pub fn set_off(self)

Sets this button’s lights to color::OFF. Shorthand for self.set_color(color::OFF).

pub const fn light_at(self, dir: LightDir) -> Lights

Returns the light at dir on this button.

pub fn is_pressed(&self) -> bool

Returns true if the button is currently pressed.

See also ButtonEvents which is an alternative way to receive button events.

pub async fn wait_for_press(&self)

Wait for this button to be pressed. If the button is already pressed it returns immediately.

pub async fn wait_for_release(&self)

Wait for this button to be released. If the button is already released it returns immediately.

Trait Implementations

impl Clone for Button

fn clone(&self) -> Button

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Button

impl Debug for Button

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Button

fn deserialize<D>( deserializer: D, ) -> Result<Button, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Button

impl From<Button> for Buttons

fn from(button: Button) -> Buttons

Converts to this type from the input type.

impl From<Button> for Lights

fn from(button: Button) -> Lights

Converts to this type from the input type.

impl FromIterator<Button> for Buttons

fn from_iter<T>(iter: T) -> Buttons

where T: IntoIterator<Item = Button>,

Creates a value from an iterator.

impl Ord for Button

fn cmp(&self, other: &Button) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Button

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Button

fn partial_cmp(&self, other: &Button) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralPartialEq for Button