Update glutin (to 0.17) and become DPI aware

Cargo.lock

  "env_logger 0.5.10 (registry+https://github.com/rust-lang/crates.io-index)",
  "gl 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "gl_generator 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "glutin 0.16.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "glutin 0.17.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "image 0.19.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "lazy_static 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "linked-hash-map 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
 
 [[package]]
 name = "glutin"
-version = "0.16.0"
+version = "0.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "android_glue 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
  "shared_library 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
  "wayland-client 0.20.10 (registry+https://github.com/rust-lang/crates.io-index)",
  "winapi 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
- "winit 0.15.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "winit 0.16.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "x11-dl 2.18.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 
 [[package]]
 name = "winit"
-version = "0.15.1"
+version = "0.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "android_glue 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "checksum gl 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "81457bb802910ad5b535eb48541c51830a761804aa5b7087adbc9d049aa57aca"
 "checksum gl_generator 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "7a795170cbd85b5a7baa58d6d7525cae6a03e486859860c220f7ebbbdd379d0a"
 "checksum gleam 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "12b793fcf40a23dd372f184c228ab3eb96f88c50bb4fba8319c483aa025a4e45"
-"checksum glutin 0.16.0 (registry+https://github.com/rust-lang/crates.io-index)" = "42fb2de780307bd2bedbe013bc585659a683e7c6307d0baa878aec3da9250fc1"
+"checksum glutin 0.17.0 (registry+https://github.com/rust-lang/crates.io-index)" = "a70c5fe78efbd5a3b243a804ea1032053c584510f8822819f94cfb29b2100317"
 "checksum httparse 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "23801d98b42eed0318e5709b0527894ba7c3793d0236814618d6a9b6224152ff"
 "checksum humantime 1.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0484fda3e7007f2a4a0d9c3a703ca38c71c54c55602ce4660c419fd32e188c9e"
 "checksum hyper 0.11.27 (registry+https://github.com/rust-lang/crates.io-index)" = "34a590ca09d341e94cddf8e5af0bbccde205d5fbc2fa3c09dd67c7f85cea59d7"
 "checksum winapi-i686-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
 "checksum winapi-x86_64-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 "checksum wincolor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "eeb06499a3a4d44302791052df005d5232b927ed1a9658146d842165c4de7767"
-"checksum winit 0.15.1 (registry+https://github.com/rust-lang/crates.io-index)" = "4bb6ea35de8bd722201914b28a33d503ee45b09fcf85fc4bbf574845e41f79e2"
+"checksum winit 0.16.0 (registry+https://github.com/rust-lang/crates.io-index)" = "b9612edff5352d247ca263aa28e9a902ba80981cf4d3e88caf1833366ba9d354"
 "checksum ws2_32-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "d59cefebd0c892fa2dd6de581e937301d8552cb44489cdff035c6187cb63fa5e"
 "checksum x11-dl 2.18.0 (registry+https://github.com/rust-lang/crates.io-index)" = "931d8584b49771143af0c422f372d8aef4280afd5920dad39b0a95a8e51df1e9"
 "checksum xml-rs 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3c1cb601d29fe2c2ac60a2b2e5e293994d87a1f6fa9687a31a15270f909be9c2"

Cargo.toml

 directories = "0.10"
 env_logger = "0.5.0-rc.2"
 gl = "0.10"
-glutin = "0.16"
+glutin = "0.17"
 image = "0.19"
 lazy_static = "1.0"
 linked-hash-map = "0.5.0"

src/coord.rs

     }
 }
 
-/// A position on the screen in pixels. Top-left corner is (0.0, 0.0).
+/// A position on the screen in physical pixels. Top-left corner is (0.0, 0.0).
 #[derive(Copy, Clone, Debug)]
 pub struct ScreenCoord {
     pub x: f64,
     }
 }
 
