Move MIN_ZOOM_LEVEL, MAX_ZOOM_LEVEL to map_view

src/map_view.rs

 use coord::MapCoord;
 
 
+pub const MIN_ZOOM_LEVEL: f64 = 0.0;
+pub const MAX_ZOOM_LEVEL: f64 = 22.0;
+
 /// A view of a map with a rectangular viewport and a zoom.
 #[derive(Clone, Debug)]
 pub struct MapView {
 
     /// Set the zoom value.
     pub fn set_zoom(&mut self, zoom: f64) {
-        self.zoom = zoom;
+        self.zoom = zoom
+            .max(MIN_ZOOM_LEVEL)
+            .min(MAX_ZOOM_LEVEL);
     }
 
     /// Change zoom value by `zoom_delta`.
     pub fn zoom(&mut self, zoom_delta: f64) {
-        self.zoom += zoom_delta;
+        self.zoom = (self.zoom + zoom_delta)
+            .max(MIN_ZOOM_LEVEL)
+            .min(MAX_ZOOM_LEVEL);
+    }
+
+    pub fn step_zoom(&mut self, steps: i32, step_size: f64) {
+        self.zoom = {
+            let z = (self.zoom + f64::from(steps) * step_size) / step_size;
+            if steps > 0 {
+                z.ceil() * step_size
+            } else {
+                z.floor() * step_size
+            }
+        }.max(MIN_ZOOM_LEVEL).min(MAX_ZOOM_LEVEL);
     }
 }

src/map_view_gl.rs

 use atmos_layer::AtmosLayer;
 use context::Context;
 use coord::{MapCoord, ScreenCoord};
-use map_view::MapView;
+use map_view::{MapView, MIN_ZOOM_LEVEL, MAX_ZOOM_LEVEL};
 use marker_layer::MarkerLayer;
 use mercator_tile_layer::MercatorTileLayer;
 use mercator_view::MercatorView;
 use tile_source::TileSource;
 
 
-const MIN_ZOOM_LEVEL: f64 = 0.0;
-const MAX_ZOOM_LEVEL: f64 = 22.0;
-
 #[derive(Debug)]
 pub struct MapViewGl {
     map_view: MapView,
     {
         let tile_size = 256;
 
-        let mut map_view = MercatorView::initial_map_view(
+        let map_view = MercatorView::initial_map_view(
             f64::from(initial_size.0),
             f64::from(initial_size.1),
             tile_size,
         );
 
-        if map_view.zoom < MIN_ZOOM_LEVEL {
-            map_view.zoom = MIN_ZOOM_LEVEL;
-        }
-
         let atlas_size = {
             let default_size = 2048;
             let max_size = cx.max_texture_size() as u32;
         }
     }
 
-    pub fn step_zoom(&mut self, steps: i32, step_size: f64) {
-        let new_zoom = {
-            let z = (self.map_view.zoom + f64::from(steps) * step_size) / step_size;
-            if steps > 0 {
-                z.ceil() * step_size
-            } else {
-                z.floor() * step_size
-            }
-        }.max(MIN_ZOOM_LEVEL).min(MAX_ZOOM_LEVEL);
-
-        self.map_view.set_zoom(new_zoom);
+    pub fn zoom(&mut self, zoom_delta: f64) {
+        self.map_view.zoom(zoom_delta);
     }
 
-    pub fn zoom(&mut self, zoom_delta: f64) {
-        if self.map_view.zoom + zoom_delta < MIN_ZOOM_LEVEL {
-            self.map_view.set_zoom(MIN_ZOOM_LEVEL);
-        } else if self.map_view.zoom + zoom_delta > MAX_ZOOM_LEVEL {
-            self.map_view.set_zoom(MAX_ZOOM_LEVEL);
-        } else {
-            self.map_view.zoom(zoom_delta);
-        }
+    pub fn step_zoom(&mut self, steps: i32, step_size: f64) {
+        self.map_view.step_zoom(steps, step_size);
     }
 
     pub fn zoom_at(&mut self, pos: ScreenCoord, zoom_delta: f64) {
                 self.map_view.center.normalize_xy();
             },
             Projection::Orthografic => {
-                //TODO ensure new zoom level in between min/max zoom level
-                OrthograficView::zoom_at(&mut self.map_view, pos, zoom_delta);
+                if self.map_view.zoom + zoom_delta < MIN_ZOOM_LEVEL {
+                    OrthograficView::set_zoom_at(&mut self.map_view, pos, MIN_ZOOM_LEVEL);
+                } else if self.map_view.zoom + zoom_delta > MAX_ZOOM_LEVEL {
+                    OrthograficView::set_zoom_at(&mut self.map_view, pos, MAX_ZOOM_LEVEL);
+                } else {
+                    OrthograficView::zoom_at(&mut self.map_view, pos, zoom_delta);
+                }
             },
         }
     }
     pub fn restore_session(&mut self, session: &Session) {
         self.map_view.center = session.view_center;
         self.map_view.center.normalize_xy();
-        self.map_view.zoom = MIN_ZOOM_LEVEL.max(MAX_ZOOM_LEVEL.min(session.zoom));
+        self.map_view.zoom = session.zoom
+            .max(MIN_ZOOM_LEVEL)
+            .min(MAX_ZOOM_LEVEL);
         self.projection = session.projection;
     }
 

src/mercator_view.rs

 use coord::{MapCoord, ScreenCoord, ScreenRect, TextureRect, TileCoord};
-use map_view::MapView;
+use map_view::{MapView, MIN_ZOOM_LEVEL, MAX_ZOOM_LEVEL};
 
 
 /// A view of a tiled map with a rectangular viewport and a zoom.
     /// with the given dimensions.
     pub fn initial_map_view(width: f64, height: f64, tile_size: u32) -> MapView {
         let min_dimension = width.min(height);
-        let zoom = (min_dimension / f64::from(tile_size)).log2().ceil();
+        let zoom = (min_dimension / f64::from(tile_size)).log2().ceil()
+            .max(MIN_ZOOM_LEVEL)
+            .min(MAX_ZOOM_LEVEL);
         MapView {
             width,
             height,

src/orthografic_view.rs

         map_view.zoom += zoom_delta;
     }
 
+    /// Change zoom value by `zoom_delta` and zoom to a position given in screen coordinates.
+    pub fn set_zoom_at(map_view: &mut MapView, pos: ScreenCoord, zoom: f64) {
+        //TODO Do something sophisticated, just like with Self::zoom_at
+        map_view.zoom = zoom;
+    }
 }
 
 #[cfg(test)]