rust-windowing
diff --git a/‎CHANGELOG.md‎
Lines changed: 37 additions & 0 deletions b/‎CHANGELOG.md‎
Lines changed: 37 additions & 0 deletions
diff --git a/‎Cargo.toml‎
Lines changed: 3 additions & 1 deletion b/‎Cargo.toml‎
Lines changed: 3 additions & 1 deletion
diff --git a/‎examples/multithreaded.rs‎
Lines changed: 115 additions & 0 deletions b/‎examples/multithreaded.rs‎
Lines changed: 115 additions & 0 deletions
diff --git a/‎src/platform/macos.rs‎
Lines changed: 4 additions & 1 deletion b/‎src/platform/macos.rs‎
Lines changed: 4 additions & 1 deletion
diff --git a/‎src/platform_impl/macos/app.rs‎
Lines changed: 88 additions & 0 deletions b/‎src/platform_impl/macos/app.rs‎
Lines changed: 88 additions & 0 deletions
diff --git a/‎src/platform_impl/macos/app_delegate.rs‎
Lines changed: 101 additions & 0 deletions b/‎src/platform_impl/macos/app_delegate.rs‎
Lines changed: 101 additions & 0 deletions
@@ -1,4 +1,41 @@
 # Unreleased
+- Changes below are considered **breaking**.
+- Change all occurrences of `EventsLoop` to `EventLoop`.
+- Previously flat API is now exposed through `event`, `event_loop`, `monitor`, and `window` modules.
+- `os` module changes:
+  - Renamed to `platform`.
+  - All traits now have platform-specific suffixes.
+  - Exposes new `desktop` module on Windows, Mac, and Linux.
+- Changes to event loop types:
+  - `EventLoopProxy::wakeup` has been removed in favor of `send_event`.
+  - **Major:** New `run` method drives winit event loop.
+    - Returns `!` to ensure API behaves identically across all supported platforms.
+      - This allows `emscripten` implementation to work without lying about the API.
+    - `ControlFlow`'s variants have been replaced with `Wait`, `WaitUntil(Instant)`, `Poll`, and `Exit`.
+      - Is read after `EventsCleared` is processed.
+      - `Wait` waits until new events are available.
+      - `WaitUntil` waits until either new events are available or the provided time has been reached.
+      - `Poll` instantly resumes the event loop.
+      - `Exit` aborts the event loop.
+    - Takes a closure that implements `'static + FnMut(Event<T>, &EventLoop<T>, &mut ControlFlow)`.
+      - `&EventLoop<T>` is provided to allow new `Window`s to be created.
+  - **Major:** `platform::desktop` module exposes `EventLoopExtDesktop` trait with `run_return` method.
+    - Behaves identically to `run`, but returns control flow to the calling context can take non-`'static` closures.
+  - `EventLoop`'s `poll_events` and `run_forever` methods have been removed in favor of `run` and `run_return`.
+- Changes to events:
+  - Remove `Event::Awakened` in favor of `Event::UserEvent(T)`.
+    - Can be sent with `EventLoopProxy::send_event`.
+  - Rename `WindowEvent::Refresh` to `WindowEvent::RedrawRequested`.
+    - `RedrawRequested` can be sent by the user with the `Window::request_redraw` method.
+  - `EventLoop`, `EventLoopProxy`, and `Event` are now generic over `T`, for use in `UserEvent`.
+  - **Major:** Add `NewEvents(StartCause)`, `EventsCleared`, and `LoopDestroyed` variants to `Event`.
+    - `NewEvents` is emitted when new events are ready to be processed by event loop.
+      - `StartCause` describes why new events are available, with `ResumeTimeReached`, `Poll`, `WaitCancelled`, and `Init` (sent once at start of loop).
+    - `EventsCleared` is emitted when all available events have been processed.
+      - Can be used to perform logic that depends on all events being processed (e.g. an iteration of a game loop).
+    - `LoopDestroyed` is emitted when the `run` or `run_return` method is about to exit.
+- Rename `MonitorId` to `MonitorHandle`.
+- Removed `serde` implementations from `ControlFlow`.
 
 - Changes below are considered **breaking**.
 - Change all occurrences of `EventsLoop` to `EventLoop`.
 
