Add option to store and restore last session

src/config.rs

@@ -1,5 +1,6 @@
 use clap;
 use directories::ProjectDirs;
+use session::Session;
 use std::fmt::Debug;
 use std::fs::File;
 use std::io::{Read, Write};
@@ -24,6 +25,7 @@ pub struct Config {
     fps: f64,
     use_network: bool,
     async: bool,
+    open_last_session: bool,
 }
 
 impl Config {
@@ -72,27 +74,6 @@ impl Config {
         }
     }
 
-    fn create_config_file<P: AsRef<Path> + Debug>(dir_path: P, file_path: P, contents: &[u8]) -> Result<(), String> {
-        if !dir_path.as_ref().is_dir() {
-            if let Err(err) = ::std::fs::create_dir_all(&dir_path) {
-                return Err(format!("failed to create config directory ({:?}): {}",
-                    dir_path,
-                    err
-                ));
-            }
-        }
-
-        let mut file = File::create(&file_path)
-            .map_err(|err| format!("failed to create config file {:?}: {}", &file_path, err))?;
-
-        file.write_all(contents)
-            .map_err(|err| format!(
-                "failed to write contents to config file {:?}: {}",
-                &file_path,
-                err
-            ))
-    }
-
     fn find_or_create() -> Result<Config, String> {
         let config_dir = PROJ_DIRS.config_dir();
         let config_file = {
@@ -108,7 +89,7 @@ impl Config {
         } else {
             // try to write a default config file
 
-            match Config::create_config_file(
+            match create_config_file(
                 config_dir,
                 &config_file,
                 DEFAULT_CONFIG.as_bytes()
@@ -136,7 +117,7 @@ impl Config {
         } else {
             // try to write a default config file
 
-            match Config::create_config_file(
+            match create_config_file(
                 config_dir,
                 &sources_file,
                 DEFAULT_TILE_SOURCES.as_bytes()
@@ -220,6 +201,14 @@ impl Config {
                     }
                 };
 
+                let open_last_session = {
+                    match table.get("open_last_session") {
+                        Some(&Value::Boolean(x)) => x,
+                        Some(_) => return Err("open_last_session has to be a boolean.".to_string()),
+                        None => false,
+                    }
+                };
+
                 Ok(
                     Config {
                         tile_cache_dir,
@@ -229,6 +218,7 @@ impl Config {
                         fps,
                         use_network,
                         async,
+                        open_last_session,
                     }
                 )
             },
@@ -361,8 +351,56 @@ impl Config {
     pub fn async(&self) -> bool {
         self.async
     }
+
+    pub fn open_last_session(&self) -> bool {
+        self.open_last_session
+    }
+}
+
+fn create_config_file<P: AsRef<Path> + Debug>(dir_path: P, file_path: P, contents: &[u8]) -> Result<(), String> {
+    if !dir_path.as_ref().is_dir() {
+        if let Err(err) = ::std::fs::create_dir_all(&dir_path) {
+            return Err(format!("failed to create config directory ({:?}): {}",
+                dir_path,
+                err
+            ));
+        }
+    }
+
+    let mut file = File::create(&file_path)
+        .map_err(|err| format!("failed to create config file {:?}: {}", &file_path, err))?;
+
+    file.write_all(contents)
+        .map_err(|err| format!(
+            "failed to write contents to config file {:?}: {}",
+            &file_path,
+            err
+        ))
+}
+
+pub fn read_last_session() -> Result<Session, String> {
+    let session_path = {
+        let config_dir = PROJ_DIRS.config_dir();
+        let mut path = PathBuf::from(config_dir);
+        path.push("last_session.toml");
+        path
+    };
+    Session::from_toml_file(session_path)
 }
 
+pub fn save_session(session: &Session) -> Result<(), String>
+{
+    let config_dir = PROJ_DIRS.config_dir();
+    let session_path = {
+        let mut path = PathBuf::from(config_dir);
+        path.push("last_session.toml");
+        path
+    };
+    let contents = session.to_toml_string();
+    create_config_file(config_dir, &session_path, contents.as_bytes())
+}
+
+
 #[cfg(test)]
 mod tests {
     use config::*;

src/main.rs

@@ -28,6 +28,7 @@ pub mod map_view_gl;
 pub mod marker_layer;
 pub mod program;
 pub mod search;
+pub mod session;
 pub mod texture;
 pub mod tile;
 pub mod tile_atlas;
@@ -240,6 +241,16 @@ fn run() -> Result<(), Box<Error>> {
         )
     };
 
+    if config.open_last_session() {
+        if let Ok(session) = config::read_last_session().as_ref() {
+            map.restore_session(session);
+
+            if let Some(ref tile_source) = session.tile_source {
+                sources.switch_to_name(tile_source);
+            }
+        }
+    }
+
     let mut input_state = InputState {
         mouse_position: (0.0, 0.0),
         mouse_pressed: false,
@@ -380,6 +391,12 @@ 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());
+        config::save_session(&session)?;
+    }
+
     Ok(())
 }
 
@@ -424,4 +441,13 @@ impl<'a> TileSources<'a> {
     pub fn switch_to_prev(&mut self) {
         self.current_index = (self.current_index + self.sources.len().saturating_sub(1)) % self.sources.len();
     }
+
+    pub fn switch_to_name(&mut self, name: &str) {
+        for (index, &(ref n, _)) in self.sources.iter().enumerate() {
+            if n == name {
+                self.current_index = index;
+                break;
+            }
+        }
+    }
 }

src/map_view_gl.rs

@@ -2,6 +2,7 @@ use context::Context;
 use coord::{MapCoord, ScreenCoord};
 use map_view::MapView;
 use marker_layer::MarkerLayer;
+use session::Session;
 use tile_layer::TileLayer;
 use tile_source::TileSource;
 
@@ -149,4 +150,18 @@ impl MapViewGl {
         self.map_view.move_pixel(delta_x, delta_y);
         self.map_view.center.normalize_xy();
     }
+
+    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));
+    }
+
+    pub fn to_session(&self) -> Session {
+        Session {
+            view_center: self.map_view.center,
+            zoom: self.map_view.zoom,
+            tile_source: None,
+        }
+    }
 }

src/session.rs

@@ -0,0 +1,91 @@
+use coord::MapCoord;
+use std::fs::File;
+use std::io::Read;
+use std::path::Path;
+use toml;
+use toml::Value;
+use toml::value::Table;
+
+
+#[derive(Debug)]
+pub struct Session {
+    pub view_center: MapCoord,
+    pub zoom: f64,
+    pub tile_source: Option<String>,
+}
+
+impl Session {
+    pub fn from_toml_file<P: AsRef<Path>>(path: P) -> Result<Session, String> {
+        let mut file = File::open(&path).map_err(|e| format!("{}", e))?;
+
+        let mut content = String::new();
+        file.read_to_string(&mut content).map_err(|e| format!("{}", e))?;
+
+        Session::from_toml_str(&content)
+    }
+
+    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,
+                    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,
+                };
+
+                Ok(
+                    Session {
+                        view_center: MapCoord::new(x, y),
+                        zoom,
+                        tile_source,
+                    }
+                )
+            },
+            Ok(_) => Err("TOML file has invalid structure. Expected a Table as the top-level element.".to_string()),
+            Err(e) => Err(format!("{}", e)),
+        }
+    }
+
+    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()));
+        }
+
+        let mut root = Table::new();
+        root.insert("view".to_string(), Value::Table(view));
+
+        toml::ser::to_string_pretty(&Value::Table(root)).unwrap()
+    }
+}