Upgrade Glutin to v0.19.0

Some changes include:

• Use the with_hardware_acceleration function on the ContextBuilder to not require the discrete GPU
• Remove the LMenu and RMenu virtual key codes (winit 0.16.0 removed these because Windows now generates LAlt and RAlt instead
• Replace set_cursor_state with hide_cursor (winit 0.16.0 removed the set_cursor_state function)
• Replace GlWindow::hidpi_factor with GlWindow::get_hidpi_factor and change to expecting an f64
• Use the glutin/winit dpi size and position types where possible

Glutin's dpi change event has been implemented. All size events now
return logical sizes. As a result of that, the logical sizes are translated
in the `display::handle_rezize` method so DPI scaling works correctly.

When the DPI is changed, the glyph cache is updated to make use of the
correct font size again.

Moving a window to a different screen which is a different DPI caused a
racing condition where the logical size of the event was sent to the
`handle_resize` method in `src/display.rs`, however if there was a DPI
change event before `handle_resize` is able to process this message, it
would incorrectly use the new DPI to scale the resize event.

To solve this issue instead of sending the logical size to the
`handle_resize` method and then converting it to a physical size in
there, the `LogicalSize` of the resize event is transformed into a
`PhysicalSize` as soon as it's received. This fixes potential racing
conditions since all events are processed in order.

The padding has been changed so it's also scaled by DPR.

The `scale_with_dpi` config option has been removed. If it's not present
a warning will be emitted.

The `winit` dependency on Windows has been removed. All interactions
with winit in Alacritty are handled through glutin.

4 files changed, 17 insertions, 2 deletions

diff --git a/font/src/darwin/mod.rs b/font/src/darwin/mod.rs
index bdcbbdfa..7f01f57b 100644
--- a/font/src/darwin/mod.rs
+++ b/font/src/darwin/mod.rs
@@ -148,15 +148,16 @@ impl ::Rasterize for Rasterizer {
     }
 
     fn load_font(&mut self, desc: &FontDesc, size: Size) -> Result<FontKey, Error> {
+        let scaled_size = Size::new(size.as_f32_pts() * self.device_pixel_ratio);
         self.keys
-            .get(&(desc.to_owned(), size))
+            .get(&(desc.to_owned(), scaled_size))
             .map(|k| Ok(*k))
             .unwrap_or_else(|| {
                 let font = self.get_font(desc, size)?;
                 let key = FontKey::next();
 
                 self.fonts.insert(key, font);
-                self.keys.insert((desc.clone(), size), key);
+                self.keys.insert((desc.clone(), scaled_size), key);
 
                 Ok(key)
             })
@@ -184,6 +185,10 @@ impl ::Rasterize for Rasterizer {
                 Err(Error::MissingGlyph(glyph.c))
             })
     }
+
+    fn update_dpr(&mut self, device_pixel_ratio: f32) {
+        self.device_pixel_ratio = device_pixel_ratio;
+    }
 }
 
 impl Rasterizer {
diff --git a/font/src/ft/mod.rs b/font/src/ft/mod.rs
index 55409174..c67665ab 100644
--- a/font/src/ft/mod.rs
+++ b/font/src/ft/mod.rs
@@ -106,6 +106,9 @@ impl ::Rasterize for FreeTypeRasterizer {
         self.get_rendered_glyph(glyph_key)
     }
 
+    fn update_dpr(&mut self, device_pixel_ratio: f32) {
+        self.device_pixel_ratio = device_pixel_ratio;
+    }
 }
 
 pub trait IntoFontconfigType {
diff --git a/font/src/lib.rs b/font/src/lib.rs
index 5fb50217..4c4f2653 100644
--- a/font/src/lib.rs
+++ b/font/src/lib.rs
@@ -355,4 +355,7 @@ pub trait Rasterize {
 
     /// Rasterize the glyph described by `GlyphKey`.
     fn get_glyph(&mut self, GlyphKey) -> Result<RasterizedGlyph, Self::Err>;
+
+    /// Update the Rasterizer's DPI factor
+    fn update_dpr(&mut self, device_pixel_ratio: f32);
 }
diff --git a/font/src/rusttype/mod.rs b/font/src/rusttype/mod.rs
index 62d17de8..c4fda66f 100644
--- a/font/src/rusttype/mod.rs
+++ b/font/src/rusttype/mod.rs
@@ -133,6 +133,10 @@ impl ::Rasterize for RustTypeRasterizer {
             buf,
         })
     }
+
+    fn update_dpr(&mut self, device_pixel_ratio: f32) {
+        self.dpi_ratio = device_pixel_ratio;
+    }
 }
 
 #[derive(Debug)]