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

@@ -23,8 +23,8 @@ 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 +33,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 +55,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,8 +87,8 @@ 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<Event<'static, Never>>>,
     pending_redraw: Mutex<Vec<WindowId>>,
     waker: Mutex<EventLoopWaker>,
 }
@@ -96,11 +97,11 @@ unsafe impl Send for Handler {}
 unsafe impl Sync for Handler {}
 
 impl Handler {
-    fn events<'a>(&'a self) -> MutexGuard<'a, VecDeque<Event<Never>>> {
+    fn events<'a>(&'a self) -> MutexGuard<'a, VecDeque<Event<'static, Never>>> {
         self.pending_events.lock().unwrap()
     }
 
-    fn deferred<'a>(&'a self) -> MutexGuard<'a, VecDeque<Event<Never>>> {
+    fn deferred<'a>(&'a self) -> MutexGuard<'a, VecDeque<Event<'static, Never>>> {
         self.deferred_events.lock().unwrap()
     }
 
@@ -144,11 +145,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<Event<'_, Never>> {
         mem::replace(&mut *self.deferred(), Default::default())
     }
 
@@ -164,7 +165,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());
         }
@@ -182,7 +183,7 @@ 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,21 +246,21 @@ 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(event: Event<'static, Never>) {
         if !unsafe { msg_send![class!(NSThread), isMainThread] } {
             panic!("Event sent from different thread: {:#?}", event);
         }

src/platform_impl/macos/event.rs

@@ -244,7 +244,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/window.rs

@@ -24,7 +24,9 @@ use objc::{
 };
 
 use crate::{
-    dpi::{LogicalPosition, LogicalSize},
+    dpi::{
+        LogicalPosition, LogicalSize, PhysicalPosition, PhysicalSize, Position, Size, Size::Logical,
+    },
     error::{ExternalError, NotSupportedError, OsError as RootOsError},
     icon::Icon,
     monitor::MonitorHandle as RootMonitorHandle,
@@ -122,10 +124,17 @@ fn create_window(
         let frame = match screen {
             Some(screen) => appkit::NSScreen::frame(screen),
             None => {
-                let (width, height) = attrs
-                    .inner_size
-                    .map(|logical| (logical.width, logical.height))
-                    .unwrap_or_else(|| (800.0, 600.0));
+                // Not sure what dpi_factor we need here.
+                // If i understand correctly, here we fail to create NSScreen frame, so we've got
+                // no dpi_factor
+                let hidpi_factor = 1.0;
+                let (width, height) = match attrs.inner_size {
+                    Some(size) => {
+                        let logical = size.to_logical(hidpi_factor);
+                        (logical.width, logical.height)
+                    }
+                    None => (800.0, 600.0),
+                };
                 NSRect::new(NSPoint::new(0.0, 0.0), NSSize::new(width, height))
             }
         };
@@ -315,13 +324,15 @@ impl UnownedWindow {
             }
 
             ns_app.activateIgnoringOtherApps_(YES);
-
-            win_attribs
-                .min_inner_size
-                .map(|dim| set_min_inner_size(*ns_window, dim));
-            win_attribs
-                .max_inner_size
-                .map(|dim| set_max_inner_size(*ns_window, dim));
+            let dpi_factor = NSWindow::backingScaleFactor(*ns_window) as f64;
+            win_attribs.min_inner_size.map(|dim| {
+                let logical_dim = dim.to_logical(dpi_factor);
+                set_min_inner_size(*ns_window, logical_dim)
+            });
+            win_attribs.max_inner_size.map(|dim| {
+                let logical_dim = dim.to_logical(dpi_factor);
+                set_max_inner_size(*ns_window, logical_dim)
+            });
 
             use cocoa::foundation::NSArray;
             // register for drag and drop operations.
@@ -415,27 +426,31 @@ impl UnownedWindow {
         AppState::queue_redraw(RootWindowId(self.id()));
     }
 
-    pub fn outer_position(&self) -> Result<LogicalPosition, NotSupportedError> {
+    pub fn outer_position(&self) -> Result<PhysicalPosition, NotSupportedError> {
         let frame_rect = unsafe { NSWindow::frame(*self.ns_window) };
-        Ok((
+        let position = LogicalPosition::new(
             frame_rect.origin.x as f64,
             util::bottom_left_to_top_left(frame_rect),
-        )
-            .into())
+        );
+        let dpi_factor = self.hidpi_factor();
+        Ok(position.to_physical(dpi_factor))
     }
 
-    pub fn inner_position(&self) -> Result<LogicalPosition, NotSupportedError> {
+    pub fn inner_position(&self) -> Result<PhysicalPosition, NotSupportedError> {
         let content_rect = unsafe {
             NSWindow::contentRectForFrameRect_(*self.ns_window, NSWindow::frame(*self.ns_window))
         };
-        Ok((
+        let position = LogicalPosition::new(
             content_rect.origin.x as f64,
             util::bottom_left_to_top_left(content_rect),
-        )
-            .into())
+        );
+        let dpi_factor = self.hidpi_factor();
+        Ok(position.to_physical(dpi_factor))
     }
 
-    pub fn set_outer_position(&self, position: LogicalPosition) {
+    pub fn set_outer_position(&self, position: Position) {
+        let dpi_factor = self.hidpi_factor();
+        let position = position.to_logical(dpi_factor);
         let dummy = NSRect::new(
             NSPoint::new(
                 position.x,
@@ -451,35 +466,50 @@ impl UnownedWindow {
     }
 
     #[inline]
-    pub fn inner_size(&self) -> LogicalSize {
+    pub fn inner_size(&self) -> PhysicalSize {
         let view_frame = unsafe { NSView::frame(*self.ns_view) };
-        (view_frame.size.width as f64, view_frame.size.height as f64).into()
+        let logical: LogicalSize =
+            (view_frame.size.width as f64, view_frame.size.height as f64).into();
+        let dpi_factor = self.hidpi_factor();
+        logical.to_physical(dpi_factor)
     }
 
     #[inline]
-    pub fn outer_size(&self) -> LogicalSize {
+    pub fn outer_size(&self) -> PhysicalSize {
         let view_frame = unsafe { NSWindow::frame(*self.ns_window) };
-        (view_frame.size.width as f64, view_frame.size.height as f64).into()
+        let logical: LogicalSize =
+            (view_frame.size.width as f64, view_frame.size.height as f64).into();
+        let dpi_factor = self.hidpi_factor();
+        logical.to_physical(dpi_factor)
     }
 
     #[inline]
-    pub fn set_inner_size(&self, size: LogicalSize) {
+    pub fn set_inner_size(&self, size: Size) {
         unsafe {
-            util::set_content_size_async(*self.ns_window, size);
+            let dpi_factor = self.hidpi_factor();
+            util::set_content_size_async(*self.ns_window, size.to_logical(dpi_factor));
         }
     }
 
-    pub fn set_min_inner_size(&self, dimensions: Option<LogicalSize>) {
+    pub fn set_min_inner_size(&self, dimensions: Option<Size>) {
         unsafe {
-            let dimensions = dimensions.unwrap_or_else(|| (0, 0).into());
-            set_min_inner_size(*self.ns_window, dimensions);
+            let dimensions = dimensions.unwrap_or(Logical(LogicalSize {
+                width: 0.0,
+                height: 0.0,
+            }));
+            let dpi_factor = self.hidpi_factor();
+            set_min_inner_size(*self.ns_window, dimensions.to_logical(dpi_factor));
         }
     }
 
-    pub fn set_max_inner_size(&self, dimensions: Option<LogicalSize>) {
+    pub fn set_max_inner_size(&self, dimensions: Option<Size>) {
         unsafe {
-            let dimensions = dimensions.unwrap_or_else(|| (!0, !0).into());
-            set_max_inner_size(*self.ns_window, dimensions);
+            let dimensions = dimensions.unwrap_or(Logical(LogicalSize {
+                width: 0.0,
+                height: 0.0,
+            }));
+            let dpi_factor = self.hidpi_factor();
+            set_max_inner_size(*self.ns_window, dimensions.to_logical(dpi_factor));
         }
     }
 
@@ -543,14 +573,14 @@ impl UnownedWindow {
     }
 
     #[inline]
-    pub fn set_cursor_position(
-        &self,
-        cursor_position: LogicalPosition,
-    ) -> Result<(), ExternalError> {
-        let window_position = self.inner_position().unwrap();
+    pub fn set_cursor_position(&self, cursor_position: Position) -> Result<(), ExternalError> {
+        let physical_window_position = self.inner_position().unwrap();
+        let dpi_factor = self.hidpi_factor();
+        let window_position = physical_window_position.to_logical(dpi_factor);
+        let logical_cursor_position = cursor_position.to_logical(dpi_factor);
         let point = appkit::CGPoint {
-            x: (cursor_position.x + window_position.x) as CGFloat,
-            y: (cursor_position.y + window_position.y) as CGFloat,
+            x: (logical_cursor_position.x + window_position.x) as CGFloat,
+            y: (logical_cursor_position.y + window_position.y) as CGFloat,
         };
         CGDisplay::warp_mouse_cursor_position(point)
             .map_err(|e| ExternalError::Os(os_error!(OsError::CGError(e))))?;
@@ -730,7 +760,9 @@ impl UnownedWindow {
     }
 
     #[inline]
-    pub fn set_ime_position(&self, logical_spot: LogicalPosition) {
+    pub fn set_ime_position(&self, spot: Position) {
+        let dpi_factor = self.hidpi_factor();
+        let logical_spot = spot.to_logical(dpi_factor);
         unsafe {
             view::set_ime_position(
                 *self.ns_view,