pel 0.1.0

//! Input data structures.

use glutin::event::{
    ElementState, KeyboardInput as InnerKeyboardInput, ModifiersState, MouseButton as InnerMouseButton, VirtualKeyCode,
};

/// Describes which keyboard button was pressed/released.
///
/// `button` is raw scancode.
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
pub struct KeyboardInput {
    pub state: ButtonState,
    pub scancode: u32,
    pub keycode: Option<VirtualKey>,
}

impl From<InnerKeyboardInput> for KeyboardInput {
    fn from(input: InnerKeyboardInput) -> Self {
        KeyboardInput {
            state: input.state.into(),
            scancode: input.scancode,
            keycode: VirtualKey::from_optional(input.virtual_keycode),
        }
    }
}

/// Describes which mouse button was pressed/released.
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
pub struct MouseInput {
    pub state: ButtonState,
    pub button: MouseButton,
}

/// Describes button state.
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
pub enum ButtonState {
    Pressed,
    Released,
}

impl From<bool> for ButtonState {
    fn from(pressed: bool) -> Self {
        if pressed {
            ButtonState::Pressed
        } else {
            ButtonState::Released
        }
    }
}

impl From<ButtonState> for bool {
    fn from(state: ButtonState) -> Self {
        match state {
            ButtonState::Pressed => true,
            ButtonState::Released => false,
        }
    }
}

impl PartialEq<bool> for ButtonState {
    fn eq(&self, other: &bool) -> bool {
        bool::from(*self) == *other
    }
}

/// Describes modifier key state.
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
pub struct ModifierKeys(ModifiersState);

impl ModifierKeys {
    pub fn shift(self) -> ButtonState {
        self.0.shift().into()
    }

    pub fn alt(self) -> ButtonState {
        self.0.alt().into()
    }

    pub fn ctrl(self) -> ButtonState {
        self.0.ctrl().into()
    }

    pub fn logo(self) -> ButtonState {
        self.0.logo().into()
    }
}

impl From<ModifiersState> for ModifierKeys {
    fn from(state: ModifiersState) -> Self {
        ModifierKeys(state)
    }
}

impl From<ElementState> for ButtonState {
    fn from(state: ElementState) -> Self {
        match state {
            ElementState::Pressed => ButtonState::Pressed,
            ElementState::Released => ButtonState::Released,
        }
    }
}

/// Symbolic name for a keyboard key.
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
#[repr(u32)]
pub enum VirtualKey {
    /// The Escape key, next to F1.
    Escape,
    /// '`' key under the Escape key.
    Backquote,
    /// Tab key.
    Tab,

    F1,
    F2,
    F3,
    F4,
    F5,
    F6,
    F7,
    F8,
    F9,
    F10,
    F11,
    F12,
    F13,
    F14,
    F15,
    F16,
    F17,
    F18,
    F19,
    F20,
    F21,
    F22,
    F23,
    F24,

    /// The '1' key over the letters.
    Key1,
    /// The '2' key over the letters.
    Key2,
    /// The '3' key over the letters.
    Key3,
    /// The '4' key over the letters.
    Key4,
    /// The '5' key over the letters.
    Key5,
    /// The '6' key over the letters.
    Key6,
    /// The '7' key over the letters.
    Key7,
    /// The '8' key over the letters.
    Key8,
    /// The '9' key over the letters.
    Key9,
    /// The '0' key over the 'O' and 'P' keys.
    Key0,

    A,
    B,
    C,
    D,
    E,
    F,
    G,
    H,
    I,
    J,
    K,
    L,
    M,
    N,
    O,
    P,
    Q,
    R,
    S,
    T,
    U,
    V,
    W,
    X,
    Y,
    Z,

    /// '-' key over the letters/in numpad.
    Minus,
    /// '+' key over the letters/in numpad.
    Plus,
    /// '=' key over the letters/in numpad.
    Equals,
    /// '[' key.
    LBracket,
    /// ']' key.
    RBracket,
    /// '\' key.
    Backslash,
    /// ';' key.
    Semicolon,
    /// ':' key.
    Colon,
    /// "'" key.
    Apostrophe,
    /// '.' key.
    Period,
    /// ',' key.
    Comma,
    /// '/' key.
    Slash,

    /// Arrow key pointing left.
    Left,
    /// Arrow key pointing up.
    Up,
    /// Arrow key pointing right.
    Right,
    /// Arrow key pointing down.
    Down,

