Allow changing render zoom level

src/main.rs

 struct InputState {
     mouse_position: (i32, i32),
     mouse_pressed: bool,
+    lctrl_pressed: bool,
+    rctrl_pressed: bool,
+}
+
+impl InputState {
+    fn ctrl_pressed(&self) -> bool {
+        self.lctrl_pressed | self.rctrl_pressed
+    }
 }
 
 fn handle_event(event: &Event, map: &mut MapViewGl, input_state: &mut InputState, sources: &mut TileSources) -> Action {
                 VirtualKeyCode::Escape => {
                     Action::Close
                 },
+                VirtualKeyCode::LControl => {
+                    input_state.lctrl_pressed = true;
+                    Action::Nothing
+                },
+                VirtualKeyCode::RControl => {
+                    input_state.rctrl_pressed = true;
+                    Action::Nothing
+                },
                 VirtualKeyCode::PageUp => {
                     sources.switch_to_prev();
                     Action::Redraw
                     Action::Redraw
                 },
                 VirtualKeyCode::Add => {
-                    map.step_zoom(1, 0.5);
+                    if input_state.ctrl_pressed() {
+                        map.change_zoom_level_offset(1.0);
+                    } else {
+                        map.step_zoom(1, 0.5);
+                    }
                     Action::Redraw
                 },
                 VirtualKeyCode::Subtract => {
-                    map.step_zoom(-1, 0.5);
+                    if input_state.ctrl_pressed() {
+                        map.change_zoom_level_offset(-1.0);
+                    } else {
+                        map.step_zoom(-1, 0.5);
+                    }
                     Action::Redraw
                 },
                 _ => Action::Nothing,
             }
         },
+        Event::KeyboardInput(glutin::ElementState::Released, _, Some(keycode)) => {
+            match keycode {
+                VirtualKeyCode::LControl => {
+                    input_state.lctrl_pressed = false;
+                    Action::Nothing
+                },
+                VirtualKeyCode::RControl => {
+                    input_state.rctrl_pressed = false;
+                    Action::Nothing
+                },
+                _ => Action::Nothing,
+            }
+        },
         Event::Refresh => {
             Action::Redraw
         },
     let mut input_state = InputState {
         mouse_position: (0, 0),
         mouse_pressed: false,
+        lctrl_pressed: false,
+        rctrl_pressed: false,
     };
 
     let fps: f64 = matches.value_of("fps").map(|s| s.parse().unwrap()).unwrap_or(config.fps());

src/map_view.rs

     pub tile_size: u32,
     pub center: MapCoord,
     pub zoom2: f64,
+    pub render_zoom_level_offset: f64,
 }
 
 #[derive(Clone, Debug)]
             tile_size: tile_size,
             center: MapCoord::new(0.5, 0.5),
             zoom2: 0.0,
+            render_zoom_level_offset: 0.0,
         }
     }
 
         visible_tiles
     }
 
-    //TODO make zoom level configurable
     pub fn render_zoom_level(&self) -> u32 {
-        self.zoom2.floor().max(0.0) as u32
+        (self.zoom2 + self.render_zoom_level_offset).floor().max(0.0) as u32
+    }
+
+    pub fn render_zoom_level_offset(&self) -> f64 {
+        self.render_zoom_level_offset
+    }
+
+    pub fn set_render_zoom_level_offset(&mut self, offset: f64) {
+        self.render_zoom_level_offset = offset;
     }
 
     pub fn set_size(&mut self, width: f64, height: f64) {

src/map_view_gl.rs

         self.map_view.center.normalize_xy();
     }
 
+    pub fn change_zoom_level_offset(&mut self, delta_offset: f64) {
+        let offset = self.map_view.render_zoom_level_offset();
+        self.map_view.set_render_zoom_level_offset(offset + delta_offset);
+    }
+
     pub fn move_pixel(&mut self, delta_x: f64, delta_y: f64) {
         self.map_view.move_pixel(delta_x, delta_y);
         self.map_view.center.normalize_xy();