fix: Don't use popups for wifi

src/components/wifi/savedWifiEntry.rs

@@ -4,10 +4,11 @@ use crate::components::wifi::savedWifiEntryImpl;
 use adw::glib;
 use adw::glib::Object;
 use adw::prelude::{ButtonExt, WidgetExt};
-use dbus::{Error, Path};
 use dbus::blocking::Connection;
-use glib::{clone, PropertySet};
+use dbus::{Error, Path};
 use glib::subclass::types::ObjectSubclassIsExt;
+use glib::{clone, PropertySet};
+use gtk::gio;
 
 glib::wrapper! {
     pub struct SavedWifiEntry(ObjectSubclass<savedWifiEntryImpl::SavedWifiEntry>)
@@ -22,22 +23,28 @@ impl SavedWifiEntry {
         // TODO handle edit
         entryImp.resetSavedWifiLabel.set_text(name);
         entryImp.resetConnectionPath.set(path);
-        entryImp.resetDeleteSavedWifiButton.connect_clicked(clone!(@weak entry as entry => move |_| {
+        entryImp.resetDeleteSavedWifiButton.connect_clicked(
+            clone!(@weak entry as entry => move |_| {
+            delete_connection(entry.imp().resetConnectionPath.take());
+            // TODO handle error
+            let parent = entry.parent().unwrap();
+            parent.set_visible(false);
+            parent.unparent();
+            }),
+        );
+        entry
+    }
+}
+
+fn delete_connection(path: Path<'static>) {
+    gio::spawn_blocking(move || {
         let conn = Connection::new_session().unwrap();
         let proxy = conn.with_proxy(
             "org.xetibo.ReSet",
             "/org/xetibo/ReSet",
             Duration::from_millis(1000),
         );
-        let res: Result<(bool,), Error> = proxy.method_call("org.xetibo.ReSet", "DeleteConnection", (entry.imp().resetConnectionPath.take(),));
+        let _: Result<(), Error> =
-        if res.is_err() || res.unwrap() == (false,) { 
+            proxy.method_call("org.xetibo.ReSet", "DeleteConnection", (path,));
-            // TODO handle error -> inform user
+    });
-           return; 
-        }
-        let parent = entry.parent().unwrap();
-        parent.set_visible(false);
-        parent.unparent();
-        }));
-        entry
-    }
 }

src/components/wifi/wifiEntry.rs

@@ -7,15 +7,18 @@ use adw::glib::{Object, PropertySet};
 use adw::prelude::{ButtonExt, EditableExt, PopoverExt};
 use adw::subclass::prelude::ObjectSubclassIsExt;
 use dbus::blocking::Connection;
-use dbus::Error;
+use dbus::{Error, Path};
 use glib::{clone, Cast};
-use gtk::prelude::WidgetExt;
+use gtk::prelude::{ListBoxRowExt, WidgetExt};
-use gtk::{AlertDialog, GestureClick};
+use gtk::{gio, AlertDialog, GestureClick};
 use ReSet_Lib::network::network::{AccessPoint, WifiStrength};
 
+use crate::components::base::listEntry::ListEntry;
 use crate::components::wifi::wifiBox::getConnectionSettings;
 use crate::components::wifi::wifiEntryImpl;
 
