key_pressed!() and key_released!() pattern macros

[barries]

Rather than spell out the patterns necessary to match key presses, I threw together the below proc macros, which was fun. Is there a better way?

Usage:

use key_macros::*;

impl MyApp {
    ...
    #[must_use]
    fn check_for_esc_and_enter(&self, ui: &mut Ui) -> (bool, bool) {
        let mut esc_clicked   = false;
        let mut enter_clicked = false;

        if !ui.ctx().wants_keyboard_input() {
            ui.ctx().input(|i| { // This locks ctx, so we queue cmds to send.
                for input_event in &i.events {
                    match input_event {
                        key_released!(Escape) => { esc_clicked   = true; }
                        key_released!(Enter)  => { enter_clicked = true; }
                        _ => {},
                    }
                }
            });
        }

        (esc_clicked, enter_clicked)
    }
}

Another code snippet, showing how the macro patterns compose as expected:

match input_event {
    key_pressed!(F8)                                               => { self.motor.start_moving(Direction::Forward);  },
    key_pressed!(F10)                                              => { self.motor.start_moving(Direction::Reverse);  },
    key_released!(ctrl C) | key_released!(F8) | key_released!(F10) => { self.motor.stop();                            },
    ...
};

key_macros.rs:

use proc_macro;

use quote::quote;

use syn::{
    Error,
    Ident,
    Result,
    parse::{
        Parse,
        ParseStream,
    },
    parse_macro_input,
};

struct ParserOutput(proc_macro2::TokenStream);

const IGNORE_SHIFT: [&str; 15] = [
    "Colon",
    "Comma",
    "Backslash",
    "Slash",
    "Pipe",
    "Questionmark",
    "OpenBracket",
    "CloseBracket",
    "Backtick",
    "Minus",
    "Period",
    "Plus",
    "Equals",
    "Semicolon",
    "Quote",
    // Note: FWIW, egui doesn't name other punctuation
];

impl Parse for ParserOutput {
    fn parse(input: ParseStream) -> Result<Self> {
        let mut key_ident = None;
        let mut shift     = false;
        let mut ctrl      = false;
        let mut alt       = false;

        while let Some(ident) = input.parse::<Option<Ident>>()? {
            match format!("{ident}").as_str() {
                "shift" => { if shift { return Err(Error::new(ident.span(), "shift modifier specified twice")); } shift = true; },
                "ctrl"  => { if ctrl  { return Err(Error::new(ident.span(), "ctrl modifier specified twice" )); } ctrl  = true; },
                "alt"   => { if alt   { return Err(Error::new(ident.span(), "alt modifier specified twice"  )); } alt   = true; },

                _ => {
                    key_ident = Some(ident);
                }
            }
        }

        match key_ident {
            None => Err(Error::new(input.span(), "Key name missing")),
            Some(key_ident) => {
                let shift = if IGNORE_SHIFT.contains(&format!("{}", key_ident).as_str()) {
                    quote! {}
                } else {
                    quote! { shift: #shift, }
                };

                Ok(Self(quote! {
                    key:     Key::#key_ident,
                    repeat:  false,

                    modifiers: Modifiers {
                        #shift
                        ctrl:  #ctrl,
                        alt:   #alt,
                        ..
                    },
                }))
            }
        }
    }
}


/// ```rust
/// key_released!(Escape);      // Escape with no modifiers pressed
/// key_released!(ctrl C);      // ^C, but _not_ shift-ctrl-C, etc.)
/// key_pressed!(Questionmark); // ?, (shift is ignored)
/// ```
#[proc_macro]
pub fn key_released(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
    let tokens = parse_macro_input!(input as ParserOutput).0;

    quote! {
        egui::Event::Key {
            #tokens
            pressed: false,
            ..
        }
    }.into()
}

/// ```rust
/// key_pressed!(Escape);       // Escape with no modifiers pressed
/// key_pressed!(ctrl C);       // ^C, but _not_ shift-ctrl-C, for example
/// key_pressed!(Questionmark); // ?, (shift is ignored)
/// ```
#[proc_macro]
pub fn key_pressed(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
    let tokens = parse_macro_input!(input as ParserOutput).0;

    quote! {
        egui::Event::Key {
            #tokens
            pressed: true,
            ..
        }
    }.into()
}