fix(memory): memory growth app side

Author: Times-Z

Cargo.lock

@@ -13,6 +13,7 @@ build = "build.rs"
 gtk4-layer-shell.workspace = true
 gtk4.workspace = true
 gdk4.workspace = true
+gdk-pixbuf.workspace = true
 bytesize.workspace = true
 chrono.workspace = true
 console.workspace = true

crates/wayle-shell/Cargo.toml

@@ -5,10 +5,11 @@ use wayle_notification::core::types::Action;
 use super::NotificationItem;
 use crate::{
     i18n::t,
-    shell::notification_popup::helpers::{RelativeTime, ResolvedIcon},
+    shell::notification_popup::helpers::{RelativeTime, ResolvedIcon, load_scaled_file_icon},
 };
 
 const MAX_ACTIONS_PER_ROW: usize = 3;
+const DROPDOWN_ICON_TEXTURE_SIZE_PX: i32 = 48;
 
 impl NotificationItem {
     pub(super) fn apply_icon(&self, icon: &gtk::Image, icon_container: &gtk::Box) {
@@ -21,8 +22,13 @@ impl NotificationItem {
             }
 
             ResolvedIcon::File(path) => {
-                icon.set_from_file(Some(path));
-                icon_container.add_css_class("file-icon");
+                if let Some(texture) = load_scaled_file_icon(path, DROPDOWN_ICON_TEXTURE_SIZE_PX)
+                {
+                    icon.set_paintable(Some(&texture));
+                    icon_container.add_css_class("file-icon");
+                } else {
+                    icon.set_icon_name(Some("ld-bell-symbolic"));
+                }
             }
         }
     }

crates/wayle-shell/src/shell/bar/dropdowns/notification/notification_item/methods.rs

@@ -1,3 +1,5 @@
+use std::{collections::hash_map::DefaultHasher, hash::Hasher, path::Path};
+
 use gtk4::{gdk, glib, prelude::Cast};
 use wayle_systray::types::item::IconPixmap;
 
@@ -25,21 +27,43 @@ pub(super) fn create_texture_from_pixmap(pixmap: &IconPixmap) -> Option<gdk::Tex
     .into()
 }
 
