Add ability to switch tile source during execution

src/config.rs

         toml::from_str(&content).ok()
     }
 
-    pub fn tile_sources(&self) -> BTreeMap<String, TileSource> {
-        let mut map = BTreeMap::new();
+    pub fn tile_sources(&self) -> Vec<(String, TileSource)> {
+        let mut vec = Vec::with_capacity(self.sources.len());
 
         for (id, (name, source)) in self.sources.iter().enumerate() {
             let mut path = PathBuf::from(&self.tile_cache_dir);
             //TODO escape name (no slashes or dots)
             path.push(name);
 
-            map.insert(
+            vec.push((
                 name.clone(),
                 TileSource::new(
                     id as u32,
                     path,
                     source.max_zoom,
                 ),
-            );
+            ));
         }
 
-        return map;
+        vec
     }
 }

src/coord.rs

 use std::f64::consts::PI;
-use tile::Tile;
 
 /// A position in map coordinates.
 /// Valid values for x and y lie in the interval [0.0, 1.0].

src/main.rs

     mouse_pressed: bool,
 }
 
-fn handle_event(event: Event, map: &mut MapViewGl, input_state: &mut InputState) -> Action {
+fn handle_event(event: Event, map: &mut MapViewGl, input_state: &mut InputState, sources: &mut TileSources) -> Action {
     match event {
         Event::Closed => Action::Close,
         Event::Awakened => Action::Redraw,
                 VirtualKeyCode::Escape => {
                     Action::Close
                 },
+                VirtualKeyCode::PageUp => {
+                    sources.switch_to_prev();
+                    Action::Redraw
+                },
+                VirtualKeyCode::PageDown => {
+                    sources.switch_to_next();
+                    Action::Redraw
+                },
                 VirtualKeyCode::Left => {
                     map.move_pixel(-50.0, 0.0);
                     Action::Redraw
 
 fn main() {
     let config = config::Config::from_toml("deltamap.toml").unwrap();
+    let mut sources = TileSources::new(config.tile_sources()).unwrap();
 
     let mut window = glutin::WindowBuilder::new().build().unwrap();
     window.set_title("DeltaMap");
     let proxy = window.create_window_proxy();
 
     let cx = context::Context::from_window(&window);
-    let mut sources = config.tile_sources();
     let mut map = map_view_gl::MapViewGl::new(
         &cx,
-        sources.into_iter().next().unwrap().1,
         window.get_inner_size_pixels().unwrap(),
         move || { proxy.wakeup_event_loop(); },
     );
 
         let mut redraw = false;
 
-        match handle_event(event, &mut map, &mut input_state) {
+        match handle_event(event, &mut map, &mut input_state, &mut sources) {
             Action::Close => break 'outer,
             Action::Redraw => {
                 redraw = true;
         }
 
         for event in window.poll_events() {
-            match handle_event(event, &mut map, &mut input_state) {
+            match handle_event(event, &mut map, &mut input_state, &mut sources) {
                 Action::Close => break 'outer,
                 Action::Redraw => {
                     redraw = true;
             if diff + draw_dur * 2 < milli16 {
                 if let Some(dur) = milli16.checked_sub(draw_dur * 2) {
                     std::thread::sleep(dur);
-                    println!("SLEEP {}", dur.as_secs() as f64 + dur.subsec_nanos() as f64 * 1e-9);
+                    println!("SLEEP {}", dur.as_secs() as f64 + f64::from(dur.subsec_nanos()) * 1e-9);
 
                     for event in window.poll_events() {
-                        match handle_event(event, &mut map, &mut input_state) {
+                        match handle_event(event, &mut map, &mut input_state, &mut sources) {
                             Action::Close => break 'outer,
                             Action::Redraw => {
                                 redraw = true;
 
         if redraw {
             let draw_start = Instant::now();
-            map.draw();
+            map.draw(sources.current());
             draw_dur = draw_start.elapsed();
 
             let _ = window.swap_buffers();
             last_draw = Instant::now();
 
             let diff = start_loop.elapsed();
-            println!("EVENT LOOP SECS {}", diff.as_secs() as f64 + diff.subsec_nanos() as f64 * 1e-9);
+            println!("EVENT LOOP SECS {}", diff.as_secs() as f64 + f64::from(diff.subsec_nanos()) * 1e-9);
+        }
+    }
+}
+
+struct TileSources {
+    current_index: usize,
+    sources: Vec<(String, TileSource)>,
+}
+
+impl TileSources {
+    pub fn new(sources: Vec<(String, TileSource)>) -> Option<TileSources> {
+        if sources.is_empty() {
+            None
+        } else {
+            Some(TileSources {
+                current_index: 0,
+                sources: sources,
+            })
         }
     }
+
+    pub fn current(&self) -> &TileSource {
+        &self.sources[self.current_index].1
+    }
+
+    pub fn switch_to_next(&mut self) {
+        self.current_index = (self.current_index + 1) % self.sources.len();
+    }
+
+    pub fn switch_to_prev(&mut self) {
+        self.current_index = (self.current_index + self.sources.len().saturating_sub(1)) % self.sources.len();
+    }
 }

src/map_view_gl.rs

     buf: Buffer<'a>,
     viewport_size: (u32, u32),
     map_view: MapView,
-    tile_source: TileSource,
     tile_cache: TileCache,
     tile_cache_gl: TileCacheGl<'a>,
 }
 
 impl<'a> MapViewGl<'a> {
-    pub fn new<F>(cx: &Context, tile_source: TileSource, initial_size: (u32, u32), update_func: F) -> MapViewGl
+    pub fn new<F>(cx: &Context, initial_size: (u32, u32), update_func: F) -> MapViewGl
         where F: Fn() + Sync + Send + 'static,
     {
         println!("version: {}", cx.gl_version());
                 buf: buf,
                 viewport_size: initial_size,
                 map_view: map_view,
-                //TODO load templates from config
-                tile_source: tile_source,
                 tile_cache: TileCache::new(move |_tile| update_func()),
                 tile_cache_gl: TileCacheGl::new(tex, 256),
             }
         }
     }
 
-    pub fn draw(&mut self) {
+    pub fn draw(&mut self, source: &TileSource) {
         {
             let visible_tiles = self.map_view.visible_tiles(true);
             let textured_visible_tiles = self.tile_cache_gl.textured_visible_tiles(
                 &visible_tiles,
-                &self.tile_source,
+                source,
                 &mut self.tile_cache,
             );
 

src/tile.rs

     pub coord: TileCoord,
     pub source_id: TileSourceId,
 }
+
+impl Tile {
+    pub fn new(coord: TileCoord, source_id: TileSourceId) -> Tile {
+        Tile {
+            coord: coord,
+            source_id: source_id,
+        }
+    }
+}

src/tile_cache.rs

 use image;
 use linked_hash_map::{Entry, LinkedHashMap};
 use coord::TileCoord;
+use tile::Tile;
 use tile_loader::TileLoader;
 use tile_source::TileSource;
 
 
 pub struct TileCache {
     loader: TileLoader,
-    map: LinkedHashMap<TileCoord, image::DynamicImage>,
+    map: LinkedHashMap<Tile, image::DynamicImage>,
     max_tiles: usize,
 }
 
 impl TileCache {
     pub fn new<F>(new_tile_func: F) -> Self
-        where F: Fn(TileCoord) + Sync + Send + 'static,
+        where F: Fn(Tile) + Sync + Send + 'static,
     {
         TileCache {
             loader: TileLoader::new(move |tile| {
 
     pub fn get_sync(
         &mut self,
-        tile: TileCoord,
+        tile_coord: TileCoord,
         source: &TileSource,
         write_to_file: bool,
         ) -> Option<&image::DynamicImage>
     {
+        let tile = Tile::new(tile_coord, source.id());
+
         //TODO Return the value from get_refresh with borrowck agreeing that this is OK.
         self.map.get_refresh(&tile);
 
                 Some(entry.into_mut())
             },
             Entry::Vacant(entry) => {
-                self.loader.get_sync(tile, source, write_to_file).map(|img| entry.insert(img) as &_)
+                self.loader.get_sync(tile_coord, source, write_to_file).map(|img| entry.insert(img) as &_)
             },
         }
     }
 
     pub fn get_async(
         &mut self,
-        tile: TileCoord,
+        tile_coord: TileCoord,
         source: &TileSource,
         write_to_file: bool,
         ) -> Option<&image::DynamicImage>
             println!("CACHE SIZE: {} tiles", self.map.len());
         }
 
+        let tile = Tile::new(tile_coord, source.id());
+
         //TODO Return the value from get_refresh with borrowck agreeing that this is OK.
         self.map.get_refresh(&tile);
 
         match self.map.entry(tile) {
             Entry::Occupied(entry) => Some(entry.into_mut()),
             Entry::Vacant(_) => {
-                self.loader.async_request(tile, source, write_to_file);
+                self.loader.async_request(tile_coord, source, write_to_file);
                 None
             }
         }
     }
 
     // Return a tile from the cache but do not use TileLoader.
-    pub fn lookup(&mut self, tile: TileCoord, source: &TileSource) -> Option<&image::DynamicImage> {
+    pub fn lookup(&mut self, tile: Tile) -> Option<&image::DynamicImage> {
         //TODO Return the value from get_refresh with borrowck agreeing that this is OK.
         self.map.get_refresh(&tile);
 

src/tile_cache_gl.rs

 use std::collections::HashMap;
 use std::collections::hash_map::Entry;
 use texture::Texture;
+use tile::Tile;
 use tile_cache::TileCache;
 use tile_source::TileSource;
 
 pub struct TileCacheGl<'a> {
     texture: Texture<'a>,
     tile_size: u32,
-    slots_lru: LinkedHashMap<CacheSlot, Option<TileCoord>>, // LRU cache of slots
-    tile_to_slot: HashMap<TileCoord, CacheSlot>,
+    slots_lru: LinkedHashMap<CacheSlot, Option<Tile>>, // LRU cache of slots
+    tile_to_slot: HashMap<Tile, CacheSlot>,
 }
 
 impl<'a> TileCacheGl<'a> {
         CacheSlot { x: 0, y: 0 }
     }
 
-    pub fn store(&mut self, tile: TileCoord, source: &TileSource, cache: &mut TileCache, load: bool) -> Option<CacheSlot> {
+    pub fn store(&mut self, tile_coord: TileCoord, source: &TileSource, cache: &mut TileCache, load: bool) -> Option<CacheSlot> {
         let mut remove_tile = None;
+        let tile = Tile::new(tile_coord, source.id());
 
         let slot = match self.tile_to_slot.entry(tile) {
             Entry::Vacant(entry) => {
                 let img_option = if load {
-                    cache.get_async(tile, source, true)
+                    cache.get_async(tile_coord, source, true)
                 } else {
-                    cache.lookup(tile, source)
+                    cache.lookup(tile)
                 };
 
                 if let Some(img) = img_option {

src/tile_loader.rs

 use std::path::{Path, PathBuf};
 use std::sync::mpsc;
 use std::thread;
-use tile_source::{TileSource, TileSourceId};
+use tile::Tile;
+use tile_source::TileSource;
 
 
 //TODO remember failed loading attempts
 pub struct TileLoader {
     client: Option<Client>,
     join_handle: thread::JoinHandle<()>,
-    request_tx: mpsc::Sender<(TileCoord, TileSourceId, String, PathBuf, bool)>,
-    result_rx: mpsc::Receiver<(TileCoord, TileSourceId, Option<DynamicImage>)>,
-    pending: HashSet<(TileCoord, TileSourceId)>,
+    request_tx: mpsc::Sender<(Tile, String, PathBuf, bool)>,
+    result_rx: mpsc::Receiver<(Tile, Option<DynamicImage>)>,
+    pending: HashSet<Tile>,
 }
 
 impl TileLoader {
     pub fn new<F>(notice_func: F) -> Self
-        where F: Fn(TileCoord) + Sync + Send + 'static,
+        where F: Fn(Tile) + Sync + Send + 'static,
     {
         let (request_tx, request_rx) = mpsc::channel();
         let (result_tx, result_rx) = mpsc::channel();
     }
 
     fn work<F>(
-        request_rx: mpsc::Receiver<(TileCoord, TileSourceId, String, PathBuf, bool)>,
-        result_tx: mpsc::Sender<(TileCoord, TileSourceId, Option<DynamicImage>)>,
+        request_rx: mpsc::Receiver<(Tile, String, PathBuf, bool)>,
+        result_tx: mpsc::Sender<(Tile, Option<DynamicImage>)>,
         notice_func: F,
     )
-        where F: Fn(TileCoord) + Sync + Send + 'static,
+        where F: Fn(Tile) + Sync + Send + 'static,
     {
         let mut client_opt = None;
-        while let Ok((tile, source_id, url, path, write_to_file)) = request_rx.recv() {
+        while let Ok((tile, url, path, write_to_file)) = request_rx.recv() {
             println!("work {:?}", tile);
             match image::open(&path) {
                 Ok(img) => {
-                    result_tx.send((tile, source_id, Some(img))).unwrap();
+                    result_tx.send((tile, Some(img))).unwrap();
                     notice_func(tile);
                     continue;
                 },
                             let mut buf: Vec<u8> = vec![];
                             response.copy_to(&mut buf).unwrap();
                             if let Ok(img) = image::load_from_memory(&buf) {
-                                result_tx.send((tile, source_id, Some(img))).unwrap();
+                                result_tx.send((tile, Some(img))).unwrap();
                                 notice_func(tile);
 
                                 if write_to_file {
                     }
                 },
             }
-            result_tx.send((tile, source_id, None)).unwrap();
+            result_tx.send((tile, None)).unwrap();
         }
     }
 
-    pub fn async_request(&mut self, tile: TileCoord, source: &TileSource, write_to_file: bool) {
-        if tile.zoom > source.max_tile_zoom() {
+    pub fn async_request(&mut self, tile_coord: TileCoord, source: &TileSource, write_to_file: bool) {
+        if tile_coord.zoom > source.max_tile_zoom() {
             return;
         }
 
-        if !self.pending.contains(&(tile, source.id())) {
-            self.pending.insert((tile, source.id()));
+        let tile = Tile::new(tile_coord, source.id());
+
+        if !self.pending.contains(&tile) {
+            self.pending.insert(tile);
             self.request_tx.send((
                 tile,
-                source.id(),
-                source.remote_tile_url(tile),
-                source.local_tile_path(tile),
+                source.remote_tile_url(tile_coord),
+                source.local_tile_path(tile_coord),
                 write_to_file
             )).unwrap();
         }
     }
 
-    pub fn async_result(&mut self) -> Option<(TileCoord, DynamicImage)> {
+    pub fn async_result(&mut self) -> Option<(Tile, DynamicImage)> {
         match self.result_rx.try_recv() {
             Err(_) => None,
-            Ok((tile, source_id, None)) => {
-                self.pending.remove(&(tile, source_id));
+            Ok((tile, None)) => {
+                self.pending.remove(&tile);
                 None
             },
-            Ok((tile, source_id, Some(img))) => {
-                self.pending.remove(&(tile, source_id));
+            Ok((tile, Some(img))) => {
+                self.pending.remove(&tile);
                 Some((tile, img))
             },
         }

src/tile_source.rs

 use coord::TileCoord;
-use std::path::{Path, PathBuf};
+use std::path::PathBuf;
 
 
 #[derive(Clone, Debug)]
         }
     }
 
-    pub fn local_tile_path(&self, tile: TileCoord) -> PathBuf {
+    pub fn local_tile_path(&self, tile_coord: TileCoord) -> PathBuf {
         let mut path = PathBuf::from(&self.directory);
-        path.push(tile.zoom.to_string());
-        path.push(tile.x.to_string());
-        path.push(tile.y.to_string() + ".png");
+        path.push(tile_coord.zoom.to_string());
+        path.push(tile_coord.x.to_string());
+        path.push(tile_coord.y.to_string() + ".png");
 
         path
     }
 
-    pub fn remote_tile_url(&self, tile: TileCoord) -> String {
-        Self::fill_template(&self.url_template, tile)
+    pub fn remote_tile_url(&self, tile_coord: TileCoord) -> String {
+        Self::fill_template(&self.url_template, tile_coord)
     }
 
     pub fn max_tile_zoom(&self) -> u32 {
         self.max_zoom
     }
 
-    fn fill_template(template: &str, tile: TileCoord) -> String {
-        let x_str = tile.x.to_string();
-        let y_str = tile.y.to_string();
-        let z_str = tile.zoom.to_string();
-
-        //let len = (template.len() + x_str.len() + y_str.len() + z_str.len()).saturating_sub(9);
+    fn fill_template(template: &str, tile_coord: TileCoord) -> String {
+        let x_str = tile_coord.x.to_string();
+        let y_str = tile_coord.y.to_string();
+        let z_str = tile_coord.zoom.to_string();
 
         //TODO use the regex crate for templates or some other more elegant method
-        let string = template.replacen("{x}", &x_str, 1);
-        let string = string.replacen("{y}", &y_str, 1);
-        let string = string.replacen("{z}", &z_str, 1);
-
-        return string;
+        template.replacen("{x}", &x_str, 1)
+                .replacen("{y}", &y_str, 1)
+                .replacen("{z}", &z_str, 1)
     }
 }