macOS: Dpi overhaul

Cargo.toml

@@ -37,7 +37,7 @@ core-foundation = "0.6"
 core-graphics = "0.17.3"
 core-video-sys = "0.1.2"
 dispatch = "0.1.4"
-objc = "0.2.3"
+objc = "0.2.6"
 
 [target.'cfg(target_os = "windows")'.dependencies]
 bitflags = "1"

src/platform_impl/macos/app_state.rs

@@ -10,21 +10,30 @@ use std::{
     time::Instant,
 };
 
-use cocoa::{appkit::NSApp, base::nil};
+use cocoa::{
+    appkit::{NSApp, NSWindow},
+    base::nil,
+};
 
 use crate::{
+    dpi::{LogicalSize, PhysicalSize},
     event::{Event, StartCause, WindowEvent},
     event_loop::{ControlFlow, EventLoopWindowTarget as RootWindowTarget},
-    platform_impl::platform::{observer::EventLoopWaker, util::Never},
+    platform_impl::platform::{
+        event::{EventProxy, EventWrapper, WindowEventProxy},
+        observer::EventLoopWaker,
+        util::{IdRef, Never},
+        window::get_window_id,
+    },
     window::WindowId,
 };
 
 lazy_static! {
     static ref HANDLER: Handler = Default::default();
 }
 
