feat: Add stop listener

Cargo.toml

@@ -6,7 +6,7 @@ description = "A wip universal Linux settings application."
 
 [dependencies]
 reset_daemon = "0.1.0"
-ReSet-Lib = "0.2.5"
+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/mod.rs

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

src/components/base/utils.rs

@@ -0,0 +1,36 @@
+use std::{
+    sync::{
+        atomic::{AtomicBool, Ordering},
+        Arc,
+    },
+    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/wifi/wifiBox.rs

@@ -6,6 +6,7 @@ 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};
@@ -58,7 +59,7 @@ impl WifiBox {
     }
 }
 
-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();
@@ -72,39 +73,36 @@ pub fn scanForWifi(wifiBox: Arc<WifiBox>) {
                 let mut wifiEntries = wifiEntries.lock().unwrap();
                 let selfImp = wifibox_ref.imp();
                 for accessPoint in accessPoints {
-                    let path = accessPoint.dbus_path.clone();
+                    let ssid = accessPoint.ssid.clone();
                     let entry = Arc::new(ListEntry::new(&*WifiEntry::new(accessPoint)));
-                    wifiEntries.insert(path, entry.clone());
+                    wifiEntries.insert(ssid, entry.clone());
                     selfImp.resetWifiList.append(&*entry);
                 }
             });
         });
-        let wifiBoxImpl = wifibox_ref_listener.imp();
+        if listeners.network_listener.load(Ordering::SeqCst) {
-        wifiBoxImpl
+            return;
-            .listener_active
+        }
-            .store(true, std::sync::atomic::Ordering::SeqCst);
+        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 res = start_event_listener::<
             (AccessPoint,),
-            (Path<'static>,),
+            (AccessPoint,),
             AccessPointAdded,
             AccessPointRemoved,
-        >(
+        >(listeners.clone(), sender_ref);
-            wifibox_ref_listener.imp().listener_active.clone(),
-            sender_ref,
-        );
         if res.is_err() {
             println!("Could not connect listener");
         }
         loop {
             let wifiEntriesListener = wifiEntriesListener.clone();
-            if wifiBoxImpl
+            if listeners
-                .listener_active
+                .network_listener
                 .load(std::sync::atomic::Ordering::SeqCst)
                 == false
             {
@@ -121,26 +119,23 @@ pub fn scanForWifi(wifiBox: Arc<WifiBox>) {
                         glib::spawn_future(async move {
                             glib::idle_add_once(move || {
                                 let mut wifiEntries = wifiEntriesListener.lock().unwrap();
-                                let path = access_point.0.dbus_path.clone();
+                                let ssid = access_point.0.ssid.clone();
-                                if wifiEntries.get(&path).is_some() {
+                                if wifiEntries.get(&ssid).is_some() {
-                                    // don't add the entry if it exists, somehow networkmanager
-                                    // spams these added things?
-                                    // TODO perhaps use ssid?
                                     return;
                                 }
                                 let entry =
                                     Arc::new(ListEntry::new(&*WifiEntry::new(access_point.0)));
-                                wifiEntries.insert(path, entry.clone());
+                                wifiEntries.insert(ssid, entry.clone());
                                 wifiBoxImpl.imp().resetWifiList.append(&*entry);
                             });
                         });
                     }
-                    Events::RemovedEvent(path) => {
+                    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(&path.0);
+                                let entry = wifiEntries.remove(&access_point.0.ssid);
                                 if entry.is_none() {
                                     return;
                                 }
@@ -158,27 +153,18 @@ pub fn scanForWifi(wifiBox: Arc<WifiBox>) {
 
 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();
-        let wifiEntries = wifiEntries.clone();
-        {
-            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 entry = ListEntry::new(&SavedWifiEntry::new(name, connection.0));
-                entry.set_activatable(false);
-                wifiEntries.push(entry);
-            }
-        }
         glib::spawn_future(async move {
             glib::idle_add_once(move || {
-                let wifiEntries = wifiEntries.lock().unwrap();
                 let selfImp = wifibox_ref.imp();
-                for wifiEntry in wifiEntries.iter() {
+                for connection in connections {
-                    selfImp.resetStoredWifiList.append(wifiEntry);
+                    // TODO include button for settings
+                    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);
+                    selfImp.resetStoredWifiList.append(&entry);
                 }
             });
         });
@@ -262,7 +248,7 @@ pub fn start_event_listener<
     AddedEvent: ReadAll + AppendAll + dbus::message::SignalArgs + GetVal<AddedType>,
     RemovedEvent: ReadAll + AppendAll + dbus::message::SignalArgs + GetVal<RemovedType>,
 >(
-    active_listener: Arc<AtomicBool>,
+    listeners: Arc<Listeners>,
     sender: Arc<Sender<Events<AddedType, RemovedType>>>,
 ) -> Result<(), dbus::Error> {
     thread::spawn(move || {
@@ -311,11 +297,11 @@ pub fn start_event_listener<
                 "Failed to match signal on ReSet.",
             ));
         }
-        active_listener.store(true, Ordering::SeqCst);
+        listeners.network_listener.store(true, Ordering::SeqCst);
         println!("starting thread listener");
         loop {
             let _ = conn.process(Duration::from_millis(1000))?;
-            if !active_listener.load(Ordering::SeqCst) {
+            if !listeners.network_listener.load(Ordering::SeqCst) {
                 println!("stopping thread listener");
                 break;
             }

src/components/wifi/wifiBoxImpl.rs

@@ -27,9 +27,8 @@ pub struct WifiBox {
     pub resetStoredWifiList: TemplateChild<ListBox>,
     #[template_child]
     pub resetAvailableNetworks: TemplateChild<ListEntry>,
-    pub wifiEntries: Arc<Mutex<HashMap<Path<'static>,Arc<ListEntry>>>>,
+    pub wifiEntries: Arc<Mutex<HashMap<Vec<u8>,Arc<ListEntry>>>>,
     pub savedWifiEntries: Arc<Mutex<Vec<ListEntry>>>,
-    pub listener_active: Arc<AtomicBool>,
 }
 
 unsafe impl Send for WifiBox {}

src/components/wifi/wifiEntry.rs

@@ -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,151 @@
 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,11 @@
+use std::sync::Arc;
+use std::sync::atomic::AtomicBool;
+
 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 +21,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,12 @@
 use std::cell::{Cell, RefCell};
+use std::sync::Arc;
+use std::sync::atomic::AtomicBool;
 
 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 +35,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,6 @@
 use std::cell::RefCell;
+use std::sync::Arc;
+use std::sync::atomic::AtomicBool;
 
 use adw::glib::StaticTypeExt;
 use adw::subclass::prelude::AdwApplicationWindowImpl;
@@ -7,6 +9,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 +43,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>