Merge pull request #51 from Xetibo/dashie

Add stop listener and replace existing entries

Cargo.toml

@@ -6,7 +6,7 @@ description = "A wip universal Linux settings application."
 
 [dependencies]
 reset_daemon = "0.1.0"
-ReSet-Lib = "0.2.3"
+ReSet-Lib = "0.2.6"
 adw = { version = "0.5.3", package = "libadwaita", features = ["v1_4"] }
 dbus = "0.9.7"
 gtk = { version = "0.7.3", package = "gtk4", features = ["v4_12"] }

src/components/base/listEntryImpl.rs

@@ -1,6 +1,6 @@
-use gtk::{CompositeTemplate, glib};
-use gtk::subclass::prelude::*;
 use crate::components::base::listEntry;
+use gtk::subclass::prelude::*;
+use gtk::{glib, CompositeTemplate};
 
 #[allow(non_snake_case)]
 #[derive(Default, CompositeTemplate)]

src/components/base/mod.rs

@@ -4,3 +4,4 @@ pub mod listEntry;
 pub mod listEntryImpl;
 pub mod popup;
 pub mod popupImpl;
+pub mod utils;

src/components/base/popupImpl.rs

@@ -1,17 +1,8 @@
 use std::cell::RefCell;
 use std::sync::Arc;
 
-use adw::subclass::prelude::{ActionRowImpl, PreferencesRowImpl};
-use adw::subclass::window::AdwWindowImpl;
-use gtk::gdk_pixbuf::subclass::prelude::{
-    PixbufAnimationImpl, PixbufAnimationIterImpl, PixbufLoaderImpl,
-};
-use gtk::prelude::PopupExt;
 use gtk::subclass::prelude::*;
-use gtk::{
+use gtk::{glib, Button, CompositeTemplate, Label, PasswordEntry, PasswordEntryBuffer, Popover};
-    gdk, glib, Button, CompositeTemplate, Entry, EntryBuffer, Label, PasswordEntry,
-    PasswordEntryBuffer, Popover,
-};
 
 use super::popup;
 

src/components/base/settingBoxImpl.rs

@@ -1,6 +1,6 @@
-use gtk::{CompositeTemplate, glib, Label};
-use gtk::subclass::prelude::*;
 use crate::components::base::settingBox;
+use gtk::subclass::prelude::*;
+use gtk::{glib, CompositeTemplate};
 
 #[allow(non_snake_case)]
 #[derive(Default, CompositeTemplate)]

src/components/base/utils.rs

@@ -0,0 +1,33 @@
+use std::{
+    sync::atomic::{AtomicBool, Ordering},
+    thread,
+    time::Duration,
+};
+
+use dbus::{blocking::Connection, Error};
+
+#[derive(Default)]
+pub struct Listeners {
+    pub network_listener: AtomicBool,
+    pub bluetooth_listener: AtomicBool,
+    pub pulse_listener: AtomicBool,
+}
+
+impl Listeners {
+    pub fn stop_network_listener(&self) {
+        if !self.network_listener.load(Ordering::SeqCst) {
+            return;
+        }
+        self.network_listener.store(false, Ordering::SeqCst);
+        thread::spawn(|| {
+            let conn = Connection::new_session().unwrap();
+            let proxy = conn.with_proxy(
+                "org.xetibo.ReSet",
+                "/org/xetibo/ReSet",
+                Duration::from_millis(1000),
+            );
+            let _: Result<(bool,), Error> =
+                proxy.method_call("org.xetibo.ReSet", "StopNetworkListener", ());
+        });
+    }
+}

src/components/output/audioBox.rs

@@ -3,7 +3,6 @@ use adw::glib::Object;
 use glib::subclass::prelude::ObjectSubclassIsExt;
 use glib::Variant;
 use gtk::prelude::ActionableExt;
