wip

Author: tangmi

examples/dpi.rs

@@ -0,0 +1,47 @@
+use winit::dpi::PhysicalSize;
+use winit::{
+    event::{Event, WindowEvent},
+    event_loop::{ControlFlow, EventLoop},
+    window::WindowBuilder,
+};
+
+/// Change the DPI settings in Windows while running this.
+fn main() {
+    simple_logger::init().unwrap();
+    let event_loop = EventLoop::new();
+
+    let window = WindowBuilder::new()
+        .with_title("A fantastic window!")
+        .with_inner_size(winit::dpi::LogicalSize::new(128.0, 128.0))
+        .build(&event_loop)
+        .unwrap();
+
+    event_loop.run(move |event, _, control_flow| {
+        *control_flow = ControlFlow::Wait;
+
+        match event {
+            Event::WindowEvent {
+                event: WindowEvent::CloseRequested,
+                window_id,
+            } if window_id == window.id() => *control_flow = ControlFlow::Exit,
+            Event::MainEventsCleared => {
+                window.request_redraw();
+            }
+
+            // DPI changed happened!
+            Event::WindowEvent {
+                event: WindowEvent::ScaleFactorChanged(state),
+                ..
+            } => {
+                dbg!(state.inner_size());
+
+                state.set_inner_size(PhysicalSize {
+                    width: 100,
+                    height: 200,
+                });
+            }
+
+            _ => (),
+        }
+    });
+}

src/event.rs

