Make size/position types generic over pixel type (#1277)

* Begin implementing DPI generics

* Fix multithreaded example

* Format

* Fix serde test

* hopefully fix most of the errors

* Fix dpi module errors

* More error fixings

* Format

* fix macos errors

* Another error pass

* Replace bad type signatures

* more fixins

src/platform_impl/ios/app_state.rs

@@ -806,7 +806,9 @@ pub unsafe fn handle_main_events_cleared() {
     let mut redraw_events: Vec<Event<Never>> = this
         .main_events_cleared_transition()
         .into_iter()
-        .map(|window| EventWrapper::StaticEvent(Event::RedrawRequested(RootWindowId(window.into()))))
+        .map(|window| {
+            EventWrapper::StaticEvent(Event::RedrawRequested(RootWindowId(window.into())))
+        })
         .collect();
 
     if !redraw_events.is_empty() {
@@ -855,7 +857,7 @@ fn handle_event_proxy(
 fn handle_hidpi_proxy(
     event_handler: &mut Box<dyn EventHandler>,
     mut control_flow: ControlFlow,
-    suggested_size: LogicalSize,
+    suggested_size: LogicalSize<f64>,
     hidpi_factor: f64,
     window_id: id,
 ) {

src/platform_impl/ios/event_loop.rs

@@ -39,7 +39,7 @@ pub enum EventWrapper {
 pub enum EventProxy {
     HiDpiFactorChangedProxy {
         window_id: id,
-        suggested_size: LogicalSize,
+        suggested_size: LogicalSize<f64>,
         hidpi_factor: f64,
     },
 }

src/platform_impl/ios/ffi.rs

@@ -43,7 +43,7 @@ pub struct CGSize {
 }
 
 impl CGSize {
-    pub fn new(size: LogicalSize) -> CGSize {
+    pub fn new(size: LogicalSize<f64>) -> CGSize {
         CGSize {
             width: size.width as _,
             height: size.height as _,

src/platform_impl/ios/monitor.rs

@@ -88,7 +88,7 @@ impl VideoMode {
         }
     }
 
-    pub fn size(&self) -> PhysicalSize {
+    pub fn size(&self) -> PhysicalSize<u32> {
         self.size.into()
     }
 
@@ -171,8 +171,8 @@ impl fmt::Debug for MonitorHandle {
         #[derive(Debug)]
         struct MonitorHandle {
             name: Option<String>,
-            size: PhysicalSize,
-            position: PhysicalPosition,
+            size: PhysicalSize<u32>,
+            position: PhysicalPosition<i32>,
             hidpi_factor: f64,
         }
 
@@ -216,14 +216,14 @@ impl Inner {
         }
     }
 
-    pub fn size(&self) -> PhysicalSize {
+    pub fn size(&self) -> PhysicalSize<u32> {
         unsafe {
             let bounds: CGRect = msg_send![self.ui_screen(), nativeBounds];
             PhysicalSize::new(bounds.size.width as u32, bounds.size.height as u32)
         }
     }
 
-    pub fn position(&self) -> PhysicalPosition {
+    pub fn position(&self) -> PhysicalPosition<i32> {
         unsafe {
             let bounds: CGRect = msg_send![self.ui_screen(), nativeBounds];
             (bounds.origin.x as f64, bounds.origin.y as f64).into()

src/platform_impl/ios/view.rs

@@ -103,8 +103,12 @@ unsafe fn get_view_class(root_view_class: &'static Class) -> &'static Class {
                 let window: id = msg_send![object, window];
                 assert!(!window.is_null());
                 app_state::handle_nonuser_events(
-                    std::iter::once(EventWrapper::StaticEvent(Event::RedrawRequested(RootWindowId(window.into()))))
-                        .chain(std::iter::once(EventWrapper::StaticEvent(Event::RedrawEventsCleared))),
+                    std::iter::once(EventWrapper::StaticEvent(Event::RedrawRequested(
+                        RootWindowId(window.into()),
+                    )))
+                    .chain(std::iter::once(EventWrapper::StaticEvent(
+                        Event::RedrawEventsCleared,
+                    ))),
                 );
                 let superclass: &'static Class = msg_send![object, superclass];
                 let () = msg_send![super(object, superclass), drawRect: rect];
@@ -125,8 +129,8 @@ unsafe fn get_view_class(root_view_class: &'static Class) -> &'static Class {
                     msg_send![object, convertRect:bounds toCoordinateSpace:screen_space];
                 let dpi_factor: CGFloat = msg_send![screen, scale];
                 let size = crate::dpi::LogicalSize {
-                    width: screen_frame.size.width as _,
-                    height: screen_frame.size.height as _,
+                    width: screen_frame.size.width as f64,
+                    height: screen_frame.size.height as f64,
                 }
                 .to_physical(dpi_factor.into());
                 app_state::handle_nonuser_event(EventWrapper::StaticEvent(Event::WindowEvent {
@@ -508,7 +512,9 @@ pub unsafe fn create_window(
             let () = msg_send![uiscreen, setCurrentMode: video_mode.video_mode.screen_mode.0];
             msg_send![window, setScreen:video_mode.monitor().ui_screen()]
         }
-        Some(Fullscreen::Borderless(ref monitor)) => msg_send![window, setScreen:monitor.ui_screen()],
+        Some(Fullscreen::Borderless(ref monitor)) => {
+            msg_send![window, setScreen:monitor.ui_screen()]
+        }
         None => (),
     }
 

src/platform_impl/ios/window.rs

@@ -76,24 +76,24 @@ impl Inner {
         }
     }
 
-    pub fn inner_position(&self) -> Result<PhysicalPosition, NotSupportedError> {
+    pub fn inner_position(&self) -> Result<PhysicalPosition<i32>, NotSupportedError> {
         unsafe {
             let safe_area = self.safe_area_screen_space();
             let position = LogicalPosition {
-                x: safe_area.origin.x as _,
-                y: safe_area.origin.y as _,
+                x: safe_area.origin.x as f64,
+                y: safe_area.origin.y as f64,
             };
             let dpi_factor = self.hidpi_factor();
             Ok(position.to_physical(dpi_factor))
         }
     }
 
-    pub fn outer_position(&self) -> Result<PhysicalPosition, NotSupportedError> {
+    pub fn outer_position(&self) -> Result<PhysicalPosition<i32>, NotSupportedError> {
         unsafe {
             let screen_frame = self.screen_frame();
             let position = LogicalPosition {
-                x: screen_frame.origin.x as _,
-                y: screen_frame.origin.y as _,
+                x: screen_frame.origin.x as f64,
+                y: screen_frame.origin.y as f64,
             };
             let dpi_factor = self.hidpi_factor();
             Ok(position.to_physical(dpi_factor))
@@ -103,7 +103,7 @@ impl Inner {
     pub fn set_outer_position(&self, physical_position: Position) {
         unsafe {
             let dpi_factor = self.hidpi_factor();
-            let position = physical_position.to_logical(dpi_factor);
+            let position = physical_position.to_logical::<f64>(dpi_factor);
             let screen_frame = self.screen_frame();
             let new_screen_frame = CGRect {
                 origin: CGPoint {
@@ -117,25 +117,25 @@ impl Inner {
         }
     }
 
-    pub fn inner_size(&self) -> PhysicalSize {
+    pub fn inner_size(&self) -> PhysicalSize<u32> {
         unsafe {
             let dpi_factor = self.hidpi_factor();
             let safe_area = self.safe_area_screen_space();
             let size = LogicalSize {
-                width: safe_area.size.width as _,
-                height: safe_area.size.height as _,
+                width: safe_area.size.width as f64,
+                height: safe_area.size.height as f64,
             };
             size.to_physical(dpi_factor)
         }
     }
 
-    pub fn outer_size(&self) -> PhysicalSize {
+    pub fn outer_size(&self) -> PhysicalSize<u32> {
         unsafe {
             let dpi_factor = self.hidpi_factor();
             let screen_frame = self.screen_frame();
             let size = LogicalSize {
-                width: screen_frame.size.width as _,
-                height: screen_frame.size.height as _,
+                width: screen_frame.size.width as f64,
+                height: screen_frame.size.height as f64,
             };
             size.to_physical(dpi_factor)
         }
@@ -356,7 +356,7 @@ impl Window {
             let frame = match window_attributes.inner_size {
                 Some(dim) => {
                     let dpi_factor = msg_send![screen, scale];
-                    let size = dim.to_logical(dpi_factor);
+                    let size = dim.to_logical::<f64>(dpi_factor);
                     CGRect {
                         origin: screen_bounds.origin,
                         size: CGSize {