-pub(super) fn load_icon_from_theme_path(theme_path: &str, icon_name: &str) -> Option<gdk::Texture> {
+pub(super) fn hash_pixmaps(pixmaps: &[IconPixmap]) -> u64 {
+    let mut hasher = DefaultHasher::new();
+
+    for pixmap in pixmaps {
+        hasher.write_i32(pixmap.width);
+        hasher.write_i32(pixmap.height);
+        hasher.write_usize(pixmap.data.len());
+        hasher.write(&pixmap.data);
+    }
+
+    hasher.finish()
+}
+
+pub(super) fn load_scaled_texture_from_file(path: &str) -> Option<gdk::Texture> {
+    let pixbuf = gdk_pixbuf::Pixbuf::from_file_at_scale(path, TARGET_ICON_SIZE, TARGET_ICON_SIZE, true).ok()?;
+    Some(gdk::Texture::for_pixbuf(&pixbuf))
+}
+
+pub(super) fn find_icon_in_theme_path(theme_path: &str, icon_name: &str) -> Option<String> {
     if theme_path.is_empty() {
         return None;
     }
 
     for ext in ICON_EXTENSIONS {
         let file_path = format!("{theme_path}/{icon_name}.{ext}");
-        if let Ok(texture) = gdk::Texture::from_filename(&file_path) {
-            return Some(texture);
+        if Path::new(&file_path).is_file() {
+            return Some(file_path);
         }
     }
 
     None
 }
 
+pub(super) fn load_icon_from_theme_path(theme_path: &str, icon_name: &str) -> Option<gdk::Texture> {
+    find_icon_in_theme_path(theme_path, icon_name).as_deref().and_then(load_scaled_texture_from_file)
+}
+
 fn argb_to_rgba(argb: &[u8]) -> Vec<u8> {
     argb.chunks_exact(4)
         .flat_map(|chunk| {

crates/wayle-shell/src/shell/bar/modules/systray/item/helpers.rs

@@ -1,3 +1,5 @@
+use std::path::Path;
+
 #[allow(deprecated)]
 use gtk4::prelude::StyleContextExt;
 use gtk4::{gdk, gio, glib::idle_add_local_once};
@@ -12,8 +14,11 @@ use wayle_systray::{
 };
 
 use super::{
-    SystrayItem, SystrayItemMsg,
-    helpers::{create_texture_from_pixmap, load_icon_from_theme_path, select_best_pixmap},
+    IconSignature, SystrayItem, SystrayItemMsg,
+    helpers::{
+        create_texture_from_pixmap, find_icon_in_theme_path, hash_pixmaps,
+        load_icon_from_theme_path, load_scaled_texture_from_file, select_best_pixmap,
+    },
 };
 use crate::shell::bar::modules::systray::helpers::find_override;
 
@@ -165,7 +170,12 @@ impl SystrayItem {
             .and_then(|entry| entry.icon.clone())
             .or_else(|| self.item.icon_name.get());
 
-        self.apply_icon(image, icon_name.as_deref());
+        let icon_signature = self.icon_signature(icon_name.as_deref());
+
+        if self.icon_signature.as_ref() != Some(&icon_signature) {
+            self.apply_icon(image, icon_name.as_deref());
+            self.icon_signature = Some(icon_signature);
+        }
 
         if let Some(color) = override_match.and_then(|entry| entry.color.clone()) {
             self.apply_icon_color(image, &color.to_css());
@@ -174,6 +184,32 @@ impl SystrayItem {
         }
     }
 
+    fn icon_signature(&self, icon_name: Option<&str>) -> IconSignature {
+        if let Some(name) = icon_name {
+            let theme_path = self.item.icon_theme_path.get();
+
+            if let Some(file_path) = theme_path
+                .as_deref()
+                .and_then(|path| find_icon_in_theme_path(path, name))
+            {
+                return IconSignature::File(file_path);
+            }
+
+            if Path::new(name).is_file() {
+                return IconSignature::File(name.to_owned());
+            }
+
+            return IconSignature::Named(name.to_owned());
+        }
+
+        let pixmaps = self.item.icon_pixmap.get();
+        if pixmaps.is_empty() {
+            return IconSignature::Fallback;
+        }
+
+        IconSignature::Pixmap(hash_pixmaps(&pixmaps))
+    }
+
     fn apply_icon_color(&mut self, image: &gtk::Image, css_color: &str) {
         let provider = self
             .icon_color_provider
@@ -182,20 +218,29 @@ impl SystrayItem {
         let css = format!("image {{ color: {css_color}; }}");
         provider.load_from_string(&css);
 
-        #[allow(deprecated)]
-        image
-            .style_context()
-            .add_provider(provider, gtk::STYLE_PROVIDER_PRIORITY_USER + 1);
+        if !self.icon_color_provider_attached {
+            #[allow(deprecated)]
+            image
+                .style_context()
+                .add_provider(provider, gtk::STYLE_PROVIDER_PRIORITY_USER + 1);
+            self.icon_color_provider_attached = true;
+        }
     }
 
     fn clear_icon_color(&mut self, image: &gtk::Image) {
-        if let Some(provider) = self.icon_color_provider.take() {
+        if self.icon_color_provider_attached
+            && let Some(provider) = self.icon_color_provider.as_ref()
+        {
             #[allow(deprecated)]
-            image.style_context().remove_provider(&provider);
+            image.style_context().remove_provider(provider);
+            self.icon_color_provider_attached = false;
         }
     }
 
     fn apply_icon(&self, image: &gtk::Image, icon_name: Option<&str>) {
+        image.set_icon_name(None);
+        image.set_paintable(None::<&gdk::Texture>);
+
         if let Some(name) = icon_name {
             let theme_path = self.item.icon_theme_path.get();
             if let Some(texture) = theme_path
@@ -206,7 +251,7 @@ impl SystrayItem {
                 return;
             }
 
-            if let Ok(texture) = gdk::Texture::from_filename(name) {
+            if let Some(texture) = load_scaled_texture_from_file(name) {
                 image.set_paintable(Some(&texture));
                 return;
             }

crates/wayle-shell/src/shell/bar/modules/systray/item/methods.rs

@@ -24,13 +24,23 @@ pub(super) struct SystrayItem {
     config: Arc<ConfigService>,
     button: Option<gtk::Button>,
     icon: Option<gtk::Image>,
+    icon_signature: Option<IconSignature>,
     icon_color_provider: Option<gtk::CssProvider>,
+    icon_color_provider_attached: bool,
     popover: Option<gtk::PopoverMenu>,
     action_group: Option<SimpleActionGroup>,
     registered_accels: Vec<String>,
     cancel_token: CancellationToken,
 }
 
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(super) enum IconSignature {
+    File(String),
+    Named(String),
+    Pixmap(u64),
+    Fallback,
+}
+
 #[derive(Debug)]
 #[allow(clippy::enum_variant_names)]
 pub(super) enum SystrayItemMsg {
@@ -74,7 +84,9 @@ impl FactoryComponent for SystrayItem {
             config: init.config,
             button: None,
             icon: None,
+            icon_signature: None,
             icon_color_provider: None,
+            icon_color_provider_attached: false,
             popover: None,
             action_group: None,
             registered_accels: Vec::new(),

crates/wayle-shell/src/shell/bar/modules/systray/item/mod.rs

@@ -6,9 +6,13 @@ use wayle_notification::core::types::Action;
 use super::NotificationPopupCard;
 use crate::{
     i18n::t,
-    shell::notification_popup::helpers::{RelativeTime, ResolvedIcon, urgency_bar_visible},
+    shell::notification_popup::helpers::{
+        RelativeTime, ResolvedIcon, load_scaled_file_icon, urgency_bar_visible,
+    },
 };
 
+const POPUP_ICON_TEXTURE_SIZE_PX: i32 = 64;
+
 impl NotificationPopupCard {
     pub(super) fn apply_css_classes(
         &self,
@@ -35,8 +39,12 @@ impl NotificationPopupCard {
             }
 
             ResolvedIcon::File(path) => {
-                icon.set_from_file(Some(path));
-                icon_container.add_css_class("file-icon");
+                if let Some(texture) = load_scaled_file_icon(path, POPUP_ICON_TEXTURE_SIZE_PX) {
+                    icon.set_paintable(Some(&texture));
+                    icon_container.add_css_class("file-icon");
+                } else {
+                    icon.set_icon_name(Some("ld-bell-symbolic"));
+                }
             }
         }
     }

crates/wayle-shell/src/shell/notification_popup/card/methods.rs

@@ -1,5 +1,5 @@
 use chrono::{DateTime, Utc};
-use relm4::gtk::{glib, pango};
+use relm4::gtk::{gdk, glib, pango};
 use wayle_config::schemas::modules::notification::{IconSource, UrgencyBarThreshold};
 use wayle_notification::types::Urgency;
 
@@ -131,6 +131,17 @@ fn mapped_icon(app_name: &Option<String>) -> ResolvedIcon {
     ResolvedIcon::Named(String::from(name))
 }
 
+/// Loads a file-based icon as a scaled texture to avoid keeping oversized
+/// image allocations alive when notifications provide large images.
+pub(crate) fn load_scaled_file_icon(path: &str, target_px: i32) -> Option<gdk::Texture> {
+    if path.is_empty() {
+        return None;
+    }
+
+    let pixbuf = gdk_pixbuf::Pixbuf::from_file_at_scale(path, target_px, target_px, true).ok()?;
+    Some(gdk::Texture::for_pixbuf(&pixbuf))
+}
+
 #[cfg(test)]
 #[allow(clippy::panic)]
 mod tests {

crates/wayle-shell/src/shell/notification_popup/helpers.rs

@@ -237,8 +237,10 @@ impl Component for BarButton {
             }
             BarButtonInput::ConfigChanged => {}
             BarButtonInput::SetThresholdColors(colors) => {
-                self.threshold_overrides = colors;
-                self.reload_css();
+                if colors != self.threshold_overrides {
+                    self.threshold_overrides = colors;
+                    self.reload_css();
+                }
             }
         }
     }