Experiment with an improved event design

examples/control_flow.rs

@@ -1,7 +1,7 @@
 use std::{thread, time};
 
 use winit::{
-    event::{Event, KeyboardInput, WindowEvent},
+    event::{Event, LogicalKey, StartCause, WindowEvent},
     event_loop::{ControlFlow, EventLoop},
     window::WindowBuilder,
 };
@@ -37,7 +37,6 @@ fn main() {
     let mut close_requested = false;
 
     event_loop.run(move |event, _, control_flow| {
-        use winit::event::{ElementState, StartCause, VirtualKeyCode};
         println!("{:?}", event);
         match event {
             Event::NewEvents(start_cause) => {
@@ -46,36 +45,28 @@ fn main() {
                     _ => false,
                 }
             }
-            Event::WindowEvent { event, .. } => match event {
+            Event::WindowEvent(_, event) => match event {
                 WindowEvent::CloseRequested => {
                     close_requested = true;
                 }
-                WindowEvent::KeyboardInput {
-                    input:
-                        KeyboardInput {
-                            virtual_keycode: Some(virtual_code),
-                            state: ElementState::Pressed,
-                            ..
-                        },
-                    ..
-                } => match virtual_code {
-                    VirtualKeyCode::Key1 => {
+                WindowEvent::KeyPress(e) if e.is_down() => match e.logical_key() {
+                    Some(LogicalKey::Key1) => {
                         mode = Mode::Wait;
                         println!("\nmode: {:?}\n", mode);
                     }
-                    VirtualKeyCode::Key2 => {
+                    Some(LogicalKey::Key2) => {
                         mode = Mode::WaitUntil;
                         println!("\nmode: {:?}\n", mode);
                     }
-                    VirtualKeyCode::Key3 => {
+                    Some(LogicalKey::Key3) => {
                         mode = Mode::Poll;
                         println!("\nmode: {:?}\n", mode);
                     }
-                    VirtualKeyCode::R => {
+                    Some(LogicalKey::R) => {
                         request_redraw = !request_redraw;
                         println!("\nrequest_redraw: {}\n", request_redraw);
                     }
-                    VirtualKeyCode::Escape => {
+                    Some(LogicalKey::Escape) => {
                         close_requested = true;
                     }
                     _ => (),

examples/cursor.rs

@@ -1,5 +1,5 @@
 use winit::{
-    event::{ElementState, Event, KeyboardInput, WindowEvent},
+    event::{Event, WindowEvent},
     event_loop::{ControlFlow, EventLoop},
     window::{CursorIcon, WindowBuilder},
 };
@@ -17,18 +17,7 @@ fn main() {
         *control_flow = ControlFlow::Wait;
 
         match event {
-            Event::WindowEvent {
-                event:
-                    WindowEvent::KeyboardInput {
-                        input:
-                            KeyboardInput {
-                                state: ElementState::Pressed,
-                                ..
-                            },
-                        ..
-                    },
-                ..
-            } => {
+            Event::WindowEvent(_, WindowEvent::KeyPress(e)) if e.is_down() => {
                 println!("Setting cursor to \"{:?}\"", CURSORS[cursor_idx]);
                 window.set_cursor_icon(CURSORS[cursor_idx]);
                 if cursor_idx < CURSORS.len() - 1 {
@@ -37,10 +26,7 @@ fn main() {
                     cursor_idx = 0;
                 }
             }
-            Event::WindowEvent {
-                event: WindowEvent::CloseRequested,
-                ..
-            } => {
+            Event::WindowEvent(_, WindowEvent::CloseRequested) => {
                 *control_flow = ControlFlow::Exit;
                 return;
             }

examples/cursor_grab.rs

@@ -1,5 +1,5 @@
 use winit::{
-    event::{DeviceEvent, ElementState, Event, KeyboardInput, ModifiersState, WindowEvent},
+    event::{Event, LogicalKey, ModifiersState, RawPointerEvent, WindowEvent},
     event_loop::{ControlFlow, EventLoop},
     window::WindowBuilder,
 };
@@ -19,34 +19,28 @@ fn main() {
         *control_flow = ControlFlow::Wait;
 
         match event {
-            Event::WindowEvent { event, .. } => match event {
+            Event::WindowEvent(_, event) => match event {
                 WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
-                WindowEvent::KeyboardInput {
-                    input:
-                        KeyboardInput {
-                            state: ElementState::Released,
-                            virtual_keycode: Some(key),
-                            ..
-                        },
-                    ..
-                } => {
-                    use winit::event::VirtualKeyCode::*;
-                    match key {
-                        Escape => *control_flow = ControlFlow::Exit,
-                        G => window.set_cursor_grab(!modifiers.shift()).unwrap(),
-                        H => window.set_cursor_visible(modifiers.shift()),
-                        _ => (),
-                    }
-                }
+                WindowEvent::KeyPress(e) if e.is_down() => match e.logical_key() {
+                    Some(LogicalKey::Escape) => *control_flow = ControlFlow::Exit,
+                    Some(LogicalKey::G) => window.set_cursor_grab(!modifiers.shift()).unwrap(),
+                    Some(LogicalKey::H) => window.set_cursor_visible(modifiers.shift()),
+                    _ => (),
+                },
                 WindowEvent::ModifiersChanged(m) => modifiers = m,
                 _ => (),
             },
-            Event::DeviceEvent { event, .. } => match event {
-                DeviceEvent::MouseMotion { delta } => println!("mouse moved: {:?}", delta),
-                DeviceEvent::Button { button, state } => match state {
-                    ElementState::Pressed => println!("mouse button {} pressed", button),
-                    ElementState::Released => println!("mouse button {} released", button),
-                },
+            Event::RawPointerEvent(_, event) => match event {
+                RawPointerEvent::MovedRelative(delta) => println!("pointer moved: {:?}", delta),
+                RawPointerEvent::MovedAbsolute(position) => {
+                    println!("pointer moved to: {:?}", position)
+                }
+                RawPointerEvent::Press(e) if e.is_down() => {
+                    println!("pointer button {:?} pressed", e.button())
+                }
+                RawPointerEvent::Press(e) if e.is_up() => {
+                    println!("pointer button {:?} released", e.button())
+                }
                 _ => (),
             },
             _ => (),

examples/custom_events.rs

@@ -37,10 +37,7 @@ fn main() {
 
         match event {
             Event::UserEvent(event) => println!("user event: {:?}", event),
-            Event::WindowEvent {
-                event: WindowEvent::CloseRequested,
-                ..
-            } => *control_flow = ControlFlow::Exit,
+            Event::WindowEvent(_, WindowEvent::CloseRequested) => *control_flow = ControlFlow::Exit,
             _ => (),
         }
     });

examples/fullscreen.rs

@@ -1,5 +1,5 @@
 use std::io::{stdin, stdout, Write};
-use winit::event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent};
+use winit::event::{Event, LogicalKey, WindowEvent};
 use winit::event_loop::{ControlFlow, EventLoop};
 use winit::monitor::{MonitorHandle, VideoMode};
 use winit::window::{Fullscreen, WindowBuilder};
@@ -34,33 +34,25 @@ fn main() {
         *control_flow = ControlFlow::Wait;
 
         match event {
-            Event::WindowEvent { event, .. } => match event {
+            Event::WindowEvent(_, event) => match event {
                 WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
-                WindowEvent::KeyboardInput {
-                    input:
-                        KeyboardInput {
-                            virtual_keycode: Some(virtual_code),
-                            state,
-                            ..
-                        },
-                    ..
-                } => match (virtual_code, state) {
-                    (VirtualKeyCode::Escape, _) => *control_flow = ControlFlow::Exit,
-                    (VirtualKeyCode::F, ElementState::Pressed) => {
+                WindowEvent::KeyPress(e) if e.is_down() => match e.logical_key() {
+                    Some(LogicalKey::Escape) => *control_flow = ControlFlow::Exit,
+                    Some(LogicalKey::F) => {
                         if window.fullscreen().is_some() {
                             window.set_fullscreen(None);
                         } else {
                             window.set_fullscreen(fullscreen.clone());
                         }
                     }
-                    (VirtualKeyCode::S, ElementState::Pressed) => {
+                    Some(LogicalKey::S) => {
                         println!("window.fullscreen {:?}", window.fullscreen());
                     }
-                    (VirtualKeyCode::M, ElementState::Pressed) => {
+                    Some(LogicalKey::M) => {
                         is_maximized = !is_maximized;
                         window.set_maximized(is_maximized);
                     }
-                    (VirtualKeyCode::D, ElementState::Pressed) => {
+                    Some(LogicalKey::D) => {
                         decorations = !decorations;
                         window.set_decorations(decorations);
                     }

examples/handling_close.rs

@@ -1,5 +1,5 @@
 use winit::{
-    event::{Event, KeyboardInput, WindowEvent},
+    event::{Event, LogicalKey, WindowEvent},
     event_loop::{ControlFlow, EventLoop},
     window::WindowBuilder,
 };
@@ -16,67 +16,51 @@ fn main() {
     let mut close_requested = false;
 
     event_loop.run(move |event, _, control_flow| {
-        use winit::event::{
-            ElementState::Released,
-            VirtualKeyCode::{N, Y},
-        };
         *control_flow = ControlFlow::Wait;
 
         match event {
-            Event::WindowEvent { event, .. } => {
-                match event {
-                    WindowEvent::CloseRequested => {
-                        // `CloseRequested` is sent when the close button on the window is pressed (or
-                        // through whatever other mechanisms the window manager provides for closing a
-                        // window). If you don't handle this event, the close button won't actually do
-                        // anything.
+            Event::WindowEvent(_, event) => match event {
+                WindowEvent::CloseRequested => {
+                    // `CloseRequested` is sent when the close button on the window is pressed (or
+                    // through whatever other mechanisms the window manager provides for closing a
+                    // window). If you don't handle this event, the close button won't actually do
+                    // anything.
 
-                        // A common thing to do here is prompt the user if they have unsaved work.
-                        // Creating a proper dialog box for that is far beyond the scope of this
-                        // example, so here we'll just respond to the Y and N keys.
-                        println!("Are you ready to bid your window farewell? [Y/N]");
-                        close_requested = true;
+                    // A common thing to do here is prompt the user if they have unsaved work.
+                    // Creating a proper dialog box for that is far beyond the scope of this
+                    // example, so here we'll just respond to the Y and N keys.
+                    println!("Are you ready to bid your window farewell? [Y/N]");
+                    close_requested = true;
 
-                        // In applications where you can safely close the window without further
-                        // action from the user, this is generally where you'd handle cleanup before
-                        // closing the window. How to close the window is detailed in the handler for
-                        // the Y key.
-                    }
-                    WindowEvent::KeyboardInput {
-                        input:
-                            KeyboardInput {
-                                virtual_keycode: Some(virtual_code),
-                                state: Released,
-                                ..
-                            },
-                        ..
-                    } => {
-                        match virtual_code {
-                            Y => {
-                                if close_requested {
-                                    // This is where you'll want to do any cleanup you need.
-                                    println!("Buh-bye!");
+                    // In applications where you can safely close the window without further
+                    // action from the user, this is generally where you'd handle cleanup before
+                    // closing the window. How to close the window is detailed in the handler for
+                    // the Y key.
+                }
+                WindowEvent::KeyPress(e) if e.is_up() => match e.logical_key() {
+                    Some(LogicalKey::Y) => {
+                        if close_requested {
+                            // This is where you'll want to do any cleanup you need.
+                            println!("Buh-bye!");
 
-                                    // For a single-window application like this, you'd normally just
-                                    // break out of the event loop here. If you wanted to keep running the
-                                    // event loop (i.e. if it's a multi-window application), you need to
-                                    // drop the window. That closes it, and results in `Destroyed` being
-                                    // sent.
-                                    *control_flow = ControlFlow::Exit;
-                                }
-                            }
-                            N => {
-                                if close_requested {
-                                    println!("Your window will continue to stay by your side.");
-                                    close_requested = false;
-                                }
-                            }
-                            _ => (),
+                            // For a single-window application like this, you'd normally just
+                            // break out of the event loop here. If you wanted to keep running the
+                            // event loop (i.e. if it's a multi-window application), you need to
+                            // drop the window. That closes it, and results in `Destroyed` being
+                            // sent.
+                            *control_flow = ControlFlow::Exit;
+                        }
+                    }
+                    Some(LogicalKey::N) => {
+                        if close_requested {
+                            println!("Your window will continue to stay by your side.");
+                            close_requested = false;
                         }
                     }
                     _ => (),
-                }
-            }
+                },
+                _ => (),
+            },
             _ => (),
         }
     });

examples/min_max_size.rs

@@ -19,10 +19,7 @@ fn main() {
         println!("{:?}", event);
 
         match event {
-            Event::WindowEvent {
-                event: WindowEvent::CloseRequested,
-                ..
-            } => *control_flow = ControlFlow::Exit,
+            Event::WindowEvent(_, WindowEvent::CloseRequested) => *control_flow = ControlFlow::Exit,
             _ => (),
         }
     });

examples/minimize.rs

@@ -1,6 +1,6 @@
 extern crate winit;
 
-use winit::event::{Event, VirtualKeyCode, WindowEvent};
+use winit::event::{Event, LogicalKey, WindowEvent};
 use winit::event_loop::{ControlFlow, EventLoop};
 use winit::window::WindowBuilder;
 
@@ -17,22 +17,13 @@ fn main() {
         *control_flow = ControlFlow::Wait;
 
         match event {
-            Event::WindowEvent {
-                event: WindowEvent::CloseRequested,
-                ..
-            } => *control_flow = ControlFlow::Exit,
+            Event::WindowEvent(_, WindowEvent::CloseRequested) => *control_flow = ControlFlow::Exit,
 
             // Keyboard input event to handle minimize via a hotkey
-            Event::WindowEvent {
-                event: WindowEvent::KeyboardInput { input, .. },
-                window_id,
-            } => {
-                if window_id == window.id() {
-                    // Pressing the 'M' key will minimize the window
-                    if input.virtual_keycode == Some(VirtualKeyCode::M) {
-                        window.set_minimized(true);
-                    }
-                }
+            Event::WindowEvent(window_id, WindowEvent::KeyPress(e))
+                if e.is_down() && e.logical_key_is(LogicalKey::M) && window_id == window.id() =>
+            {
+                window.set_minimized(true)
             }
             _ => (),
         }