User events

Author: francesca64

src/platform_impl/macos/app_state.rs

@@ -27,15 +27,16 @@ impl Event<Never> {
 
 pub trait EventHandler: Debug {
     fn handle_nonuser_event(&mut self, event: Event<Never>, control_flow: &mut ControlFlow);
-    //fn handle_user_events(&mut self, control_flow: &mut ControlFlow);
+    fn handle_user_events(&mut self, control_flow: &mut ControlFlow);
 }
 
 struct EventLoopHandler<F, T: 'static> {
     callback: F,
+    will_exit: bool,
     window_target: RootWindowTarget<T>,
 }
 
-impl<F, T: 'static> Debug for EventLoopHandler<F, T> {
+impl<F, T> Debug for EventLoopHandler<F, T> {
     fn fmt(&self, formatter: &mut Formatter) -> fmt::Result {
         formatter.debug_struct("EventLoopHandler")
             .field("window_target", &self.window_target)
@@ -54,17 +55,27 @@ where
             &self.window_target,
             control_flow,
         );
+        self.will_exit |= *control_flow == ControlFlow::Exit;
+        if self.will_exit {
+            *control_flow = ControlFlow::Exit;
+        }
     }
 
-    /*fn handle_user_events(&mut self, control_flow: &mut ControlFlow) {
-        for event in self.event_loop.inner.receiver.try_iter() {
+    fn handle_user_events(&mut self, control_flow: &mut ControlFlow) {
+        let mut will_exit = self.will_exit;
+        for event in self.window_target.inner.receiver.try_iter() {
             (self.callback)(
                 Event::UserEvent(event),
-                &self.event_loop,
+                &self.window_target,
                 control_flow,
             );
+            will_exit |= *control_flow == ControlFlow::Exit;
+            if will_exit {
+                *control_flow = ControlFlow::Exit;
+            }
         }
-    }*/
+        self.will_exit = will_exit;
+    }
 }
 
 #[derive(Default)]
@@ -98,7 +109,7 @@ impl Handler {
         self.ready.store(true, Ordering::Release);
     }
 
-    fn is_control_flow_exit(&self) -> bool {
+    fn should_exit(&self) -> bool {
         *self.control_flow.lock().unwrap() == ControlFlow::Exit
     }
 
@@ -134,6 +145,14 @@ impl Handler {
             );
         }
     }
+
+    fn handle_user_events(&self) {
+        if let Some(ref mut callback) = *self.callback.lock().unwrap() {
+            callback.handle_user_events(
+                &mut *self.control_flow.lock().unwrap(),
+            );
+        }
+    }
 }
 
 pub enum AppState {}
