Add --sync option

src/main.rs

                     .map_err(|e| e.description().to_string())
             })
             .help("Set target frames per second (default is 60). \
-                  This should equal the refresh rate of the display.")
+                This should equal the refresh rate of the display.")
             .takes_value(true))
         .arg(Arg::with_name("offline")
             .long("offline")
-            .help("Do not use the network"))
+            .help("Do not use the network. \
+                Try to load tiles from the offline file system cache."))
+        .arg(Arg::with_name("sync")
+            .long("sync")
+            .help("Load tiles in a synchronous fashion. \
+                Interaction is not possible while tiles are loading."))
         .get_matches();
 
     let config = if let Some(config_path) = matches.value_of_os("config") {
             &cx,
             window.get_inner_size_pixels().unwrap(),
             move || { proxy.wakeup_event_loop(); },
-            !matches.is_present("offline")
+            !matches.is_present("offline"),
+            !matches.is_present("sync"),
         )
     };
 

src/map_view_gl.rs

 }
 
 impl<'a> MapViewGl<'a> {
-    pub fn new<F>(cx: &Context, initial_size: (u32, u32), update_func: F, use_network: bool) -> MapViewGl
+    pub fn new<F>(
+        cx: &Context,
+        initial_size: (u32, u32),
+        update_func: F,
+        use_network: bool,
+        use_async: bool,
+        ) -> MapViewGl
         where F: Fn() + Sync + Send + 'static,
     {
         unsafe {
                 viewport_size: initial_size,
                 map_view: map_view,
                 tile_cache: TileCache::new(move |_tile| update_func(), use_network),
-                tile_atlas: TileAtlas::new(tex, 256),
+                tile_atlas: TileAtlas::new(tex, 256, use_async),
             }
         }
     }

src/tile_atlas.rs

     tile_size: u32,
     slots_lru: LinkedHashMap<CacheSlot, Option<Tile>>, // LRU cache of slots
     tile_to_slot: HashMap<Tile, CacheSlot>,
+    use_async: bool,
 }
 
 impl<'a> TileAtlas<'a> {
         self.tile_to_slot.reserve(num_slots);
     }
 
-    pub fn new(tex: Texture<'a>, tile_size: u32) -> Self {
+    pub fn new(tex: Texture<'a>, tile_size: u32, use_async: bool) -> Self {
         let mut atlas = TileAtlas {
             texture: tex,
             tile_size: tile_size,
             slots_lru: LinkedHashMap::new(),
             tile_to_slot: HashMap::new(),
+            use_async: use_async,
         };
 
         atlas.init();
         let slot = match self.tile_to_slot.entry(tile) {
             Entry::Vacant(entry) => {
                 let img_option = if load {
-                    cache.get_async(tile_coord, source, true)
+                    if self.use_async {
+                        cache.get_async(tile_coord, source, true)
+                    } else {
+                        cache.get_sync(tile_coord, source, true)
+                    }
                 } else {
                     cache.lookup(tile)
                 };

src/tile_loader.rs

 
         match image::open(source.local_tile_path(tile)) {
             Ok(img) => {
+                debug!("sync ok from path {:?}", tile);
                 Some(img)
             },
             Err(_) => {
                                             warn!("could not write file {}, {}", &path.display(), e.description());
                                         }
                                     }
+                                    debug!("sync ok from network {:?}", tile);
                                     return Some(img);
                                 }
                             }
                         }
                     }
+                    debug!("sync fail from network {:?}", tile);
                     None
                 } else {
+                    debug!("sync fail from path {:?}", tile);
                     None
                 }
             },