fix: shared window class issue, state not resetting, thread issue

Author: tadghh

Cargo.lock

@@ -33,7 +33,6 @@ slint-build="1.9.2"
 anyhow           ="1.0.95"
 crossbeam-channel="0.5.14"
 directories      ="5.0.1"
-rustc-hash       ="2.1.0"
 tray-item        ="0.10.0"
 
 serde     ={ version="1.0.217", default-features=false, features=["derive"] }
@@ -68,3 +67,4 @@ windows={ version="0.59.0", default-features=false, features=[
   "Win32_UI_Shell",
   "Win32_UI_WindowsAndMessaging",
 ] }
+async-compat = "0.2.4"

Cargo.toml

@@ -3,7 +3,6 @@ use std::path::PathBuf;
 use std::sync::Arc;
 use tokio::sync::{broadcast, RwLock};
 
-use crate::monitor::{refresh_config, reset_config};
 use crate::transparency::create_rules_window;
 use crate::util::Config;
 use crate::win_utils::{self, create_percentage_window};
@@ -49,6 +48,15 @@ impl AppState {
             }
         });
     }
+    pub fn spawn_force_config(&self, value: WindowConfig) {
+        let app_state: Arc<AppState> = Arc::new(self.clone());
+
+        tokio::spawn(async move {
+            if let Err(e) = app_state.add_force_config(value).await {
+                eprintln!("Failed to update window config: {}", e);
+            }
+        });
+    }
 
     pub async fn get_window_rules(&self) -> Vec<TransparencyRule> {
         let config = self.get_config().await;
@@ -86,71 +94,81 @@ impl AppState {
 
     pub async fn add_window_config(
         &self,
-        mut window_config: WindowConfig,
+        window_config: WindowConfig,
     ) -> Result<(), anyhow::Error> {
         let mut config = self.get_config_mut().await;
 
-        if window_config.is_wide() && window_config.get_old_classname().is_none() {
-            let old_key: String = window_config.get_key();
-            let old_class: String = window_config.get_window_class().to_owned();
-
-            config.get_windows().remove(&old_key);
-
-            match find_parent_from_child_class(window_config.get_window_class()) {
-                Ok(class) => {
-                    if let Some(info) = class {
-                        window_config.set_window_class(info.1);
-                        refresh_config(window_config.clone());
-                        config.get_windows().remove(&window_config.get_key());
-                        window_config.set_old_classname(Some(old_class));
-                    }
-                }
-                Err(_) => (),
-            }
-        }
+        config
+            .get_windows()
+            .insert(window_config.get_key(), window_config);
+
+        let config_json = serde_json::to_string_pretty(&config.to_owned())?;
+        self.config_tx.send(config.to_owned())?;
+
+        fs::write(&self.get_config_path(), config_json)?;
 
-        if !window_config.is_wide() {
-            println!("d");
-            match find_parent_from_child_class(window_config.get_window_class()) {
-                Ok(class) => {
-                    if let Some(info) = class {
-                        let key = &format!("{}|{}", window_config.get_name(), info.1);
-                        println!("hrere {:?}", info);
-                        if config.get_windows().contains_key(key) {
-                            println!("key yo {:?}", key);
-                            let clone_config = window_config.clone();
-                            let real_class = clone_config.get_window_class();
-                            window_config.set_window_class(info.1);
-                            reset_config(window_config.clone());
-                            // let handles = window_config.get_window_hwnds();
-                            window_config.set_window_class(real_class.to_string());
-                            // println!("handles yo {:?}", handles);
-
-                            config.get_windows().remove(key);
-                        }
-                    } else {
-                        println!("2{:?}", class);
-                    }
-                }
-                Err(_) => {
-                    println!("2");
-                    ()
-                }
+        Ok(())
+    }
+
+    pub async fn add_force_config(
+        &self,
+        mut window_config: WindowConfig,
+    ) -> Result<(), anyhow::Error> {
+        let mut config = self.get_config_mut().await;
+
+        // Get the class name to use for parent lookup
+        let lookup_class = window_config
+            .get_old_classname()
+            .clone()
+            .unwrap_or_else(|| window_config.get_window_class().to_owned());
+
+        // Try to find parent class
+        if let Ok(Some(parent_info)) = find_parent_from_child_class(&lookup_class) {
+            let parent_class = parent_info.1;
+
+            // Remove existing configuration
+            self.remove_existing_config(&mut config, &window_config);
+
+            if window_config.is_forced() {
+                window_config.set_window_class(&parent_class);
+                window_config.refresh_config();
+                window_config.set_old_classname(Some(lookup_class));
+            } else {
+                window_config.set_window_class(&parent_class);
+                window_config.reset_config();
+                window_config.set_window_class(&lookup_class);
+                window_config.set_old_classname(None);
+
+                // Remove parent configuration
+                let parent_key = format!("{}|{}", window_config.get_name(), parent_class);
+                config.get_windows().remove(&parent_key);
             }
         }
 
+        // Update configuration
         config
             .get_windows()
             .insert(window_config.get_key(), window_config);
 
         let config_json = serde_json::to_string_pretty(&config.to_owned())?;
-        fs::write(&self.get_config_path(), config_json)?;
+        self.config_tx.send(config.to_owned())?;
 
-        self.config_tx.send(config.clone())?;
+        fs::write(&self.get_config_path(), config_json)?;
 
         Ok(())
     }
 
+    fn remove_existing_config(&self, config: &mut Config, window_config: &WindowConfig) {
+        // Remove configuration by original key
+        config.get_windows().remove(&window_config.get_key());
+
+        // Remove configuration by old class if it exists
+        if let Some(old_class) = window_config.get_old_classname() {
+            let key = format!("{}|{}", window_config.get_name(), old_class);
+            config.get_windows().remove(&key);
+        }
+    }
+
     pub fn subscribe_config_updates(&self) -> broadcast::Receiver<Config> {
         self.config_tx.subscribe()
     }

src/app_state.rs

@@ -1,4 +1,3 @@
-use crate::window_config::WindowConfig;
 use crate::{app_state::AppState, util::Config, win_utils::make_window_transparent};
 
 use core::time::Duration;
@@ -42,19 +41,35 @@ impl WindowHandleState {
     pub fn is_enabled(&self) -> bool {
         self.enabled
     }
+
+    pub fn refresh_window(&mut self) {
+        if make_window_transparent(self.get_handle(), 255).is_ok() {
+            self.update_state(255, false);
+        }
+    }
+
+    pub fn update_window(&mut self, mut new_transparency: u8, enabled: bool) {
+        let real_transparency = new_transparency;
+        if enabled == false {
+            new_transparency = 255;
+        }
+        if make_window_transparent(self.get_handle(), new_transparency).is_ok() {
+            self.update_state(real_transparency, enabled);
+        }
+    }
 }
 
 /*
   Monitors the current windows specified in the config file. This is setup to target based on the window class rather than title (multiple windows open of X application...)
 */
 #[inline(always)]
 pub async fn monitor_windows(app_state: Arc<AppState>) {
-    let mut window_cache = HashMap::with_capacity(8);
     let refresh_interval = Duration::from_millis(120);
+
     let mut config = app_state.get_config().await;
     let mut is_enabled = app_state.is_enabled().await;
+    let mut window_cache = HashMap::with_capacity(8);
     let mut config_rx = app_state.subscribe_config_updates();
-
     let mut enabled_rx = app_state.subscribe_enabled_updates();
 
     loop {
@@ -65,7 +80,6 @@ pub async fn monitor_windows(app_state: Arc<AppState>) {
             Ok(new_config) = config_rx.recv() => {
                 config = new_config;
             }
-
             Ok(state) = enabled_rx.recv() => {
                 if state != is_enabled && is_enabled {
                     reset_windows(&mut window_cache);
@@ -113,19 +127,14 @@ fn refresh_window_cache(config: &Config, cache: &mut HashMap<String, Vec<WindowH
 fn update_windows(config: &Config, window_cache: &mut HashMap<String, Vec<WindowHandleState>>) {
     for window_config in config.get_windows_non_mut().values() {
         if let Some(handle_states) = window_cache.get_mut(&window_config.get_cache_key()) {
-            let mut new_transparency = window_config.get_transparency();
+            let new_transparency = window_config.get_transparency();
             let new_state = window_config.is_enabled();
 
             for state in handle_states.iter_mut() {
                 if state.get_transparency() != window_config.get_transparency()
                     || state.is_enabled() != new_state
                 {
-                    if new_state == false {
-                        new_transparency = 255;
-                    }
-                    if make_window_transparent(state.get_handle(), new_transparency).is_ok() {
-                        state.update_state(window_config.get_transparency(), new_state);
-                    }
+                    state.update_window(new_transparency, new_state);
                 }
             }
         }
@@ -138,26 +147,6 @@ fn reset_windows(window_cache: &mut HashMap<String, Vec<WindowHandleState>>) {
         .values_mut()
         .flat_map(|handles| handles.iter_mut())
         .for_each(|handle| {
-            if make_window_transparent(handle.get_handle(), 255).is_ok() {
-                handle.update_state(255, false);
-            }
+            handle.refresh_window();
         });
 }
-
-pub fn reset_config(window_config: WindowConfig) {
-    let handles = window_config.get_window_hwnds();
-    for handle in handles {
-        if make_window_transparent(HWND(handle as *mut c_void), 255).is_ok() {}
-    }
-}
-pub fn refresh_config(window_config: WindowConfig) {
-    let handles = window_config.get_window_hwnds();
-    for handle in handles {
-        if make_window_transparent(
-            HWND(handle as *mut c_void),
-            window_config.get_transparency(),
-        )
-        .is_ok()
-        {}
-    }
-}

src/monitor.rs

@@ -2,7 +2,7 @@ use std::{rc::Rc, sync::Arc};
 
 use crate::{app_state::AppState, RulesStorage, RulesWindow, TransparencyRule};
 
-use slint::{ComponentHandle, VecModel};
+use slint::{ComponentHandle, Model, VecModel};
 
 /*
   Creates the rules window, this is so the user can see what rules are currently active.
@@ -12,19 +12,52 @@ pub async fn create_rules_window(app_state: Arc<AppState>) -> Result<(), core::f
     let window = RulesWindow::new().unwrap();
     let window_handle = window.as_weak();
 
+    // Create the model once
     let mut window_info = app_state.get_window_rules().await;
-
-    // Oh boo hoo its sorted every time the rules window is opened 😢
     window_info.sort_by_key(|rule| rule.process_name.clone());
+    let items_model = Rc::new(VecModel::from(window_info));
 
+    // Set initial items
     window
         .global::<RulesStorage>()
-        .set_items(Rc::new(VecModel::from(window_info)).into());
+        .set_items(items_model.clone().into());
+
+    // Handle submit events
+    let app_clone = app_state.clone();
 
     window.on_submit(move |value: TransparencyRule| {
-        app_state.spawn_update_config(value.into());
+        app_clone.spawn_update_config(value.clone().into());
+    });
+
+    let items_model_weak = window.as_weak();
+    // Handle force events
+    window.on_force(move |value: TransparencyRule| {
+        app_state.spawn_force_config(value.clone().into());
+
+        let handle = items_model_weak.clone();
+        let app_state_clone = app_state.clone();
+        tokio::spawn(async move {
+            let current_items = app_state_clone.get_window_rules().await;
+
+            handle.upgrade_in_event_loop(move |window| {
+                if let Some(items_vec) = window
+                    .global::<RulesStorage>()
+                    .get_items()
+                    .as_any()
+                    .downcast_ref::<VecModel<TransparencyRule>>()
+                {
+                    if let Some(idx) = (0..items_vec.row_count()).find(|&i| {
+                        items_vec.row_data(i).unwrap().process_name == value.process_name
+                    }) {
+                        items_vec.set_row_data(idx, current_items.get(idx).unwrap().clone());
+                    }
+                }
+            })?;
+            Ok::<(), anyhow::Error>(())
+        });
     });
 
+    // Handle cancel events
     window.on_cancel(move || {
         if let Some(window) = window_handle.upgrade() {
             window.hide().unwrap();