@@ -45,8 +45,10 @@ use crate::{
 /// Describes a generic event.
 ///
 /// See the module-level docs for more information on the event loop manages each event.
+///
+/// `T` is a user-defined custom event type.
 #[derive(Debug, PartialEq)]
-pub enum Event<'a, T: 'static> {
+pub enum Event<T: 'static> {
     /// Emitted when new events arrive from the OS to be processed.
     ///
     /// This event type is useful as a place to put code that should be done before you start
@@ -58,7 +60,7 @@ pub enum Event<'a, T: 'static> {
     /// Emitted when the OS sends an event to a winit window.
     WindowEvent {
         window_id: WindowId,
-        event: WindowEvent<'a>,
+        event: WindowEvent,
     },
 
     /// Emitted when the OS sends an event to a device.
@@ -114,8 +116,8 @@ pub enum Event<'a, T: 'static> {
     LoopDestroyed,
 }
 
-impl<'a, T> Event<'a, T> {
-    pub fn map_nonuser_event<U>(self) -> Result<Event<'a, U>, Event<'a, T>> {
+impl<T> Event<T> {
+    pub fn map_nonuser_event<U>(self) -> Result<Event<U>, Event<T>> {
         use self::Event::*;
         match self {
             UserEvent(_) => Err(self),
@@ -133,7 +135,7 @@ impl<'a, T> Event<'a, T> {
 
     /// If the event doesn't contain a reference, turn it into an event with a `'static` lifetime.
     /// Otherwise, return `None`.
-    pub fn to_static(self) -> Option<Event<'static, T>> {
+    pub fn to_static(self) -> Option<Event<T>> {
         use self::Event::*;
         match self {
             WindowEvent { window_id, event } => event
@@ -180,7 +182,7 @@ pub enum StartCause {
 
 /// Describes an event from a `Window`.
 #[derive(Debug, PartialEq)]
-pub enum WindowEvent<'a> {
+pub enum WindowEvent {
     /// The size of the window has changed. Contains the client area's new dimensions.
     Resized(PhysicalSize<u32>),
 
@@ -305,10 +307,7 @@ pub enum WindowEvent<'a> {
     /// by the OS, but it can be changed to any value.
     ///
     /// For more information about DPI in general, see the [`dpi`](crate::dpi) module.
-    ScaleFactorChanged {
-        scale_factor: f64,
-        new_inner_size: &'a mut PhysicalSize<u32>,
-    },
+    ScaleFactorChanged(ScaleFactorChangedState),
 
     /// The system window theme has changed.
     ///
@@ -319,8 +318,38 @@ pub enum WindowEvent<'a> {
     ThemeChanged(Theme),
 }
 
-impl<'a> WindowEvent<'a> {
-    pub fn to_static(self) -> Option<WindowEvent<'static>> {
+use std::sync::Arc;
+use std::sync::Mutex;
+
+#[derive(Debug)]
+pub struct ScaleFactorChangedState {
+    pub scale_factor: f64,
+    pub(crate) new_inner_size: Arc<Mutex<PhysicalSize<u32>>>,
+}
+
+impl PartialEq<ScaleFactorChangedState> for ScaleFactorChangedState {
+    fn eq(&self, other: &ScaleFactorChangedState) -> bool {
+        use std::ops::Deref;
+
+        self.scale_factor == other.scale_factor
+            && self.new_inner_size.lock().unwrap().deref()
+                == other.new_inner_size.lock().unwrap().deref()
+    }
+}
+
+impl ScaleFactorChangedState {
+    pub fn inner_size(&self) -> PhysicalSize<u32> {
+        *self.new_inner_size.lock().unwrap()
+    }
+
+    pub fn set_inner_size(&self, new_size: PhysicalSize<u32>) {
+        *self.new_inner_size.lock().unwrap() = new_size;
+    }
+}
+
+impl WindowEvent {
+    // TODO remove?
+    pub fn to_static(self) -> Option<WindowEvent> {
         use self::WindowEvent::*;
         match self {
             Resized(size) => Some(Resized(size)),

src/event_loop.rs

@@ -143,7 +143,7 @@ impl<T> EventLoop<T> {
     #[inline]
     pub fn run<F>(self, event_handler: F) -> !
     where
-        F: 'static + FnMut(Event<'_, T>, &EventLoopWindowTarget<T>, &mut ControlFlow),
+        F: 'static + FnMut(Event<T>, &EventLoopWindowTarget<T>, &mut ControlFlow),
     {
         self.event_loop.run(event_handler)
     }

src/platform/desktop.rs

@@ -1,7 +1,11 @@
 #![cfg(any(
     target_os = "windows",
     target_os = "macos",
-    target_os = "linux", target_os = "dragonfly", target_os = "freebsd", target_os = "netbsd", target_os = "openbsd"
+    target_os = "linux",
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "netbsd",
+    target_os = "openbsd"
 ))]
 
 use crate::{
@@ -30,23 +34,15 @@ pub trait EventLoopExtDesktop {
     /// You are strongly encouraged to use `run`, unless the use of this is absolutely necessary.
     fn run_return<F>(&mut self, event_handler: F)
     where
-        F: FnMut(
-            Event<'_, Self::UserEvent>,
-            &EventLoopWindowTarget<Self::UserEvent>,
-            &mut ControlFlow,
-        );
+        F: FnMut(Event<Self::UserEvent>, &EventLoopWindowTarget<Self::UserEvent>, &mut ControlFlow);
 }
 
 impl<T> EventLoopExtDesktop for EventLoop<T> {
     type UserEvent = T;
 
     fn run_return<F>(&mut self, event_handler: F)
     where
-        F: FnMut(
-            Event<'_, Self::UserEvent>,
-            &EventLoopWindowTarget<Self::UserEvent>,
-            &mut ControlFlow,
-        ),
+        F: FnMut(Event<Self::UserEvent>, &EventLoopWindowTarget<Self::UserEvent>, &mut ControlFlow),
     {
         self.event_loop.run_return(event_handler)
     }

src/platform_impl/windows/drop_handler.rs

@@ -31,7 +31,7 @@ pub struct FileDropHandlerData {
     pub interface: IDropTarget,
     refcount: AtomicUsize,
     window: HWND,
-    send_event: Box<dyn Fn(Event<'static, ()>)>,
+    send_event: Box<dyn Fn(Event<()>)>,
     cursor_effect: DWORD,
     hovered_is_valid: bool, /* If the currently hovered item is not valid there must not be any `HoveredFileCancelled` emitted */
 }
@@ -42,7 +42,7 @@ pub struct FileDropHandler {
 
 #[allow(non_snake_case)]
 impl FileDropHandler {
-    pub fn new(window: HWND, send_event: Box<dyn Fn(Event<'static, ()>)>) -> FileDropHandler {
+    pub fn new(window: HWND, send_event: Box<dyn Fn(Event<()>)>) -> FileDropHandler {
         let data = Box::new(FileDropHandlerData {
             interface: IDropTarget {
                 lpVtbl: &DROP_TARGET_VTBL as *const IDropTargetVtbl,
@@ -227,7 +227,7 @@ impl FileDropHandler {
 }
 
 impl FileDropHandlerData {
-    fn send_event(&self, event: Event<'static, ()>) {
+    fn send_event(&self, event: Event<()>) {
         (self.send_event)(event);
     }
 }

src/platform_impl/windows/event_loop.rs

@@ -44,7 +44,10 @@ use winapi::{
 use self::runner::{ELRShared, EventLoopRunnerShared};
 use crate::{
     dpi::{PhysicalPosition, PhysicalSize},
-    event::{DeviceEvent, Event, Force, KeyboardInput, Touch, TouchPhase, WindowEvent},
+    event::{
+        DeviceEvent, Event, Force, KeyboardInput, ScaleFactorChangedState, Touch, TouchPhase,
+        WindowEvent,
+    },
     event_loop::{ControlFlow, EventLoopClosed, EventLoopWindowTarget as RootELW},
     platform_impl::platform::{
         dark_mode::try_dark_mode,
@@ -100,7 +103,7 @@ pub(crate) struct SubclassInput<T: 'static> {
 }
 
 impl<T> SubclassInput<T> {
-    unsafe fn send_event(&self, event: Event<'_, T>) {
+    unsafe fn send_event(&self, event: Event<T>) {
         self.event_loop_runner.send_event(event);
     }
 }
@@ -112,7 +115,7 @@ struct ThreadMsgTargetSubclassInput<T: 'static> {
 }
 
 impl<T> ThreadMsgTargetSubclassInput<T> {
-    unsafe fn send_event(&self, event: Event<'_, T>) {
+    unsafe fn send_event(&self, event: Event<T>) {
         self.event_loop_runner.send_event(event);
     }
 }
@@ -187,15 +190,15 @@ impl<T: 'static> EventLoop<T> {
 
     pub fn run<F>(mut self, event_handler: F) -> !
     where
-        F: 'static + FnMut(Event<'_, T>, &RootELW<T>, &mut ControlFlow),
+        F: 'static + FnMut(Event<T>, &RootELW<T>, &mut ControlFlow),
     {
         self.run_return(event_handler);
         ::std::process::exit(0);
     }
 
     pub fn run_return<F>(&mut self, mut event_handler: F)
     where
-        F: FnMut(Event<'_, T>, &RootELW<T>, &mut ControlFlow),
+        F: FnMut(Event<T>, &RootELW<T>, &mut ControlFlow),
     {
         let event_loop_windows_ref = &self.window_target;
 
@@ -1512,7 +1515,7 @@ unsafe extern "system" fn public_window_callback<T: 'static>(
 
             // `allow_resize` prevents us from re-applying DPI adjustment to the restored size after
             // exiting fullscreen (the restored size is already DPI adjusted).
-            let mut new_physical_inner_size = match allow_resize {
+            let new_physical_inner_size = match allow_resize {
                 // We calculate our own size because the default suggested rect doesn't do a great job
                 // of preserving the window's logical size.
                 true => old_physical_inner_size
@@ -1521,14 +1524,18 @@ unsafe extern "system" fn public_window_callback<T: 'static>(
                 false => old_physical_inner_size,
             };
 
+            let cell = std::sync::Arc::new(std::sync::Mutex::new(new_physical_inner_size));
+
             let _ = subclass_input.send_event(Event::WindowEvent {
                 window_id: RootWindowId(WindowId(window)),
-                event: ScaleFactorChanged {
+                event: ScaleFactorChanged(ScaleFactorChangedState {
                     scale_factor: new_dpi_factor,
-                    new_inner_size: &mut new_physical_inner_size,
-                },
+                    new_inner_size: cell.clone(),
+                }),
             });
 
+            let new_physical_inner_size = *std::ops::Deref::deref(&cell.lock().unwrap());
+
             // Unset maximized if we're changing the window's size.
             if new_physical_inner_size != old_physical_inner_size {
                 WindowState::set_window_flags(subclass_input.window_state.lock(), window, |f| {