Xetibo/ReSet
1
0
Fork 0
mirror of https://github.com/Xetibo/ReSet.git synced 2025-04-12 08:28:32 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #51 from Xetibo/dashie

Browse source 
Add stop listener and replace existing entries
This commit is contained in:
takotori 2023-11-13 11:01:10 +01:00 committed by GitHub
parent 97e81a617d a62288be07
commit 679b4f0331
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
21 changed files with 380 additions and 203 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
Cargo.toml
View file

@ -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"] }

4
src/components/base/listEntryImpl.rs
View file

@ -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)]

1
src/components/base/mod.rs
View file

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

11
src/components/base/popupImpl.rs
View file

@ -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::{
gdk, glib, Button, CompositeTemplate, Entry, EntryBuffer, Label, PasswordEntry,
PasswordEntryBuffer, Popover,
};
use gtk::{glib, Button, CompositeTemplate, Label, PasswordEntry, PasswordEntryBuffer, Popover};
use super::popup;

4
src/components/base/settingBoxImpl.rs
View file

@ -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)]

33
src/components/base/utils.rs Normal file
View file

@ -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", ());
});
}
}

1
src/components/output/audioBox.rs
View file

@ -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! {

4
src/components/output/audioBoxImpl.rs
View file

@ -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;
@ -50,4 +50,4 @@ impl WidgetImpl for AudioBox {}
impl WindowImpl for AudioBox {}
impl ApplicationWindowImpl for AudioBox {}
impl ApplicationWindowImpl for AudioBox {}

4
src/components/output/audioSourceImpl.rs
View file

@ -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;
@ -37,4 +37,4 @@ impl BoxImpl for AudioSourceEntry {}
impl ObjectImpl for AudioSourceEntry {}
impl WidgetImpl for AudioSourceEntry {}
impl WidgetImpl for AudioSourceEntry {}

1
src/components/wifi/savedWifiEntry.rs
View file

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

263
src/components/wifi/wifiBox.rs
View file

@ -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.resetSavedNetworks.set_action_target_value(Some(&Variant::from("saved")));
selfImp
.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 {
let accessPoints = get_access_points().await;
gio::spawn_blocking(move || {
let accessPoints = get_access_points();
let wifiEntriesListener = wifiEntries.clone();
let wifiEntries = wifiEntries.clone();
{
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::spawn_future(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() {
selfImp.resetWifiList.append(wifiEntry);
for accessPoint in accessPoints {
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>,)>>,
Receiver<Events<(AccessPoint,), (Path<'static>,)>>,
Sender<Events<(AccessPoint,), (AccessPoint,)>>,
Receiver<Events<(AccessPoint,), (AccessPoint,)>>,
) = channel();
let sender_ref = Arc::new(sender);
let listener_active = Arc::new(AtomicBool::new(false));
ReSet_Lib::utils::start_event_listener::<
let res = start_event_listener::<
(AccessPoint,),
(AccessPoint,),
(Path<'static>,),
AccessPointAdded,
AccessPointRemoved,
>(listener_active, sender_ref);
// handle receiver...
let res = receiver.try_recv();
if res.is_ok() {
let access_point = res.unwrap();
match access_point {
Events::AddedEvent(access_point) => {
dbg!(access_point);
}
_ => (),
};
} else {
println!("no message there :)");
>(listeners.clone(), sender_ref);
if res.is_err() {
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) => {
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();
glib::spawn_future_local(async move {
let connections = get_stored_connections().await;
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::MainContext::default().spawn_local(async move {
gio::spawn_blocking(move || {
let connections = get_stored_connections();
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() {
selfImp.resetStoredWifiList.append(wifiEntry);
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);
selfImp.resetStoredWifiList.append(&entry);
}
});
});
});
}
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> =
proxy.method_call("org.xetibo.ReSet", "GetConnectionSettings", (path,));
let res: Result<
(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(())
}

3
src/components/wifi/wifiBoxImpl.rs
View file

@ -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>>>,
}

9
src/components/wifi/wifiEntry.rs
View file

@ -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(

2
src/components/wifi/wifiEntryImpl.rs
View file

@ -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>,

212
src/components/window/handleSidebarClick.rs
View file

@ -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| {
let wifiBox = Arc::new(WifiBox::new());
show_stored_connections(wifiBox.clone());
scanForWifi(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_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(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| {
let wifiBox = Arc::new(WifiBox::new());
scanForWifi(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_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(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| {
let bluetoothFrame = wrapInFrame(SettingBox::new(&BluetoothBox::new()));
resetMain.remove_all();
resetMain.insert(&bluetoothFrame, -1);
resetMain.set_max_children_per_line(1);
};
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| {
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_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| {
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_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| {
let audioFrame = wrapInFrame(SettingBox::new(&AudioBox::new()));
resetMain.remove_all();
resetMain.insert(&audioFrame, -1);
resetMain.set_max_children_per_line(1);
};
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| {
let sourceFrame = wrapInFrame(SettingBox::new(&SourceBox::new()));
resetMain.remove_all();
resetMain.insert(&sourceFrame, -1);
resetMain.set_max_children_per_line(1);
};
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| {
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_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| {
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(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| {
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(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| {
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(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| {
resetMain.remove_all();
};
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);

5
src/components/window/sidebarEntry.rs
View file

@ -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();

6
src/components/window/sidebarEntryImpl.rs
View file

@ -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 {
@ -62,4 +64,4 @@ impl ObjectImpl for SidebarEntry {}
impl ListBoxRowImpl for SidebarEntry {}
impl WidgetImpl for SidebarEntry {}
impl WidgetImpl for SidebarEntry {}

2
src/components/window/window.rs
View file

@ -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());
}),
);

3
src/components/window/windowImpl.rs
View file

@ -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 {}

5
src/resources/resetUI.cmb
View file

@ -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),

8
src/resources/resetWifiEntry.ui
View file

@ -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>