fix lag in mediaview by moving availability check to config

src/config.rs

@@ -91,6 +91,7 @@ pub struct Config {
     pub media_autoplay: bool,
     pub media_mute: bool,
     pub media_previewer: String,
+    pub media_previewer_exists: bool,
     pub ratios: Vec::<usize>,
     pub graphics: String,
     pub keybinds: KeyBinds,
@@ -115,6 +116,7 @@ impl Config {
             media_autoplay: false,
             media_mute: false,
             media_previewer: "hunter-media".to_string(),
+            media_previewer_exists: false,
             ratios: vec![20,30,49],
             graphics: detect_g_mode(),
             keybinds: KeyBinds::default(),
@@ -157,20 +159,36 @@ impl Config {
                 Ok(("media_mute", "on")) => config.media_mute = true,
                 Ok(("media_mute", "off")) => config.media_mute = false,
                 Ok(("media_previewer", cmd)) => {
+                    use crate::minibuffer::find_bins;
+
                     let cmd = cmd.to_string();
                     config.media_previewer = cmd;
+
+                    let previewer = std::path::Path::new(&config.media_previewer);
+                    let exists = match previewer.is_absolute() {
+                        true => previewer.exists(),
+                        false => find_bins(&config.media_previewer).is_ok()
+                    };
+
+                    config.media_previewer_exists = exists;
+
                 },
                 Ok(("ratios", ratios)) => {
                     let ratios_str = ratios.to_string();
                     if ratios_str.chars().all(|x| x.is_digit(10) || x.is_whitespace()
                         || x == ':' || x == ',' ) {
-                            let ratios: Vec<usize> = ratios_str.split([',', ':'].as_ref())
+                        let ratios: Vec<usize> = ratios_str.split([',', ':'].as_ref())
-                                .map(|r| r.trim().parse::<usize>().unwrap()).collect();
+                            .map(|r| r.trim()
-                            let ratios_sum: usize = ratios.iter().sum();
+                                 .parse().unwrap())
-                            if ratios.len() == 3 && ratios_sum > 0 && ratios.iter()
+                            .collect();
-                                .filter(|&r| *r > u16::max_value() as usize).next() == None {
+                        let ratios_sum: usize = ratios.iter().sum();
-                                    config.ratios = ratios;
+                        if ratios.len() == 3 && ratios_sum > 0 &&
-                        }
+                            ratios
+                            .iter()
+                            .filter(|&r| *r > u16::max_value() as usize)
+                            .next() == None {
+                                config.ratios = ratios;
+                            }
                     }
                 }
                 #[cfg(feature = "sixel")]
@@ -212,6 +230,10 @@ impl Config {
     pub fn show_hidden(&self) -> bool {
         self.show_hidden
     }
+
+    pub fn media_available(&self) -> bool {
+        self.media_previewer_exists
+    }
 }
 
 fn detect_g_mode() -> String {

src/file_browser.rs

@@ -661,9 +661,20 @@ impl FileBrowser {
                 self.preview_widget_mut()?.set_stale().log();
                 return Ok(());
             }
-        let file = self.selected_file()?.clone();
+
+        let file = self.selected_file()?;
+
+        // Don't even call previewer on empty files to save CPU cycles
+        match (file.is_dir(), file.calculate_size()) {
+            (false, Ok((size, unit))) => if size == 0 && unit.as_str() == "" {
+                self.preview_widget_mut()?.set_stale().log();
+                return Ok(());
+            },
+            _ => {}
+        }
+
         let preview = self.preview_widget_mut()?;
-        preview.set_file(&file).log();
+        preview.set_file(file).log();
         Ok(())
     }
 

src/mediaview.rs

@@ -77,22 +77,6 @@ impl MediaView {
     pub fn new_from_file(core: WidgetCore,
                          file: &Path,
                          media_type: MediaType) -> HResult<MediaView> {
-        // Check if previewer is present, or bail out to show message
-        let media_previewer = core.config().media_previewer;
-        if crate::minibuffer::find_bins(&media_previewer).is_err() {
-            let msg = format!("Couldn't find previewer: {}{}{}!",
-                              crate::term::color_red(),
-                              media_previewer,
-                              crate::term::normal_color());
-
-
-            core.show_status(&msg).log();
-
-            return Err(MediaError::NoPreviewer(msg))?;
-        }
-
-
-
         let imgview = ImgView {
             core: core.clone(),
             buffer: vec![],

src/preview.rs

@@ -355,6 +355,7 @@ impl Previewer {
         let core = self.core.clone();
         let cache = self.cache.clone();
         let animator = self.animator.clone();
+        let has_media = self.core.config().media_available();
 
         self.widget.set_stale().ok();
 
@@ -390,19 +391,19 @@ impl Previewer {
                     let is_gif = mime.subtype() == "gif";
 
                     match mime_type {
-                        _ if mime_type == "video" || is_gif => {
+                        _ if mime_type == "video" || is_gif && has_media => {
                             let media_type = crate::mediaview::MediaType::Video;
                             let mediaview = MediaView::new_from_file(core.clone(),
                                                                      &file.path,
                                                                      media_type)?;
                             return Ok(PreviewWidget::MediaView(mediaview));
                         }
-                        "image" => {
+                        "image" if has_media => {
                             let imgview = ImgView::new_from_file(core.clone(),
                                                                  &file.path())?;
                             return Ok(PreviewWidget::ImgView(imgview));
                         }
-                        "audio" => {
+                        "audio" if has_media => {
                             let media_type = crate::mediaview::MediaType::Audio;
                             let mediaview = MediaView::new_from_file(core.clone(),
                                                                      &file.path,