-use crate::components::base::listEntry::ListEntry;
 use crate::components::output::audioBoxImpl;
 
 glib::wrapper! {

src/components/output/audioBoxImpl.rs

@@ -1,4 +1,4 @@
-use gtk::{CompositeTemplate, DropDown, TemplateChild, glib, Button};
+use gtk::{CompositeTemplate, DropDown, TemplateChild, glib};
 use gtk::prelude::*;
 use gtk::subclass::prelude::*;
 use crate::components::output::audioBox;

src/components/output/audioSourceImpl.rs

@@ -1,4 +1,4 @@
-use gtk::{Button, CompositeTemplate, glib, Image, Label, ProgressBar, Scale};
+use gtk::{Button, CompositeTemplate, glib, Label, ProgressBar, Scale};
 use gtk::subclass::prelude::*;
 use crate::components::output::audioSource;
 

src/components/wifi/savedWifiEntry.rs

@@ -1,4 +1,3 @@
-use std::sync::Arc;
 use std::time::Duration;
 
 use crate::components::wifi::savedWifiEntryImpl;

src/components/wifi/wifiBox.rs

@@ -1,22 +1,26 @@
 use std::collections::HashMap;
+use std::sync::atomic::Ordering;
 use std::sync::mpsc::{channel, Receiver, Sender};
-use std::sync::{atomic::AtomicBool, Arc};
+use std::sync::Arc;
+use std::thread;
 use std::time::Duration;
 
 use crate::components::base::listEntry::ListEntry;
+use crate::components::base::utils::Listeners;
 use adw::glib;
 use adw::glib::Object;
-use adw::prelude::{BoxExt, ListBoxRowExt};
+use adw::prelude::ListBoxRowExt;
 use adw::subclass::prelude::ObjectSubclassIsExt;
-use dbus::arg::RefArg;
+use dbus::arg::{AppendAll, ReadAll, RefArg};
 use dbus::blocking::Connection;
 use dbus::Error;
 use dbus::Path;
+use gtk::gio;
 use gtk::glib::Variant;
 use gtk::prelude::ActionableExt;
 use ReSet_Lib::network::network::AccessPoint;
-use ReSet_Lib::signals::AccessPointAdded;
 use ReSet_Lib::signals::AccessPointRemoved;
+use ReSet_Lib::signals::{AccessPointAdded, GetVal};
 use ReSet_Lib::utils::Events;
 
 use crate::components::wifi::wifiBoxImpl;
@@ -42,106 +46,142 @@ impl WifiBox {
 
     pub fn setupCallbacks(&self) {
         let selfImp = self.imp();
-        selfImp.resetSavedNetworks.set_action_name(Some("navigation.push"));
+        selfImp
-        selfImp.resetSavedNetworks.set_action_target_value(Some(&Variant::from("saved")));
+            .resetSavedNetworks
+            .set_action_name(Some("navigation.push"));
+        selfImp
+            .resetSavedNetworks
+            .set_action_target_value(Some(&Variant::from("saved")));
 
-        selfImp.resetAvailableNetworks.set_action_name(Some("navigation.pop"));
+        selfImp
+            .resetAvailableNetworks
+            .set_action_name(Some("navigation.pop"));
     }
-
-    // pub fn donotdisturb() {
-    //     thread::spawn(|| {
-    //         let conn = Connection::new_session().unwrap();
-    //         let proxy = conn.with_proxy(
-    //             "org.freedesktop.Notifications",
-    //             "/org/freedesktop/Notifications",
-    //             Duration::from_millis(1000),
-    //         );
-    //         let _: Result<(), Error> =
-    //             proxy.method_call("org.freedesktop.Notifications", "DoNotDisturb", ());
-    //     });
-    // }
 }
 
-pub fn scanForWifi(wifiBox: Arc<WifiBox>) {
+pub fn scanForWifi(listeners: Arc<Listeners>, wifiBox: Arc<WifiBox>) {
     let wifibox_ref = wifiBox.clone();
+    let wifibox_ref_listener = wifiBox.clone();
     let wifiEntries = wifiBox.imp().wifiEntries.clone();
 
-    glib::spawn_future_local(async move {
+    gio::spawn_blocking(move || {
-        let accessPoints = get_access_points().await;
+        let accessPoints = get_access_points();
+        let wifiEntriesListener = wifiEntries.clone();
         let wifiEntries = wifiEntries.clone();
-        {
+        glib::spawn_future(async move {
-            let mut wifiEntries = wifiEntries.lock().unwrap();
-            for accessPoint in accessPoints {
-                wifiEntries.push(ListEntry::new(&*WifiEntry::new(accessPoint)));
-            }
-        }
-        glib::MainContext::default().spawn_local(async move {
             glib::idle_add_once(move || {
-                let wifiEntries = wifiEntries.lock().unwrap();
+                let mut wifiEntries = wifiEntries.lock().unwrap();
                 let selfImp = wifibox_ref.imp();
-                for wifiEntry in wifiEntries.iter() {
+                for accessPoint in accessPoints {
-                    selfImp.resetWifiList.append(wifiEntry);
+                    let ssid = accessPoint.ssid.clone();
+                    let entry = Arc::new(ListEntry::new(&*WifiEntry::new(accessPoint)));
+                    wifiEntries.insert(ssid, entry.clone());
+                    selfImp.resetWifiList.append(&*entry);
                 }
             });
         });
+        if listeners.network_listener.load(Ordering::SeqCst) {
+            return;
+        }
+        listeners.network_listener.store(true, Ordering::SeqCst);
+        dbus_start_network_events();
         let (sender, receiver): (
-            Sender<Events<(AccessPoint,), (Path<'static>,)>>,
+            Sender<Events<(AccessPoint,), (AccessPoint,)>>,
-            Receiver<Events<(AccessPoint,), (Path<'static>,)>>,
+            Receiver<Events<(AccessPoint,), (AccessPoint,)>>,
         ) = channel();
         let sender_ref = Arc::new(sender);
-        let listener_active = Arc::new(AtomicBool::new(false));
+        let res = start_event_listener::<
-        ReSet_Lib::utils::start_event_listener::<
+            (AccessPoint,),
             (AccessPoint,),
-            (Path<'static>,),
             AccessPointAdded,
             AccessPointRemoved,
-        >(listener_active, sender_ref);
+        >(listeners.clone(), sender_ref);
-        // handle receiver...
+        if res.is_err() {
-        let res = receiver.try_recv();
+            println!("Could not connect listener");
+        }
+        loop {
+            let wifiEntriesListener = wifiEntriesListener.clone();
+            if listeners
+                .network_listener
+                .load(std::sync::atomic::Ordering::SeqCst)
+                == false
+            {
+                break;
+            }
+            println!("receiving!");
+            let res = receiver.recv();
             if res.is_ok() {
                 let access_point = res.unwrap();
                 match access_point {
                     Events::AddedEvent(access_point) => {
-                    dbg!(access_point);
+                        let wifiEntriesListener = wifiEntriesListener.clone();
+                        let wifiBoxImpl = wifibox_ref_listener.clone();
+                        glib::spawn_future(async move {
+                            glib::idle_add_once(move || {
+                                let mut wifiEntries = wifiEntriesListener.lock().unwrap();
+                                let ssid = access_point.0.ssid.clone();
+                                if wifiEntries.get(&ssid).is_some() {
+                                    return;
+                                }
+                                let entry =
+                                    Arc::new(ListEntry::new(&*WifiEntry::new(access_point.0)));
+                                wifiEntries.insert(ssid, entry.clone());
+                                wifiBoxImpl.imp().resetWifiList.append(&*entry);
+                            });
+                        });
+                    }
+                    Events::RemovedEvent(access_point) => {
+                        let wifiBoxImpl = wifibox_ref_listener.clone();
+                        glib::spawn_future(async move {
+                            glib::idle_add_once(move || {
+                                let mut wifiEntries = wifiEntriesListener.lock().unwrap();
+                                let entry = wifiEntries.remove(&access_point.0.ssid);
+                                if entry.is_none() {
+                                    return;
+                                }
+                                wifiBoxImpl.imp().resetWifiList.remove(&*entry.unwrap());
+                            });
+                        });
                     }
-                _ => (),
                 };
             } else {
                 println!("no message there :)");
             }
+        }
     });
 }
 
 pub fn show_stored_connections(wifiBox: Arc<WifiBox>) {
     let wifibox_ref = wifiBox.clone();
-    let wifiEntries = wifiBox.imp().savedWifiEntries.clone();
+    gio::spawn_blocking(move || {
-
+        let connections = get_stored_connections();
-    glib::spawn_future_local(async move {
+        glib::spawn_future(async move {
-        let connections = get_stored_connections().await;
+            glib::idle_add_once(move || {
-        let wifiEntries = wifiEntries.clone();
+                let selfImp = wifibox_ref.imp();
-        {
-            let mut wifiEntries = wifiEntries.lock().unwrap();
                 for connection in connections {
                     // TODO include button for settings
-                let name = &String::from_utf8(connection.1).unwrap_or_else(|_| String::from(""));
+                    let name =
+                        &String::from_utf8(connection.1).unwrap_or_else(|_| String::from(""));
                     let entry = ListEntry::new(&SavedWifiEntry::new(name, connection.0));
                     entry.set_activatable(false);
-                wifiEntries.push(entry);
+                    selfImp.resetStoredWifiList.append(&entry);
-            }
-        }
-        glib::MainContext::default().spawn_local(async move {
-            glib::idle_add_once(move || {
-                let wifiEntries = wifiEntries.lock().unwrap();
-                let selfImp = wifibox_ref.imp();
-                for wifiEntry in wifiEntries.iter() {
-                    selfImp.resetStoredWifiList.append(wifiEntry);
                 }
             });
         });
     });
 }
 
-pub async fn get_access_points() -> Vec<AccessPoint> {
+pub fn dbus_start_network_events() {
+    let conn = Connection::new_session().unwrap();
+    let proxy = conn.with_proxy(
+        "org.xetibo.ReSet",
+        "/org/xetibo/ReSet",
+        Duration::from_millis(1000),
+    );
+    let _: Result<(), Error> = proxy.method_call("org.xetibo.ReSet", "StartNetworkListener", ());
+}
+
+pub fn get_access_points() -> Vec<AccessPoint> {
     let conn = Connection::new_session().unwrap();
     let proxy = conn.with_proxy(
         "org.xetibo.ReSet",
@@ -157,7 +197,7 @@ pub async fn get_access_points() -> Vec<AccessPoint> {
     accessPoints
 }
 
-pub async fn get_stored_connections() -> Vec<(Path<'static>, Vec<u8>)> {
+pub fn get_stored_connections() -> Vec<(Path<'static>, Vec<u8>)> {
     let conn = Connection::new_session().unwrap();
     let proxy = conn.with_proxy(
         "org.xetibo.ReSet",
@@ -182,8 +222,10 @@ pub fn getConnectionSettings(path: Path<'static>) -> Option<ResetConnection> {
         "/org/xetibo/ReSet",
         Duration::from_millis(1000),
     );
-    let res: Result<(HashMap<String, HashMap<String, dbus::arg::Variant<Box<dyn RefArg>>>,>,), Error> =
+    let res: Result<
-        proxy.method_call("org.xetibo.ReSet", "GetConnectionSettings", (path,));
+        (HashMap<String, HashMap<String, dbus::arg::Variant<Box<dyn RefArg>>>>,),
+        Error,
+    > = proxy.method_call("org.xetibo.ReSet", "GetConnectionSettings", (path,));
     if res.is_err() {
         println!("lol not work");
         return None;
@@ -196,3 +238,76 @@ pub fn getConnectionSettings(path: Path<'static>) -> Option<ResetConnection> {
     }
     Some(res.unwrap())
 }
+
+// temporary, testing this with lib is pain
+//
+
+pub fn start_event_listener<
+    AddedType: ReadAll + AppendAll + Send + Sync + 'static,
+    RemovedType: ReadAll + AppendAll + Send + Sync + 'static,
+    AddedEvent: ReadAll + AppendAll + dbus::message::SignalArgs + GetVal<AddedType>,
+    RemovedEvent: ReadAll + AppendAll + dbus::message::SignalArgs + GetVal<RemovedType>,
+>(
+    listeners: Arc<Listeners>,
+    sender: Arc<Sender<Events<AddedType, RemovedType>>>,
+) -> Result<(), dbus::Error> {
+    thread::spawn(move || {
+        let added_sender = sender.clone();
+        let removed_sender = sender.clone();
+        let conn = Connection::new_session().unwrap();
+        let mr = AddedEvent::match_rule(
+            Some(&"org.xetibo.ReSet".into()),
+            Some(&Path::from("/org/xetibo/ReSet")),
+        )
+        .static_clone();
+        let mrb = RemovedEvent::match_rule(
+            Some(&"org.xetibo.ReSet".into()),
+            Some(&Path::from("/org/xetibo/ReSet")),
+        )
+        .static_clone();
+        let res = conn.add_match(mr, move |ir: AddedEvent, _, _| {
+            println!("received added event");
+            let res = added_sender.send(Events::AddedEvent(ir.get_value()));
+            if res.is_err() {
+                println!("fail on sending added");
+                return false;
+            }
+            true
+        });
+        if res.is_err() {
+            println!("fail on add");
+            return Err(dbus::Error::new_custom(
+                "SignalMatchFailed",
+                "Failed to match signal on ReSet.",
+            ));
+        }
+        let res = conn.add_match(mrb, move |ir: RemovedEvent, _, _| {
+            println!("received removed event");
+            let res = removed_sender.send(Events::RemovedEvent(ir.get_value()));
+            if res.is_err() {
+                println!("fail on sending removed");
+                return false;
+            }
+            true
+        });
+        if res.is_err() {
+            println!("fail on remove");
+            return Err(dbus::Error::new_custom(
+                "SignalMatchFailed",
+                "Failed to match signal on ReSet.",
+            ));
+        }
+        listeners.network_listener.store(true, Ordering::SeqCst);
+        println!("starting thread listener");
+        loop {
+            let _ = conn.process(Duration::from_millis(1000))?;
+            if !listeners.network_listener.load(Ordering::SeqCst) {
+                println!("stopping thread listener");
+                break;
+            }
+            thread::sleep(Duration::from_millis(1000));
+        }
+        Ok(())
+    });
+    Ok(())
+}

src/components/wifi/wifiBoxImpl.rs

@@ -1,3 +1,4 @@
+use std::collections::HashMap;
 use std::sync::{Arc, Mutex};
 use gtk::{CompositeTemplate, glib, ListBox, Switch};
 use gtk::prelude::*;
@@ -23,7 +24,7 @@ pub struct WifiBox {
     pub resetStoredWifiList: TemplateChild<ListBox>,
     #[template_child]
     pub resetAvailableNetworks: TemplateChild<ListEntry>,
-    pub wifiEntries: Arc<Mutex<Vec<ListEntry>>>,
+    pub wifiEntries: Arc<Mutex<HashMap<Vec<u8>,Arc<ListEntry>>>>,
     pub savedWifiEntries: Arc<Mutex<Vec<ListEntry>>>,
 }
 

src/components/wifi/wifiEntry.rs

@@ -4,7 +4,7 @@ use std::time::Duration;
 
 use adw::glib;
 use adw::glib::{Object, PropertySet};
-use adw::prelude::{ButtonExt, EditableExt, EntryExt, PopoverExt};
+use adw::prelude::{ButtonExt, EditableExt, PopoverExt};
 use adw::subclass::prelude::ObjectSubclassIsExt;
 use dbus::blocking::Connection;
 use dbus::Error;
@@ -62,14 +62,11 @@ impl WifiEntry {
         entryImp.accessPoint.set(access_point);
         let gesture = GestureClick::new();
         if stored {
-            entryImp
-                .resetWifiStored
-                .get()
-                .set_from_icon_name(Some("document-save-symbolic"));
             gesture.connect_released(move |_, _, _, _| {
                 click_stored_network(stored_entry.clone());
             });
         } else {
+            entryImp.resetWifiEditButton.set_sensitive(false);
             gesture.connect_released(move |_, _, _, _| {
                 click_new_network(new_entry.clone());
             });
@@ -93,11 +90,9 @@ pub fn click_stored_network(entry: Arc<WifiEntry>) {
     let root = &entry.root().unwrap();
     let root = root.downcast_ref::<gtk::Window>();
     if root.is_none() {
-        println!("ERROR BRO");
         return;
     }
     let root = root.unwrap();
-    // TODO handle unknown access point -> should be done by having 2 different categories
     let entryImp = entry.imp();
     let conn = Connection::new_session().unwrap();
     let proxy = conn.with_proxy(

src/components/wifi/wifiEntryImpl.rs

@@ -20,8 +20,6 @@ pub struct WifiEntry {
     #[template_child]
     pub resetWifiConnected: TemplateChild<Image>,
     #[template_child]
-    pub resetWifiStored: TemplateChild<Image>,
-    #[template_child]
     pub resetWifiPopup: TemplateChild<Popup>,
     pub wifiName: RefCell<String>,
     pub wifiStrength: RefCell<WifiStrength>,

src/components/window/handleSidebarClick.rs

@@ -1,104 +1,150 @@
 use gtk::prelude::FrameExt;
 use std::sync::Arc;
+use std::sync::atomic::Ordering;
 
-use crate::components::output::audioBox::AudioBox;
 use crate::components::base::settingBox::SettingBox;
+use crate::components::base::utils::Listeners;
 use crate::components::bluetooth::bluetoothBox::BluetoothBox;
-use crate::components::wifi::wifiBox::{scanForWifi, show_stored_connections, WifiBox};
-use gtk::{FlowBox, Frame, Label,};
-use gtk::prelude::WidgetExt;
-use crate::components::input::sourceBox;
 use crate::components::input::sourceBox::SourceBox;
+use crate::components::output::audioBox::AudioBox;
+use crate::components::wifi::wifiBox::{scanForWifi, show_stored_connections, WifiBox};
+use gtk::prelude::WidgetExt;
+use gtk::{FlowBox, Frame, Label};
 
-pub const HANDLE_CONNECTIVITY_CLICK: fn(FlowBox) = |resetMain: FlowBox| {
+pub const HANDLE_CONNECTIVITY_CLICK: fn(Arc<Listeners>, FlowBox) =
+    |listeners: Arc<Listeners>, resetMain: FlowBox| {
+        listeners.pulse_listener.store(false, Ordering::SeqCst);
         let wifiBox = Arc::new(WifiBox::new());
         show_stored_connections(wifiBox.clone());
-    scanForWifi(wifiBox.clone());
+        scanForWifi(listeners.clone(),wifiBox.clone());
         let wifiFrame = wrapInFrame(SettingBox::new(&*wifiBox));
         let bluetoothFrame = wrapInFrame(SettingBox::new(&BluetoothBox::new()));
         resetMain.remove_all();
         resetMain.insert(&wifiFrame, -1);
         resetMain.insert(&bluetoothFrame, -1);
         resetMain.set_max_children_per_line(2);
-};
+    };
 
-pub const HANDLE_WIFI_CLICK: fn(FlowBox) =  |resetMain: FlowBox|   {
+pub const HANDLE_WIFI_CLICK: fn(Arc<Listeners>, FlowBox) =
+    |listeners: Arc<Listeners>, resetMain: FlowBox| {
+        listeners.bluetooth_listener.store(false, Ordering::SeqCst);
+        listeners.pulse_listener.store(false, Ordering::SeqCst);
         let wifiBox = Arc::new(WifiBox::new());
-    scanForWifi(wifiBox.clone());
+        scanForWifi(listeners.clone(),wifiBox.clone());
         let wifiFrame = wrapInFrame(SettingBox::new(&*wifiBox));
         resetMain.remove_all();
         resetMain.insert(&wifiFrame, -1);
         resetMain.set_max_children_per_line(1);
-};
+    };
 
-pub const HANDLE_BLUETOOTH_CLICK: fn(FlowBox) =  |resetMain: FlowBox|   {
+pub const HANDLE_BLUETOOTH_CLICK: fn(Arc<Listeners>, FlowBox) =
+    |listeners: Arc<Listeners>, resetMain: FlowBox| {
+        listeners.stop_network_listener();
+        listeners.pulse_listener.store(false, Ordering::SeqCst);
         let bluetoothFrame = wrapInFrame(SettingBox::new(&BluetoothBox::new()));
         resetMain.remove_all();
         resetMain.insert(&bluetoothFrame, -1);
         resetMain.set_max_children_per_line(1);
-};
+    };
 
-pub const HANDLE_VPN_CLICK: fn(FlowBox) = |resetMain: FlowBox| {
+pub const HANDLE_VPN_CLICK: fn(Arc<Listeners>, FlowBox) =
+    |listeners: Arc<Listeners>, resetMain: FlowBox| {
+        listeners.stop_network_listener();
+        listeners.bluetooth_listener.store(false, Ordering::SeqCst);
+        listeners.pulse_listener.store(false, Ordering::SeqCst);
         let label = Label::new(Some("not implemented yet"));
         resetMain.remove_all();
         resetMain.insert(&label, -1);
         resetMain.set_max_children_per_line(1);
-};
+    };
 
-pub const HANDLE_AUDIO_CLICK: fn(FlowBox) =  |resetMain: FlowBox|   {
+pub const HANDLE_AUDIO_CLICK: fn(Arc<Listeners>, FlowBox) =
+    |listeners: Arc<Listeners>, resetMain: FlowBox| {
+        listeners.stop_network_listener();
+        listeners.bluetooth_listener.store(false, Ordering::SeqCst);
+        listeners.pulse_listener.store(true, Ordering::SeqCst);
         let audioFrame = wrapInFrame(SettingBox::new(&AudioBox::new()));
         let sourceFrame = wrapInFrame(SettingBox::new(&SourceBox::new()));
         resetMain.remove_all();
         resetMain.insert(&audioFrame, -1);
         resetMain.insert(&sourceFrame, -1);
         resetMain.set_max_children_per_line(2);
-};
+    };
 
-pub const HANDLE_VOLUME_CLICK: fn(FlowBox) =  |resetMain: FlowBox|   {
+pub const HANDLE_VOLUME_CLICK: fn(Arc<Listeners>, FlowBox) =
+    |listeners: Arc<Listeners>, resetMain: FlowBox| {
+        listeners.stop_network_listener();
+        listeners.bluetooth_listener.store(false, Ordering::SeqCst);
+        listeners.pulse_listener.store(false, Ordering::SeqCst);
         let audioFrame = wrapInFrame(SettingBox::new(&AudioBox::new()));
         resetMain.remove_all();
         resetMain.insert(&audioFrame, -1);
         resetMain.set_max_children_per_line(1);
-};
+    };
 
-pub const HANDLE_MICROPHONE_CLICK: fn(FlowBox) = |resetMain: FlowBox| {
+pub const HANDLE_MICROPHONE_CLICK: fn(Arc<Listeners>, FlowBox) =
+    |listeners: Arc<Listeners>, resetMain: FlowBox| {
+        listeners.stop_network_listener();
+        listeners.bluetooth_listener.store(false, Ordering::SeqCst);
+        listeners.pulse_listener.store(false, Ordering::SeqCst);
         let sourceFrame = wrapInFrame(SettingBox::new(&SourceBox::new()));
         resetMain.remove_all();
         resetMain.insert(&sourceFrame, -1);
         resetMain.set_max_children_per_line(1);
-};
+    };
 
-pub const HANDLE_PERIPHERALS_CLICK: fn(FlowBox) = |resetMain: FlowBox| {
+pub const HANDLE_PERIPHERALS_CLICK: fn(Arc<Listeners>, FlowBox) =
+    |listeners: Arc<Listeners>, resetMain: FlowBox| {
+        listeners.stop_network_listener();
+        listeners.bluetooth_listener.store(false, Ordering::SeqCst);
+        listeners.pulse_listener.store(false, Ordering::SeqCst);
         let label = Label::new(Some("not implemented yet"));
         resetMain.remove_all();
         resetMain.insert(&label, -1);
         resetMain.set_max_children_per_line(1);
-};
+    };
 
-pub const HANDLE_MONITOR_CLICK: fn(FlowBox) = |resetMain: FlowBox| {
+pub const HANDLE_MONITOR_CLICK: fn(Arc<Listeners>, FlowBox) =
+    |listeners: Arc<Listeners>, resetMain: FlowBox| {
+        listeners.stop_network_listener();
+        listeners.bluetooth_listener.store(false, Ordering::SeqCst);
+        listeners.pulse_listener.store(false, Ordering::SeqCst);
         let label = Label::new(Some("not implemented yet"));
         resetMain.remove_all();
         resetMain.insert(&label, -1);
         resetMain.set_max_children_per_line(1);
-};
+    };
 
-pub const HANDLE_MOUSE_CLICK: fn(FlowBox) = |resetMain: FlowBox| {
+pub const HANDLE_MOUSE_CLICK: fn(Arc<Listeners>, FlowBox) =
+    |listeners: Arc<Listeners>, resetMain: FlowBox| {
+        listeners.stop_network_listener();
+        listeners.bluetooth_listener.store(false, Ordering::SeqCst);
+        listeners.pulse_listener.store(false, Ordering::SeqCst);
         let label = Label::new(Some("not implemented yet"));
         resetMain.remove_all();
         resetMain.insert(&label, -1);
         resetMain.set_max_children_per_line(1);
-};
+    };
 
-pub const HANDLE_KEYBOARD_CLICK: fn(FlowBox) = |resetMain: FlowBox| {
+pub const HANDLE_KEYBOARD_CLICK: fn(Arc<Listeners>, FlowBox) =
+    |listeners: Arc<Listeners>, resetMain: FlowBox| {
+        listeners.stop_network_listener();
+        listeners.bluetooth_listener.store(false, Ordering::SeqCst);
+        listeners.pulse_listener.store(false, Ordering::SeqCst);
         let label = Label::new(Some("not implemented yet"));
         resetMain.remove_all();
         resetMain.insert(&label, -1);
         resetMain.set_max_children_per_line(1);
-};
+    };
 
-pub const HANDLE_HOME: fn(FlowBox) =  |resetMain: FlowBox|   {
+pub const HANDLE_HOME: fn(Arc<Listeners>, FlowBox) =
+    |listeners: Arc<Listeners>, resetMain: FlowBox| {
+        listeners.stop_network_listener();
+        listeners.network_listener.store(false, Ordering::SeqCst);
+        listeners.bluetooth_listener.store(false, Ordering::SeqCst);
+        listeners.pulse_listener.store(false, Ordering::SeqCst);
         resetMain.remove_all();
-};
+    };
 
 fn wrapInFrame(widget: SettingBox) -> Frame {
     let frame = Frame::new(None);

src/components/window/sidebarEntry.rs

@@ -1,7 +1,10 @@
+use std::sync::Arc;
+
 use adw::subclass::prelude::ObjectSubclassIsExt;
 use glib::Object;
 use gtk::{FlowBox, glib};
 use gtk::prelude::*;
+use crate::components::base::utils::Listeners;
 use crate::components::window::sidebarEntryImpl;
 use crate::components::window::sidebarEntryImpl::{Categories, SidebarAction};
 
@@ -17,7 +20,7 @@ impl SidebarEntry {
         iconName: &str,
         category: Categories,
         isSubcategory: bool,
-        clickEvent: fn(FlowBox),
+        clickEvent: fn(Arc<Listeners>, FlowBox),
     ) -> Self {
         let entry: SidebarEntry = Object::builder().build();
         let entryImp = entry.imp();

src/components/window/sidebarEntryImpl.rs

@@ -1,9 +1,11 @@
 use std::cell::{Cell, RefCell};
+use std::sync::Arc;
 
 use glib::subclass::InitializingObject;
 use gtk::{CompositeTemplate, FlowBox, glib, Image, Label, ListBoxRow};
 use gtk::subclass::prelude::*;
 
+use crate::components::base::utils::Listeners;
 use crate::components::window::handleSidebarClick::HANDLE_HOME;
 use crate::components::window::sidebarEntry;
 
@@ -32,7 +34,7 @@ pub struct SidebarEntry {
 
 #[allow(non_snake_case)]
 pub struct SidebarAction {
-    pub onClickEvent: fn(FlowBox),
+    pub onClickEvent: fn(Arc<Listeners>,FlowBox),
 }
 
 impl Default for SidebarAction {

src/components/window/window.rs

@@ -45,7 +45,7 @@ impl Window {
             clone!(@ weak selfImp as flowbox => move |_, y| {
                 let result = y.downcast_ref::<SidebarEntry>().unwrap();
                 let clickEvent = result.imp().onClickEvent.borrow().onClickEvent;
-                (clickEvent)(flowbox.resetMain.get());
+                (clickEvent)(flowbox.listeners.clone(), flowbox.resetMain.get());
             }),
         );
 

src/components/window/windowImpl.rs

@@ -1,4 +1,5 @@
 use std::cell::RefCell;
+use std::sync::Arc;
 
 use adw::glib::StaticTypeExt;
 use adw::subclass::prelude::AdwApplicationWindowImpl;
@@ -7,6 +8,7 @@ use glib::subclass::InitializingObject;
 use gtk::subclass::prelude::*;
 use gtk::{glib, Box, Button, CompositeTemplate, FlowBox, ListBox, PopoverMenu, SearchEntry};
 
+use crate::components::base::utils::Listeners;
 use crate::components::wifi::wifiBox::WifiBox;
 use crate::components::window::sidebarEntry::SidebarEntry;
 use crate::components::window::window;
@@ -40,6 +42,7 @@ pub struct Window {
     #[template_child]
     pub resetShortcutsButton: TemplateChild<Button>,
     pub sidebarEntries: RefCell<Vec<(SidebarEntry, Vec<SidebarEntry>)>>,
+    pub listeners: Arc<Listeners>,
 }
 
 unsafe impl Send for Window {}

src/resources/resetUI.cmb

@@ -86,7 +86,6 @@
 	(5,6,"GtkLabel","resetWifiLabel",2,None,None,None,1,None),
 	(5,7,"GtkButton","resetWifiEditButton",2,None,None,None,4,None),
 	(5,8,"GtkImage","resetWifiConnected",2,None,None,None,3,None),
-	(5,10,"GtkImage","resetWifiStored",2,None,None,None,2,None),
 	(5,11,"resetPopup","resetWifiPopup",2,None,None,None,-1,None),
 	(6,1,"GtkListBoxRow","resetSidebarEntry",None,None,None,None,None,None),
 	(6,2,"GtkBox",None,1,None,None,None,-1,None),
@@ -398,13 +397,11 @@
 	(5,6,"GtkWidget","margin-end","10",None,None,None,None,None,None,None,None,None),
 	(5,6,"GtkWidget","width-request","200",None,None,None,None,None,None,None,None,None),
 	(5,7,"GtkButton","has-frame","False",None,None,None,None,None,None,None,None,None),
-	(5,7,"GtkButton","icon-name","info-symbolic",None,None,None,None,None,None,None,None,None),
+	(5,7,"GtkButton","icon-name","document-edit-symbolic",None,None,None,None,None,None,None,None,None),
 	(5,7,"GtkWidget","halign","start",None,None,None,None,None,None,None,None,None),
 	(5,7,"GtkWidget","valign","center",None,None,None,None,None,None,None,None,None),
 	(5,8,"GtkWidget","halign","end",None,None,None,None,None,None,None,None,None),
 	(5,8,"GtkWidget","valign","center",None,None,None,None,None,None,None,None,None),
-	(5,10,"GtkWidget","halign","end",None,None,None,None,None,None,None,None,None),
-	(5,10,"GtkWidget","valign","center",None,None,None,None,None,None,None,None,None),
 	(6,1,"GtkListBoxRow","child",None,None,None,None,None,2,None,None,None,None),
 	(6,1,"GtkWidget","css-classes","resetSidebarEntry",None,None,None,None,None,None,None,None,None),
 	(6,2,"GtkWidget","margin-bottom","10",None,None,None,None,None,None,None,None,None),

src/resources/resetWifiEntry.ui

@@ -37,12 +37,6 @@
         <property name="xalign">0.0</property>
       </object>
     </child>
-    <child>
-      <object class="GtkImage" id="resetWifiStored">
-        <property name="halign">end</property>
-        <property name="valign">center</property>
-      </object>
-    </child>
     <child>
       <object class="GtkImage" id="resetWifiConnected">
         <property name="halign">end</property>
@@ -53,7 +47,7 @@
       <object class="GtkButton" id="resetWifiEditButton">
         <property name="halign">start</property>
         <property name="has-frame">False</property>
-        <property name="icon-name">info-symbolic</property>
+        <property name="icon-name">document-edit-symbolic</property>
         <property name="valign">center</property>
       </object>
     </child>