    /// '0' in numpad.
    Numpad0,
    /// '1' in numpad.
    Numpad1,
    /// '2' in numpad.
    Numpad2,
    /// '3' in numpad.
    Numpad3,
    /// '4' in numpad.
    Numpad4,
    /// '5' in numpad.
    Numpad5,
    /// '6' in numpad.
    Numpad6,
    /// '7' in numpad.
    Numpad7,
    /// '8' in numpad.
    Numpad8,
    /// '9' in numpad.
    Numpad9,

    /// Delete key.
    Delete,
    /// Insert key.
    Insert,
    /// Home key.
    Home,
    /// End key.
    End,
    /// Page down key.
    PageDown,
    /// Page up key.
    PageUp,
    /// Backspace (erase last character) key.
    Backspace,
    /// Enter (return to beginning of the new line).
    Enter,
}

impl VirtualKey {
    fn from_key(key: VirtualKeyCode) -> Option<Self> {
        match key {
            VirtualKeyCode::Escape => Some(VirtualKey::Escape),
            VirtualKeyCode::Grave => Some(VirtualKey::Backquote),
            VirtualKeyCode::Tab => Some(VirtualKey::Tab),
            VirtualKeyCode::F1 => Some(VirtualKey::F1),
            VirtualKeyCode::F2 => Some(VirtualKey::F2),
            VirtualKeyCode::F3 => Some(VirtualKey::F3),
            VirtualKeyCode::F4 => Some(VirtualKey::F4),
            VirtualKeyCode::F5 => Some(VirtualKey::F5),
            VirtualKeyCode::F6 => Some(VirtualKey::F6),
            VirtualKeyCode::F7 => Some(VirtualKey::F7),
            VirtualKeyCode::F8 => Some(VirtualKey::F8),
            VirtualKeyCode::F9 => Some(VirtualKey::F9),
            VirtualKeyCode::F10 => Some(VirtualKey::F10),
            VirtualKeyCode::F11 => Some(VirtualKey::F11),
            VirtualKeyCode::F12 => Some(VirtualKey::F12),
            VirtualKeyCode::F13 => Some(VirtualKey::F13),
            VirtualKeyCode::F14 => Some(VirtualKey::F14),
            VirtualKeyCode::F15 => Some(VirtualKey::F15),
            VirtualKeyCode::F16 => Some(VirtualKey::F16),
            VirtualKeyCode::F17 => Some(VirtualKey::F17),
            VirtualKeyCode::F18 => Some(VirtualKey::F18),
            VirtualKeyCode::F19 => Some(VirtualKey::F19),
            VirtualKeyCode::F20 => Some(VirtualKey::F20),
            VirtualKeyCode::F21 => Some(VirtualKey::F21),
            VirtualKeyCode::F22 => Some(VirtualKey::F22),
            VirtualKeyCode::F23 => Some(VirtualKey::F23),
            VirtualKeyCode::F24 => Some(VirtualKey::F24),
            VirtualKeyCode::Key1 => Some(VirtualKey::Key1),
            VirtualKeyCode::Key2 => Some(VirtualKey::Key2),
            VirtualKeyCode::Key3 => Some(VirtualKey::Key3),
            VirtualKeyCode::Key4 => Some(VirtualKey::Key4),
            VirtualKeyCode::Key5 => Some(VirtualKey::Key5),
            VirtualKeyCode::Key6 => Some(VirtualKey::Key6),
            VirtualKeyCode::Key7 => Some(VirtualKey::Key7),
            VirtualKeyCode::Key8 => Some(VirtualKey::Key8),
            VirtualKeyCode::Key9 => Some(VirtualKey::Key9),
            VirtualKeyCode::Key0 => Some(VirtualKey::Key0),
            VirtualKeyCode::A => Some(VirtualKey::A),
            VirtualKeyCode::B => Some(VirtualKey::B),
            VirtualKeyCode::C => Some(VirtualKey::C),
            VirtualKeyCode::D => Some(VirtualKey::D),
            VirtualKeyCode::E => Some(VirtualKey::E),
            VirtualKeyCode::F => Some(VirtualKey::F),
            VirtualKeyCode::G => Some(VirtualKey::G),
            VirtualKeyCode::H => Some(VirtualKey::H),
            VirtualKeyCode::I => Some(VirtualKey::I),
            VirtualKeyCode::J => Some(VirtualKey::J),
            VirtualKeyCode::K => Some(VirtualKey::K),
            VirtualKeyCode::L => Some(VirtualKey::L),
            VirtualKeyCode::M => Some(VirtualKey::M),
            VirtualKeyCode::N => Some(VirtualKey::N),
            VirtualKeyCode::O => Some(VirtualKey::O),
            VirtualKeyCode::P => Some(VirtualKey::P),
            VirtualKeyCode::Q => Some(VirtualKey::Q),
            VirtualKeyCode::R => Some(VirtualKey::R),
            VirtualKeyCode::S => Some(VirtualKey::S),
            VirtualKeyCode::T => Some(VirtualKey::T),
            VirtualKeyCode::U => Some(VirtualKey::U),
            VirtualKeyCode::V => Some(VirtualKey::V),
            VirtualKeyCode::W => Some(VirtualKey::W),
            VirtualKeyCode::X => Some(VirtualKey::X),
            VirtualKeyCode::Y => Some(VirtualKey::Y),
            VirtualKeyCode::Z => Some(VirtualKey::Z),
            VirtualKeyCode::Subtract => Some(VirtualKey::Minus),
            VirtualKeyCode::Add => Some(VirtualKey::Plus),
            VirtualKeyCode::Equals => Some(VirtualKey::Equals),
            VirtualKeyCode::LBracket => Some(VirtualKey::LBracket),
            VirtualKeyCode::RBracket => Some(VirtualKey::RBracket),
            VirtualKeyCode::Backslash => Some(VirtualKey::Backslash),
            VirtualKeyCode::Semicolon => Some(VirtualKey::Semicolon),
            VirtualKeyCode::Colon => Some(VirtualKey::Colon),
            VirtualKeyCode::Apostrophe => Some(VirtualKey::Apostrophe),
            VirtualKeyCode::Period => Some(VirtualKey::Period),
            VirtualKeyCode::Comma => Some(VirtualKey::Comma),
            VirtualKeyCode::Slash => Some(VirtualKey::Slash),
            VirtualKeyCode::Divide => Some(VirtualKey::Slash),
            VirtualKeyCode::Left => Some(VirtualKey::Left),
            VirtualKeyCode::Up => Some(VirtualKey::Up),
            VirtualKeyCode::Right => Some(VirtualKey::Right),
            VirtualKeyCode::Down => Some(VirtualKey::Down),
            VirtualKeyCode::Numpad0 => Some(VirtualKey::Numpad0),
            VirtualKeyCode::Numpad1 => Some(VirtualKey::Numpad1),
            VirtualKeyCode::Numpad2 => Some(VirtualKey::Numpad2),
            VirtualKeyCode::Numpad3 => Some(VirtualKey::Numpad3),
            VirtualKeyCode::Numpad4 => Some(VirtualKey::Numpad4),
            VirtualKeyCode::Numpad5 => Some(VirtualKey::Numpad5),
            VirtualKeyCode::Numpad6 => Some(VirtualKey::Numpad6),
            VirtualKeyCode::Numpad7 => Some(VirtualKey::Numpad7),
            VirtualKeyCode::Numpad8 => Some(VirtualKey::Numpad8),
            VirtualKeyCode::Numpad9 => Some(VirtualKey::Numpad9),
            VirtualKeyCode::Insert => Some(VirtualKey::Insert),
            VirtualKeyCode::Home => Some(VirtualKey::Home),
            VirtualKeyCode::Delete => Some(VirtualKey::Delete),
            VirtualKeyCode::End => Some(VirtualKey::End),
            VirtualKeyCode::PageDown => Some(VirtualKey::PageDown),
            VirtualKeyCode::PageUp => Some(VirtualKey::PageUp),
            VirtualKeyCode::Back => Some(VirtualKey::Backspace),
            VirtualKeyCode::Return => Some(VirtualKey::Enter),
            _ => None,
        }
    }

    fn from_optional(key: Option<VirtualKeyCode>) -> Option<Self> {
        match key {
            Some(key) => Self::from_key(key),
            None => None,
        }
    }
}

impl PartialEq<Option<VirtualKey>> for VirtualKey {
    fn eq(&self, other: &Option<VirtualKey>) -> bool {
        match other {
            Some(other) => *self == *other,
            None => false,
        }
    }
}

/// Describes button location on the mouse.
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
pub enum MouseButton {
    Left,
    Right,
    Middle,
    Other(u8),
}

impl From<InnerMouseButton> for MouseButton {
    fn from(state: InnerMouseButton) -> Self {
        match state {
            InnerMouseButton::Left => MouseButton::Left,
            InnerMouseButton::Right => MouseButton::Right,
            InnerMouseButton::Middle => MouseButton::Middle,
            InnerMouseButton::Other(button) => MouseButton::Other(button),
        }
    }
}