Switch to a futures-compatible API

examples/cursor.rs

@@ -1,6 +1,6 @@
 extern crate winit;
 
-use winit::{Event, ElementState, MouseCursor};
+use winit::{WindowEvent as Event, ElementState, MouseCursor};
 
 fn main() {
     let window = winit::WindowBuilder::new().build().unwrap();

examples/grabbing.rs

@@ -1,6 +1,6 @@
 extern crate winit;
 
-use winit::{Event, ElementState};
+use winit::{WindowEvent as Event, ElementState};
 
 fn main() {
     let window = winit::WindowBuilder::new().build().unwrap();

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/ios/delegate.rs

@@ -1,7 +1,7 @@
 use libc;
 use std::mem;
 use super::DelegateState;
-use Event;
+use WindowEvent as Event;
 use events::{ Touch, TouchPhase };
 
 use objc::runtime::{ Class, Object, Sel, BOOL, YES };

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/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);
                 },
 

src/api_transition.rs

@@ -0,0 +1,98 @@
+
+//! This temporary module generates types that wrap around the old API (winit v5 and below) and
+//! expose the new API (winit v6 and above).
+//!
+//! This is temporary so that existing backends can smoothly transition. After all implementations
+//! have finished transitionning, this module should disappear.
+
+macro_rules! gen_api_transition {
+    () => {
+        pub struct EventsLoop {
+            windows: ::std::sync::Mutex<Vec<::std::sync::Arc<Window>>>,
+            interrupted: ::std::sync::atomic::AtomicBool,
+        }
+
+        impl EventsLoop {
+            pub fn new() -> EventsLoop {
+                EventsLoop {
+                    windows: ::std::sync::Mutex::new(vec![]),
+                    interrupted: ::std::sync::atomic::AtomicBool::new(false),
+                }
+            }
+
+            pub fn interrupt(&self) {
+                self.interrupted.store(true, ::std::sync::atomic::Ordering::Relaxed);
+            }
+
+            pub fn poll_events<F>(&self, mut callback: F)
+                where F: FnMut(::Event)
+            {
+                let mut windows = self.windows.lock().unwrap();
+                for window in windows.iter() {
+                    for event in window.poll_events() {
+                        callback(::Event::WindowEvent {
+                            window_id: &**window as *const Window as usize,
+                            event: event,
+                        })
+                    }
+                }
+            }
+
+            pub fn run_forever<F>(&self, mut callback: F)
+                where F: FnMut(::Event)
+            {
+                self.interrupted.store(false, ::std::sync::atomic::Ordering::Relaxed);
+
+                // Yeah that's a very bad implementation.
+                loop {
+                    self.poll_events(|e| callback(e));
+                    ::std::thread::sleep_ms(5);
+                    if self.interrupted.load(::std::sync::atomic::Ordering::Relaxed) {
+                        break;
+                    }
+                }
+            }
+        }
+
+        pub struct Window2 {
+            window: ::std::sync::Arc<Window>,
+            events_loop: ::std::sync::Weak<EventsLoop>,
+        }
+
+        impl ::std::ops::Deref for Window2 {
+            type Target = Window;
+            #[inline]
+            fn deref(&self) -> &Window {
+                &*self.window
+            }
+        }
+
+        impl Window2 {
+            pub fn new(events_loop: ::std::sync::Arc<EventsLoop>, window: &::WindowAttributes,
+                       pl_attribs: &PlatformSpecificWindowBuilderAttributes)
+                       -> Result<Window2, CreationError>
+            {
+                let win = ::std::sync::Arc::new(try!(Window::new(window, pl_attribs)));
+                events_loop.windows.lock().unwrap().push(win.clone());
+                Ok(Window2 {
+                    window: win,
+                    events_loop: ::std::sync::Arc::downgrade(&events_loop),
+                })
+            }
+
+            #[inline]
+            pub fn id(&self) -> usize {
+                &*self.window as *const Window as usize
+            }
+        }
+
+        impl Drop for Window2 {
+            fn drop(&mut self) {
+                if let Some(ev) = self.events_loop.upgrade() {
+                    let mut windows = ev.windows.lock().unwrap();
+                    windows.retain(|w| &**w as *const Window != &*self.window as *const _);
+                }
+            }
+        }
+    };
+}

src/events.rs

@@ -2,6 +2,17 @@ use std::path::PathBuf;
 
 #[derive(Clone, Debug)]
 pub enum Event {
+    WindowEvent {
+        window_id: usize,
+        event: WindowEvent,
+    }
+}
+
+#[derive(Clone, Debug)]
+pub enum WindowEvent {
+    // TODO: remove ; can break the lib internally so be careful
+    Awakened,
+
     /// The size of the window has changed.
     Resized(u32, u32),
 
@@ -49,9 +60,6 @@ pub enum Event {
     /// is being pressed) and stage (integer representing the click level).
     TouchpadPressure(f32, i64),
 
-    /// The event loop was woken up by another thread.
-    Awakened,
-
     /// The window needs to be redrawn.
     Refresh,
 
@@ -60,7 +68,6 @@ pub enum Event {
     /// The parameter is true if app was suspended, and false if it has been resumed.
     Suspended(bool),
 
-
     /// Touch event has been received
     Touch(Touch)
 }