@@ -21,6 +21,7 @@ serde = { version = "1", optional = true, features = ["serde_derive"] }
 
 [dev-dependencies]
 image = "0.21"
+env_logger = "0.5"
 
 [target.'cfg(target_os = "android")'.dependencies.android_glue]
 version = "0.2"
@@ -29,10 +30,11 @@ version = "0.2"
 objc = "0.2.3"
 
 [target.'cfg(target_os = "macos")'.dependencies]
-objc = "0.2.3"
 cocoa = "0.18.4"
 core-foundation = "0.6"
 core-graphics = "0.17.3"
+dispatch = "0.1.4"
+objc = "0.2.3"
 
 [target.'cfg(target_os = "windows")'.dependencies]
 backtrace = "0.3"
 
@@ -0,0 +1,115 @@
+extern crate env_logger;
+extern crate winit;
+
+use std::{collections::HashMap, sync::mpsc, thread, time::Duration};
+
+use winit::{
+    event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent},
+    event_loop::{ControlFlow, EventLoop}, window::{MouseCursor, WindowBuilder},
+};
+
+const WINDOW_COUNT: usize = 3;
+const WINDOW_SIZE: (u32, u32) = (600, 400);
+
+fn main() {
+    env_logger::init();
+    let event_loop = EventLoop::new();
+    let mut window_senders = HashMap::with_capacity(WINDOW_COUNT);
+    for _ in 0..WINDOW_COUNT {
+        let window = WindowBuilder::new()
+            .with_dimensions(WINDOW_SIZE.into())
+            .build(&event_loop)
+            .unwrap();
+        let (tx, rx) = mpsc::channel();
+        window_senders.insert(window.id(), tx);
+        thread::spawn(move || {
+            while let Ok(event) = rx.recv() {
+                match event {
+                    WindowEvent::KeyboardInput { input: KeyboardInput {
+                        state: ElementState::Released,
+                        virtual_keycode: Some(key),
+                        modifiers,
+                        ..
+                    }, .. } => {
+                        window.set_title(&format!("{:?}", key));
+                        let state = !modifiers.shift;
+                        use self::VirtualKeyCode::*;
+                        match key {
+                            A => window.set_always_on_top(state),
+                            C => window.set_cursor(match state {
+                                true => MouseCursor::Progress,
+                                false => MouseCursor::Default,
+                            }),
+                            D => window.set_decorations(!state),
+                            F => window.set_fullscreen(match state {
+                                true => Some(window.get_current_monitor()),
+                                false => None,
+                            }),
+                            G => window.grab_cursor(state).unwrap(),
+                            H => window.hide_cursor(state),
+                            I => {
+                                println!("Info:");
+                                println!("-> position       : {:?}", window.get_position());
+                                println!("-> inner_position : {:?}", window.get_inner_position());
+                                println!("-> outer_size     : {:?}", window.get_outer_size());
+                                println!("-> inner_size     : {:?}", window.get_inner_size());
+                            },
+                            L => window.set_min_dimensions(match state {
+                                true => Some(WINDOW_SIZE.into()),
+                                false => None,
+                            }),
+                            M => window.set_maximized(state),
+                            P => window.set_position({
+                                let mut position = window.get_position().unwrap();
+                                let sign = if state { 1.0 } else { -1.0 };
+                                position.x += 10.0 * sign;
+                                position.y += 10.0 * sign;
+                                position
+                            }),
+                            Q => window.request_redraw(),
+                            R => window.set_resizable(state),
+                            S => window.set_inner_size(match state {
+                                true => (WINDOW_SIZE.0 + 100, WINDOW_SIZE.1 + 100),
+                                false => WINDOW_SIZE,
+                            }.into()),
+                            W => window.set_cursor_position((
+                                WINDOW_SIZE.0 as i32 / 2,
+                                WINDOW_SIZE.1 as i32 / 2,
+                            ).into()).unwrap(),
+                            Z => {
+                                window.hide();
+                                thread::sleep(Duration::from_secs(1));
+                                window.show();
+                            },
+                            _ => (),
+                        }
+                    },
+                    _ => (),
+                }
+            }
+        });
+    }
+    event_loop.run(move |event, _event_loop, control_flow| {
+        *control_flow = match !window_senders.is_empty() {
+            true => ControlFlow::Wait,
+            false => ControlFlow::Exit,
+        };
+        match event {
+            Event::WindowEvent { event, window_id } => {
+                match event {
+                    WindowEvent::CloseRequested
+                    | WindowEvent::Destroyed
+                    | WindowEvent::KeyboardInput { input: KeyboardInput {
+                        virtual_keycode: Some(VirtualKeyCode::Escape),
+                    .. }, .. } => {
+                        window_senders.remove(&window_id);
+                    },
+                    _ => if let Some(tx) = window_senders.get(&window_id) {
+                        tx.send(event).unwrap();
+                    },
+                }
+            }
+            _ => (),
+        }
+    })
+}
@@ -1,7 +1,10 @@
 #![cfg(target_os = "macos")]
 
 use std::os::raw::c_void;