+use super::savedWifiEntry::SavedWifiEntry;
+
 glib::wrapper! {
     pub struct WifiEntry(ObjectSubclass<wifiEntryImpl::WifiEntry>)
         @extends gtk::Box, gtk::Widget,
@@ -35,7 +38,6 @@ impl WifiEntry {
         let ssid = access_point.ssid.clone();
         let name_opt = String::from_utf8(ssid).unwrap_or_else(|_| String::from(""));
         let name = name_opt.as_str();
-        let stored = access_point.stored;
         entryImp.wifiStrength.set(strength);
         entryImp.resetWifiLabel.get().set_text(name);
         entryImp.resetWifiEncrypted.set_visible(false);
@@ -49,7 +51,10 @@ impl WifiEntry {
                 WifiStrength::Weak => Some("network-wireless-signal-weak-symbolic"),
                 WifiStrength::None => Some("network-wireless-signal-none-symbolic"),
             });
-        if access_point.connected == true {
+        if !access_point.stored {
+            entryImp.resetWifiEditButton.set_sensitive(false);
+        }
+        if access_point.connected {
             entryImp
                 .resetWifiConnected
                 .get()
@@ -61,16 +66,16 @@ impl WifiEntry {
         }
         entryImp.accessPoint.set(access_point);
         let gesture = GestureClick::new();
-        if stored {
+        gesture.connect_released(clone!(@weak entryImp => move |_, _, _, _| {
-            gesture.connect_released(move |_, _, _, _| {
+            let access_point = entryImp.accessPoint.borrow();
+            if access_point.connected {
+                click_disconnect();
+            } else if access_point.stored {
                 click_stored_network(stored_entry.clone());
-            });
+            } else {
-        } else {
-            entryImp.resetWifiEditButton.set_sensitive(false);
-            gesture.connect_released(move |_, _, _, _| {
                 click_new_network(new_entry.clone());
-            });
+            }
-        }
+        }));
         entry.add_controller(gesture);
         entry
     }
@@ -84,63 +89,69 @@ impl WifiEntry {
     }
 }
 
-pub fn click_stored_network(entry: Arc<WifiEntry>) {
+pub fn click_disconnect() {
-    let alert = AlertDialog::builder().build();
+    println!("called disconnect");
-    let root = &entry.root().unwrap();
+    gio::spawn_blocking(move || {
-    let root = root.downcast_ref::<gtk::Window>();
+        let conn = Connection::new_session().unwrap();
-    if root.is_none() {
+        let proxy = conn.with_proxy(
-        return;
+            "org.xetibo.ReSet",
-    }
+            "/org/xetibo/ReSet",
-    let root = root.unwrap();
+            Duration::from_millis(10000),
-    let entryImp = entry.imp();
+        );
-    let conn = Connection::new_session().unwrap();
-    let proxy = conn.with_proxy(
-        "org.xetibo.ReSet",
-        "/org/xetibo/ReSet",
-        Duration::from_millis(1000),
-    );
-    let access_point = entryImp.accessPoint.clone().into_inner();
-    if access_point.connected == true {
         let res: Result<(bool,), Error> =
             proxy.method_call("org.xetibo.ReSet", "DisconnectFromCurrentAccessPoint", ());
         if res.is_err() {
-            alert.set_message("Error on connecting to dbus.");
+            println!("res of disconnect was error bro");
-            alert.show(Some(root));
             return;
         }
-        let (res,) = res.unwrap();
+            println!("disconnect worked");
-        if res == false {
+    });
-            alert.set_message("Could not disconnect from access point.");
+}
-            alert.show(Some(root));
+pub fn click_stored_network(entry: Arc<WifiEntry>) {
-        } else {
+    let result = Arc::new(AtomicBool::new(false));
-            entryImp.resetWifiConnected.get().set_from_icon_name(None);
+    let entryImp = entry.imp();
-            let mut access_point = entryImp.accessPoint.borrow_mut();
+    let access_point = entryImp.accessPoint.borrow().clone();
-            (*access_point).connected = false;
+    let entry_ref = entry.clone();
-        }
+    let popup = entry.imp().resetWifiPopup.imp();
-        return;
+    popup.resetPopupLabel.set_text("Connecting...");
-    }
+    popup.resetPopupLabel.set_visible(true);
-    let res: Result<(bool,), Error> = proxy.method_call(
+    popup.resetPopupEntry.set_sensitive(false);
-        "org.xetibo.ReSet",
+    popup.resetPopupButton.set_sensitive(false);
-        "ConnectToKnownAccessPoint",
+
-        (access_point,),
+    gio::spawn_blocking(move || {
-    );
+        let conn = Connection::new_session().unwrap();
-    if res.is_err() {
+        let proxy = conn.with_proxy(
-        alert.set_message("Error on connecting to dbus.");
+            "org.xetibo.ReSet",
-        alert.show(Some(root));
+            "/org/xetibo/ReSet",
-    } else {
+            Duration::from_millis(10000),
-        let (res,) = res.unwrap();
+        );
-        if res == false {
+        let res: Result<(bool,), Error> = proxy.method_call(
-            alert.set_message("Could not connect to access point.");
+            "org.xetibo.ReSet",
-            alert.show(Some(root));
+            "ConnectToKnownAccessPoint",
-        } else {
+            (access_point,),
-            entryImp
+        );
-                .resetWifiConnected
+        glib::spawn_future(async move {
-                .get()
+            glib::idle_add_once(move || {
-                .set_from_icon_name(Some("network-wireless-connected-symbolic"));
+                let imp = entry_ref.imp();
-            let mut access_point = entryImp.accessPoint.borrow_mut();
+                let popup = imp.resetWifiPopup.imp();
-            (*access_point).connected = true;
+                if res.is_err() {
-        }
+                    popup.resetPopupLabel.set_text("Could not connect to dbus.");
-    }
+                    result.store(false, std::sync::atomic::Ordering::SeqCst);
+                    return;
+                }
+                if res.unwrap() == (false,) {
+                    popup
+                        .resetPopupLabel
+                        .set_text("Could not connect to access point.");
+                    result.store(false, std::sync::atomic::Ordering::SeqCst);
+                    return;
+                }
+                entry_ref.imp().resetWifiPopup.popdown();
+                result.store(true, std::sync::atomic::Ordering::SeqCst);
+            });
+        });
+    });
+    // TODO crate spinner animation and block UI
 }
 
 pub fn click_new_network(entry: Arc<WifiEntry>) {
@@ -155,7 +166,7 @@ pub fn click_new_network(entry: Arc<WifiEntry>) {
         popup.resetPopupEntry.set_sensitive(false);
         popup.resetPopupButton.set_sensitive(false);
 
-        glib::spawn_future_local(async move {
+        gio::spawn_blocking(move || {
             let conn = Connection::new_session().unwrap();
             let proxy = conn.with_proxy(
                 "org.xetibo.ReSet",
@@ -167,9 +178,10 @@ pub fn click_new_network(entry: Arc<WifiEntry>) {
                 "ConnectToNewAccessPoint",
                 (access_point, password),
             );
-            glib::MainContext::default().spawn_local(async move {
+            glib::spawn_future(async move {
                 glib::idle_add_once(move || {
                     if res.is_err() {
+                        println!("error bro");
                         entry_ref
                             .imp()
                             .resetWifiPopup
@@ -180,6 +192,7 @@ pub fn click_new_network(entry: Arc<WifiEntry>) {
                         return;
                     }
                     if res.unwrap() == (false,) {
+                        println!("wrong pw");
                         entry_ref
                             .imp()
                             .resetWifiPopup
@@ -189,6 +202,7 @@ pub fn click_new_network(entry: Arc<WifiEntry>) {
                         result.store(false, std::sync::atomic::Ordering::SeqCst);
                         return;
                     }
+                    println!("worked?");
                     entry_ref.imp().resetWifiPopup.popdown();
                     result.store(true, std::sync::atomic::Ordering::SeqCst);
                 });

src/components/wifi/wifiEntryImpl.rs

@@ -3,8 +3,11 @@ use crate::components::wifi::wifiEntry;
 use gtk::subclass::prelude::*;
 use gtk::{glib, Button, CompositeTemplate, Image, Label};
 use std::cell::RefCell;
+use std::sync::Arc;
 use ReSet_Lib::network::network::{AccessPoint, WifiStrength};
 
+use super::wifiBox::WifiBox;
+
 #[allow(non_snake_case)]
 #[derive(Default, CompositeTemplate)]
 #[template(resource = "/org/Xetibo/ReSet/resetWifiEntry.ui")]

src/components/window/handleSidebarClick.rs

@@ -31,6 +31,7 @@ pub const HANDLE_WIFI_CLICK: fn(Arc<Listeners>, FlowBox) =
         listeners.stop_audio_listener();
         listeners.stop_bluetooth_listener();
         let wifiBox = Arc::new(WifiBox::new());
+        show_stored_connections(wifiBox.clone());
         scanForWifi(listeners.clone(), wifiBox.clone());
         let wifiFrame = wrapInFrame(SettingBox::new(&*wifiBox));
         resetMain.remove_all();