@@ -146,6 +165,7 @@ impl AppState {
     {
         *HANDLER.callback.lock().unwrap() = Some(Box::new(EventLoopHandler {
             callback,
+            will_exit: false,
             window_target,
         }));
     }
@@ -203,14 +223,12 @@ impl AppState {
 
     pub fn cleared() {
         if !HANDLER.is_ready() { return }
-        let mut will_stop = HANDLER.is_control_flow_exit();
+        HANDLER.handle_user_events();
         for event in HANDLER.take_events() {
             HANDLER.handle_nonuser_event(event);
-            will_stop |= HANDLER.is_control_flow_exit();
         }
         HANDLER.handle_nonuser_event(Event::EventsCleared);
-        will_stop |= HANDLER.is_control_flow_exit();
-        if will_stop {
+        if HANDLER.should_exit() {
             let _: () = unsafe { msg_send![NSApp(), stop:nil] };
             return
         }

src/platform_impl/macos/event_loop.rs

@@ -1,5 +1,5 @@
 use std::{
-    collections::VecDeque, marker::PhantomData, process,
+    collections::VecDeque, mem, os::raw::c_void, process, ptr, sync::mpsc,
 };
 
 use cocoa::{appkit::NSApp, base::{id, nil}, foundation::NSAutoreleasePool};
@@ -11,16 +11,18 @@ use {
 use platform_impl::platform::{
     app::APP_CLASS, app_delegate::APP_DELEGATE_CLASS,
     app_state::AppState, monitor::{self, MonitorHandle},
-    observer::setup_control_flow_observers, util::IdRef,
+    observer::*, util::IdRef,
 };
 
 pub struct EventLoopWindowTarget<T: 'static> {
-    _marker: PhantomData<T>,
+    pub sender: mpsc::Sender<T>, // this is only here to be cloned elsewhere
+    pub receiver: mpsc::Receiver<T>,
 }
 
 impl<T> Default for EventLoopWindowTarget<T> {
     fn default() -> Self {
-        EventLoopWindowTarget { _marker: PhantomData }
+        let (sender, receiver) = mpsc::channel();
+        EventLoopWindowTarget { sender, receiver }
     }
 }
 
@@ -90,23 +92,50 @@ impl<T> EventLoop<T> {
     }
 
     pub fn create_proxy(&self) -> Proxy<T> {
-        Proxy::default()
+        Proxy::new(self.window_target.inner.sender.clone())
     }
 }
 
 #[derive(Clone)]
 pub struct Proxy<T> {
-    _marker: PhantomData<T>,
+    sender: mpsc::Sender<T>,
+    source: CFRunLoopSourceRef,
 }
 
-impl<T> Default for Proxy<T> {
-    fn default() -> Self {
-        Proxy { _marker: PhantomData }
-    }
-}
+unsafe impl<T> Send for Proxy<T> {}
+unsafe impl<T> Sync for Proxy<T> {}
 
 impl<T> Proxy<T> {
-    pub fn send_event(&self, _event: T) -> Result<(), EventLoopClosed> {
-        unimplemented!();
+    fn new(sender: mpsc::Sender<T>) -> Self {
+        unsafe {
+            // just wakeup the eventloop
+            extern "C" fn event_loop_proxy_handler(_: *mut c_void) {}
+
+            // adding a Source to the main CFRunLoop lets us wake it up and
+            // process user events through the normal OS EventLoop mechanisms.
+            let rl = CFRunLoopGetMain();
+            let mut context: CFRunLoopSourceContext = mem::zeroed();
+            context.perform = event_loop_proxy_handler;
+            let source = CFRunLoopSourceCreate(
+                ptr::null_mut(),
+                CFIndex::max_value() - 1,
+                &mut context,
+            );
+            CFRunLoopAddSource(rl, source, kCFRunLoopCommonModes);
+            CFRunLoopWakeUp(rl);
+
+            Proxy { sender, source }
+        }
+    }
+
+    pub fn send_event(&self, event: T) -> Result<(), EventLoopClosed> {
+        self.sender.send(event).map_err(|_| EventLoopClosed)?;
+        unsafe {
+            // let the main thread know there's a new event
+            CFRunLoopSourceSignal(self.source);
+            let rl = CFRunLoopGetMain();
+            CFRunLoopWakeUp(rl);
+        }
+        Ok(())
     }
 }

src/platform_impl/macos/observer.rs

@@ -215,7 +215,7 @@ impl Default for EventLoopWaker {
     fn default() -> EventLoopWaker {
         extern fn wakeup_main_loop(_timer: CFRunLoopTimerRef, _info: *mut c_void) {}
         unsafe {
-            // create a timer with a 1microsec interval (1ns does not work) to mimic polling.
+            // create a timer with a 1µs interval (1ns does not work) to mimic polling.
             // it is initially setup with a first fire time really far into the
             // future, but that gets changed to fire immediatley in did_finish_launching
             let timer = CFRunLoopTimerCreate(
@@ -228,7 +228,6 @@ impl Default for EventLoopWaker {
                 ptr::null_mut(),
             );
             CFRunLoopAddTimer(CFRunLoopGetMain(), timer, kCFRunLoopCommonModes);
-
             EventLoopWaker { timer }
         }
     }

src/platform_impl/macos/util.rs

@@ -402,72 +402,78 @@ pub unsafe fn create_input_context(view: id) -> IdRef {
     IdRef::new(input_context)
 }
 
-pub enum CursorType {
+pub enum Cursor {
     Native(&'static str),
     Undocumented(&'static str),
     WebKit(&'static str),
 }
 
-impl From<MouseCursor> for CursorType {
+impl From<MouseCursor> for Cursor {
     fn from(cursor: MouseCursor) -> Self {
         match cursor {
-            MouseCursor::Arrow | MouseCursor::Default => CursorType::Native("arrowCursor"),
-            MouseCursor::Hand => CursorType::Native("pointingHandCursor"),
-            MouseCursor::Grabbing | MouseCursor::Grab => CursorType::Native("closedHandCursor"),
-            MouseCursor::Text => CursorType::Native("IBeamCursor"),
-            MouseCursor::VerticalText => CursorType::Native("IBeamCursorForVerticalLayout"),
-            MouseCursor::Copy => CursorType::Native("dragCopyCursor"),
-            MouseCursor::Alias => CursorType::Native("dragLinkCursor"),
-            MouseCursor::NotAllowed | MouseCursor::NoDrop => CursorType::Native("operationNotAllowedCursor"),
-            MouseCursor::ContextMenu => CursorType::Native("contextualMenuCursor"),
-            MouseCursor::Crosshair => CursorType::Native("crosshairCursor"),
-            MouseCursor::EResize => CursorType::Native("resizeRightCursor"),
-            MouseCursor::NResize => CursorType::Native("resizeUpCursor"),
-            MouseCursor::WResize => CursorType::Native("resizeLeftCursor"),
-            MouseCursor::SResize => CursorType::Native("resizeDownCursor"),
-            MouseCursor::EwResize | MouseCursor::ColResize => CursorType::Native("resizeLeftRightCursor"),
-            MouseCursor::NsResize | MouseCursor::RowResize => CursorType::Native("resizeUpDownCursor"),
+            MouseCursor::Arrow | MouseCursor::Default => Cursor::Native("arrowCursor"),
+            MouseCursor::Hand => Cursor::Native("pointingHandCursor"),
+            MouseCursor::Grabbing | MouseCursor::Grab => Cursor::Native("closedHandCursor"),
+            MouseCursor::Text => Cursor::Native("IBeamCursor"),
+            MouseCursor::VerticalText => Cursor::Native("IBeamCursorForVerticalLayout"),
+            MouseCursor::Copy => Cursor::Native("dragCopyCursor"),
+            MouseCursor::Alias => Cursor::Native("dragLinkCursor"),
+            MouseCursor::NotAllowed | MouseCursor::NoDrop => Cursor::Native("operationNotAllowedCursor"),
+            MouseCursor::ContextMenu => Cursor::Native("contextualMenuCursor"),
+            MouseCursor::Crosshair => Cursor::Native("crosshairCursor"),
+            MouseCursor::EResize => Cursor::Native("resizeRightCursor"),
+            MouseCursor::NResize => Cursor::Native("resizeUpCursor"),
+            MouseCursor::WResize => Cursor::Native("resizeLeftCursor"),
+            MouseCursor::SResize => Cursor::Native("resizeDownCursor"),
+            MouseCursor::EwResize | MouseCursor::ColResize => Cursor::Native("resizeLeftRightCursor"),
+            MouseCursor::NsResize | MouseCursor::RowResize => Cursor::Native("resizeUpDownCursor"),
 
             // Undocumented cursors: https://stackoverflow.com/a/46635398/5435443
-            MouseCursor::Help => CursorType::Undocumented("_helpCursor"),
-            MouseCursor::ZoomIn => CursorType::Undocumented("_zoomInCursor"),
-            MouseCursor::ZoomOut => CursorType::Undocumented("_zoomOutCursor"),
-            MouseCursor::NeResize => CursorType::Undocumented("_windowResizeNorthEastCursor"),
-            MouseCursor::NwResize => CursorType::Undocumented("_windowResizeNorthWestCursor"),
-            MouseCursor::SeResize => CursorType::Undocumented("_windowResizeSouthEastCursor"),
-            MouseCursor::SwResize => CursorType::Undocumented("_windowResizeSouthWestCursor"),
-            MouseCursor::NeswResize => CursorType::Undocumented("_windowResizeNorthEastSouthWestCursor"),
-            MouseCursor::NwseResize => CursorType::Undocumented("_windowResizeNorthWestSouthEastCursor"),
+            MouseCursor::Help => Cursor::Undocumented("_helpCursor"),
+            MouseCursor::ZoomIn => Cursor::Undocumented("_zoomInCursor"),
+            MouseCursor::ZoomOut => Cursor::Undocumented("_zoomOutCursor"),
+            MouseCursor::NeResize => Cursor::Undocumented("_windowResizeNorthEastCursor"),
+            MouseCursor::NwResize => Cursor::Undocumented("_windowResizeNorthWestCursor"),
+            MouseCursor::SeResize => Cursor::Undocumented("_windowResizeSouthEastCursor"),
+            MouseCursor::SwResize => Cursor::Undocumented("_windowResizeSouthWestCursor"),
+            MouseCursor::NeswResize => Cursor::Undocumented("_windowResizeNorthEastSouthWestCursor"),
+            MouseCursor::NwseResize => Cursor::Undocumented("_windowResizeNorthWestSouthEastCursor"),
 
             // While these are available, the former just loads a white arrow,
             // and the latter loads an ugly deflated beachball!
-            // MouseCursor::Move => CursorType::Undocumented("_moveCursor"),
-            // MouseCursor::Wait => CursorType::Undocumented("_waitCursor"),
+            // MouseCursor::Move => Cursor::Undocumented("_moveCursor"),
+            // MouseCursor::Wait => Cursor::Undocumented("_waitCursor"),
 
             // An even more undocumented cursor...
             // https://bugs.eclipse.org/bugs/show_bug.cgi?id=522349
             // This is the wrong semantics for `Wait`, but it's the same as
             // what's used in Safari and Chrome.
-            MouseCursor::Wait | MouseCursor::Progress => CursorType::Undocumented("busyButClickableCursor"),
+            MouseCursor::Wait | MouseCursor::Progress => Cursor::Undocumented("busyButClickableCursor"),
 
             // For the rest, we can just snatch the cursors from WebKit...
             // They fit the style of the native cursors, and will seem
             // completely standard to macOS users.
             // https://stackoverflow.com/a/21786835/5435443
-            MouseCursor::Move | MouseCursor::AllScroll => CursorType::WebKit("move"),
-            MouseCursor::Cell => CursorType::WebKit("cell"),
+            MouseCursor::Move | MouseCursor::AllScroll => Cursor::WebKit("move"),
+            MouseCursor::Cell => Cursor::WebKit("cell"),
         }
     }
 }
 
-impl CursorType {
-    pub unsafe fn load(self) -> id {
+impl Default for Cursor {
+    fn default() -> Self {
+        Cursor::Native("arrowCursor")
+    }
+}
+
+impl Cursor {
+    pub unsafe fn load(&self) -> id {
         match self {
-            CursorType::Native(cursor_name) => {
+            Cursor::Native(cursor_name) => {
                 let sel = Sel::register(cursor_name);
                 msg_send![class!(NSCursor), performSelector:sel]
             },
-            CursorType::Undocumented(cursor_name) => {
+            Cursor::Undocumented(cursor_name) => {
                 let class = class!(NSCursor);
                 let sel = Sel::register(cursor_name);
                 let sel = if msg_send![class, respondsToSelector:sel] {
@@ -478,7 +484,7 @@ impl CursorType {
                 };
                 msg_send![class, performSelector:sel]
             },
-            CursorType::WebKit(cursor_name) => load_webkit_cursor(cursor_name),
+            Cursor::WebKit(cursor_name) => load_webkit_cursor(cursor_name),
         }
     }
 }

src/platform_impl/macos/view.rs

@@ -1,7 +1,7 @@
-// This is a pretty close port of the implementation in GLFW:
-// https://github.com/glfw/glfw/blob/7ef34eb06de54dd9186d3d21a401b2ef819b59e7/src/cocoa_window.m
-
-use std::{boxed::Box, collections::VecDeque, os::raw::*, slice, str};
+use std::{
+    boxed::Box, collections::VecDeque, os::raw::*, slice, str,
+    sync::{Arc, Mutex, Weak},
+};
 
 use cocoa::{
     appkit::{NSApp, NSEvent, NSEventModifierFlags, NSEventPhase, NSView, NSWindow},
@@ -32,15 +32,19 @@ struct Modifiers {
 
 struct ViewState {
     nswindow: id,
+    pub cursor: Arc<Mutex<util::Cursor>>,
     ime_spot: Option<(f64, f64)>,
     raw_characters: Option<String>,
     is_key_down: bool,
     modifiers: Modifiers,
 }
 
-pub fn new_view(nswindow: id) -> IdRef {
+pub fn new_view(nswindow: id) -> (IdRef, Weak<Mutex<util::Cursor>>) {
+    let cursor = Default::default();
+    let cursor_access = Arc::downgrade(&cursor);
     let state = ViewState {
         nswindow,
+        cursor,
         ime_spot: None,
         raw_characters: None,
         is_key_down: false,
@@ -50,23 +54,21 @@ pub fn new_view(nswindow: id) -> IdRef {
         // This is free'd in `dealloc`
         let state_ptr = Box::into_raw(Box::new(state)) as *mut c_void;
         let nsview: id = msg_send![VIEW_CLASS.0, alloc];
-        IdRef::new(msg_send![nsview, initWithWinit:state_ptr])
+        (IdRef::new(msg_send![nsview, initWithWinit:state_ptr]), cursor_access)
     }
 }
 
-pub fn set_ime_spot(nsview: id, input_context: id, x: f64, y: f64) {
-    unsafe {
-        let state_ptr: *mut c_void = *(*nsview).get_mut_ivar("winitState");
-        let state = &mut *(state_ptr as *mut ViewState);
-        let content_rect = NSWindow::contentRectForFrameRect_(
-            state.nswindow,
-            NSWindow::frame(state.nswindow),
-        );
-        let base_x = content_rect.origin.x as f64;
-        let base_y = (content_rect.origin.y + content_rect.size.height) as f64;
-        state.ime_spot = Some((base_x + x, base_y - y));
-        let _: () = msg_send![input_context, invalidateCharacterCoordinates];
-    }
+pub unsafe fn set_ime_spot(nsview: id, input_context: id, x: f64, y: f64) {
+    let state_ptr: *mut c_void = *(*nsview).get_mut_ivar("winitState");
+    let state = &mut *(state_ptr as *mut ViewState);
+    let content_rect = NSWindow::contentRectForFrameRect_(
+        state.nswindow,
+        NSWindow::frame(state.nswindow),
+    );
+    let base_x = content_rect.origin.x as f64;
+    let base_y = (content_rect.origin.y + content_rect.size.height) as f64;
+    state.ime_spot = Some((base_x + x, base_y - y));
+    let _: () = msg_send![input_context, invalidateCharacterCoordinates];
 }
 
 struct ViewClass(*const Class);
@@ -93,6 +95,14 @@ lazy_static! {
             sel!(acceptsFirstResponder),
             accepts_first_responder as extern fn(&Object, Sel) -> BOOL,
         );
+        decl.add_method(
+            sel!(touchBar),
+            touch_bar as extern fn(&Object, Sel) -> BOOL,
+        );
+        decl.add_method(
+            sel!(resetCursorRects),
+            reset_cursor_rects as extern fn(&Object, Sel),
+        );
         decl.add_method(
             sel!(hasMarkedText),
            has_marked_text as extern fn(&Object, Sel) -> BOOL,
@@ -270,6 +280,28 @@ extern fn accepts_first_responder(_this: &Object, _sel: Sel) -> BOOL {
     YES
 }
 
+// This is necessary to prevent a beefy terminal error on MacBook Pros:
+// IMKInputSession [0x7fc573576ff0 presentFunctionRowItemTextInputViewWithEndpoint:completionHandler:] : [self textInputContext]=0x7fc573558e10 *NO* NSRemoteViewController to client, NSError=Error Domain=NSCocoaErrorDomain Code=4099 "The connection from pid 0 was invalidated from this process." UserInfo={NSDebugDescription=The connection from pid 0 was invalidated from this process.}, com.apple.inputmethod.EmojiFunctionRowItem
+// TODO: Add an API extension for using `NSTouchBar`
+extern fn touch_bar(_this: &Object, _sel: Sel) -> BOOL {
+    NO
+}
+
+extern fn reset_cursor_rects(this: &Object, _sel: Sel) {
+    unsafe {
+        let state_ptr: *mut c_void = *this.get_ivar("winitState");
+        let state = &mut *(state_ptr as *mut ViewState);
+
+        let bounds: NSRect = msg_send![this, bounds];
+        let cursor = state.cursor.lock().unwrap().load();
+        let _: () = msg_send![this,
+            addCursorRect:bounds
+            cursor:cursor
+        ];
+    }
+}
+
+
 extern fn has_marked_text(this: &Object, _sel: Sel) -> BOOL {
     unsafe {
         trace!("Triggered `hasMarkedText`");

src/platform_impl/macos/window.rs

@@ -1,6 +1,6 @@
 use std::{
     collections::VecDeque, f64, os::raw::c_void,
-    sync::{Arc, atomic::{Ordering, AtomicBool}, Mutex},
+    sync::{Arc, atomic::{Ordering, AtomicBool}, Mutex, Weak},
 };
 
 use cocoa::{
@@ -24,7 +24,7 @@ use platform::macos::{ActivationPolicy, WindowExtMacOS};
 use platform_impl::platform::{
     {ffi, util::{self, IdRef}},
     monitor::{self, MonitorHandle},
-    view::{new_view, set_ime_spot},
+    view::{self, new_view},
     window_delegate::{WindowDelegate, WindowDelegateState},
 };
 
@@ -67,8 +67,9 @@ fn create_app(activation_policy: ActivationPolicy) -> Option<id> {
     }
 }
 
-unsafe fn create_view(nswindow: id) -> Option<IdRef> {
-    new_view(nswindow).non_nil().map(|nsview| {
+unsafe fn create_view(nswindow: id) -> Option<(IdRef, Weak<Mutex<util::Cursor>>)> {
+    let (nsview, cursor) = new_view(nswindow);
+    nsview.non_nil().map(|nsview| {
         nsview.setWantsBestResolutionOpenGLSurface_(YES);
 
         // On Mojave, views automatically become layer-backed shortly after being added to
@@ -82,7 +83,7 @@ unsafe fn create_view(nswindow: id) -> Option<IdRef> {
 
         nswindow.setContentView_(*nsview);
         nswindow.makeFirstResponder_(*nsview);
-        nsview
+        (nsview, cursor)
     })
 }
 
@@ -234,6 +235,7 @@ pub struct UnownedWindow {
     input_context: IdRef, // never changes
     pub shared_state: Arc<Mutex<SharedState>>,
     decorations: AtomicBool,
+    cursor: Weak<Mutex<util::Cursor>>,
     cursor_hidden: AtomicBool,
 }
 
@@ -263,7 +265,7 @@ impl UnownedWindow {
             CreationError::OsError(format!("Couldn't create `NSWindow`"))
         })?;
 
-        let nsview = unsafe { create_view(*nswindow) }.ok_or_else(|| {
+        let (nsview, cursor) = unsafe { create_view(*nswindow) }.ok_or_else(|| {
             unsafe { pool.drain() };
             CreationError::OsError(format!("Couldn't create `NSView`"))
         })?;
@@ -305,6 +307,7 @@ impl UnownedWindow {
             input_context,
             shared_state: Arc::new(Mutex::new(win_attribs.into())),
             decorations: AtomicBool::new(decorations),
+            cursor,
             cursor_hidden: Default::default(),
         });
 
@@ -477,9 +480,14 @@ impl UnownedWindow {
     }
 
     pub fn set_cursor(&self, cursor: MouseCursor) {
+        let cursor = util::Cursor::from(cursor);
+        if let Some(cursor_access) = self.cursor.upgrade() {
+            *cursor_access.lock().unwrap() = cursor;
+        }
         unsafe {
-            let cursor = util::CursorType::from(cursor).load();
-            let _: () = msg_send![cursor, set];
+            let _: () = msg_send![*self.nswindow,
+                invalidateCursorRectsForView:*self.nsview
+            ];
         }
     }
 
@@ -707,7 +715,14 @@ impl UnownedWindow {
 
     #[inline]
     pub fn set_ime_spot(&self, logical_spot: LogicalPosition) {
-        set_ime_spot(*self.nsview, *self.input_context, logical_spot.x, logical_spot.y);
+        unsafe {
+            view::set_ime_spot(
+                *self.nsview,
+                *self.input_context,
+                logical_spot.x,
+                logical_spot.y,
+            );
+        }
     }
 
     #[inline]