use winit::{Event as WinitEvent, ModifiersState, MouseButton, VirtualKeyCode, WindowEvent};
use crate::keyboard::{Keyboard, KeyboardInput};
use crate::mouse::{Mouse, MouseInput};
use crate::Event;
pub type WinitKeyboard = Keyboard<VirtualKeyCode, ModifiersState>;
pub type WinitMouse = Mouse<MouseButton, f64>;
pub fn keyboard() -> WinitKeyboard {
Keyboard::new()
}
pub fn mouse() -> WinitMouse {
Mouse::new()
}
impl<'a> Event<KeyboardInput<'a, VirtualKeyCode, ModifiersState>> for WinitEvent {
fn handle(&self, keyboard: &mut KeyboardInput<VirtualKeyCode, ModifiersState>) {
if let WinitEvent::WindowEvent { event, .. } = self {
event.handle(keyboard);
}
}
}
impl<'a> Event<KeyboardInput<'a, VirtualKeyCode, ModifiersState>> for WindowEvent {
fn handle(&self, keyboard: &mut KeyboardInput<VirtualKeyCode, ModifiersState>) {
use winit::{ElementState, KeyboardInput};
if let WindowEvent::KeyboardInput { input, .. } = self {
let KeyboardInput {
state,
virtual_keycode,
modifiers,
..
} = input;
keyboard.set_modifiers(*modifiers);
if let Some(vkc) = virtual_keycode {
match state {
ElementState::Pressed => keyboard.press(*vkc),
ElementState::Released => keyboard.release(*vkc),
};
}
}
}
}
impl<'a> Event<MouseInput<'a, MouseButton, f64>> for WinitEvent {
fn handle(&self, mouse: &mut MouseInput<MouseButton, f64>) {
if let WinitEvent::WindowEvent { event, .. } = self {
event.handle(mouse);
}
}
}
impl<'a> Event<MouseInput<'a, MouseButton, f64>> for WindowEvent {
fn handle(&self, mouse: &mut MouseInput<MouseButton, f64>) {
use winit::ElementState;
match self {
WindowEvent::MouseInput { state, button, .. } => {
match state {
ElementState::Pressed => mouse.press(*button),
ElementState::Released => mouse.release(*button),
};
}
WindowEvent::CursorMoved { position, .. } => {
mouse.move_to([position.x, position.y]);
}
_ => (),
}
}
}
#[cfg(test)]
#[allow(deprecated)]
mod tests {
use super::*;
use winit::{self, ElementState};
#[test]
fn create_mouse_and_keyboard() {
let mut keyboard = keyboard();
let mut mouse = mouse();
{
let keyboard = &mut keyboard.begin_frame_input();
let mouse = &mut mouse.begin_frame_input();
keyboard.press(VirtualKeyCode::H);
keyboard.set_modifiers(ModifiersState::default());
mouse.press(MouseButton::Left);
mouse.move_to([0.0, 0.0]);
}
}
fn make_keyboard_event(pressed: bool, key: VirtualKeyCode, ctrl: bool) -> WinitEvent {
let state = match pressed {
true => ElementState::Pressed,
false => ElementState::Released,
};
let modifiers = ModifiersState {
ctrl,
..Default::default()
};
unsafe {
WinitEvent::WindowEvent {
window_id: ::std::mem::uninitialized(),
event: WindowEvent::KeyboardInput {
device_id: ::std::mem::uninitialized(),
input: winit::KeyboardInput {
scancode: 0,
state,
virtual_keycode: Some(key),
modifiers,
},
},
}
}
}
fn make_mouse_button_event(pressed: bool, button: MouseButton) -> WinitEvent {
let state = match pressed {
true => ElementState::Pressed,
false => ElementState::Released,
};
unsafe {
WinitEvent::WindowEvent {
window_id: ::std::mem::uninitialized(),
event: WindowEvent::MouseInput {
device_id: ::std::mem::uninitialized(),
state,
button,
modifiers: ModifiersState::default(),
},
}
}
}
fn make_cursor_event(position: [f64; 2]) -> WinitEvent {
use winit::dpi::LogicalPosition;
let [x, y] = position;
unsafe {
WinitEvent::WindowEvent {
window_id: ::std::mem::uninitialized(),
event: WindowEvent::CursorMoved {
device_id: ::std::mem::uninitialized(),
position: LogicalPosition { x, y },
modifiers: ModifiersState::default(),
},
}
}
}
#[test]
fn press_via_event() {
let event = make_keyboard_event(true, VirtualKeyCode::H, false);
let mut keyboard = keyboard();
{
keyboard.begin_frame_input().handle_event(&event);
}
assert!(keyboard.pressed(VirtualKeyCode::H));
}
#[test]
fn release_via_event() {
let event = make_keyboard_event(false, VirtualKeyCode::H, false);
let mut keyboard = keyboard();
{
keyboard.begin_frame_input().handle_event(&event);
}
assert!(keyboard.released(VirtualKeyCode::H));
}
#[test]
fn modifiers_via_event() {
let event = make_keyboard_event(false, VirtualKeyCode::H, true);
let mut keyboard = keyboard();
{
keyboard.begin_frame_input().handle_event(&event);
}
let modifiers = ModifiersState {
ctrl: true,
..Default::default()
};
assert_eq!(keyboard.modifiers(), modifiers);
}
#[test]
fn mouse_button_press_via_event() {
let event = make_mouse_button_event(true, MouseButton::Right);
let mut mouse = mouse();
{
mouse.begin_frame_input().handle_event(&event);
}
assert!(mouse.pressed(MouseButton::Right));
}
#[test]
fn mouse_button_release_via_event() {
let event = make_mouse_button_event(false, MouseButton::Right);
let mut mouse = mouse();
{
mouse.begin_frame_input().handle_event(&event);
}
assert!(mouse.released(MouseButton::Right));
}
#[test]
fn mouse_move_via_event() {
let event = make_cursor_event([1.0, 1.0]);
let mut mouse = mouse();
{
mouse.begin_frame_input().handle_event(&event);
}
assert_eq!(mouse.position(), [1.0, 1.0]);
}
}