Remove map_view

Move functionality to orthografic_view and mercator_view.

src/atmos_layer.rs

@@ -1,7 +1,6 @@
 use ::std::ffi::CStr;
 use buffer::{Buffer, DrawMode};
 use context::Context;
-use map_view::MapView;
 use orthografic_view::OrthograficView;
 use program::{Program, UniformId};
 use std::f32::consts::PI;
@@ -67,11 +66,11 @@ impl AtmosLayer {
     pub fn draw(
         &mut self,
         cx: &mut Context,
-        map_view: &MapView,
+        ortho: &OrthograficView,
     ) {
         let (scale_x, scale_y) = {
-            let diam = OrthograficView::diameter_physical_pixels(map_view);
-            ((diam / map_view.width) as f32, (diam / map_view.height) as f32)
+            let diam = ortho.diameter_physical_pixels();
+            ((diam / ortho.viewport_size.x) as f32, (diam / ortho.viewport_size.y) as f32)
         };
 
         self.program.set_uniform_2f(cx, self.scale_uniform, scale_x, scale_y);

src/main.rs

@@ -27,7 +27,6 @@ pub mod atmos_layer;
 pub mod buffer;
 pub mod config;
 pub mod coord;
-pub mod map_view;
 pub mod map_view_gl;
 pub mod marker_layer;
 pub mod mercator_tile_layer;
@@ -36,6 +35,7 @@ pub mod ortho_tile_layer;
 pub mod orthografic_view;
 pub mod program;
 pub mod projection;
+pub mod projection_view;
 pub mod query;
 pub mod search;
 pub mod session;
@@ -283,7 +283,7 @@ fn run() -> Result<(), Box<Error>> {
         None
     };
 
-    if let Some(tile_source) = last_session.as_ref().and_then(|s| s.tile_source.as_ref()) {
+    if let Some(tile_source) = last_session.as_ref().and_then(|s| s.tile_source()) {
         sources.switch_to_name(tile_source);
     }
 
@@ -319,7 +319,7 @@ fn run() -> Result<(), Box<Error>> {
     };
 
     if let Some(ref session) = last_session {
-        map.restore_session(session);
+        map.restore_session(session)?;
     }
 
     let (marker_tx, marker_rx) = mpsc::channel();
@@ -463,7 +463,7 @@ fn run() -> Result<(), Box<Error>> {
 
     if config.open_last_session() {
         let mut session = map.to_session();
-        session.tile_source = Some(sources.current_name().to_string());
+        session.set_tile_source(Some(sources.current_name()));
         config::save_session(&session)?;
     }
 

src/map_view.rs

@@ -1,79 +0,0 @@
-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 {
-    /// Width of the viewport.
-    pub width: f64,
-    /// Height of the viewport.
-    pub height: f64,
-    /// Size of each square tile in the same unit as the viewport dimensions (usually pixels).
-    pub tile_size: u32,
-    /// The `MapCoord` that corresponds to the center of the viewport.
-    pub center: MapCoord,
-    /// The zoom value. The zoom factor is given by 2.0.powf(zoom);
-    pub zoom: f64,
-    /// Tiles only exist for integer zoom values. The tile zoom value that is used for rendering
-    /// is computed by the `tile_zoom` method. Increasing `tile_zoom_offset` increases the number
-    /// of visible tiles for a given zoom value.
-    pub tile_zoom_offset: f64,
-}
-
-impl MapView {
-    /// Constructs a new `MapView`.
-    pub fn new(width: f64, height: f64, tile_size: u32, center: MapCoord, zoom: f64) -> MapView {
-        MapView {
-            width,
-            height,
-            tile_size,
-            center,
-            zoom,
-            tile_zoom_offset: 0.0,
-        }
-    }
-
-    /// Returns the tile zoom offset.
-    pub fn tile_zoom_offset(map_view: &MapView) -> f64 {
-        map_view.tile_zoom_offset
-    }
-
-    /// Set the tile zoom offset.
-    pub fn set_tile_zoom_offset(&mut self, offset: f64) {
-        self.tile_zoom_offset = offset;
-    }
-
-    /// Set the viewport size.
-    pub fn set_size(&mut self, width: f64, height: f64) {
-        self.width = width;
-        self.height = height;
-    }
-
-    /// Set the zoom value.
-    pub fn set_zoom(&mut self, zoom: f64) {
-        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 = (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

@@ -1,13 +1,14 @@
 use atmos_layer::AtmosLayer;
+use cgmath::vec2;
 use context::Context;
 use coord::{MapCoord, ScreenCoord};
-use map_view::{MapView, MIN_ZOOM_LEVEL, MAX_ZOOM_LEVEL};
 use marker_layer::MarkerLayer;
 use mercator_tile_layer::MercatorTileLayer;
 use mercator_view::MercatorView;
 use ortho_tile_layer::OrthoTileLayer;
 use orthografic_view::OrthograficView;
 use projection::Projection;
+use projection_view::ProjectionView;
 use session::Session;
 use texture::{Texture, TextureFormat};
 use tile_atlas::TileAtlas;
@@ -15,9 +16,12 @@ use tile_cache::TileCache;
 use tile_source::TileSource;
 
 
+pub const MIN_TILE_ZOOM_OFFSET: f64 = -4.0;
+pub const MAX_TILE_ZOOM_OFFSET: f64 = 4.0;
+
 #[derive(Debug)]
 pub struct MapViewGl {
-    map_view: MapView,
+    proj_view: ProjectionView,
     /// Size in physical pixels
     viewport_size: (u32, u32),
     dpi_factor: f64,
@@ -27,7 +31,6 @@ pub struct MapViewGl {
     marker_layer: MarkerLayer,
     ortho_tile_layer: OrthoTileLayer,
     atmos_layer: AtmosLayer,
-    projection: Projection,
     show_marker: bool,
     show_atmos: bool,
     last_draw_type: DrawType,
@@ -55,10 +58,12 @@ impl MapViewGl {
     {
         let tile_size = 256;
 
-        let map_view = MercatorView::initial_map_view(
-            f64::from(initial_size.0),
-            f64::from(initial_size.1),
-            tile_size,
+        let proj_view = ProjectionView::Mercator(
+            MercatorView::initial_view(
+                f64::from(initial_size.0),
+                f64::from(initial_size.1),
+                tile_size,
+            )
         );
 
         let atlas_size = {
@@ -85,7 +90,7 @@ impl MapViewGl {
         let atmos_layer = AtmosLayer::new(cx);
 
         MapViewGl {
-            map_view,
+            proj_view,
             viewport_size: initial_size,
             dpi_factor,
             tile_cache: TileCache::new(move |_tile| update_func(), use_network),
@@ -94,7 +99,6 @@ impl MapViewGl {
             marker_layer: MarkerLayer::new(cx),
             ortho_tile_layer,
             atmos_layer,
-            projection: Projection::Mercator,
             show_marker: true,
             show_atmos: false,
             last_draw_type: DrawType::Null,
@@ -103,7 +107,11 @@ impl MapViewGl {
 
     pub fn set_viewport_size(&mut self, cx: &mut Context, width: u32, height: u32) {
         self.viewport_size = (width, height);
-        self.map_view.set_size(f64::from(width), f64::from(height));
+        let vec_size = vec2(f64::from(width), f64::from(height));
+        match &mut self.proj_view {
+            ProjectionView::Mercator(merc) => merc.viewport_size = vec_size,
+            ProjectionView::Orthografic(ortho) => ortho.viewport_size = vec_size,
+        }
         cx.set_viewport(0, 0, width, height);
     }
 
@@ -116,9 +124,9 @@ impl MapViewGl {
     }
 
     pub fn map_covers_viewport(&self) -> bool {
-        match self.projection {
-            Projection::Mercator => MercatorView::covers_viewport(&self.map_view),
-            Projection::Orthografic => OrthograficView::covers_viewport(&self.map_view),
+        match &self.proj_view {
+            ProjectionView::Mercator(ref merc) => merc.covers_viewport(),
+            ProjectionView::Orthografic(ref ortho) => ortho.covers_viewport(),
         }
     }
 
@@ -127,9 +135,11 @@ impl MapViewGl {
     }
 
     pub fn toggle_projection(&mut self) {
-        self.projection = match self.projection {
-            Projection::Mercator => Projection::Orthografic,
-            Projection::Orthografic => Projection::Mercator,
+        self.proj_view = match &self.proj_view {
+            ProjectionView::Orthografic(ortho) =>
+                ProjectionView::Mercator(MercatorView::from_orthografic_view(ortho)),
+            ProjectionView::Mercator(merc) =>
+                ProjectionView::Orthografic(OrthograficView::from_mercator_view(merc)),
         };
     }
 
@@ -141,7 +151,7 @@ impl MapViewGl {
         self.show_atmos = !self.show_atmos;
     }
 
-    fn draw_mercator_tiles(&mut self, cx: &mut Context, source: &TileSource, snap_to_pixel: bool)
+    fn draw_mercator_tiles(&mut self, cx: &mut Context, merc: &MercatorView, source: &TileSource, snap_to_pixel: bool)
         -> Result<usize, usize>
     {
         if self.last_draw_type != DrawType::Tiles {
@@ -151,7 +161,7 @@ impl MapViewGl {
 
         self.mercator_tile_layer.draw(
             cx,
-            &self.map_view,
+            merc,
             source,
             &mut self.tile_cache,
             &mut self.tile_atlas,
@@ -159,7 +169,7 @@ impl MapViewGl {
         )
     }
 
-    fn draw_mercator_marker(&mut self, cx: &mut Context, snap_to_pixel: bool) {
+    fn draw_mercator_marker(&mut self, cx: &mut Context, merc: &MercatorView, snap_to_pixel: bool) {
         if self.last_draw_type != DrawType::Markers {
             self.last_draw_type = DrawType::Markers;
             self.marker_layer.prepare_draw(cx);
@@ -167,13 +177,13 @@ impl MapViewGl {
 
         self.marker_layer.draw_mercator(
             cx,
-            &self.map_view,
+            merc,
             self.dpi_factor,
             snap_to_pixel,
         );
     }
 
-    fn draw_ortho_marker(&mut self, cx: &mut Context) {
+    fn draw_ortho_marker(&mut self, cx: &mut Context, ortho: &OrthograficView) {
         if self.last_draw_type != DrawType::Markers {
             self.last_draw_type = DrawType::Markers;
             self.marker_layer.prepare_draw(cx);
@@ -181,12 +191,12 @@ impl MapViewGl {
 
         self.marker_layer.draw_ortho(
             cx,
-            &self.map_view,
+            ortho,
             self.dpi_factor,
         );
     }
 
-    fn draw_ortho_tiles(&mut self, cx: &mut Context, source: &TileSource) -> Result<usize, usize> {
+    fn draw_ortho_tiles(&mut self, cx: &mut Context, ortho: &OrthograficView, source: &TileSource) -> Result<usize, usize> {
         if self.last_draw_type != DrawType::OrthoTiles {
             self.last_draw_type = DrawType::OrthoTiles;
             self.ortho_tile_layer.prepare_draw(cx, &self.tile_atlas);
@@ -194,14 +204,14 @@ impl MapViewGl {
 
         self.ortho_tile_layer.draw(
             cx,
-            &self.map_view,
+            ortho,
             source,
             &mut self.tile_cache,
             &mut self.tile_atlas,
         )
     }
 
-    fn draw_atmos(&mut self, cx: &mut Context) {
+    fn draw_atmos(&mut self, cx: &mut Context, ortho: &OrthograficView) {
         if self.last_draw_type != DrawType::Atmos {
             self.last_draw_type = DrawType::Atmos;
             self.atmos_layer.prepare_draw(cx);
@@ -209,7 +219,7 @@ impl MapViewGl {
 
         self.atmos_layer.draw(
             cx,
-            &self.map_view,
+            ortho,
         )
     }
 
@@ -217,89 +227,110 @@ impl MapViewGl {
     /// Returns the number of OpenGL draw calls, which can be decreased to `1` by increasing the
     /// size of the tile atlas.
     pub fn draw(&mut self, cx: &mut Context, source: &TileSource) -> Result<usize, usize> {
-        // only snap to pixel grid if zoom has integral value
-        let snap_to_pixel = (self.map_view.zoom - (self.map_view.zoom + 0.5).floor()).abs() < 1e-10;
+        match self.proj_view.clone() {
+            ProjectionView::Mercator(ref merc) => {
+                // only snap to pixel grid if zoom has integral value
+                let snap_to_pixel = (merc.zoom - (merc.zoom + 0.5).floor()).abs() < 1e-10;
 
-        match self.projection {
-            Projection::Mercator => {
-                let ret = self.draw_mercator_tiles(cx, source, snap_to_pixel);
+                let ret = self.draw_mercator_tiles(cx, merc, source, snap_to_pixel);
                 if self.show_marker && !self.marker_layer.is_empty() {
-                    self.draw_mercator_marker(cx, snap_to_pixel);
+                    self.draw_mercator_marker(cx, merc, snap_to_pixel);
                 }
                 ret
             },
-            Projection::Orthografic => {
-                let ret = self.draw_ortho_tiles(cx, source);
+            ProjectionView::Orthografic(ref ortho) => {
+                let ret = self.draw_ortho_tiles(cx, ortho, source);
                 if self.show_marker && !self.marker_layer.is_empty() {
-                    self.draw_ortho_marker(cx);
+                    self.draw_ortho_marker(cx, ortho);
                 }
                 if self.show_atmos {
-                    self.draw_atmos(cx);
+                    self.draw_atmos(cx, ortho);
                 }
                 ret
             },
         }
     }
 
-    pub fn zoom(&mut self, zoom_delta: f64) {
-        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);
+        match &mut self.proj_view {
+            ProjectionView::Mercator(merc) => {
+                merc.step_zoom(steps, step_size);
+            },
+            ProjectionView::Orthografic(ortho) => {
+                ortho.step_zoom(steps, step_size);
+            },
+        }
     }
 
     pub fn zoom_at(&mut self, pos: ScreenCoord, zoom_delta: f64) {
-        match self.projection {
-            Projection::Mercator => {
-                if self.map_view.zoom + zoom_delta < MIN_ZOOM_LEVEL {
-                    MercatorView::set_zoom_at(&mut self.map_view, pos, MIN_ZOOM_LEVEL);
-                } else if self.map_view.zoom + zoom_delta > MAX_ZOOM_LEVEL {
-                    MercatorView::set_zoom_at(&mut self.map_view, pos, MAX_ZOOM_LEVEL);
-                } else {
-                    MercatorView::zoom_at(&mut self.map_view, pos, zoom_delta);
-                }
-                self.map_view.center.normalize_xy();
+        match &mut self.proj_view {
+            ProjectionView::Mercator(merc) => {
+                merc.zoom_at(pos, zoom_delta)
             },
-            Projection::Orthografic => {
-                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);
-                }
+            ProjectionView::Orthografic(ortho) => {
+                ortho.zoom_at(pos, zoom_delta)
             },
         }
     }
 
     pub fn change_tile_zoom_offset(&mut self, delta_offset: f64) {
-        let offset = self.map_view.tile_zoom_offset;
-        self.map_view.set_tile_zoom_offset(offset + delta_offset);
+        match &mut self.proj_view {
+            ProjectionView::Mercator(merc) => {
+                merc.tile_zoom_offset = (merc.tile_zoom_offset + delta_offset)
+                    .max(MIN_TILE_ZOOM_OFFSET)
+                    .min(MAX_TILE_ZOOM_OFFSET);
+            },
+            ProjectionView::Orthografic(ortho) => {
+                ortho.tile_zoom_offset = (ortho.tile_zoom_offset + delta_offset)
+                    .max(MIN_TILE_ZOOM_OFFSET)
+                    .min(MAX_TILE_ZOOM_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);
-        self.map_view.center.normalize_xy();
+        match &mut self.proj_view {
+            ProjectionView::Mercator(merc) => {
+                merc.move_pixel(delta_x, delta_y);
+            },
+            ProjectionView::Orthografic(ortho) => {
+                ortho.move_pixel(delta_x, delta_y);
+            },
+        }
     }
 
-    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 = session.zoom
-            .max(MIN_ZOOM_LEVEL)
-            .min(MAX_ZOOM_LEVEL);
-        self.projection = session.projection;
+    pub fn restore_session(&mut self, session: &Session) -> Result<(), String> {
+        let viewport_size = self.proj_view.viewport_size();
+        let tile_size = self.proj_view.tile_size();
+        match session.projection() {
+            Some(Projection::Mercator) => {
+                self.proj_view = ProjectionView::Mercator(
+                    MercatorView::from_toml_table(&session.view, viewport_size, tile_size)?
+                )
+            },
+            Some(Projection::Orthografic) => {
+                self.proj_view = ProjectionView::Orthografic(
+                    OrthograficView::from_toml_table(&session.view, viewport_size, tile_size)?
+                )
+            },
+            None => {},
+        }
+        Ok(())
     }
 
     pub fn to_session(&self) -> Session {
+        let view = match &self.proj_view {
+            ProjectionView::Mercator(merc) => {
+                merc.toml_table()
+            },
+            ProjectionView::Orthografic(ortho) => {
+                ortho.toml_table()
+            },
+        };
+
         Session {
-            view_center: self.map_view.center,
-            zoom: self.map_view.zoom,
-            tile_source: None,
-            projection: self.projection,
+            view,
         }
     }
 }

src/marker_layer.rs

@@ -4,7 +4,6 @@ use cgmath::{Matrix3, Point2, Transform, vec2, vec3};
 use context::Context;
 use coord::{MapCoord, ScreenCoord, ScreenRect};
 use image;
-use map_view::MapView;
 use mercator_view::MercatorView;
 use orthografic_view::OrthograficView;
 use program::Program;
@@ -79,7 +78,7 @@ impl MarkerLayer {
     pub fn draw_mercator(
         &mut self,
         cx: &mut Context,
-        map_view: &MapView,
+        merc: &MercatorView,
         dpi_factor: f64,
         snap_to_pixel: bool
     ) {
@@ -88,8 +87,8 @@ impl MarkerLayer {
         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 / map_view.width as f32;
-        let scale_y = -2.0 / map_view.height as f32;
+        let scale_x = 2.0 / merc.viewport_size.x as f32;
+        let scale_y = -2.0 / merc.viewport_size.y as f32;
 
         let tex_mat: Matrix3<f32> = Matrix3::from_cols(
             vec3(marker_size.x as f32, 0.0, 0.0),
@@ -111,15 +110,15 @@ impl MarkerLayer {
         let visible_rect = ScreenRect {
             x: -(marker_offset.x + marker_size.x),
             y: -(marker_offset.y + marker_size.y),
-            width: map_view.width + marker_size.x,
-            height: map_view.height + marker_size.y,
+            width: merc.viewport_size.x + marker_size.x,
+            height: merc.viewport_size.y + marker_size.y,
         };
 
         for map_pos in &self.positions {
             let screen_pos = {
-                let mut sp = MercatorView::map_to_screen_coord(map_view, *map_pos);
+                let mut sp = merc.map_to_screen_coord(*map_pos);
                 if snap_to_pixel {
-                    let topleft = MercatorView::map_to_screen_coord(map_view, MapCoord::new(0.0, 0.0));
+                    let topleft = merc.map_to_screen_coord(MapCoord::new(0.0, 0.0));
                     let mut snapped = topleft;
                     snapped.snap_to_pixel();
 
@@ -166,7 +165,7 @@ impl MarkerLayer {
     pub fn draw_ortho(
         &mut self,
         cx: &mut Context,
-        map_view: &MapView,
+        ortho: &OrthograficView,
         dpi_factor: f64,
     ) {
         let mut vertex_data: Vec<f32> = vec![];
@@ -174,8 +173,8 @@ impl MarkerLayer {
         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 / map_view.width as f32;
-        let scale_y = -2.0 / map_view.height as f32;
+        let scale_x = 2.0 / ortho.viewport_size.x as f32;
+        let scale_y = -2.0 / ortho.viewport_size.y as f32;
 
         let tex_mat: Matrix3<f32> = Matrix3::from_cols(
             vec3(marker_size.x as f32, 0.0, 0.0),
@@ -197,11 +196,11 @@ impl MarkerLayer {
         let visible_rect = ScreenRect {
             x: -(marker_offset.x + marker_size.x),
             y: -(marker_offset.y + marker_size.y),
-            width: map_view.width + marker_size.x,
-            height: map_view.height + marker_size.y,
+            width: ortho.viewport_size.x + marker_size.x,
+            height: ortho.viewport_size.y + marker_size.y,
         };
 
-        let transform = OrthograficView::transformation_matrix(map_view);
+        let transform = ortho.transformation_matrix();
 
         for map_pos in &self.positions {
             let screen_pos = {
@@ -212,8 +211,8 @@ impl MarkerLayer {
                 }
 
                 ScreenCoord::new(
-                    (norm_pos.x + 1.0) * (0.5 * map_view.width),
-                    (-norm_pos.y + 1.0) * (0.5 * map_view.height),
+                    (norm_pos.x + 1.0) * (0.5 * ortho.viewport_size.x),
+                    (-norm_pos.y + 1.0) * (0.5 * ortho.viewport_size.y),
                 )
             };
 

src/mercator_tile_layer.rs

@@ -2,7 +2,6 @@ use ::std::ffi::CStr;
 use buffer::{Buffer, DrawMode};
 use context::Context;
 use coord::View;
-use map_view::MapView;
 use mercator_view::MercatorView;
 use program::Program;
 use tile_atlas::{TileAtlas, VisibleTilesProvider};
@@ -68,7 +67,7 @@ impl MercatorTileLayer {
     pub fn draw(
         &mut self,
         cx: &mut Context,
-        map_view: &MapView,
+        merc: &MercatorView,
         source: &TileSource,
         cache: &mut TileCache,
         atlas: &mut TileAtlas,
@@ -76,11 +75,11 @@ impl MercatorTileLayer {
     ) -> Result<usize, usize> {
         cache.set_view_location(View {
             source_id: source.id(),
-            zoom: MercatorView::tile_zoom(map_view),
-            center: map_view.center,
+            zoom: merc.tile_zoom(),
+            center: merc.center,
         });
 
-        let visible_tiles = MercatorView::visible_tiles(map_view, snap_to_pixel);
+        let visible_tiles = merc.visible_tiles(snap_to_pixel);
         let mut remainder = visible_tiles.as_slice();
         let mut num_draws = 0;
         let mut max_tiles_to_use = cache.max_tiles();
@@ -99,8 +98,8 @@ impl MercatorTileLayer {
             max_tiles_to_use = max_tiles_to_use.saturating_sub(used_tiles);
 
             let mut vertex_data: Vec<f32> = Vec::with_capacity(textured_visible_tiles.len() * (6 * 8));
-            let scale_x = 2.0 / map_view.width;
-            let scale_y = -2.0 / map_view.height;
+            let scale_x = 2.0 / merc.viewport_size.x;
+            let scale_y = -2.0 / merc.viewport_size.y;
             for tvt in &textured_visible_tiles {
                 let minmax = [
                     tvt.tex_minmax.x1 as f32,

src/mercator_view.rs

@@ -1,10 +1,30 @@
+use cgmath::{vec2, Vector2};
 use coord::{MapCoord, ScreenCoord, ScreenRect, TextureRect, TileCoord};
-use map_view::{MapView, MIN_ZOOM_LEVEL, MAX_ZOOM_LEVEL};
+use orthografic_view::OrthograficView;
+use projection::Projection;
+use toml::Value;
+use toml::value::Table;
 
 
+pub const MIN_ZOOM_LEVEL: f64 = 0.0;
+pub const MAX_ZOOM_LEVEL: f64 = 22.0;
+
 /// A view of a tiled map with a rectangular viewport and a zoom.
+/// Projection: EPSG:3857: WGS 84 / Pseudo-Mercator
 #[derive(Clone, Debug)]
 pub struct MercatorView {
+    /// Size of the viewport in physical pixels.
+    pub viewport_size: Vector2<f64>,
+    /// Size of each square tile in the same unit as the viewport dimensions.
+    pub tile_size: u32,
+    /// The `MapCoord` that corresponds to the center of the viewport.
+    pub center: MapCoord,
+    /// The zoom value. The zoom factor is given by 2.0.powf(zoom);
+    pub zoom: f64,
+    /// Tiles only exist for integer zoom values. The tile zoom value that is used for rendering
+    /// is computed by the `tile_zoom` method. Increasing `tile_zoom_offset` increases the number
+    /// of visible tiles for a given zoom value.
+    pub tile_zoom_offset: f64,
 }
 
 /// The position and size of a specific tile on the screen.
@@ -25,14 +45,13 @@ pub struct TexturedVisibleTile {
 impl MercatorView {
     /// Constructs a `MapView` centered at Null Island with an integer zoom that fills a screen
     /// with the given dimensions.
-    pub fn initial_map_view(width: f64, height: f64, tile_size: u32) -> MapView {
+    pub fn initial_view(width: f64, height: f64, tile_size: u32) -> MercatorView {
         let min_dimension = width.min(height);
         let zoom = (min_dimension / f64::from(tile_size)).log2().ceil()
             .max(MIN_ZOOM_LEVEL)
             .min(MAX_ZOOM_LEVEL);
-        MapView {
-            width,
-            height,
+        MercatorView {
+            viewport_size: vec2(width, height),
             tile_size,
             center: MapCoord::new(0.5, 0.5),
             zoom,
@@ -40,39 +59,103 @@ impl MercatorView {
         }
     }
 
+    pub fn from_orthografic_view(ortho: &OrthograficView) -> Self {
+        MercatorView {
+            viewport_size: ortho.viewport_size,
+            tile_size: ortho.tile_size,
+            center: ortho.center,
+            zoom: ortho.zoom,
+            tile_zoom_offset: ortho.tile_zoom_offset,
+        }
+    }
+
+    pub fn from_toml_table(
+        table: &Table,
+        viewport_size: Vector2<f64>,
+        tile_size: u32,
+    ) -> Result<Self, String> {
+        let x = match table.get("x") {
+            Some(&Value::Float(x)) => x,
+            Some(&Value::Integer(x)) => x as f64,
+            Some(_) => return Err("x has to be a number.".to_string()),
+            None => return Err("x position is missing.".to_string()),
+        };
+
+        let y = match table.get("y") {
+            Some(&Value::Float(y)) => y,
+            Some(&Value::Integer(y)) => y as f64,
+            Some(_) => return Err("y has to be a number.".to_string()),
+            None => return Err("y position is missing.".to_string()),
+        };
+
+        let zoom = match table.get("zoom") {
+            Some(&Value::Float(z)) => z,
+            Some(&Value::Integer(z)) => z as f64,
+            Some(_) => return Err("zoom has to be a number.".to_string()),
+            None => return Err("zoom value is missing.".to_string()),
+        }.min(MAX_ZOOM_LEVEL).max(MIN_ZOOM_LEVEL);
+
+        if let Some(&Value::String(ref s)) = table.get("projection") {
+            if s != "mercator" {
+                return Err("try to deserialize wrong projection".to_string());
+            }
+        }
+
+        Ok(MercatorView {
+            viewport_size,
+            tile_size,
+            center: MapCoord::new(x, y),
+            zoom,
+            tile_zoom_offset: 0.0,
+        })
+    }
+
+    pub fn toml_table(&self) -> Table {
+        let mut table = Table::new();
+        table.insert("projection".to_string(), Value::String(Self::projection().to_str().to_string()));
+        table.insert("x".to_string(), Value::Float(self.center.x));
+        table.insert("y".to_string(), Value::Float(self.center.y));
+        table.insert("zoom".to_string(), Value::Float(self.zoom));
+        table
+    }
+
+    pub fn projection() -> Projection {
+        Projection::Mercator
+    }
+
     /// Returns the map coordinate that corresponds to the top-left corner of the viewport.
-    pub fn top_left_coord(map_view: &MapView) -> MapCoord {
-        let scale = f64::powf(2.0, -map_view.zoom) / f64::from(map_view.tile_size);
+    pub fn top_left_coord(&self) -> MapCoord {
+        let scale = f64::powf(2.0, -self.zoom) / f64::from(self.tile_size);
 
-        let x = map_view.center.x + -0.5 * map_view.width * scale;
-        let y = map_view.center.y + -0.5 * map_view.height * scale;
+        let x = self.center.x + -0.5 * self.viewport_size.x * scale;
+        let y = self.center.y + -0.5 * self.viewport_size.y * scale;
 
         MapCoord::new(x, y)
     }
 
     /// Returns the screen coordinate that corresponds to the given map coordinate.
-    pub fn map_to_screen_coord(map_view: &MapView, map_coord: MapCoord) -> ScreenCoord {
-        let scale = f64::powf(2.0, map_view.zoom) * f64::from(map_view.tile_size);
+    pub fn map_to_screen_coord(&self, map_coord: MapCoord) -> ScreenCoord {
+        let scale = f64::powf(2.0, self.zoom) * f64::from(self.tile_size);
 
-        let delta_x = map_coord.x - map_view.center.x;
-        let delta_y = map_coord.y - map_view.center.y;
+        let delta_x = map_coord.x - self.center.x;
+        let delta_y = map_coord.y - self.center.y;
 
         ScreenCoord {
-            x: 0.5 * map_view.width + delta_x * scale,
-            y: 0.5 * map_view.height + delta_y * scale,
+            x: 0.5 * self.viewport_size.x + delta_x * scale,
+            y: 0.5 * self.viewport_size.y + delta_y * scale,
         }
     }
 
     /// Returns the map coordinate that corresponds to the given screen coordinate.
-    pub fn screen_to_map_coord(map_view: &MapView, screen_coord: ScreenCoord) -> MapCoord {
-        let scale = f64::powf(2.0, -map_view.zoom) / f64::from(map_view.tile_size);
+    pub fn screen_to_map_coord(&self, screen_coord: ScreenCoord) -> MapCoord {
+        let scale = f64::powf(2.0, -self.zoom) / f64::from(self.tile_size);
 
-        let delta_x = screen_coord.x - map_view.width * 0.5;
-        let delta_y = screen_coord.y - map_view.height * 0.5;
+        let delta_x = screen_coord.x - self.viewport_size.x * 0.5;
+        let delta_y = screen_coord.y - self.viewport_size.y * 0.5;
 
         let mut m = MapCoord {
-            x: map_view.center.x + delta_x * scale,
-            y: map_view.center.y + delta_y * scale,
+            x: self.center.x + delta_x * scale,
+            y: self.center.y + delta_y * scale,
         };
 
         m.normalize_x();
@@ -80,27 +163,27 @@ impl MercatorView {
     }
 
     /// Returns true if the viewport rectangle is fully inside the map.
-    pub fn covers_viewport(map_view: &MapView) -> bool {
-        let scale = f64::powf(2.0, -map_view.zoom) / f64::from(map_view.tile_size);
+    pub fn covers_viewport(&self) -> bool {
+        let scale = f64::powf(2.0, -self.zoom) / f64::from(self.tile_size);
 
-        let y_top = map_view.center.y + -0.5 * map_view.height * scale;
-        let y_bottom = map_view.center.y + 0.5 * map_view.height * scale;
+        let y_top = self.center.y + -0.5 * self.viewport_size.x * scale;
+        let y_bottom = self.center.y + 0.5 * self.viewport_size.y * scale;
 
         y_top >= 0.0 && y_bottom <= 1.0
     }
 
     /// Returns the screen coordinate of the top-left corner of a tile.
-    pub fn tile_screen_position(map_view: &MapView, tile: &TileCoord) -> ScreenCoord {
-        Self::map_to_screen_coord(map_view, tile.map_coord_north_west())
+    pub fn tile_screen_position(&self, tile: &TileCoord) -> ScreenCoord {
+        self.map_to_screen_coord(tile.map_coord_north_west())
     }
 
     /// Returns a `Vec` of all tiles that are visible in the current viewport.
-    pub fn visible_tiles(map_view: &MapView, snap_to_pixel: bool) -> Vec<VisibleTile> {
-        let uzoom = Self::tile_zoom(map_view);
-        let top_left_tile = Self::top_left_coord(map_view).on_tile_at_zoom(uzoom);
-        let mut top_left_tile_screen_coord = Self::tile_screen_position(map_view, &top_left_tile);
-        let tile_screen_size = f64::powf(2.0, map_view.zoom - f64::from(uzoom)) *
-            f64::from(map_view.tile_size);
+    pub fn visible_tiles(&self, snap_to_pixel: bool) -> Vec<VisibleTile> {
+        let uzoom = self.tile_zoom();
+        let top_left_tile = self.top_left_coord().on_tile_at_zoom(uzoom);
+        let mut top_left_tile_screen_coord = self.tile_screen_position(&top_left_tile);
+        let tile_screen_size = f64::powf(2.0, self.zoom - f64::from(uzoom)) *
+            f64::from(self.tile_size);
 
         if snap_to_pixel {
             top_left_tile_screen_coord.snap_to_pixel();
@@ -108,9 +191,9 @@ impl MercatorView {
 
         let start_tile_x = top_left_tile.x;
         let start_tile_y = top_left_tile.y;
-        let num_tiles_x = ((map_view.width - top_left_tile_screen_coord.x) /
+        let num_tiles_x = ((self.viewport_size.x - top_left_tile_screen_coord.x) /
                            tile_screen_size).ceil().max(0.0) as i32;
-        let num_tiles_y = ((map_view.height - top_left_tile_screen_coord.y) /
+        let num_tiles_y = ((self.viewport_size.y - top_left_tile_screen_coord.y) /
                            tile_screen_size).ceil().max(0.0) as i32;
 
         let mut visible_tiles = Vec::with_capacity(num_tiles_x as usize * num_tiles_y as usize);
@@ -138,40 +221,48 @@ impl MercatorView {
     }
 
     /// Returns the tile zoom value that is used for rendering with the current zoom.
-    pub fn tile_zoom(map_view: &MapView) -> u32 {
-        (map_view.zoom + map_view.tile_zoom_offset).floor().max(0.0) as u32
+    pub fn tile_zoom(&self) -> u32 {
+        (self.zoom + self.tile_zoom_offset).floor().max(0.0) as u32
     }
 
     /// Change zoom value by `zoom_delta` and zoom to a position given in screen coordinates.
-    pub fn zoom_at(map_view: &mut MapView, pos: ScreenCoord, zoom_delta: f64) {
-        let delta_x = pos.x - map_view.width * 0.5;
-        let delta_y = pos.y - map_view.height * 0.5;
-
-        let scale = (f64::powf(2.0, -map_view.zoom) - f64::powf(2.0, -map_view.zoom - zoom_delta))
-            / f64::from(map_view.tile_size);
-
-        map_view.zoom += zoom_delta;
-        map_view.center.x += delta_x * scale;
-        map_view.center.y += delta_y * scale;
+    pub fn zoom_at(&mut self, pos: ScreenCoord, zoom_delta: f64) {
+        let new_zoom = self.zoom + zoom_delta;
+        self.set_zoom_at(pos, new_zoom);
     }
 
     /// Set a zoom value and zoom to a `position` given in screen coordinates.
-    pub fn set_zoom_at(map_view: &mut MapView, pos: ScreenCoord, zoom: f64) {
-        let delta_x = pos.x - map_view.width * 0.5;
-        let delta_y = pos.y - map_view.height * 0.5;
+    pub fn set_zoom_at(&mut self, pos: ScreenCoord, new_zoom: f64) {
+        let new_zoom = new_zoom.min(MAX_ZOOM_LEVEL).max(MIN_ZOOM_LEVEL);
+
+        let delta_x = pos.x - self.viewport_size.x * 0.5;
+        let delta_y = pos.y - self.viewport_size.y * 0.5;
 
-        let scale = (f64::powf(2.0, -map_view.zoom) - f64::powf(2.0, -zoom)) /
-            f64::from(map_view.tile_size);
+        let scale = (f64::powf(2.0, -self.zoom) - f64::powf(2.0, -new_zoom)) /
+            f64::from(self.tile_size);
 
-        map_view.zoom = zoom;
-        map_view.center.x += delta_x * scale;
-        map_view.center.y += delta_y * scale;
+        self.zoom = new_zoom;
+        self.center.x += delta_x * scale;
+        self.center.y += delta_y * scale;
+        self.center.normalize_xy();
+    }
+
+    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);
     }
 
     /// Move the center of the viewport by (`delta_x`, `delta_y`) in screen coordinates.
-    pub fn move_pixel(map_view: &mut MapView, delta_x: f64, delta_y: f64) {
-        let scale = f64::powf(2.0, -map_view.zoom) / f64::from(map_view.tile_size);
-        map_view.center.x += delta_x * scale;
-        map_view.center.y += delta_y * scale;
+    pub fn move_pixel(&mut self, delta_x: f64, delta_y: f64) {
+        let scale = f64::powf(2.0, -self.zoom) / f64::from(self.tile_size);
+        self.center.x += delta_x * scale;
+        self.center.y += delta_y * scale;
+        self.center.normalize_xy();
     }
 }

src/ortho_tile_layer.rs

@@ -2,7 +2,6 @@ use buffer::{Buffer, DrawMode};
 use cgmath::Transform;
 use context::Context;
 use coord::{LatLonRad, ScreenCoord, View};
-use map_view::MapView;
 use orthografic_view::OrthograficView;
 use program::Program;
 use std::ffi::CStr;
@@ -91,7 +90,7 @@ impl OrthoTileLayer {
     pub fn draw(
         &mut self,
         cx: &mut Context,
-        map_view: &MapView,
+        ortho: &OrthograficView,
         source: &TileSource,
         cache: &mut TileCache,
         tile_atlas: &mut TileAtlas,
@@ -99,13 +98,13 @@ impl OrthoTileLayer {
         //TODO Add distance function to TileCache that takes topology of the sphere into account.
         cache.set_view_location(View {
             source_id: source.id(),
-            zoom: OrthograficView::tile_zoom(map_view),
-            center: map_view.center,
+            zoom: ortho.tile_zoom(),
+            center: ortho.center,
         });
 
-        let transform = OrthograficView::transformation_matrix(map_view);
+        let transform = ortho.transformation_matrix();
 
-        let visible_tiles = OrthograficView::visible_tiles(map_view);
+        let visible_tiles = ortho.visible_tiles();
         let mut remainder = visible_tiles.as_slice();
         let mut num_draws = 0;
         let mut max_tiles_to_use = cache.max_tiles();

src/orthografic_view.rs

@@ -1,11 +1,17 @@
-use cgmath::{Matrix3, Point3, Transform, vec3};
-use coord::{LatLonRad, ScreenCoord, TextureRect, TileCoord};
-use map_view::MapView;
+use cgmath::{Matrix3, Point3, Transform, vec3, Vector2};
+use coord::{LatLonRad, MapCoord, ScreenCoord, TextureRect, TileCoord};
+use mercator_view::MercatorView;
+use projection::Projection;
 use std::collections::HashSet;
 use std::f64::consts::{PI, FRAC_1_PI};
 use std::f64;
+use toml::Value;
+use toml::value::Table;
 
 
+pub const MIN_ZOOM_LEVEL: f64 = 0.0;
+pub const MAX_ZOOM_LEVEL: f64 = 22.0;
+
 #[derive(Clone, Debug)]
 pub struct VisibleTile {
     pub tile: TileCoord,
@@ -136,31 +142,124 @@ pub fn tile_neighbors(origin: TileCoord, result: &mut Vec<TileNeighbor>) {
 }
 
 
+/// Orthographic projection, WGS 84 coordinates mapped to the sphere
 #[derive(Clone, Debug)]
 pub struct OrthograficView {
+    /// Size of the viewport in physical pixels.
+    pub viewport_size: Vector2<f64>,
+    /// Size of each square tile in the same unit as the viewport dimensions.
+    pub tile_size: u32,
+    /// The `MapCoord` that corresponds to the center of the viewport.
+    pub center: MapCoord,
+    /// The zoom value. The zoom factor is given by 2.0.powf(zoom);
+    pub zoom: f64,
+    /// Tiles only exist for integer zoom values. The tile zoom value that is used for rendering
+    /// is computed by the `tile_zoom` method. Increasing `tile_zoom_offset` increases the number
+    /// of visible tiles for a given zoom value.
+    pub tile_zoom_offset: f64,
 }
 
 impl OrthograficView {
+    /// Constructs a new `OrthograficView`.
+    pub fn new(
+        viewport_size: Vector2<f64>,
+        tile_size: u32,
+        center: MapCoord,
+        zoom: f64
+    ) -> OrthograficView {
+        OrthograficView {
+            viewport_size,
+            tile_size,
+            center,
+            zoom,
+            tile_zoom_offset: 0.0,
+        }
+    }
+
+    pub fn from_mercator_view(merc: &MercatorView) -> Self {
+        OrthograficView {
+            viewport_size: merc.viewport_size,
+            tile_size: merc.tile_size,
+            center: merc.center,
+            zoom: merc.zoom,
+            tile_zoom_offset: merc.tile_zoom_offset,
+        }
+    }
+
+    pub fn from_toml_table(
+        table: &Table,
+        viewport_size: Vector2<f64>,
+        tile_size: u32,
+    ) -> Result<Self, String> {
+        let x = match table.get("x") {
+            Some(&Value::Float(x)) => x,
+            Some(&Value::Integer(x)) => x as f64,
+            Some(_) => return Err("x has to be a number.".to_string()),
+            None => return Err("x position is missing.".to_string()),
+        };
+
+        let y = match table.get("y") {
+            Some(&Value::Float(y)) => y,
+            Some(&Value::Integer(y)) => y as f64,
+            Some(_) => return Err("y has to be a number.".to_string()),
+            None => return Err("y position is missing.".to_string()),
+        };
+
+        let zoom = match table.get("zoom") {
+            Some(&Value::Float(z)) => z,
+            Some(&Value::Integer(z)) => z as f64,
+            Some(_) => return Err("zoom has to be a number.".to_string()),
+            None => return Err("zoom value is missing.".to_string()),
+        }.min(MAX_ZOOM_LEVEL).max(MIN_ZOOM_LEVEL);
+
+        if let Some(&Value::String(ref s)) = table.get("projection") {
+            if s != "orthografic" {
+                return Err("try to deserialize wrong projection".to_string());
+            }
+        }
+
+        Ok(OrthograficView {
+            viewport_size,
+            tile_size,
+            center: MapCoord::new(x, y),
+            zoom,
+            tile_zoom_offset: 0.0,
+        })
+    }
+
+    pub fn toml_table(&self) -> Table {
+        let mut table = Table::new();
+        table.insert("projection".to_string(), Value::String(Self::projection().to_str().to_string()));
+        table.insert("x".to_string(), Value::Float(self.center.x));
+        table.insert("y".to_string(), Value::Float(self.center.y));
+        table.insert("zoom".to_string(), Value::Float(self.zoom));
+        table
+    }
+
+    pub fn projection() -> Projection {
+        Projection::Orthografic
+    }
+
     /// Returns true if the rendering covers the whole viewport.
-    pub fn covers_viewport(map_view: &MapView) -> bool {
-        let sphere_diameter = 2.0f64.powf(map_view.zoom) *
-            (f64::consts::FRAC_1_PI * f64::from(map_view.tile_size));
+    pub fn covers_viewport(&self) -> bool {
+        let sphere_diameter = 2.0f64.powf(self.zoom) *
+            (f64::consts::FRAC_1_PI * f64::from(self.tile_size));
 
         // Add a little safety margin (the constant factor) since the rendered globe is not a
         // perfect sphere and its screen area is underestimated by the tesselation.
-        map_view.width.hypot(map_view.height) < sphere_diameter * 0.9
+        self.viewport_size.x.hypot(self.viewport_size.y) < sphere_diameter * 0.9
     }
 
     /// Returns the tile zoom value that is used for rendering with the current zoom.
     //TODO Insert real implementation. Add TileCoord parameter -> lower resolution at the poles
-    pub fn tile_zoom(map_view: &MapView) -> u32 {
-        (map_view.zoom + map_view.tile_zoom_offset).floor().max(0.0) as u32
+    pub fn tile_zoom(&self) -> u32 {
+        (self.zoom + self.tile_zoom_offset).floor().max(0.0) as u32
     }
 
     //TODO Return the transformation matrix that is used here to avoid redundant calculation.
     /// Returns a `Vec` of all tiles that are visible in the current viewport.
-    pub fn visible_tiles(map_view: &MapView) -> Vec<VisibleTile> {
-        let uzoom = Self::tile_zoom(map_view);
+    pub fn visible_tiles(&self) -> Vec<VisibleTile> {
+        let uzoom = self.tile_zoom();
 
         match uzoom {
             0 => return vec![TileCoord::new(0, 0, 0).into()],
@@ -175,9 +274,9 @@ impl OrthograficView {
             _ => {},
         }
 
-        let center_tile = map_view.center.on_tile_at_zoom(uzoom).nearest_valid();
+        let center_tile = self.center.on_tile_at_zoom(uzoom).nearest_valid();
 
-        let transform = Self::transformation_matrix(map_view);
+        let transform = self.transformation_matrix();
 
         let tile_is_visible = |tc: TileCoord| -> bool {
             let nw = tc.latlon_rad_north_west();
@@ -231,14 +330,14 @@ impl OrthograficView {
         tiles
     }
 
-    pub fn diameter_physical_pixels(map_view: &MapView) -> f64 {
-        2.0f64.powf(map_view.zoom) * (FRAC_1_PI * f64::from(map_view.tile_size))
+    pub fn diameter_physical_pixels(&self) -> f64 {
+        2.0f64.powf(self.zoom) * (FRAC_1_PI * f64::from(self.tile_size))
     }
 
-    pub fn transformation_matrix(map_view: &MapView) -> Matrix3<f64> {
+    pub fn transformation_matrix(&self) -> Matrix3<f64> {
         let (scale_x, scale_y) = {
-            let diam = Self::diameter_physical_pixels(map_view);
-            (diam / map_view.width, diam / map_view.height)
+            let diam = self.diameter_physical_pixels();
+            (diam / self.viewport_size.x, diam / self.viewport_size.y)
         };
 
         let scale_mat: Matrix3<f64> = Matrix3::from_cols(
@@ -247,7 +346,7 @@ impl OrthograficView {
             vec3(0.0, 0.0, 1.0),
         );
 
-        let center_latlon = map_view.center.to_latlon_rad();
+        let center_latlon = self.center.to_latlon_rad();
 
         let rot_mat_x: Matrix3<f64> = {
             let alpha = center_latlon.lon + (PI * 0.5);
@@ -278,8 +377,8 @@ impl OrthograficView {
     }
 
     // Returns the inverse rotation matrix of the given view.
-    pub fn inv_rotation_matrix(map_view: &MapView) -> Matrix3<f64> {
-        let center_latlon = map_view.center.to_latlon_rad();
+    pub fn inv_rotation_matrix(&self) -> Matrix3<f64> {
+        let center_latlon = self.center.to_latlon_rad();
 
         let rot_mat_x: Matrix3<f64> = {
             let alpha = -center_latlon.lon - (PI * 0.5);
@@ -307,12 +406,12 @@ impl OrthograficView {
     }
 
     // Returns the coordinates of the location that is nearest to the given `ScreenCoord`.
-    pub fn screen_coord_to_sphere_point(map_view: &MapView, screen_coord: ScreenCoord) -> Point3<f64> {
+    pub fn screen_coord_to_sphere_point(&self, screen_coord: ScreenCoord) -> Point3<f64> {
         // Point on unit sphere
         let sphere_point = {
-            let recip_radius = 2.0 * Self::diameter_physical_pixels(map_view).recip();
-            let sx = (screen_coord.x - map_view.width * 0.5) * recip_radius;
-            let sy = (screen_coord.y - map_view.height * 0.5) * -recip_radius;
+            let recip_radius = 2.0 * self.diameter_physical_pixels().recip();
+            let sx = (screen_coord.x - self.viewport_size.x * 0.5) * recip_radius;
+            let sy = (screen_coord.y - self.viewport_size.y * 0.5) * -recip_radius;
             let t = 1.0 - sx * sx - sy * sy;
             if t >= 0.0 {
                 // screen_coord is on the sphere
@@ -333,38 +432,58 @@ impl OrthograficView {
         };
 
         // Rotate
-        let inv_trans = Self::inv_rotation_matrix(map_view);
+        let inv_trans = self.inv_rotation_matrix();
         inv_trans.transform_point(sphere_point)
     }
 
     // Returns the coordinates of the location that is nearest to the given `ScreenCoord`.
-    pub fn screen_coord_to_latlonrad(map_view: &MapView, screen_coord: ScreenCoord) -> LatLonRad {
-        let p = Self::screen_coord_to_sphere_point(map_view, screen_coord);
+    pub fn screen_coord_to_latlonrad(&self, screen_coord: ScreenCoord) -> LatLonRad {
+        let p = self.screen_coord_to_sphere_point(screen_coord);
 
         // Transform to latitude, longitude
         LatLonRad::new(p.y.asin(), p.z.atan2(p.x))
     }
 
     /// Change zoom value by `zoom_delta` and zoom to a position given in screen coordinates.
-    pub fn zoom_at(map_view: &mut MapView, pos: ScreenCoord, zoom_delta: f64) {
+    pub fn zoom_at(&mut self, pos: ScreenCoord, zoom_delta: f64) {
         //TODO Do something sophisticated: Increase zoom and rotate slightly so that the given
         // ScreenCoord points to the same geographical location.
         /*
-        let latlon = Self::screen_coord_to_latlonrad(map_view, pos);
+        let latlon = self.screen_coord_to_latlonrad(pos);
 
-        let delta_x = pos.x - map_view.width * 0.5;
-        let delta_y = pos.y - map_view.height * 0.5;
+        let delta_x = pos.x - self.viewport_size.x * 0.5;
+        let delta_y = pos.y - self.viewport_size.y * 0.5;
 
-        map_view.center = latlon.into();
+        self.center = latlon.into();
         */
 
-        map_view.zoom += zoom_delta;
+        self.zoom = (self.zoom + zoom_delta).min(MAX_ZOOM_LEVEL).max(MIN_ZOOM_LEVEL);
     }
 
     /// 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;
+    pub fn set_zoom_at(&mut self, pos: ScreenCoord, zoom: f64) {
+        //TODO Do something sophisticated
+        self.zoom = zoom.min(MAX_ZOOM_LEVEL).max(MIN_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);
+    }
+
+    /// Move the center of the viewport by approx. (`delta_x`, `delta_y`) in screen coordinates.
+    pub fn move_pixel(&mut self, delta_x: f64, delta_y: f64) {
+        //TODO Do something more sophisticated
+        let scale = f64::powf(2.0, -self.zoom) / f64::from(self.tile_size);
+        self.center.x += delta_x * scale;
+        self.center.y += delta_y * scale;
+        self.center.normalize_xy();
     }
 }
 

src/projection_view.rs

@@ -0,0 +1,27 @@
+use cgmath::Vector2;
+use mercator_view::MercatorView;
+use orthografic_view::OrthograficView;
+
+
+/// A view of the map with a specific projection.
+#[derive(Clone, Debug)]
+pub enum ProjectionView {
+    Mercator(MercatorView),
+    Orthografic(OrthograficView),
+}
+
+impl ProjectionView {
+    pub fn viewport_size(&self) -> Vector2<f64> {
+        match *self {
+            ProjectionView::Mercator(ref merc) => merc.viewport_size,
+            ProjectionView::Orthografic(ref ortho) => ortho.viewport_size,
+        }
+    }
+
+    pub fn tile_size(&self) -> u32 {
+        match *self {
+            ProjectionView::Mercator(ref merc) => merc.tile_size,
+            ProjectionView::Orthografic(ref ortho) => ortho.tile_size,
+        }
+    }
+}

src/session.rs

@@ -1,4 +1,3 @@
-use coord::MapCoord;
 use projection::Projection;
 use std::fs::File;
 use std::io::Read;
@@ -11,10 +10,7 @@ use toml;
 
 #[derive(Debug)]
 pub struct Session {
-    pub view_center: MapCoord,
-    pub zoom: f64,
-    pub tile_source: Option<String>,
-    pub projection: Projection,
+    pub view: Table,
 }
 
 impl Session {
@@ -29,55 +25,16 @@ impl Session {
 
     pub fn from_toml_str(toml_str: &str) -> Result<Session, String> {
         match toml_str.parse::<Value>() {
-            Ok(Value::Table(ref table)) => {
-
-                let view = match table.get("view") {
-                    Some(&Value::Table(ref table)) => table,
+            Ok(Value::Table(mut table)) => {
+                let view = match table.remove("view") {
+                    Some(Value::Table(table)) => table,
                     Some(_) => return Err("view has to be a table.".to_string()),
                     None => return Err("view table is missing.".to_string()),
                 };
 
-                let x = match view.get("x") {
-                    Some(&Value::Float(x)) => x,
-                    Some(&Value::Integer(x)) => x as f64,
-                    Some(_) => return Err("x has to be a number.".to_string()),
-                    None => return Err("x position is missing.".to_string()),
-                };
-
-                let y = match view.get("y") {
-                    Some(&Value::Float(y)) => y,
-                    Some(&Value::Integer(y)) => y as f64,
-                    Some(_) => return Err("y has to be a number.".to_string()),
-                    None => return Err("y position is missing.".to_string()),
-                };
-
-                let zoom = match view.get("zoom") {
-                    Some(&Value::Float(z)) => z,
-                    Some(&Value::Integer(z)) => z as f64,
-                    Some(_) => return Err("zoom has to be a number.".to_string()),
-                    None => return Err("zoom value is missing.".to_string()),
-                };
-
-                let tile_source = match view.get("tile_source") {
-                    Some(&Value::String(ref s)) => Some(s.clone()),
-                    Some(_) => return Err("tile_source has to be a string.".to_string()),
-                    None => None,
-                };
-
-                let projection = match view.get("projection") {
-                    Some(&Value::String(ref s)) => {
-                        Projection::from_str(s).unwrap_or_else(|_| Projection::Mercator)
-                    },
-                    Some(_) => return Err("projection has to be a string.".to_string()),
-                    None => Projection::Mercator,
-                };
-
                 Ok(
                     Session {
-                        view_center: MapCoord::new(x, y),
-                        zoom,
-                        tile_source,
-                        projection,
+                        view,
                     }
                 )
             },
@@ -87,18 +44,38 @@ impl Session {
     }
 
     pub fn to_toml_string(&self) -> String {
-        let mut view = Table::new();
-        view.insert("x".to_string(), Value::Float(self.view_center.x));
-        view.insert("y".to_string(), Value::Float(self.view_center.y));
-        view.insert("zoom".to_string(), Value::Float(self.zoom));
-        if let Some(ref tile_source) = self.tile_source {
-            view.insert("tile_source".to_string(), Value::String(tile_source.clone()));
-        }
-        view.insert("projection".to_string(), Value::String(self.projection.to_str().to_string()));
-
         let mut root = Table::new();
-        root.insert("view".to_string(), Value::Table(view));
+        root.insert("view".to_string(), Value::Table(self.view.clone()));
 
         toml::ser::to_string_pretty(&Value::Table(root)).unwrap()
     }
+
+    pub fn set_tile_source(&mut self, tile_source: Option<&str>) {
+        match tile_source {
+            None => {
+                self.view.remove("tile_source");
+            },
+            Some(tile_source) => {
+                self.view.insert(
+                    "tile_source".to_string(),
+                    Value::String(tile_source.to_string())
+                );
+            },
+        }
+    }
+
+    pub fn tile_source(&self) -> Option<&str> {
+        if let Some(Value::String(s)) = self.view.get("tile_source") {
+            Some(s.as_str())
+        } else {
+            None
+        }
+    }
+
+    pub fn projection(&self) -> Option<Projection> {
+        match self.view.get("projection") {
+            Some(Value::String(s)) => Projection::from_str(s.as_str()).ok(),
+            _ => None,
+        }
+    }
 }