Add option for offline usage

src/main.rs

             .value_name("FILE")
             .help("Set a custom config file")
             .takes_value(true))
+        .arg(Arg::with_name("offline")
+            .long("offline")
+            .help("Do not use the network"))
         .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")
         )
     };
 

src/map_view_gl.rs

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

src/tile_cache.rs

 }
 
 impl TileCache {
-    pub fn new<F>(new_tile_func: F) -> Self
+    pub fn new<F>(new_tile_func: F, use_network: bool) -> Self
         where F: Fn(Tile) + Sync + Send + 'static,
     {
         TileCache {
-            loader: TileLoader::new(move |tile| {
-                new_tile_func(tile);
-            }),
+            loader: TileLoader::new(
+                move |tile| {
+                    new_tile_func(tile);
+                },
+                use_network,
+            ),
             map: LinkedHashMap::new(),
             max_tiles: 512, //TODO set a reasonable value
         }

src/tile_loader.rs

 use std::cmp::Ordering;
 use std::cmp;
 use std::collections::hash_set::HashSet;
+use std::error::Error;
 use std::fs::File;
 use std::io::Write;
 use std::path::{Path, PathBuf};
-use std::sync::{Arc, mpsc, Mutex};
 use std::sync::mpsc::TryRecvError;
+use std::sync::{Arc, mpsc, Mutex};
 use std::thread;
 use tile::Tile;
 use tile_source::TileSource;
     request_tx: mpsc::Sender<LoaderMessage>,
     result_rx: mpsc::Receiver<(Tile, Option<DynamicImage>)>,
     pending: HashSet<Tile>,
+    use_network: bool,
 }
 
 impl TileLoader {
-    pub fn new<F>(notice_func: F) -> Self
+    pub fn new<F>(notice_func: F, use_network: bool) -> Self
         where F: Fn(Tile) + Sync + Send + 'static,
     {
         let (request_tx, request_rx) = mpsc::channel();
 
         TileLoader {
             client: None,
-            join_handle: thread::spawn(move || Self::work(&request_rx, &result_tx, notice_func)),
+            join_handle: thread::spawn(move || Self::work(&request_rx, &result_tx, notice_func, use_network)),
             request_tx: request_tx,
             result_rx: result_rx,
             pending: HashSet::new(),
+            use_network: use_network,
         }
     }
 
         request_rx: &mpsc::Receiver<LoaderMessage>,
         result_tx: &mpsc::Sender<(Tile, Option<DynamicImage>)>,
         notice_func: F,
+        use_network: bool,
     )
         where F: Fn(Tile) + Sync + Send + 'static,
     {
                                 continue;
                             },
                             Err(_) => {
-                                if let Ok(mut remote_queue) = remote_queue.lock() {
-                                    //TODO restrict size of remote_queue
-                                    remote_queue.push(request);
-                                    if let Some(view) = view_opt {
-                                        remote_queue.as_mut_slice().sort_by(|a, b| {
-                                            compare_tiles(a.tile, b.tile, view)
-                                        });
-                                    }
-                                    if remote_request_tx.send(RemoteLoaderMessage::PopQueue).is_err() {
-                                        //TODO remote worker terminated
+                                if use_network {
+                                    if let Ok(mut remote_queue) = remote_queue.lock() {
+                                        //TODO restrict size of remote_queue
+                                        remote_queue.push(request);
+                                        if let Some(view) = view_opt {
+                                            remote_queue.as_mut_slice().sort_by(|a, b| {
+                                                compare_tiles(a.tile, b.tile, view)
+                                            });
+                                        }
+                                        if let Err(e) = remote_request_tx.send(RemoteLoaderMessage::PopQueue) {
+                                            //TODO what now? restart worker?
+                                            error!("remote worker terminated, {}", e.description());
+                                        }
                                     }
+                                } else if result_tx.send((request.tile, None)).is_err() {
+                                    break 'outer;
                                 }
                             },
                         }
                                     notice_func(request.tile);
 
                                     if request.write_to_file {
-                                        //TODO do something on write errors
-                                        let _ = Self::write_to_file(&request.path, &buf);
+                                        if let Err(e) = Self::write_to_file(&request.path, &buf) {
+                                            warn!("could not write file {}, {}", request.path.display(), e.description());
+                                        }
                                     }
 
                                     continue;
             Err(_) => None,
             Ok((tile, None)) => {
                 self.pending.remove(&tile);
+                debug!("async_result none, pending.len: {}, {:?}", self.pending.len(), tile);
                 None
             },
             Ok((tile, Some(img))) => {
                 self.pending.remove(&tile);
+                debug!("async_result some, pending.len: {}, {:?}", self.pending.len(), tile);
                 Some((tile, img))
             },
         }
                 Some(img)
             },
             Err(_) => {
-                //TODO do not try to create a client every time when it failed before
-                if self.client.is_none() {
-                    self.client = Client::builder().build().ok();
-                }
+                if self.use_network {
+                    //TODO do not try to create a client every time when it failed before
+                    if self.client.is_none() {
+                        self.client = Client::builder().build().ok();
+                    }
 
-                if let (Some(client), Some(url)) = (self.client.as_ref(), source.remote_tile_url(tile)) {
-                    if let Ok(mut response) = client.get(&url).send() {
-                        let mut buf: Vec<u8> = vec![];
-                        if response.copy_to(&mut buf).is_ok() {
-                            if let Ok(img) = image::load_from_memory(&buf) {
-                                if write_to_file {
-                                    let path = source.local_tile_path(tile);
-                                    let _ = Self::write_to_file(path, &buf);
+                    if let (Some(client), Some(url)) = (self.client.as_ref(), source.remote_tile_url(tile)) {
+                        if let Ok(mut response) = client.get(&url).send() {
+                            let mut buf: Vec<u8> = vec![];
+                            if response.copy_to(&mut buf).is_ok() {
+                                if let Ok(img) = image::load_from_memory(&buf) {
+                                    if write_to_file {
+                                        let path = source.local_tile_path(tile);
+                                        if let Err(e) = Self::write_to_file(&path, &buf) {
+                                            warn!("could not write file {}, {}", &path.display(), e.description());
+                                        }
+                                    }
+                                    return Some(img);
                                 }
-                                return Some(img);
                             }
                         }
                     }
+                    None
+                } else {
+                    None
                 }
-                None
             },
         }
     }