-use {LogicalSize, MonitorHandle, Window, WindowBuilder};
+
+use crate::dpi::LogicalSize;
+use crate::monitor::MonitorHandle;
+use crate::window::{Window, WindowBuilder};
 
 /// Additional methods on `Window` that are specific to MacOS.
 pub trait WindowExtMacOS {
 
@@ -0,0 +1,88 @@
+use std::collections::VecDeque;
+
+use cocoa::{appkit::{self, NSEvent}, base::id};
+use objc::{declare::ClassDecl, runtime::{Class, Object, Sel}};
+
+use event::{DeviceEvent, Event};
+use platform_impl::platform::{app_state::AppState, DEVICE_ID, util};
+
+pub struct AppClass(pub *const Class);
+unsafe impl Send for AppClass {}
+unsafe impl Sync for AppClass {}
+
+lazy_static! {
+    pub static ref APP_CLASS: AppClass = unsafe {
+        let superclass = class!(NSApplication);
+        let mut decl = ClassDecl::new("WinitApp", superclass).unwrap();
+
+        decl.add_method(
+            sel!(sendEvent:),
+            send_event as extern fn(&Object, Sel, id),
+        );
+
+        AppClass(decl.register())
+    };
+}
+
+// Normally, holding Cmd + any key never sends us a `keyUp` event for that key.
+// Overriding `sendEvent:` like this fixes that. (https://stackoverflow.com/a/15294196)
+// Fun fact: Firefox still has this bug! (https://bugzilla.mozilla.org/show_bug.cgi?id=1299553)
+extern fn send_event(this: &Object, _sel: Sel, event: id) {
+    unsafe {
+        // For posterity, there are some undocumented event types
+        // (https://github.com/servo/cocoa-rs/issues/155)
+        // but that doesn't really matter here.
+        let event_type = event.eventType();
+        let modifier_flags = event.modifierFlags();
+        if event_type == appkit::NSKeyUp && util::has_flag(
+            modifier_flags,
+            appkit::NSEventModifierFlags::NSCommandKeyMask,
+        ) {
+            let key_window: id = msg_send![this, keyWindow];
+            let _: () = msg_send![key_window, sendEvent:event];
+        } else {
+            maybe_dispatch_device_event(event);
+            let superclass = util::superclass(this);
+            let _: () = msg_send![super(this, superclass), sendEvent:event];
+        }
+    }
+}
+
+unsafe fn maybe_dispatch_device_event(event: id) {
+    let event_type = event.eventType();
+    match event_type {
+        appkit::NSMouseMoved |
+        appkit::NSLeftMouseDragged |
+        appkit::NSOtherMouseDragged |
+        appkit::NSRightMouseDragged => {
+            let mut events = VecDeque::with_capacity(3);
+
+            let delta_x = event.deltaX() as f64;
+            let delta_y = event.deltaY() as f64;
+
+            if delta_x != 0.0 {
+                events.push_back(Event::DeviceEvent {
+                    device_id: DEVICE_ID,
+                    event: DeviceEvent::Motion { axis: 0, value: delta_x },
+                });
+            }
+
+            if delta_y != 0.0 {
+                events.push_back(Event::DeviceEvent {
+                    device_id: DEVICE_ID,
+                    event: DeviceEvent::Motion { axis: 1, value: delta_y },
+                });
+            }
+
+            if delta_x != 0.0 || delta_y != 0.0 {
+                events.push_back(Event::DeviceEvent {
+                    device_id: DEVICE_ID,
+                    event: DeviceEvent::MouseMotion { delta: (delta_x, delta_y) },
+                });
+            }
+
+            AppState::queue_events(events);
+        },
+        _ => (),
+    }
+}
@@ -0,0 +1,101 @@
+use cocoa::base::id;
+use objc::{runtime::{Class, Object, Sel, BOOL, YES}, declare::ClassDecl};
+
+use platform_impl::platform::app_state::AppState;
+
+pub struct AppDelegateClass(pub *const Class);
+unsafe impl Send for AppDelegateClass {}
+unsafe impl Sync for AppDelegateClass {}
+
+lazy_static! {
+    pub static ref APP_DELEGATE_CLASS: AppDelegateClass = unsafe {
+        let superclass = class!(NSResponder);
+        let mut decl = ClassDecl::new("WinitAppDelegate", superclass).unwrap();
+
+        decl.add_method(
+            sel!(applicationDidFinishLaunching:),
+            did_finish_launching as extern fn(&Object, Sel, id) -> BOOL,
+        );
+        decl.add_method(
+            sel!(applicationDidBecomeActive:),
+            did_become_active as extern fn(&Object, Sel, id),
+        );
+        decl.add_method(
+            sel!(applicationWillResignActive:),
+            will_resign_active as extern fn(&Object, Sel, id),
+        );
+        decl.add_method(
+            sel!(applicationWillEnterForeground:),
+            will_enter_foreground as extern fn(&Object, Sel, id),
+        );
+        decl.add_method(
+            sel!(applicationDidEnterBackground:),
+            did_enter_background as extern fn(&Object, Sel, id),
+        );
+        decl.add_method(
+            sel!(applicationWillTerminate:),
+            will_terminate as extern fn(&Object, Sel, id),
+        );
+
+        AppDelegateClass(decl.register())
+    };
+}
+
+extern fn did_finish_launching(_: &Object, _: Sel, _: id) -> BOOL {
+    trace!("Triggered `didFinishLaunching`");
+    AppState::launched();
+    trace!("Completed `didFinishLaunching`");
+    YES
+}
+
+extern fn did_become_active(_: &Object, _: Sel, _: id) {
+    trace!("Triggered `didBecomeActive`");
+    /*unsafe {
+        HANDLER.lock().unwrap().handle_nonuser_event(Event::Suspended(false))
+    }*/
+    trace!("Completed `didBecomeActive`");
+}
+
+extern fn will_resign_active(_: &Object, _: Sel, _: id) {
+    trace!("Triggered `willResignActive`");
+    /*unsafe {
+        HANDLER.lock().unwrap().handle_nonuser_event(Event::Suspended(true))
+    }*/
+    trace!("Completed `willResignActive`");
+}
+
+extern fn will_enter_foreground(_: &Object, _: Sel, _: id) {
+    trace!("Triggered `willEnterForeground`");
+    trace!("Completed `willEnterForeground`");
+}
+
+extern fn did_enter_background(_: &Object, _: Sel, _: id) {
+    trace!("Triggered `didEnterBackground`");
+    trace!("Completed `didEnterBackground`");
+}
+
+extern fn will_terminate(_: &Object, _: Sel, _: id) {
+    trace!("Triggered `willTerminate`");
+    /*unsafe {
+        let app: id = msg_send![class!(UIApplication), sharedApplication];
+        let windows: id = msg_send![app, windows];
+        let windows_enum: id = msg_send![windows, objectEnumerator];
+        let mut events = Vec::new();
+        loop {
+            let window: id = msg_send![windows_enum, nextObject];
+            if window == nil {
+                break
+            }
+            let is_winit_window: BOOL = msg_send![window, isKindOfClass:class!(WinitUIWindow)];
+            if is_winit_window == YES {
+                events.push(Event::WindowEvent {
+                    window_id: RootWindowId(window.into()),
+                    event: WindowEvent::Destroyed,
+                });
+            }
+        }
+        HANDLER.lock().unwrap().handle_nonuser_events(events);
+        HANDLER.lock().unwrap().terminated();
+    }*/
+    trace!("Completed `willTerminate`");
+}