-/// A rectangle in screen coordinates.
+/// A rectangle in screen coordinates. Position and size are in physical pixels.
 #[derive(Copy, Clone, Debug)]
 pub struct ScreenRect {
     pub x: f64,

src/main.rs

 
 use coord::{LatLonDeg, ScreenCoord};
 use glutin::{ControlFlow, ElementState, Event, GlContext, MouseButton, MouseScrollDelta, VirtualKeyCode, WindowEvent};
+use glutin::dpi::{LogicalPosition, LogicalSize, PhysicalPosition};
 use map_view_gl::MapViewGl;
 use std::error::Error;
 use std::sync::mpsc;
 use tile_source::TileSource;
 
 
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+#[derive(Copy, Clone, Debug, PartialEq)]
 enum Action {
     Nothing,
     Redraw,
-    Resize(u32, u32),
+    Resize(LogicalSize),
     Close,
 }
 
     fn combine_with(&mut self, newer_action: Self) {
         *self = match (*self, newer_action) {
             (Action::Close, _) | (_, Action::Close) => Action::Close,
-            (Action::Resize(..), Action::Resize(w, h)) => Action::Resize(w, h),
-            (Action::Resize(w, h), _) | (_, Action::Resize(w, h)) => Action::Resize(w, h),
+            (Action::Resize(..), Action::Resize(size)) => Action::Resize(size),
+            (Action::Resize(size), _) | (_, Action::Resize(size)) => Action::Resize(size),
             (Action::Redraw, _) | (_, Action::Redraw) => Action::Redraw,
             (Action::Nothing, Action::Nothing) => Action::Nothing,
         };
 
 #[derive(Copy, Clone, Debug, PartialEq)]
 struct InputState {
-    mouse_position: (f64, f64),
+    mouse_position: LogicalPosition,
     mouse_pressed: bool,
+    viewport_size: LogicalSize,
+    dpi_factor: f64,
 }
 
 fn handle_event(
                 input_state.mouse_pressed = false;
                 Action::Nothing
             },
-            WindowEvent::CursorMoved { position: (x, y), .. } => {
+            WindowEvent::CursorMoved { position: pos, .. } => {
                 if input_state.mouse_pressed {
                     map.move_pixel(
-                        input_state.mouse_position.0 - x,
-                        input_state.mouse_position.1 - y,
+                        (input_state.mouse_position.x - pos.x) * input_state.dpi_factor,
+                        (input_state.mouse_position.y - pos.y) * input_state.dpi_factor,
                     );
-                    input_state.mouse_position = (x, y);
+                    input_state.mouse_position = pos;
                     Action::Redraw
                 } else {
-                    input_state.mouse_position = (x, y);
+                    input_state.mouse_position = pos;
                     Action::Nothing
                 }
             },
             WindowEvent::MouseWheel { delta, modifiers, .. } => {
-                let (dx, dy) = match delta {
+                let delta: PhysicalPosition = match delta {
                     MouseScrollDelta::LineDelta(dx, dy) => {
                         // filter strange wheel events with huge values.
                         // (maybe this is just a personal touchpad driver issue)
                         if dx.abs() < 16.0 && dy.abs() < 16.0 {
                             //TODO find a sensible line height value (servo (the glutin port) uses 38)
-                            (dx, dy * 38.0)
+                            PhysicalPosition::new(
+                                f64::from(dx) * input_state.dpi_factor,
+                                f64::from(dy) * 38.0 * input_state.dpi_factor,
+                            )
                         } else {
-                            (0.0, 0.0)
+                            PhysicalPosition::new(0.0, 0.0)
                         }
                     },
-                    MouseScrollDelta::PixelDelta(dx, dy) => (dx, dy),
+                    MouseScrollDelta::PixelDelta(size) => {
+                        size.to_physical(input_state.dpi_factor)
+                    }
                 };
 
                 //TODO add option for default mouse wheel behavior (scroll or zoom?)
                 //TODO add option to reverse scroll/zoom direction
 
                 if modifiers.ctrl {
-                    map.move_pixel(f64::from(-dx), f64::from(-dy));
+                    map.move_pixel(-delta.x, -delta.y);
                 } else {
                     map.zoom_at(
                         ScreenCoord::new(
-                            input_state.mouse_position.0,
-                            input_state.mouse_position.1,
+                            input_state.mouse_position.x * input_state.dpi_factor,
+                            input_state.mouse_position.y * input_state.dpi_factor,
                         ),
-                        f64::from(dy) * (1.0 / 320.0),
+                        f64::from(delta.y) * (1.0 / 320.0),
                     );
                 }
                 Action::Redraw
             WindowEvent::Refresh => {
                 Action::Redraw
             },
-            WindowEvent::Resized(w, h) => {
-                Action::Resize(w, h)
+            WindowEvent::Resized(size) => {
+                input_state.viewport_size = size;
+                Action::Resize(size)
             },
+            WindowEvent::HiDpiFactorChanged(dpi_factor) => {
+                input_state.dpi_factor = dpi_factor;
+                map.set_dpi_factor(dpi_factor);
+                Action::Resize(input_state.viewport_size)
+            }
             _ => Action::Nothing,
         },
         _ => Action::Nothing,
     let _ = unsafe { gl_window.make_current() };
     let mut cx = context::Context::from_gl_window(&gl_window);
 
+    let mut input_state = InputState {
+        mouse_position: LogicalPosition::new(0.0, 0.0),
+        mouse_pressed: false,
+        viewport_size: window.get_inner_size().unwrap(),
+        dpi_factor: window.get_hidpi_factor(),
+    };
+
     let mut map = {
         let proxy = events_loop.create_proxy();
 
         map_view_gl::MapViewGl::new(
             &mut cx,
-            window.get_inner_size().unwrap(),
+            input_state.viewport_size.to_physical(input_state.dpi_factor).into(),
+            input_state.dpi_factor,
             move || { proxy.wakeup().unwrap(); },
             config.use_network(),
             config.async(),
         map.restore_session(session);
     }
 
-    let mut input_state = InputState {
-        mouse_position: (0.0, 0.0),
-        mouse_pressed: false,
-    };
-
     let (marker_tx, marker_rx) = mpsc::channel();
     if let (Some(path), Some(pattern)) = (config.pbf_path(), config.search_pattern()) {
         let proxy = events_loop.create_proxy();
             }
         }
 
-        if let Action::Resize(w, h) = action {
-            gl_window.resize(w, h);
-            map.set_viewport_size(&mut cx, w, h);
+        if let Action::Resize(size) = action {
+            let phys_size = size.to_physical(input_state.dpi_factor);
+            gl_window.resize(phys_size);
+
+            let phys_size: (u32, u32) = phys_size.into();
+            map.set_viewport_size(&mut cx, phys_size.0, phys_size.1);
         }
 
         let redraw = match action {

src/map_view_gl.rs

 use map_view::MapView;
 use marker_layer::MarkerLayer;
 use mercator_view::MercatorView;
-use orthografic_view::OrthograficView;
 use session::Session;
 use texture::{Texture, TextureFormat};
 use tile_atlas::TileAtlas;
 #[derive(Debug)]
 pub struct MapViewGl {
     map_view: MapView,
+    /// Size in physical pixels
     viewport_size: (u32, u32),
+    dpi_factor: f64,
     tile_cache: TileCache,
     tile_atlas: TileAtlas,
     tile_layer: TileLayer,
     pub fn new<F>(
         cx: &mut Context,
         initial_size: (u32, u32),
+        dpi_factor: f64,
         update_func: F,
         use_network: bool,
         use_async: bool,
         MapViewGl {
             map_view,
             viewport_size: initial_size,
+            dpi_factor,
             tile_cache: TileCache::new(move |_tile| update_func(), use_network),
             tile_atlas,
             tile_layer,
         cx.set_viewport(0, 0, width, height);
     }
 
+    pub fn set_dpi_factor(&mut self, dpi_factor: f64) {
+        self.dpi_factor = dpi_factor;
+    }
+
     pub fn add_marker(&mut self, map_coord: MapCoord) {
         self.marker_layer.add_marker(map_coord);
     }
         }
 
         //TODO remove viewport_size parameter
-        self.marker_layer.draw(cx, &self.map_view, self.viewport_size, snap_to_pixel);
+        self.marker_layer.draw(
+            cx,
+            &self.map_view,
+            self.viewport_size,
+            self.dpi_factor,
+            snap_to_pixel,
+        );
     }
 
     fn draw_ortho_tiles(&mut self, cx: &mut Context, source: &TileSource) {
         self.map_view.set_tile_zoom_offset(offset + delta_offset);
     }
 
+    //TODO Make sure to use physical pixel deltas
     pub fn move_pixel(&mut self, delta_x: f64, delta_y: f64) {
         //TODO implement for OrthograficView
         MercatorView::move_pixel(&mut self.map_view, delta_x, delta_y);

src/marker_layer.rs

         ).unwrap();
         check_gl_errors!(cx);
 
+        //TODO Create textures for higher DPI factors / use mipmaps
         let texture = {
             let img = image::load_from_memory(
                 include_bytes!("../img/marker.png"),
         cx: &mut Context,
         map_view: &MapView,
         viewport_size: (u32, u32),
+        dpi_factor: f64,
         snap_to_pixel: bool
     ) {
         let mut vertex_data: Vec<f32> = vec![];
 
-        let marker_size = vec2::<f64>(40.0, 50.0);
-        let marker_offset = vec2::<f64>(-20.0, -50.0);
+        let marker_size = vec2::<f64>(40.0, 50.0) * dpi_factor;
+        let marker_offset = vec2::<f64>(-20.0, -50.0) * dpi_factor;
 
         let scale_x = 2.0 / viewport_size.0 as f32;
         let scale_y = -2.0 / viewport_size.1 as f32;