MacOS: Only activate after the application has finished launching (#1903)

* MacOS: Only activate after the application has finished launching

This fixes the main menu not responding until you refocus, at least from what I can tell - though we might have to do something similar to linebender/druid#994 to fix it fully?

* MacOS: Remove activation hack

* Stop unnecessarily calling `makeKeyWindow` on initially hidden windows

You can't make hidden windows the key window

* Add new, simpler activation hack

For activating multiple windows created before the application finished launching

Author: madsmtm

CHANGELOG.md

@@ -1,5 +1,6 @@
 # Unreleased
 
+- On macOS, wait with activating the application until the application has initialized.
 - On macOS, fix creating new windows when the application has a main menu.
 - On Windows, fix fractional deltas for mouse wheel device events.
 - On macOS, fix segmentation fault after dropping the main window.

src/platform_impl/macos/activation_hack.rs

@@ -2,14 +2,14 @@ use std::collections::VecDeque;
 
 use cocoa::{
     appkit::{self, NSEvent},
-    base::{id, nil},
+    base::id,
 };
 use objc::{
     declare::ClassDecl,
     runtime::{Class, Object, Sel},
 };
 
-use super::{activation_hack, app_state::AppState, event::EventWrapper, util, DEVICE_ID};
+use super::{app_state::AppState, event::EventWrapper, util, DEVICE_ID};
 use crate::event::{DeviceEvent, ElementState, Event};
 
 pub struct AppClass(pub *const Class);
@@ -49,14 +49,14 @@ extern "C" fn send_event(this: &Object, _sel: Sel, event: id) {
             let key_window: id = msg_send![this, keyWindow];
             let _: () = msg_send![key_window, sendEvent: event];
         } else {
-            maybe_dispatch_device_event(this, event);
+            maybe_dispatch_device_event(event);
             let superclass = util::superclass(this);
             let _: () = msg_send![super(this, superclass), sendEvent: event];
         }
     }
 }
 
-unsafe fn maybe_dispatch_device_event(this: &Object, event: id) {
+unsafe fn maybe_dispatch_device_event(event: id) {
     let event_type = event.eventType();
     match event_type {
         appkit::NSMouseMoved
@@ -98,21 +98,6 @@ unsafe fn maybe_dispatch_device_event(this: &Object, event: id) {
             }
 
             AppState::queue_events(events);
-
-            // Notify the delegate when the first mouse move occurs. This is
-            // used for the unbundled app activation hack, which needs to know
-            // if any mouse motions occurred prior to the app activating.
-            let delegate: id = msg_send![this, delegate];
-            assert_ne!(delegate, nil);
-            if !activation_hack::State::get_mouse_moved(&*delegate) {
-                activation_hack::State::set_mouse_moved(&*delegate, true);
-                let () = msg_send![
-                    delegate,
-                    performSelector: sel!(activationHackMouseMoved:)
-                    withObject: nil
-                    afterDelay: 0.0
-                ];
-            }
         }
         appkit::NSLeftMouseDown | appkit::NSRightMouseDown | appkit::NSOtherMouseDown => {
             let mut events = VecDeque::with_capacity(1);

src/platform_impl/macos/app.rs

@@ -1,10 +1,9 @@
-use super::{activation_hack, app_state::AppState};
+use super::app_state::AppState;
 use cocoa::base::id;
 use objc::{
     declare::ClassDecl,
     runtime::{Class, Object, Sel},
 };
-use std::os::raw::c_void;
 
 pub struct AppDelegateClass(pub *const Class);
 unsafe impl Send for AppDelegateClass {}
@@ -15,67 +14,17 @@ lazy_static! {
         let superclass = class!(NSResponder);
         let mut decl = ClassDecl::new("WinitAppDelegate", superclass).unwrap();
 
-        decl.add_class_method(sel!(new), new as extern "C" fn(&Class, Sel) -> id);
-        decl.add_method(sel!(dealloc), dealloc as extern "C" fn(&Object, Sel));
         decl.add_method(
             sel!(applicationDidFinishLaunching:),
             did_finish_launching as extern "C" fn(&Object, Sel, id),
         );
-        decl.add_method(
-            sel!(applicationDidBecomeActive:),
-            did_become_active as extern "C" fn(&Object, Sel, id),
-        );
-        decl.add_method(
-            sel!(applicationDidResignActive:),
-            did_resign_active as extern "C" fn(&Object, Sel, id),
-        );
-
-        decl.add_ivar::<*mut c_void>(activation_hack::State::name());
-        decl.add_method(
-            sel!(activationHackMouseMoved:),
-            activation_hack::mouse_moved as extern "C" fn(&Object, Sel, id),
-        );
 
         AppDelegateClass(decl.register())
     };
 }
 
-extern "C" fn new(class: &Class, _: Sel) -> id {
-    unsafe {
-        let this: id = msg_send![class, alloc];
-        let this: id = msg_send![this, init];
-        (*this).set_ivar(
-            activation_hack::State::name(),
-            activation_hack::State::new(),
-        );
-        this
-    }
-}
-
-extern "C" fn dealloc(this: &Object, _: Sel) {
-    unsafe {
-        activation_hack::State::free(activation_hack::State::get_ptr(this));
-    }
-}
-
 extern "C" fn did_finish_launching(_: &Object, _: Sel, _: id) {
     trace!("Triggered `applicationDidFinishLaunching`");
     AppState::launched();
     trace!("Completed `applicationDidFinishLaunching`");
 }
-
-extern "C" fn did_become_active(this: &Object, _: Sel, _: id) {
-    trace!("Triggered `applicationDidBecomeActive`");
-    unsafe {
-        activation_hack::State::set_activated(this, true);
-    }
-    trace!("Completed `applicationDidBecomeActive`");
-}
-
-extern "C" fn did_resign_active(this: &Object, _: Sel, _: id) {
-    trace!("Triggered `applicationDidResignActive`");
-    unsafe {
-        activation_hack::refocus(this);
-    }
-    trace!("Completed `applicationDidResignActive`");
-}