Switch to a futures-compatible API

examples/cursor.rs

@@ -1,17 +1,19 @@
 extern crate winit;
 
-use winit::{Event, ElementState, MouseCursor};
+use winit::{Event, ElementState, MouseCursor, WindowEvent};
 
 fn main() {
-    let window = winit::WindowBuilder::new().build().unwrap();
+    let events_loop = winit::EventsLoop::new();
+
+    let window = winit::WindowBuilder::new().build(&events_loop).unwrap();
     window.set_title("A fantastic window!");
 
     let cursors = [MouseCursor::Default, MouseCursor::Crosshair, MouseCursor::Hand, MouseCursor::Arrow, MouseCursor::Move, MouseCursor::Text, MouseCursor::Wait, MouseCursor::Help, MouseCursor::Progress, MouseCursor::NotAllowed, MouseCursor::ContextMenu, MouseCursor::NoneCursor, MouseCursor::Cell, MouseCursor::VerticalText, MouseCursor::Alias, MouseCursor::Copy, MouseCursor::NoDrop, MouseCursor::Grab, MouseCursor::Grabbing, MouseCursor::AllScroll, MouseCursor::ZoomIn, MouseCursor::ZoomOut, MouseCursor::EResize, MouseCursor::NResize, MouseCursor::NeResize, MouseCursor::NwResize, MouseCursor::SResize, MouseCursor::SeResize, MouseCursor::SwResize, MouseCursor::WResize, MouseCursor::EwResize, MouseCursor::NsResize, MouseCursor::NeswResize, MouseCursor::NwseResize, MouseCursor::ColResize, MouseCursor::RowResize];
     let mut cursor_idx = 0;
 
-    for event in window.wait_events() {
+    events_loop.run_forever(|event| {
         match event {
-            Event::KeyboardInput(ElementState::Pressed, _, _) => {
+            Event::WindowEvent { event: WindowEvent::KeyboardInput(ElementState::Pressed, _, _), .. } => {
                 println!("Setting cursor to \"{:?}\"", cursors[cursor_idx]);
                 window.set_cursor(cursors[cursor_idx]);
                 if cursor_idx < cursors.len() - 1 {
@@ -20,8 +22,10 @@ fn main() {
                     cursor_idx = 0;
                 }
             },
-            Event::Closed => break,
-            _ => (),
+            Event::WindowEvent { event: WindowEvent::Closed, .. } => {
+                events_loop.interrupt()
+            },
+            _ => ()
         }
-    }
+    });
 }

examples/fullscreen.rs

@@ -22,19 +22,25 @@ fn main() {
         monitor
     };
 
-    let window = winit::WindowBuilder::new()
+    let events_loop = winit::EventsLoop::new();
+
+    let _window = winit::WindowBuilder::new()
         .with_title("Hello world!")
         .with_fullscreen(monitor)
-        .build()
+        .build(&events_loop)
         .unwrap();
 
-    for event in window.wait_events() {
+    events_loop.run_forever(|event| {
         println!("{:?}", event);
 
         match event {
-            winit::Event::Closed => break,
-            winit::Event::KeyboardInput(_, _, Some(winit::VirtualKeyCode::Escape)) => break,
-            _ => ()
+            winit::Event::WindowEvent { event, .. } => {
+                match event {
+                    winit::WindowEvent::Closed => events_loop.interrupt(),
+                    winit::WindowEvent::KeyboardInput(_, _, Some(winit::VirtualKeyCode::Escape)) => events_loop.interrupt(),
+                    _ => ()
+                }
+            },
         }
-    }
+    });
 }

examples/grabbing.rs

@@ -1,34 +1,42 @@
 extern crate winit;
 
-use winit::{Event, ElementState};
+use winit::{WindowEvent, ElementState};
 
 fn main() {
-    let window = winit::WindowBuilder::new().build().unwrap();
+    let events_loop = winit::EventsLoop::new();
+
+    let window = winit::WindowBuilder::new().build(&events_loop).unwrap();
     window.set_title("winit - Cursor grabbing test");
 
     let mut grabbed = false;
 
-    for event in window.wait_events() {
+    events_loop.run_forever(|event| {
+        println!("{:?}", event);
+
         match event {
-            Event::KeyboardInput(ElementState::Pressed, _, _) => {
-                if grabbed {
-                    grabbed = false;
-                    window.set_cursor_state(winit::CursorState::Normal)
-                          .ok().expect("could not ungrab mouse cursor");
-                } else {
-                    grabbed = true;
-                    window.set_cursor_state(winit::CursorState::Grab)
-                          .ok().expect("could not grab mouse cursor");
-                }
-            },
+            winit::Event::WindowEvent { event, .. } => {
+                match event {
+                    WindowEvent::KeyboardInput(ElementState::Pressed, _, _) => {
+                        if grabbed {
+                            grabbed = false;
+                            window.set_cursor_state(winit::CursorState::Normal)
+                                .ok().expect("could not ungrab mouse cursor");
+                        } else {
+                            grabbed = true;
+                            window.set_cursor_state(winit::CursorState::Grab)
+                                .ok().expect("could not grab mouse cursor");
+                        }
+                    },
 
-            Event::Closed => break,
+                    WindowEvent::Closed => events_loop.interrupt(),
 
-            a @ Event::MouseMoved(_, _) => {
-                println!("{:?}", a);
-            },
+                    a @ WindowEvent::MouseMoved(_, _) => {
+                        println!("{:?}", a);
+                    },
 
-            _ => (),
+                    _ => (),
+                }
+            },
         }
-    }
+    });
 }

examples/min_max_size.rs

@@ -1,16 +1,20 @@
 extern crate winit;
 
 fn main() {
-    let window = winit::WindowBuilder::new()
+    let events_loop = winit::EventsLoop::new();
+
+    let _window = winit::WindowBuilder::new()
         .with_min_dimensions(400, 200)
         .with_max_dimensions(800, 400)
-        .build()
+        .build(&events_loop)
         .unwrap();
 
-    for event in window.wait_events() {
+    events_loop.run_forever(|event| {
+        println!("{:?}", event);
+
         match event {
-            winit::Event::Closed => break,
+            winit::Event::WindowEvent { event: winit::WindowEvent::Closed, .. } => events_loop.interrupt(),
             _ => ()
         }
-    }
+    });
 }

examples/multiwindow.rs

@@ -1,34 +1,33 @@
 extern crate winit;
 
-use std::thread;
-
 fn main() {
-    let window1 = winit::WindowBuilder::new().build().unwrap();
-    let window2 = winit::WindowBuilder::new().build().unwrap();
-    let window3 = winit::WindowBuilder::new().build().unwrap();
-
-    let t1 = thread::spawn(move || {
-        run(window1);
-    });
+    let events_loop = winit::EventsLoop::new();
 
-    let t2 = thread::spawn(move || {
-        run(window2);
-    });
+    let window1 = winit::Window::new(&events_loop).unwrap();
+    let window2 = winit::Window::new(&events_loop).unwrap();
+    let window3 = winit::Window::new(&events_loop).unwrap();
 
-    let t3 = thread::spawn(move || {
-        run(window3);
-    });
+    let mut num_windows = 3;
 
-    let _ = t1.join();
-    let _ = t2.join();
-    let _ = t3.join();
-}
-
-fn run(window: winit::Window) {
-    for event in window.wait_events() {
+    events_loop.run_forever(|event| {
         match event {
-            winit::Event::Closed => break,
-            _ => ()
+            winit::Event::WindowEvent { event: winit::WindowEvent::Closed, window_id } => {
+                if window_id == window1.id() {
+                    println!("Window 1 has been closed")
+                } else if window_id == window2.id() {
+                    println!("Window 2 has been closed")
+                } else if window_id == window3.id() {
+                    println!("Window 3 has been closed");
+                } else {
+                    unreachable!()
+                }
+
+                num_windows -= 1;
+                if num_windows == 0 {
+                    events_loop.interrupt();
+                }
+            },
+            _ => (),
         }
-    }
+    })
 }

examples/transparent.rs

@@ -1,22 +1,20 @@
 extern crate winit;
 
-fn resize_callback(width: u32, height: u32) {
-    println!("Window resized to {}x{}", width, height);
-}
-
 fn main() {
-    let mut window = winit::WindowBuilder::new().with_decorations(false)
+    let events_loop = winit::EventsLoop::new();
+
+    let window = winit::WindowBuilder::new().with_decorations(false)
                                                  .with_transparency(true)
-                                                 .build().unwrap();
+                                                 .build(&events_loop).unwrap();
+
     window.set_title("A fantastic window!");
-    window.set_window_resize_callback(Some(resize_callback as fn(u32, u32)));
 
-    for event in window.wait_events() {
+    events_loop.run_forever(|event| {
         println!("{:?}", event);
 
         match event {
-            winit::Event::Closed => break,
+            winit::Event::WindowEvent { event: winit::WindowEvent::Closed, .. } => events_loop.interrupt(),
             _ => ()
         }
-    }
+    });
 }

examples/window.rs

@@ -1,22 +1,19 @@
 extern crate winit;
 
-fn resize_callback(width: u32, height: u32) {
-    println!("Window resized to {}x{}", width, height);
-}
-
 fn main() {
+    let events_loop = winit::EventsLoop::new();
+
     let window = winit::WindowBuilder::new()
         .with_title("A fantastic window!")
-        .with_window_resize_callback(resize_callback)
-        .build()
+        .build(&events_loop)
         .unwrap();
 
-    for event in window.wait_events() {
+    events_loop.run_forever(|event| {
         println!("{:?}", event);
 
         match event {
-            winit::Event::Closed => break,
+            winit::Event::WindowEvent { event: winit::WindowEvent::Closed, .. } => events_loop.interrupt(),
             _ => ()
         }
-    }
+    });
 }

src/api/wayland/context.rs

@@ -1,4 +1,4 @@
-use {Event, ElementState, MouseButton, MouseScrollDelta, TouchPhase};
+use {WindowEvent as Event, ElementState, MouseButton, MouseScrollDelta, TouchPhase};
 
 use std::collections::VecDeque;
 use std::sync::{Arc, Mutex};

src/api/wayland/keyboard.rs

@@ -1,7 +1,7 @@
 use std::collections::VecDeque;
 use std::sync::{Arc, Mutex};
 
-use {VirtualKeyCode, ElementState, Event};
+use {VirtualKeyCode, ElementState, WindowEvent as Event};
 
 use super::wayland_kbd;
 use wayland_client::EventQueueHandle;

src/api/wayland/window.rs

@@ -4,7 +4,7 @@ use std::sync::{Arc, Mutex};
 use wayland_client::{EventQueue, EventQueueHandle, Init};
 use wayland_client::protocol::{wl_display,wl_surface,wl_shell_surface};
 
-use {CreationError, MouseCursor, CursorState, Event, WindowAttributes};
+use {CreationError, MouseCursor, CursorState, WindowEvent as Event, WindowAttributes};
 use platform::MonitorId as PlatformMonitorId;
 
 use super::WaylandContext;

src/api/x11/input.rs

@@ -7,7 +7,7 @@ use std::slice::from_raw_parts;
 
 use WindowAttributes;
 
-use events::Event;
+use events::WindowEvent as Event;
 
 use super::{events, ffi};
 use super::XConnection;
@@ -123,7 +123,7 @@ impl XInputEventHandler {
     }
 
     pub fn translate_key_event(&self, event: &mut ffi::XKeyEvent) -> Vec<Event> {
-        use events::Event::{KeyboardInput, ReceivedCharacter};
+        use events::WindowEvent::{KeyboardInput, ReceivedCharacter};
         use events::ElementState::{Pressed, Released};
 
         let mut translated_events = Vec::new();
@@ -170,7 +170,7 @@ impl XInputEventHandler {
     }
 
     pub fn translate_event(&mut self, cookie: &ffi::XGenericEventCookie) -> Option<Event> {
-        use events::Event::{Focused, MouseEntered, MouseInput, MouseLeft, MouseMoved, MouseWheel};
+        use events::WindowEvent::{Focused, MouseEntered, MouseInput, MouseLeft, MouseMoved, MouseWheel};
         use events::ElementState::{Pressed, Released};
         use events::MouseButton::{Left, Right, Middle};
         use events::MouseScrollDelta::LineDelta;

src/api/x11/window.rs

@@ -1,4 +1,4 @@
-use {Event, MouseCursor};
+use {WindowEvent as Event, MouseCursor};
 use CreationError;
 use CreationError::OsError;
 use libc;
@@ -178,7 +178,7 @@ impl<'a> Iterator for PollEventsIterator<'a> {
                 },
 
                 ffi::ClientMessage => {
-                    use events::Event::{Closed, Awakened};
+                    use events::WindowEvent::{Closed, Awakened};
                     use std::sync::atomic::Ordering::Relaxed;
 
                     let client_msg: &ffi::XClientMessageEvent = unsafe { mem::transmute(&xev) };
@@ -192,7 +192,7 @@ impl<'a> Iterator for PollEventsIterator<'a> {
                 },
 
                 ffi::ConfigureNotify => {
-                    use events::Event::Resized;
+                    use events::WindowEvent::Resized;
                     let cfg_event: &ffi::XConfigureEvent = unsafe { mem::transmute(&xev) };
                     let (current_width, current_height) = self.window.current_size.get();
                     if current_width != cfg_event.width || current_height != cfg_event.height {
@@ -202,7 +202,7 @@ impl<'a> Iterator for PollEventsIterator<'a> {
                 },
 
                 ffi::Expose => {
-                    use events::Event::Refresh;
+                    use events::WindowEvent::Refresh;
                     return Some(Refresh);
                 },