-impl Event<Never> {
-    fn userify<T: 'static>(self) -> Event<T> {
+impl<'a, Never> Event<'a, Never> {
+    fn userify<T: 'static>(self) -> Event<'a, T> {
         self.map_nonuser_event()
             // `Never` can't be constructed, so the `UserEvent` variant can't
             // be present here.
@@ -33,7 +42,8 @@ impl Event<Never> {
 }
 
 pub trait EventHandler: Debug {
-    fn handle_nonuser_event(&mut self, event: Event<Never>, control_flow: &mut ControlFlow);
+    // Not sure probably it should accept Event<'static, Never>
+    fn handle_nonuser_event(&mut self, event: Event<'_, Never>, control_flow: &mut ControlFlow);
     fn handle_user_events(&mut self, control_flow: &mut ControlFlow);
 }
 
@@ -54,10 +64,10 @@ impl<F, T> Debug for EventLoopHandler<F, T> {
 
 impl<F, T> EventHandler for EventLoopHandler<F, T>
 where
-    F: 'static + FnMut(Event<T>, &RootWindowTarget<T>, &mut ControlFlow),
+    F: 'static + FnMut(Event<'_, T>, &RootWindowTarget<T>, &mut ControlFlow),
     T: 'static,
 {
-    fn handle_nonuser_event(&mut self, event: Event<Never>, control_flow: &mut ControlFlow) {
+    fn handle_nonuser_event(&mut self, event: Event<'_, Never>, control_flow: &mut ControlFlow) {
         (self.callback)(event.userify(), &self.window_target, control_flow);
         self.will_exit |= *control_flow == ControlFlow::Exit;
         if self.will_exit {
@@ -86,29 +96,30 @@ struct Handler {
     control_flow_prev: Mutex<ControlFlow>,
     start_time: Mutex<Option<Instant>>,
     callback: Mutex<Option<Box<dyn EventHandler>>>,
-    pending_events: Mutex<VecDeque<Event<Never>>>,
-    deferred_events: Mutex<VecDeque<Event<Never>>>,
+    pending_events: Mutex<VecDeque<Event<'static, Never>>>,
+    deferred_events: Mutex<VecDeque<EventWrapper>>,
     pending_redraw: Mutex<Vec<WindowId>>,
     waker: Mutex<EventLoopWaker>,
+    window_size: Box<Option<PhysicalSize>>,
 }
 
 unsafe impl Send for Handler {}
 unsafe impl Sync for Handler {}
 
 impl Handler {
-    fn events<'a>(&'a self) -> MutexGuard<'a, VecDeque<Event<Never>>> {
+    fn events(&self) -> MutexGuard<'_, VecDeque<Event<'static, Never>>> {
         self.pending_events.lock().unwrap()
     }
 
-    fn deferred<'a>(&'a self) -> MutexGuard<'a, VecDeque<Event<Never>>> {
+    fn deferred(&self) -> MutexGuard<'_, VecDeque<EventWrapper>> {
         self.deferred_events.lock().unwrap()
     }
 
-    fn redraw<'a>(&'a self) -> MutexGuard<'a, Vec<WindowId>> {
+    fn redraw(&self) -> MutexGuard<'_, Vec<WindowId>> {
         self.pending_redraw.lock().unwrap()
     }
 
-    fn waker<'a>(&'a self) -> MutexGuard<'a, EventLoopWaker> {
+    fn waker(&self) -> MutexGuard<'_, EventLoopWaker> {
         self.waker.lock().unwrap()
     }
 
@@ -144,11 +155,11 @@ impl Handler {
         *self.start_time.lock().unwrap() = Some(Instant::now());
     }
 
-    fn take_events(&self) -> VecDeque<Event<Never>> {
+    fn take_events(&self) -> VecDeque<Event<'_, Never>> {
         mem::replace(&mut *self.events(), Default::default())
     }
 
-    fn take_deferred(&self) -> VecDeque<Event<Never>> {
+    fn take_deferred(&self) -> VecDeque<EventWrapper> {
         mem::replace(&mut *self.deferred(), Default::default())
     }
 
@@ -164,7 +175,7 @@ impl Handler {
         self.in_callback.store(in_callback, Ordering::Release);
     }
 
-    fn handle_nonuser_event(&self, event: Event<Never>) {
+    fn handle_nonuser_event(&self, event: Event<'_, Never>) {
         if let Some(ref mut callback) = *self.callback.lock().unwrap() {
             callback.handle_nonuser_event(event, &mut *self.control_flow.lock().unwrap());
         }
@@ -175,14 +186,38 @@ impl Handler {
             callback.handle_user_events(&mut *self.control_flow.lock().unwrap());
         }
     }
+
+    fn create_hidpi_factor_changed_event(&mut self, ns_window: &IdRef) -> Event<'_, Never> {
+        let hidpi_factor = unsafe { NSWindow::backingScaleFactor(**ns_window) } as f64;
+        let ns_size = unsafe { NSWindow::frame(**ns_window).size };
+        let new_size = LogicalSize::new(ns_size.width, ns_size.height).to_physical(hidpi_factor);
+        self.window_size = Box::new(Some(new_size));
+        // let new_inner_size: &'static mut Option<PhysicalSize> =
+        Event::WindowEvent {
+            window_id: WindowId(get_window_id(**ns_window)),
+            event: WindowEvent::HiDpiFactorChanged {
+                hidpi_factor,
+                new_inner_size: &mut *self.window_size,
+            },
+        }
+    }
+
+    fn make_event(&mut self, proxy: &EventProxy) -> Event<'_, Never> {
+        match proxy {
+            EventProxy::WindowEvent {
+                ns_window,
+                proxy: WindowEventProxy::HiDpiFactorChangedProxy,
+            } => self.create_hidpi_factor_changed_event(ns_window),
+        }
+    }
 }
 
 pub enum AppState {}
 
 impl AppState {
     pub fn set_callback<F, T>(callback: F, window_target: RootWindowTarget<T>)
     where
-        F: 'static + FnMut(Event<T>, &RootWindowTarget<T>, &mut ControlFlow),
+        F: 'static + FnMut(Event<'_, T>, &RootWindowTarget<T>, &mut ControlFlow),
         T: 'static,
     {
         *HANDLER.callback.lock().unwrap() = Some(Box::new(EventLoopHandler {
@@ -245,29 +280,42 @@ impl AppState {
         }
     }
 
-    pub fn queue_event(event: Event<Never>) {
+    pub fn queue_event(event: Event<'static, Never>) {
         if !unsafe { msg_send![class!(NSThread), isMainThread] } {
             panic!("Event queued from different thread: {:#?}", event);
         }
         HANDLER.events().push_back(event);
     }
 
-    pub fn queue_events(mut events: VecDeque<Event<Never>>) {
+    pub fn queue_events(mut events: VecDeque<Event<'static, Never>>) {
         if !unsafe { msg_send![class!(NSThread), isMainThread] } {
             panic!("Events queued from different thread: {:#?}", events);
         }
         HANDLER.events().append(&mut events);
     }
 
-    pub fn send_event_immediately(event: Event<Never>) {
+    pub fn send_event_immediately(wrapper: EventWrapper) {
         if !unsafe { msg_send![class!(NSThread), isMainThread] } {
-            panic!("Event sent from different thread: {:#?}", event);
+            panic!("Event sent from different thread: {:#?}", wrapper);
         }
-        HANDLER.deferred().push_back(event);
+        HANDLER.deferred().push_back(wrapper);
         if !HANDLER.get_in_callback() {
             HANDLER.set_in_callback(true);
-            for event in HANDLER.take_deferred() {
-                HANDLER.handle_nonuser_event(event);
+            for wrapper in HANDLER.take_deferred() {
+                match wrapper {
+                    EventWrapper::StaticEvent(event) => HANDLER.handle_nonuser_event(event),
+                    EventWrapper::EventProxy(proxy) => {
+                        let event = HANDLER.make_event(&proxy);
+                        HANDLER.handle_nonuser_event(event);
+                        if let Event::WindowEvent {
+                            event: window_event,
+                            ..
+                        } = event
+                        {
+                            proxy.callback(&window_event);
+                        };
+                    }
+                };
             }
             HANDLER.set_in_callback(false);
         }

src/platform_impl/macos/event.rs

@@ -1,15 +1,68 @@
 use std::os::raw::c_ushort;
 
 use cocoa::{
-    appkit::{NSEvent, NSEventModifierFlags},
+    appkit::{NSEvent, NSEventModifierFlags, NSWindow},
     base::id,
+    foundation::{NSRect, NSSize},
 };
 
 use crate::{
-    event::{ElementState, KeyboardInput, ModifiersState, VirtualKeyCode, WindowEvent},
-    platform_impl::platform::DEVICE_ID,
+    event::{ElementState, Event, KeyboardInput, ModifiersState, VirtualKeyCode, WindowEvent},
+    platform_impl::platform::{
+        util::{IdRef, Never},
+        DEVICE_ID,
+    },
 };
 
+#[derive(Debug)]
+pub(crate) enum EventWrapper {
+    StaticEvent(Event<'static, Never>),
+    EventProxy(EventProxy),
+}
+
+#[derive(Debug, PartialEq)]
+pub(crate) enum EventProxy {
+    WindowEvent {
+        ns_window: IdRef,
+        proxy: WindowEventProxy,
+    },
+}
+
+impl EventProxy {
+    pub fn callback(self, event: &WindowEvent<'_>) {
+        match self {
+            EventProxy::WindowEvent { ns_window, proxy } => proxy.callback(ns_window, event),
+        };
+    }
+}
+
+#[derive(Debug, PartialEq)]
+pub(crate) enum WindowEventProxy {
+    HiDpiFactorChangedProxy,
+}
+
+impl WindowEventProxy {
+    fn callback(self, ns_window: IdRef, event: &WindowEvent<'_>) {
+        match self {
+            WindowEventProxy::HiDpiFactorChangedProxy => {
+                if let WindowEvent::HiDpiFactorChanged {
+                    hidpi_factor,
+                    new_inner_size,
+                } = event
+                {
+                    let origin = unsafe { NSWindow::frame(*ns_window).origin };
+                    if let Some(physical_size) = new_inner_size {
+                        let logical_size = physical_size.to_logical(*hidpi_factor);
+                        let size = NSSize::new(logical_size.width, logical_size.height);
+                        let rect = NSRect::new(origin, size);
+                        unsafe { ns_window.setFrame_display_(rect, cocoa::base::YES) };
+                    };
+                };
+            }
+        }
+    }
+}
+
 pub fn char_to_keycode(c: char) -> Option<VirtualKeyCode> {
     // We only translate keys that are affected by keyboard layout.
     //
@@ -244,7 +297,7 @@ pub unsafe fn modifier_event(
     ns_event: id,
     keymask: NSEventModifierFlags,
     was_key_pressed: bool,
-) -> Option<WindowEvent> {
+) -> Option<WindowEvent<'static>> {
     if !was_key_pressed && NSEvent::modifierFlags(ns_event).contains(keymask)
         || was_key_pressed && !NSEvent::modifierFlags(ns_event).contains(keymask)
     {

src/platform_impl/macos/event_loop.rs

@@ -83,7 +83,7 @@ impl<T> EventLoop<T> {
 
     pub fn run<F>(self, callback: F) -> !
     where
-        F: 'static + FnMut(Event<T>, &RootWindowTarget<T>, &mut ControlFlow),
+        F: 'static + FnMut(Event<'_, T>, &RootWindowTarget<T>, &mut ControlFlow),
     {
         unsafe {
             let _pool = NSAutoreleasePool::new(nil);
@@ -98,7 +98,7 @@ impl<T> EventLoop<T> {
 
     pub fn run_return<F>(&mut self, _callback: F)
     where
-        F: FnMut(Event<T>, &RootWindowTarget<T>, &mut ControlFlow),
+        F: FnMut(Event<'_, T>, &RootWindowTarget<T>, &mut ControlFlow),
     {
         unimplemented!();
     }

src/platform_impl/macos/util/mod.rs

@@ -31,6 +31,7 @@ pub const EMPTY_RANGE: ffi::NSRange = ffi::NSRange {
     length: 0,
 };
 
+#[derive(Debug, PartialEq)]
 pub struct IdRef(id);
 
 impl IdRef {