refactor: replace icon loading with improved general image loading

src/desktop_file.rs

@@ -1,6 +1,3 @@
-use gtk::gdk_pixbuf::Pixbuf;
-use gtk::prelude::*;
-use gtk::{IconLookupFlags, IconTheme};
 use std::collections::HashMap;
 use std::fs::File;
 use std::io;
@@ -67,7 +64,7 @@ fn parse_desktop_file(path: PathBuf) -> io::Result<HashMap<String, String>> {
 }
 
 /// Attempts to get the icon name from the app's `.desktop` file.
-fn get_desktop_icon_name(app_id: &str) -> Option<String> {
+pub fn get_desktop_icon_name(app_id: &str) -> Option<String> {
     find_desktop_file(app_id).and_then(|file| {
         let map = parse_desktop_file(file);
         map.map_or(None, |map| {
@@ -75,65 +72,3 @@ fn get_desktop_icon_name(app_id: &str) -> Option<String> {
         })
     })
 }
-
-enum IconLocation {
-    Theme(String),
-    File(PathBuf),
-}
-
-/// Attempts to get the location of an icon.
-///
-/// Handles icons that are part of a GTK theme, icons specified as path
-/// and icons for steam games.
-fn get_icon_location(theme: &IconTheme, app_id: &str, size: i32) -> Option<IconLocation> {
-    let has_icon = theme
-        .lookup_icon(app_id, size, IconLookupFlags::empty())
-        .is_some();
-
-    if has_icon {
-        return Some(IconLocation::Theme(app_id.to_string()));
-    }
-
-    let is_steam_game = app_id.starts_with("steam_app_");
-    if is_steam_game {
-        let steam_id: String = app_id.chars().skip("steam_app_".len()).collect();
-
-        return match dirs::data_dir() {
-            Some(dir) => {
-                let path = dir.join(format!(
-                    "icons/hicolor/32x32/apps/steam_icon_{steam_id}.png"
-                ));
-
-                return Some(IconLocation::File(path));
-            }
-            None => None,
-        };
-    }
-
-    let icon_name = get_desktop_icon_name(app_id);
-    if let Some(icon_name) = icon_name {
-        let is_path = PathBuf::from(&icon_name).exists();
-
-        return if is_path {
-            Some(IconLocation::File(PathBuf::from(icon_name)))
-        } else {
-            return Some(IconLocation::Theme(icon_name));
-        };
-    }
-
-    None
-}
-
-/// Gets the icon associated with an app.
-pub fn get_icon(theme: &IconTheme, app_id: &str, size: i32) -> Option<Pixbuf> {
-    let icon_location = get_icon_location(theme, app_id, size);
-
-    match icon_location {
-        Some(IconLocation::Theme(icon_name)) => {
-            let icon = theme.load_icon(&icon_name, size, IconLookupFlags::FORCE_SIZE);
-            icon.map_or(None, |icon| icon)
-        }
-        Some(IconLocation::File(path)) => Pixbuf::from_file_at_scale(path, size, size, true).ok(),
-        None => None,
-    }
-}

src/image.rs

@@ -0,0 +1,166 @@
+use crate::desktop_file::get_desktop_icon_name;
+use crate::send;
+use color_eyre::{Report, Result};
+use glib::Bytes;
+use gtk::gdk_pixbuf::Pixbuf;
+use gtk::gio::{Cancellable, MemoryInputStream};
+use gtk::prelude::*;
+use gtk::{IconLookupFlags, IconTheme};
+use reqwest::Url;
+use std::path::{Path, PathBuf};
+use tokio::spawn;
+use tracing::error;
+
+#[derive(Debug)]
+enum ImageLocation<'a> {
+    Icon { name: String, theme: &'a IconTheme },
+    Local(PathBuf),
+    Steam(String),
+    Remote(Url),
+}
+
+pub struct ImageProvider<'a> {
+    location: ImageLocation<'a>,
+    size: i32,
+}
+
+impl<'a> ImageProvider<'a> {
+    /// Attempts to parse the image input to find its location.
+    /// Errors if no valid location type can be found.
+    ///
+    /// Note this checks that icons exist in theme, or files exist on disk
+    /// but no other check is performed.
+    pub fn parse(input: String, theme: &'a IconTheme, size: i32) -> Result<Self> {
+        let location = Self::get_location(input, theme, size)?;
+        Ok(Self { location, size })
+    }
+
+    fn get_location(input: String, theme: &'a IconTheme, size: i32) -> Result<ImageLocation> {
+        let (input_type, input_name) = input
+            .split_once(':')
+            .map(|(t, n)| (Some(t), n))
+            .unwrap_or((None, &input));
+
+        match input_type {
+            Some(input_type) if input_type == "icon" => Ok(ImageLocation::Icon {
+                name: input_name.to_string(),
+                theme,
+            }),
+            Some(input_type) if input_type == "file" => Ok(ImageLocation::Local(PathBuf::from(
+                input_name[2..].to_string(),
+            ))),
+            Some(input_type) if input_type == "http" || input_type == "https" => {
+                Ok(ImageLocation::Remote(input.parse()?))
+            }
+            None if input.starts_with("steam_app_") => Ok(ImageLocation::Steam(
+                input_name.chars().skip("steam_app_".len()).collect(),
+            )),
+            None if theme
+                .lookup_icon(&input, size, IconLookupFlags::empty())
+                .is_some() =>
+            {
+                Ok(ImageLocation::Icon {
+                    name: input_name.to_string(),
+                    theme,
+                })
+            }
+            Some(input_type) => Err(Report::msg(format!("Unsupported image type: {input_type}"))),
+            None if PathBuf::from(input_name).exists() => {
+                Ok(ImageLocation::Local(PathBuf::from(input_name)))
+            }
+            None => match get_desktop_icon_name(&input_name) {
+                Some(input) => Self::get_location(input, theme, size),
+                None => Err(Report::msg("Unknown image type")),
+            },
+        }
+    }
+
+    /// Attempts to fetch the image from the location
+    /// and load it into the provided `GTK::Image` widget.
+    pub fn load_into_image(&self, image: gtk::Image) -> Result<()> {
+        // handle remote locations async to avoid blocking UI thread while downloading
+        if let ImageLocation::Remote(url) = &self.location {
+            let url = url.clone();
+            let (tx, rx) = glib::MainContext::channel(glib::PRIORITY_DEFAULT);
+
+            spawn(async move {
+                let bytes = Self::get_bytes_from_http(url).await;
+                if let Ok(bytes) = bytes {
+                    send!(tx, bytes);
+                }
+            });
+
+            {
+                let size = self.size;
+                rx.attach(None, move |bytes| {
+                    let stream = MemoryInputStream::from_bytes(&bytes);
+                    let pixbuf = Pixbuf::from_stream_at_scale(
+                        &stream,
+                        size,
+                        size,
+                        true,
+                        Some(&Cancellable::new()),
+                    );
+
+                    match pixbuf {
+                        Ok(pixbuf) => image.set_pixbuf(Some(&pixbuf)),
+                        Err(err) => error!("{err:?}"),
+                    }
+
+                    Continue(false)
+                });
+            }
+
+            Ok(())
+        } else {
+            let pixbuf = match &self.location {
+                ImageLocation::Icon { name, theme } => self.get_from_icon(name, theme),
+                ImageLocation::Local(path) => self.get_from_file(path),
+                ImageLocation::Steam(steam_id) => self.get_from_steam_id(steam_id),
+                ImageLocation::Remote(_) => unreachable!(), // handled above
+            }?;
+
+            image.set_pixbuf(Some(&pixbuf));
+            Ok(())
+        }
+    }
+
+    /// Attempts to get a `Pixbuf` from the GTK icon theme.
+    fn get_from_icon(&self, name: &str, theme: &IconTheme) -> Result<Pixbuf> {
+        let pixbuf = match theme.lookup_icon(name, self.size, IconLookupFlags::empty()) {
+            Some(_) => theme.load_icon(name, self.size, IconLookupFlags::FORCE_SIZE),
+            None => Ok(None),
+        }?;
+
+        match pixbuf {
+            Some(pixbuf) => Ok(pixbuf),
+            None => Err(Report::msg("Icon theme does not contain icon '{name}'")),
+        }
+    }
+
+    /// Attempts to get a `Pixbuf` from a local file.
+    fn get_from_file(&self, path: &Path) -> Result<Pixbuf> {
+        let pixbuf = Pixbuf::from_file_at_scale(path, self.size, self.size, true)?;
+        Ok(pixbuf)
+    }
+
+    /// Attempts to get a `Pixbuf` from a local file,
+    /// using the Steam game ID to look it up.
+    fn get_from_steam_id(&self, steam_id: &str) -> Result<Pixbuf> {
+        // TODO: Can we load this from icon theme with app id `steam_icon_{}`?
+        let path = match dirs::data_dir() {
+            Some(dir) => Ok(dir.join(format!(
+                "icons/hicolor/32x32/apps/steam_icon_{steam_id}.png"
+            ))),
+            None => Err(Report::msg("Missing XDG data dir")),
+        }?;
+
+        self.get_from_file(&path)
+    }
+
+    /// Attempts to get `Bytes` from an HTTP resource asynchronously.
+    async fn get_bytes_from_http(url: Url) -> Result<Bytes> {
+        let bytes = reqwest::get(url).await?.bytes().await?;
+        Ok(Bytes::from_owned(bytes))
+    }
+}

src/main.rs

@@ -2,9 +2,10 @@ mod bar;
 mod bridge_channel;
 mod clients;
 mod config;
+mod desktop_file;
 mod dynamic_string;
 mod error;
-mod icon;
+mod image;
 mod logging;
 mod macros;
 mod modules;

src/modules/focused.rs

@@ -1,14 +1,16 @@
 use crate::clients::wayland::{self, ToplevelChange};
 use crate::config::{CommonConfig, TruncateMode};
+use crate::image::ImageProvider;
 use crate::modules::{Module, ModuleInfo, ModuleUpdateEvent, ModuleWidget, WidgetContext};
-use crate::{await_sync, icon, read_lock, send_async};
+use crate::{await_sync, read_lock, send_async};
 use color_eyre::Result;
 use glib::Continue;
 use gtk::prelude::*;
-use gtk::{IconTheme, Image, Label};
+use gtk::{IconTheme, Label};
 use serde::Deserialize;
 use tokio::spawn;
 use tokio::sync::mpsc::{Receiver, Sender};
+use tracing::error;
 
 #[derive(Debug, Deserialize, Clone)]
 pub struct FocusedModule {
@@ -101,7 +103,7 @@ impl Module<gtk::Box> for FocusedModule {
 
         let container = gtk::Box::new(info.bar_position.get_orientation(), 5);
 
-        let icon = Image::builder().name("icon").build();
+        let icon = gtk::Image::builder().name("icon").build();
         let label = Label::builder().name("label").build();
 
         if let Some(truncate) = self.truncate {
@@ -113,10 +115,12 @@ impl Module<gtk::Box> for FocusedModule {
 
         {
             context.widget_rx.attach(None, move |(name, id)| {
-                let pixbuf = icon::get_icon(&icon_theme, &id, self.icon_size);
-
                 if self.show_icon {
-                    icon.set_pixbuf(pixbuf.as_ref());
+                    if let Err(err) = ImageProvider::parse(id, &icon_theme, self.icon_size)
+                        .and_then(|image| image.load_into_image(icon.clone()))
+                    {
+                        error!("{err:?}");
+                    }
                 }
 
                 if self.show_title {

src/modules/launcher/item.rs

@@ -1,16 +1,17 @@
 use super::open_state::OpenState;
 use crate::clients::wayland::ToplevelInfo;
-use crate::icon::get_icon;
+use crate::image::ImageProvider;
 use crate::modules::launcher::{ItemEvent, LauncherUpdate};
 use crate::modules::ModuleUpdateEvent;
 use crate::popup::Popup;
 use crate::{read_lock, try_send};
 use gtk::prelude::*;
-use gtk::{Button, IconTheme, Image, Orientation};
+use gtk::{Button, IconTheme, Orientation};
 use indexmap::IndexMap;
 use std::rc::Rc;
 use std::sync::RwLock;
 use tokio::sync::mpsc::Sender;
+use tracing::error;
 
 #[derive(Debug, Clone)]
 pub struct Item {
@@ -151,16 +152,24 @@ impl ItemButton {
             button = button.label(&item.name);
         }
 
-        if show_icons {
-            let icon = get_icon(icon_theme, &item.app_id, 32);
-            if icon.is_some() {
-                let image = Image::from_pixbuf(icon.as_ref());
-                button = button.image(&image).always_show_image(true);
-            }
-        }
-
         let button = button.build();
 
+        if show_icons {
+            let gtk_image = gtk::Image::new();
+            let image = ImageProvider::parse(item.app_id.clone(), icon_theme, 32);
+            match image {
+                Ok(image) => {
+                    button.set_image(Some(&gtk_image));
+                    button.set_always_show_image(true);
+
+                    if let Err(err) = image.load_into_image(gtk_image) {
+                        error!("{err:?}");
+                    }
+                }
+                Err(err) => error!("{err:?}"),
+            };
+        }
+
         let style_context = button.style_context();
         style_context.add_class("item");
 

src/modules/launcher/mod.rs

@@ -5,7 +5,7 @@ use self::item::{Item, ItemButton, Window};
 use self::open_state::OpenState;
 use crate::clients::wayland::{self, ToplevelChange};
 use crate::config::CommonConfig;
-use crate::icon::find_desktop_file;
+use crate::desktop_file::find_desktop_file;
 use crate::modules::{Module, ModuleInfo, ModuleUpdateEvent, ModuleWidget, WidgetContext};
 use crate::{lock, read_lock, try_send, write_lock};
 use color_eyre::{Help, Report};