Merge pull request #136 from robbert-vdh/feature/resize

Support resizing windows after creation

Author: micahrj

src/gl/macos.rs

@@ -11,6 +11,7 @@ use cocoa::appkit::{
     NSOpenGLProfileVersionLegacy, NSOpenGLView, NSView,
 };
 use cocoa::base::{id, nil, YES};
+use cocoa::foundation::NSSize;
 
 use core_foundation::base::TCFType;
 use core_foundation::bundle::{CFBundleGetBundleWithIdentifier, CFBundleGetFunctionPointerForName};
@@ -134,6 +135,14 @@ impl GlContext {
             let () = msg_send![self.view, setNeedsDisplay: YES];
         }
     }
+
+    /// On macOS the `NSOpenGLView` needs to be resized separtely from our main view.
+    pub(crate) fn resize(&self, size: NSSize) {
+        unsafe { NSView::setFrameSize(self.view, size) };
+        unsafe {
+            let _: () = msg_send![self.view, setNeedsDisplay: YES];
+        }
+    }
 }
 
 impl Drop for GlContext {

src/gl/mod.rs

@@ -106,4 +106,10 @@ impl GlContext {
     pub fn swap_buffers(&self) {
         self.context.swap_buffers();
     }
+
+    /// On macOS the `NSOpenGLView` needs to be resized separtely from our main view.
+    #[cfg(target_os = "macos")]
+    pub(crate) fn resize(&self, size: cocoa::foundation::NSSize) {
+        self.context.resize(size);
+    }
 }

src/macos/view.rs

@@ -234,18 +234,23 @@ extern "C" fn view_did_change_backing_properties(this: &Object, _: Sel, _: id) {
         let ns_window: *mut Object = msg_send![this, window];
 
         let scale_factor: f64 =
-            if ns_window.is_null() { 1.0 } else { NSWindow::backingScaleFactor(ns_window) as f64 };
+            if ns_window.is_null() { 1.0 } else { NSWindow::backingScaleFactor(ns_window) };
 
         let state: &mut WindowState = WindowState::from_field(this);
 
         let bounds: NSRect = msg_send![this, bounds];
 
-        let window_info = WindowInfo::from_logical_size(
+        let new_window_info = WindowInfo::from_logical_size(
             Size::new(bounds.size.width, bounds.size.height),
             scale_factor,
         );
 
-        state.trigger_event(Event::Window(WindowEvent::Resized(window_info)));
+        // Only send the event when the window's size has actually changed to be in line with the
+        // other platform implementations
+        if new_window_info.physical_size() != state.window_info.physical_size() {
+            state.window_info = new_window_info;
+            state.trigger_event(Event::Window(WindowEvent::Resized(new_window_info)));
+        }
     }
 }
 
@@ -364,6 +369,6 @@ extern "C" fn scroll_wheel(this: &Object, _: Sel, event: id) {
 
     state.trigger_event(Event::Mouse(MouseEvent::WheelScrolled {
         delta,
-        modifiers: make_modifiers(modifiers)
+        modifiers: make_modifiers(modifiers),
     }));
 }

src/macos/window.rs

@@ -5,10 +5,10 @@ use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
 
 use cocoa::appkit::{
-    NSApp, NSApplication, NSApplicationActivationPolicyRegular, NSBackingStoreBuffered, NSWindow,
-    NSWindowStyleMask,
+    NSApp, NSApplication, NSApplicationActivationPolicyRegular, NSBackingStoreBuffered, NSView,
+    NSWindow, NSWindowStyleMask,
 };
-use cocoa::base::{id, nil, NO};
+use cocoa::base::{id, nil, NO, YES};
 use cocoa::foundation::{NSAutoreleasePool, NSPoint, NSRect, NSSize, NSString};
 use core_foundation::runloop::{
     CFRunLoop, CFRunLoopTimer, CFRunLoopTimerContext, __CFRunLoopTimer, kCFRunLoopDefaultMode,
@@ -20,7 +20,7 @@ use objc::{msg_send, runtime::Object, sel, sel_impl};
 use raw_window_handle::{AppKitHandle, HasRawWindowHandle, RawWindowHandle};
 
 use crate::{
-    Event, EventStatus, WindowEvent, WindowHandler, WindowInfo, WindowOpenOptions,
+    Event, EventStatus, Size, WindowEvent, WindowHandler, WindowInfo, WindowOpenOptions,
     WindowScalePolicy,
 };
 
@@ -124,6 +124,13 @@ impl Window {
     {
         let pool = unsafe { NSAutoreleasePool::new(nil) };
 
+        let scaling = match options.scale {
+            WindowScalePolicy::ScaleFactor(scale) => scale,
+            WindowScalePolicy::SystemScaleFactor => 1.0,
+        };
+
+        let window_info = WindowInfo::from_logical_size(options.size, scaling);
+
         let handle = if let RawWindowHandle::AppKit(handle) = parent.raw_window_handle() {
             handle
         } else {
@@ -144,7 +151,7 @@ impl Window {
                 .map(|gl_config| Self::create_gl_context(None, ns_view, gl_config)),
         };
 
-        let window_handle = Self::init(true, window, build);
+        let window_handle = Self::init(true, window, window_info, build);
 
         unsafe {
             let _: id = msg_send![handle.ns_view as *mut Object, addSubview: ns_view];
@@ -164,6 +171,13 @@ impl Window {
     {
         let pool = unsafe { NSAutoreleasePool::new(nil) };
 
+        let scaling = match options.scale {
+            WindowScalePolicy::ScaleFactor(scale) => scale,
+            WindowScalePolicy::SystemScaleFactor => 1.0,
+        };
+
+        let window_info = WindowInfo::from_logical_size(options.size, scaling);
+
         let ns_view = unsafe { create_view(&options) };
 
         let window = Window {
@@ -178,7 +192,7 @@ impl Window {
                 .map(|gl_config| Self::create_gl_context(None, ns_view, gl_config)),
         };
 
-        let window_handle = Self::init(true, window, build);
+        let window_handle = Self::init(true, window, window_info, build);
 
         unsafe {
             let () = msg_send![pool, drain];
@@ -215,10 +229,7 @@ impl Window {
 
         let rect = NSRect::new(
             NSPoint::new(0.0, 0.0),
-            NSSize::new(
-                window_info.logical_size().width as f64,
-                window_info.logical_size().height as f64,
-            ),
+            NSSize::new(window_info.logical_size().width, window_info.logical_size().height),
         );
 
         let ns_window = unsafe {
@@ -254,7 +265,7 @@ impl Window {
                 .map(|gl_config| Self::create_gl_context(Some(ns_window), ns_view, gl_config)),
         };
 
-        let _ = Self::init(false, window, build);
+        let _ = Self::init(false, window, window_info, build);
 
         unsafe {
             ns_window.setContentView_(ns_view);
@@ -266,7 +277,9 @@ impl Window {
         }
     }
 
-    fn init<H, B>(parented: bool, mut window: Window, build: B) -> WindowHandle
+    fn init<H, B>(
+        parented: bool, mut window: Window, window_info: WindowInfo, build: B,
+    ) -> WindowHandle
     where
         H: WindowHandler + 'static,
         B: FnOnce(&mut crate::Window) -> H,
@@ -285,6 +298,7 @@ impl Window {
             keyboard_state: KeyboardState::new(),
             frame_timer: None,
             retain_count_after_build,
+            window_info,
             _parent_handle: parent_handle,
         }));
 
@@ -302,6 +316,28 @@ impl Window {
         self.close_requested = true;
     }
 
+    pub fn resize(&mut self, size: Size) {
+        // NOTE: macOS gives you a personal rave if you pass in fractional pixels here. Even though
+        //       the size is in fractional pixels.
+        let size = NSSize::new(size.width.round(), size.height.round());
+
+        unsafe { NSView::setFrameSize(self.ns_view, size) };
+        unsafe {
+            let _: () = msg_send![self.ns_view, setNeedsDisplay: YES];
+        }
+
+        // When using OpenGL the `NSOpenGLView` needs to be resized separately? Why? Because macOS.
+        #[cfg(feature = "opengl")]
+        if let Some(gl_context) = &self.gl_context {
+            gl_context.resize(size);
+        }
+
+        // If this is a standalone window then we'll also need to resize the window itself
+        if let Some(ns_window) = self.ns_window {
+            unsafe { NSWindow::setContentSize_(ns_window, size) };
+        }
+    }
+
     #[cfg(feature = "opengl")]
     pub fn gl_context(&self) -> Option<&GlContext> {
         self.gl_context.as_ref()
@@ -325,6 +361,8 @@ pub(super) struct WindowState {
     frame_timer: Option<CFRunLoopTimer>,
     _parent_handle: Option<ParentHandle>,
     pub retain_count_after_build: usize,
+    /// The last known window info for this window.
+    pub window_info: WindowInfo,
 }
 
 impl WindowState {