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

chore: Code cleanup

Browse source
This commit is contained in:
Fabio Lenherr / DashieTM 2023-12-02 17:07:17 +01:00
parent 4a7fa8c584
commit 4a34144ebc
8 changed files with 359 additions and 281 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -12,4 +12,3 @@ pub mod wifiOptions;
pub mod wifiOptionsImpl;
pub mod wifiRouteEntry;
pub mod wifiRouteEntryImpl;

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

@ -14,7 +14,7 @@ pub enum IpProtocol {
}
type ResultType =
Result<(HashMap<String, HashMap<String, dbus::arg::Variant<Box<dyn RefArg>>>>,), Error>;
Result<(HashMap<String, HashMap<String, dbus::arg::Variant<Box<dyn RefArg>>>>,), Error>;
pub fn getConnectionSettings(path: Path<'static>) -> ResetConnection {
let conn = Connection::new_session().unwrap();

50
src/components/wifi/wifiAddressEntry.rs
View file

@ -22,7 +22,11 @@ glib::wrapper! {
}
impl WifiAddressEntry {
pub fn new(address: Option<usize>, conn: Rc<RefCell<Connection>>, protocol: IpProtocol) -> Self {
pub fn new(
address: Option<usize>,
conn: Rc<RefCell<Connection>>,
protocol: IpProtocol,
) -> Self {
let entry: WifiAddressEntry = Object::builder().build();
let entryImp = entry.imp();
@ -30,9 +34,13 @@ impl WifiAddressEntry {
let conn = conn.borrow();
let address = unsafe { conn.ipv4.address_data.get_unchecked(address) };
entryImp.resetAddressAddress.set_text(&*address.address);
entryImp.resetAddressPrefix.set_text(&*address.prefix_length.to_string());
entryImp.resetAddressRow.set_title(&format!("{}/{}", &*address.address, address.prefix_length));
entryImp.resetAddressAddress.set_text(&address.address);
entryImp
.resetAddressPrefix
.set_text(&address.prefix_length.to_string());
entryImp
.resetAddressRow
.set_title(&format!("{}/{}", &*address.address, address.prefix_length));
}
entryImp.protocol.set(protocol);
entry.setupCallbacks(conn);
@ -53,8 +61,8 @@ impl WifiAddressEntry {
return;
}
let result = match selfImp.protocol.get() {
IpProtocol::IPv4 => Ipv4Addr::from_str(addressInput.as_str()).map(|a| IpAddr::V4(a)),
IpProtocol::IPv6 => Ipv6Addr::from_str(addressInput.as_str()).map(|a| IpAddr::V6(a)),
IpProtocol::IPv4 => Ipv4Addr::from_str(addressInput.as_str()).map(IpAddr::V4),
IpProtocol::IPv6 => Ipv6Addr::from_str(addressInput.as_str()).map(IpAddr::V6),
};
match result {
Ok(ipAddr) => {
@ -88,10 +96,9 @@ impl WifiAddressEntry {
}
selfImp.prefix.set((false, 0));
setRowName(&selfImp);
return;
};
if prefixInput.is_empty() || !prefix.is_ok() {
if prefixInput.is_empty() || prefix.is_err() {
handleError();
return;
}
@ -124,24 +131,31 @@ impl WifiAddressEntry {
}));
let conn = connection.clone();
selfImp.resetAddressRemove.connect_clicked(clone!(@weak selfImp, @weak self as what => move |_| {
let address = selfImp.resetAddressAddress.text();
let mut conn = conn.borrow_mut();
conn.ipv4.address_data.retain(|addr| addr.address != address.to_string());
what.unparent();
}));
selfImp.resetAddressRemove.connect_clicked(
clone!(@weak selfImp, @weak self as what => move |_| {
let address = selfImp.resetAddressAddress.text();
let mut conn = conn.borrow_mut();
conn.ipv4.address_data.retain(|addr| addr.address != address);
what.unparent();
}),
);
}
}
fn setRowName(selfImp: &WifiAddressEntryImpl) {
if selfImp.resetAddressAddress.text().is_empty() { return; }
if selfImp.resetAddressAddress.text().is_empty() {
return;
}
let address = selfImp.address.borrow();
let prefix = selfImp.prefix.get();
let title = match (address.0, prefix.0) {
(true, true) => { format!("{}/{}", address.1, prefix.1) },
(true, true) => {
format!("{}/{}", address.1, prefix.1)
}
(true, false) => "Prefix wrong".to_string(),
(false, true) => "Address wrong".to_string(),
(false, false) => "Address and Prefix wrong".to_string(),
};
selfImp.resetAddressRow.set_title(&*title);
}
selfImp.resetAddressRow.set_title(&title);
}

13
src/components/wifi/wifiAddressEntryImpl.rs
View file

@ -1,12 +1,9 @@
use std::cell::{Cell, RefCell};
use adw::{EntryRow, ExpanderRow};
use glib::once_cell::sync::Lazy;
use glib::StaticType;
use glib::subclass::Signal;
use crate::components::wifi::{wifiAddressEntry};
use gtk::subclass::prelude::*;
use gtk::{glib, CompositeTemplate, Button};
use crate::components::wifi::utils::IpProtocol;
use crate::components::wifi::wifiAddressEntry;
use adw::{EntryRow, ExpanderRow};
use gtk::subclass::prelude::*;
use gtk::{glib, Button, CompositeTemplate};
use std::cell::{Cell, RefCell};
#[allow(non_snake_case)]
#[derive(Default, CompositeTemplate)]

275
src/components/wifi/wifiOptions.rs
View file

@ -8,8 +8,8 @@ use adw::prelude::{ActionRowExt, ComboRowExt, PreferencesGroupExt};
use adw::subclass::prelude::ObjectSubclassIsExt;
use glib::{clone, PropertySet};
use gtk::prelude::{ButtonExt, EditableExt, WidgetExt};
use ReSet_Lib::network::connection::{Connection, DNSMethod4, DNSMethod6, Enum, TypeSettings};
use IpProtocol::{IPv4, IPv6};
use ReSet_Lib::network::connection::{Connection, DNSMethod4, DNSMethod6, Enum, TypeSettings};
use crate::components::wifi::utils::IpProtocol;
use crate::components::wifi::wifiAddressEntry::WifiAddressEntry;
@ -22,6 +22,9 @@ glib::wrapper! {
@implements gtk::Accessible, gtk::Buildable, gtk::ConstraintTarget;
}
unsafe impl Send for WifiOptions {}
unsafe impl Sync for WifiOptions {}
impl WifiOptions {
pub fn new(connection: Connection) -> Arc<Self> {
let wifiOption: Arc<WifiOptions> = Arc::new(Object::builder().build());
@ -33,10 +36,10 @@ impl WifiOptions {
pub fn initializeUI(&self) {
let selfImp = self.imp();
let mut ip4AddressLength = 0;
let mut ip4RouteLength = 0;
let mut ip6AddressLength = 0;
let mut ip6RouteLength = 0;
let ip4AddressLength;
let ip4RouteLength;
let ip6AddressLength;
let ip6RouteLength;
{
let conn = selfImp.connection.borrow();
ip4AddressLength = conn.ipv4.address_data.len();
@ -46,8 +49,12 @@ impl WifiOptions {
// General
selfImp.resetWifiAutoConnect.set_active(conn.settings.autoconnect);
selfImp.resetWifiMetered.set_active(conn.settings.metered != -1);
selfImp
.resetWifiAutoConnect
.set_active(conn.settings.autoconnect);
selfImp
.resetWifiMetered
.set_active(conn.settings.metered != -1);
match &conn.device {
TypeSettings::WIFI(wifi) => {
selfImp.resetWifiLinkSpeed.set_visible(false);
@ -56,9 +63,10 @@ impl WifiOptions {
selfImp.resetWifiDNS.set_visible(false);
selfImp.resetWifiGateway.set_visible(false);
selfImp.resetWifiLastUsed.set_visible(true);
selfImp.resetWifiMac.set_subtitle(&*wifi.cloned_mac_address);
selfImp.resetWifiName.set_subtitle(&*String::from_utf8(wifi.ssid.clone())
.unwrap_or(String::default()));
selfImp.resetWifiMac.set_subtitle(&wifi.cloned_mac_address);
selfImp
.resetWifiName
.set_subtitle(&String::from_utf8(wifi.ssid.clone()).unwrap_or_default());
}
TypeSettings::ETHERNET(ethernet) => {
selfImp.resetWifiLinkSpeed.set_visible(true);
@ -67,28 +75,52 @@ impl WifiOptions {
selfImp.resetWifiDNS.set_visible(true);
selfImp.resetWifiGateway.set_visible(true);
selfImp.resetWifiLastUsed.set_visible(false);
selfImp.resetWifiMac.set_subtitle(&*ethernet.cloned_mac_address);
selfImp.resetWifiLinkSpeed.set_subtitle(&*ethernet.speed.to_string());
selfImp
.resetWifiMac
.set_subtitle(&ethernet.cloned_mac_address);
selfImp
.resetWifiLinkSpeed
.set_subtitle(&ethernet.speed.to_string());
}
TypeSettings::VPN(_vpn) => {}
TypeSettings::None => {}
};
// IPv4
selfImp.resetIP4Method.set_selected(conn.ipv4.dns_method.to_i32() as u32);
selfImp
.resetIP4Method
.set_selected(conn.ipv4.dns_method.to_i32() as u32);
self.setIP4Visibility(conn.ipv4.dns_method.to_i32() as u32);
let ipv4Dns: Vec<String> = conn.ipv4.dns.iter().map(|addr| {
addr.iter().map(|octet| octet.to_string()).collect::<Vec<String>>().join(".")
}).collect();
let ipv4Dns: Vec<String> = conn
.ipv4
.dns
.iter()
.map(|addr| {
addr.iter()
.map(|octet| octet.to_string())
.collect::<Vec<String>>()
.join(".")
})
.collect();
selfImp.resetIP4DNS.set_text(&ipv4Dns.join(", "));
selfImp.resetIP4Gateway.set_text(&conn.ipv4.gateway);
// IPv6
selfImp.resetIP6Method.set_selected(conn.ipv6.dns_method.to_i32() as u32);
selfImp
.resetIP6Method
.set_selected(conn.ipv6.dns_method.to_i32() as u32);
self.setIP6Visibility(conn.ipv6.dns_method.to_i32() as u32);
let ipv6Dns: Vec<String> = conn.ipv6.dns.iter().map(|addr| {
addr.iter().map(|octet| octet.to_string()).collect::<Vec<String>>().join(":")
}).collect();
let ipv6Dns: Vec<String> = conn
.ipv6
.dns
.iter()
.map(|addr| {
addr.iter()
.map(|octet| octet.to_string())
.collect::<Vec<String>>()
.join(":")
})
.collect();
selfImp.resetIP6DNS.set_text(&ipv6Dns.join(", "));
selfImp.resetIP6Gateway.set_text(&conn.ipv6.gateway);
dbg!(conn);
@ -128,12 +160,14 @@ impl WifiOptions {
pub fn setIP4Visibility(&self, method: u32) {
let selfImp = self.imp();
match method {
0 => { // auto
0 => {
// auto
selfImp.resetIP4AddressGroup.set_visible(false);
selfImp.resetIP4RoutesGroup.set_visible(true);
selfImp.resetIP4Gateway.set_visible(false);
}
1 => { // manual
1 => {
// manual
selfImp.resetIP4AddressGroup.set_visible(true);
selfImp.resetIP4RoutesGroup.set_visible(true);
selfImp.resetIP4Gateway.set_visible(true);
@ -149,12 +183,14 @@ impl WifiOptions {
pub fn setIP6Visibility(&self, method: u32) {
let selfImp = self.imp();
match method {
0 | 1 => { // auto, dhcp
0 | 1 => {
// auto, dhcp
selfImp.resetIP6AddressGroup.set_visible(false);
selfImp.resetIP6RoutesGroup.set_visible(true);
selfImp.resetIP6Gateway.set_visible(false);
}
2 => { // manual
2 => {
// manual
selfImp.resetIP6AddressGroup.set_visible(true);
selfImp.resetIP6RoutesGroup.set_visible(true);
selfImp.resetIP6Gateway.set_visible(true);
@ -172,107 +208,118 @@ fn setupCallbacks(wifiOptions: &Arc<WifiOptions>) {
let imp = wifiOptions.imp();
// General
imp.resetWifiAutoConnect.connect_active_notify(clone!(@weak imp => move |x| {
imp.connection.borrow_mut().settings.autoconnect = x.is_active();
}));
imp.resetWifiMetered.connect_active_notify(clone!(@weak imp => move |x| {
imp.connection.borrow_mut().settings.metered = if x.is_active() { 1 } else { 2 };
}));
imp.wifiOptionsApplyButton.connect_clicked(clone!(@weak imp => move |_| {
let prop = imp.connection.borrow().convert_to_propmap();
// todo send to daemon somehow
}));
imp.resetWifiAutoConnect
.connect_active_notify(clone!(@weak imp => move |x| {
imp.connection.borrow_mut().settings.autoconnect = x.is_active();
}));
imp.resetWifiMetered
.connect_active_notify(clone!(@weak imp => move |x| {
imp.connection.borrow_mut().settings.metered = if x.is_active() { 1 } else { 2 };
}));
imp.wifiOptionsApplyButton
.connect_clicked(clone!(@weak imp => move |_| {
let prop = imp.connection.borrow().convert_to_propmap();
// todo send to daemon somehow
}));
// IPv4
let wifiOptionsIP4 = wifiOptions.clone();
imp.resetIP4Method.connect_selected_notify(clone!(@weak imp => move |dropdown| {
let selected = dropdown.selected();
let mut conn = imp.connection.borrow_mut();
conn.ipv4.dns_method = DNSMethod4::from_i32(selected as i32);
wifiOptionsIP4.setIP4Visibility(selected);
}));
imp.resetIP4Method
.connect_selected_notify(clone!(@weak imp => move |dropdown| {
let selected = dropdown.selected();
let mut conn = imp.connection.borrow_mut();
conn.ipv4.dns_method = DNSMethod4::from_i32(selected as i32);
wifiOptionsIP4.setIP4Visibility(selected);
}));
imp.resetIP4DNS.connect_changed(clone!(@weak imp => move |entry| {
let dnsInput = entry.text();
let mut conn = imp.connection.borrow_mut();
conn.ipv4.dns.clear();
if dnsInput.is_empty() {
imp.resetIP4DNS.remove_css_class("error");
return;
}
for dnsEntry in dnsInput.as_str().split(',').map(|s| s.trim()) {
if let Ok(addr) = Ipv4Addr::from_str(dnsEntry) {
imp.resetIP4DNS
.connect_changed(clone!(@weak imp => move |entry| {
let dnsInput = entry.text();
let mut conn = imp.connection.borrow_mut();
conn.ipv4.dns.clear();
if dnsInput.is_empty() {
imp.resetIP4DNS.remove_css_class("error");
conn.ipv4.dns.push(addr.octets().to_vec());
} else {
imp.resetIP4DNS.add_css_class("error");
return;
}
}
}));
imp.resetIP4AddressAddButton.connect_clicked(clone!(@weak imp => move |_| {
let address = &WifiAddressEntry::new(None, imp.connection.clone(), IpProtocol::IPv4);
imp.resetIP4AddressGroup.add(address);
}));
for dnsEntry in dnsInput.as_str().split(',').map(|s| s.trim()) {
if let Ok(addr) = Ipv4Addr::from_str(dnsEntry) {
imp.resetIP4DNS.remove_css_class("error");
conn.ipv4.dns.push(addr.octets().to_vec());
} else {
imp.resetIP4DNS.add_css_class("error");
}
}
}));
imp.resetIP4AddressAddButton
.connect_clicked(clone!(@weak imp => move |_| {
let address = &WifiAddressEntry::new(None, imp.connection.clone(), IpProtocol::IPv4);
imp.resetIP4AddressGroup.add(address);
}));
imp.resetIP4Gateway.connect_changed(clone!(@weak imp => move |entry| {
let gatewayInput = entry.text();
let mut conn = imp.connection.borrow_mut();
conn.ipv4.gateway.clear();
if gatewayInput.is_empty() {
imp.resetIP4Gateway.remove_css_class("error");
return;
}
if let Ok(_) = Ipv4Addr::from_str(gatewayInput.as_str()) {
imp.resetIP4Gateway.remove_css_class("error");
conn.ipv4.gateway = gatewayInput.to_string();
} else {
imp.resetIP4Gateway.add_css_class("error");
}
}));
imp.resetIP4Gateway
.connect_changed(clone!(@weak imp => move |entry| {
let gatewayInput = entry.text();
let mut conn = imp.connection.borrow_mut();
conn.ipv4.gateway.clear();
if gatewayInput.is_empty() {
imp.resetIP4Gateway.remove_css_class("error");
return;
}
if Ipv4Addr::from_str(gatewayInput.as_str()).is_ok() {
imp.resetIP4Gateway.remove_css_class("error");
conn.ipv4.gateway = gatewayInput.to_string();
} else {
imp.resetIP4Gateway.add_css_class("error");
}
}));
// IPv6
let wifiOptionsIP6 = wifiOptions.clone();
imp.resetIP6Method.connect_selected_notify(clone!(@weak imp => move |dropdown| {
let selected = dropdown.selected();
let mut conn = imp.connection.borrow_mut();
conn.ipv6.dns_method = DNSMethod6::from_i32(selected as i32);
wifiOptionsIP6.setIP6Visibility(selected);
}));
imp.resetIP6Method
.connect_selected_notify(clone!(@weak imp => move |dropdown| {
let selected = dropdown.selected();
let mut conn = imp.connection.borrow_mut();
conn.ipv6.dns_method = DNSMethod6::from_i32(selected as i32);
wifiOptionsIP6.setIP6Visibility(selected);
}));
imp.resetIP6DNS.connect_changed(clone!(@weak imp => move |entry| {
let dnsInput = entry.text();
let mut conn = imp.connection.borrow_mut();
conn.ipv6.dns.clear();
if dnsInput.is_empty() {
imp.resetIP6DNS.remove_css_class("error");
return;
}
for dnsEntry in dnsInput.as_str().split(',').map(|s| s.trim()) {
if let Ok(addr) = Ipv6Addr::from_str(dnsEntry) {
imp.resetIP6DNS
.connect_changed(clone!(@weak imp => move |entry| {
let dnsInput = entry.text();
let mut conn = imp.connection.borrow_mut();
conn.ipv6.dns.clear();
if dnsInput.is_empty() {
imp.resetIP6DNS.remove_css_class("error");
conn.ipv6.dns.push(addr.octets().to_vec());
} else {
imp.resetIP6DNS.add_css_class("error");
return;
}
}
}));
imp.resetIP6AddressAddButton.connect_clicked(clone!(@weak imp => move |_| {
let address = &WifiAddressEntry::new(None, imp.connection.clone(), IpProtocol::IPv4);
imp.resetIP6AddressGroup.add(address);
}));
for dnsEntry in dnsInput.as_str().split(',').map(|s| s.trim()) {
if let Ok(addr) = Ipv6Addr::from_str(dnsEntry) {
imp.resetIP6DNS.remove_css_class("error");
conn.ipv6.dns.push(addr.octets().to_vec());
} else {
imp.resetIP6DNS.add_css_class("error");
}
}
}));
imp.resetIP6AddressAddButton
.connect_clicked(clone!(@weak imp => move |_| {
let address = &WifiAddressEntry::new(None, imp.connection.clone(), IpProtocol::IPv4);
imp.resetIP6AddressGroup.add(address);
}));
imp.resetIP6Gateway.connect_changed(clone!(@weak imp => move |entry| {
let gatewayInput = entry.text();
let mut conn = imp.connection.borrow_mut();
conn.ipv6.gateway.clear();
if gatewayInput.is_empty() {
imp.resetIP6Gateway.remove_css_class("error");
return;
}
if let Ok(_) = Ipv6Addr::from_str(gatewayInput.as_str()) {
imp.resetIP6Gateway.remove_css_class("error");
conn.ipv6.gateway = gatewayInput.to_string();
} else {
imp.resetIP6Gateway.add_css_class("error");
}
}));
imp.resetIP6Gateway
.connect_changed(clone!(@weak imp => move |entry| {
let gatewayInput = entry.text();
let mut conn = imp.connection.borrow_mut();
conn.ipv6.gateway.clear();
if gatewayInput.is_empty() {
imp.resetIP6Gateway.remove_css_class("error");
return;
}
if Ipv6Addr::from_str(gatewayInput.as_str()).is_ok() {
imp.resetIP6Gateway.remove_css_class("error");
conn.ipv6.gateway = gatewayInput.to_string();
} else {
imp.resetIP6Gateway.add_css_class("error");
}
}));
// Security
}

173
src/components/wifi/wifiRouteEntry.rs
View file

@ -1,16 +1,15 @@
use std::cell::{Ref, RefCell};
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
use std::rc::Rc;
use std::str::FromStr;
use crate::components::wifi::utils::IpProtocol;
use adw::glib;
use adw::glib::Object;
use adw::prelude::{ExpanderRowExt, PreferencesRowExt};
use glib::clone;
use glib::subclass::prelude::ObjectSubclassIsExt;
use gtk::prelude::{EditableExt, WidgetExt};
use std::cell::RefCell;
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
use std::rc::Rc;
use std::str::FromStr;
use ReSet_Lib::network::connection::{Address, Connection};
use crate::components::wifi::utils::IpProtocol;
use crate::components::wifi::utils::IpProtocol::IPv4;
use crate::components::wifi::wifiRouteEntryImpl;
use crate::components::wifi::wifiRouteEntryImpl::WifiRouteEntryImpl;
@ -22,7 +21,11 @@ glib::wrapper! {
}
impl WifiRouteEntry {
pub fn new(address: Option<usize>, conn : Rc<RefCell<Connection>>, protocol: IpProtocol) -> Self {
pub fn new(
address: Option<usize>,
conn: Rc<RefCell<Connection>>,
protocol: IpProtocol,
) -> Self {
let entry: WifiRouteEntry = Object::builder().build();
let entryImp = entry.imp();
@ -30,15 +33,19 @@ impl WifiRouteEntry {
let conn = conn.borrow();
let address = unsafe { conn.ipv4.route_data.get_unchecked(address) };
entryImp.resetRouteAddress.set_text(&*address.address);
entryImp.resetRoutePrefix.set_text(&*address.prefix_length.to_string());
entryImp.resetRouteAddress.set_text(&address.address);
entryImp
.resetRoutePrefix
.set_text(&address.prefix_length.to_string());
if let Some(gateway) = &address.gateway {
entryImp.resetRouteGateway.set_text(&*gateway);
entryImp.resetRouteGateway.set_text(gateway);
}
if let Some(metric) = address.metric {
entryImp.resetRouteMetric.set_text(&*metric.to_string());
entryImp.resetRouteMetric.set_text(&metric.to_string());
}
entryImp.resetRouteRow.set_title(&format!("{}/{}", &*address.address, address.prefix_length));
entryImp
.resetRouteRow
.set_title(&format!("{}/{}", &*address.address, address.prefix_length));
}
entryImp.protocol.set(protocol);
entry.setupCallbacks(conn);
@ -59,8 +66,8 @@ impl WifiRouteEntry {
return;
}
let result = match selfImp.protocol.get() {
IpProtocol::IPv4 => Ipv4Addr::from_str(addressInput.as_str()).map(|a| IpAddr::V4(a)),
IpProtocol::IPv6 => Ipv6Addr::from_str(addressInput.as_str()).map(|a| IpAddr::V6(a)),
IpProtocol::IPv4 => Ipv4Addr::from_str(addressInput.as_str()).map(IpAddr::V4),
IpProtocol::IPv6 => Ipv6Addr::from_str(addressInput.as_str()).map(IpAddr::V6),
};
match result {
Ok(ipAddr) => {
@ -94,10 +101,9 @@ impl WifiRouteEntry {
}
selfImp.prefix.set((false, 0));
setRowTitle(&selfImp);
return;
};
if prefixInput.is_empty() || !prefix.is_ok() {
if prefixInput.is_empty() || prefix.is_err() {
handleError();
return;
}
@ -130,98 +136,107 @@ impl WifiRouteEntry {
}));
let conn = connection.clone();
selfImp.resetRouteGateway.connect_changed(clone!(@weak selfImp => move |entry| {
let gatewayInput = entry.text();
let mut conn = conn.borrow_mut();
selfImp
.resetRouteGateway
.connect_changed(clone!(@weak selfImp => move |entry| {
let gatewayInput = entry.text();
let mut conn = conn.borrow_mut();
if gatewayInput.is_empty() {
selfImp.resetRouteGateway.remove_css_class("error");
*selfImp.gateway.borrow_mut() = None;
setRowSubtitle(&selfImp);
return;
}
let result = match selfImp.protocol.get() {
IpProtocol::IPv4 => Ipv4Addr::from_str(gatewayInput.as_str()).map(|a| IpAddr::V4(a)),
IpProtocol::IPv6 => Ipv6Addr::from_str(gatewayInput.as_str()).map(|a| IpAddr::V6(a)),
};
match result {
Ok(ipAddr) => {
if gatewayInput.is_empty() {
selfImp.resetRouteGateway.remove_css_class("error");
let addressData = match selfImp.protocol.get() {
IpProtocol::IPv4 => &mut conn.ipv4.route_data,
IpProtocol::IPv6 => &mut conn.ipv6.route_data,
};
if let Some(address) = addressData.iter_mut()
.find(|connAddr| *connAddr.address == selfImp.resetRouteAddress.text()) {
address.gateway = Some(ipAddr.to_string());
}
*selfImp.gateway.borrow_mut() = Some(ipAddr.to_string());
}
Err(_) => {
selfImp.resetRouteGateway.add_css_class("error");
*selfImp.gateway.borrow_mut() = None;
setRowSubtitle(&selfImp);
return;
}
}
setRowSubtitle(&selfImp);
}));
let result = match selfImp.protocol.get() {
IpProtocol::IPv4 => Ipv4Addr::from_str(gatewayInput.as_str()).map(IpAddr::V4),
IpProtocol::IPv6 => Ipv6Addr::from_str(gatewayInput.as_str()).map(IpAddr::V6),
};
match result {
Ok(ipAddr) => {
selfImp.resetRouteGateway.remove_css_class("error");
let addressData = match selfImp.protocol.get() {
IpProtocol::IPv4 => &mut conn.ipv4.route_data,
IpProtocol::IPv6 => &mut conn.ipv6.route_data,
};
if let Some(address) = addressData.iter_mut()
.find(|connAddr| *connAddr.address == selfImp.resetRouteAddress.text()) {
address.gateway = Some(ipAddr.to_string());
}
*selfImp.gateway.borrow_mut() = Some(ipAddr.to_string());
}
Err(_) => {
selfImp.resetRouteGateway.add_css_class("error");
*selfImp.gateway.borrow_mut() = None;
}
}
setRowSubtitle(&selfImp);
}));
let conn = connection.clone();
selfImp.resetRouteMetric.connect_changed(clone!(@weak selfImp => move |entry| {
let metricInput = entry.text();
let mut conn = conn.borrow_mut();
selfImp
.resetRouteMetric
.connect_changed(clone!(@weak selfImp => move |entry| {
let metricInput = entry.text();
let mut conn = conn.borrow_mut();
if metricInput.is_empty() {
selfImp.resetRouteMetric.remove_css_class("error");
selfImp.metric.set(None);
setRowSubtitle(&selfImp);
return;
}
let result = metricInput.parse::<u32>();
match result {
Ok(metric) => {
if metricInput.is_empty() {
selfImp.resetRouteMetric.remove_css_class("error");
let addressData = match selfImp.protocol.get() {
IpProtocol::IPv4 => &mut conn.ipv4.route_data,
IpProtocol::IPv6 => &mut conn.ipv6.route_data,
};
if let Some(address) = addressData.iter_mut()
.find(|connAddr| *connAddr.address == selfImp.resetRouteAddress.text()) {
address.metric = Some(metric);
}
selfImp.metric.set(Some(metric));
}
Err(_) => {
selfImp.resetRouteMetric.add_css_class("error");
selfImp.metric.set(None);
setRowSubtitle(&selfImp);
return;
}
}
setRowSubtitle(&selfImp);
}));
let result = metricInput.parse::<u32>();
match result {
Ok(metric) => {
selfImp.resetRouteMetric.remove_css_class("error");
let addressData = match selfImp.protocol.get() {
IpProtocol::IPv4 => &mut conn.ipv4.route_data,
IpProtocol::IPv6 => &mut conn.ipv6.route_data,
};
if let Some(address) = addressData.iter_mut()
.find(|connAddr| *connAddr.address == selfImp.resetRouteAddress.text()) {
address.metric = Some(metric);
}
selfImp.metric.set(Some(metric));
}
Err(_) => {
selfImp.resetRouteMetric.add_css_class("error");
selfImp.metric.set(None);
}
}
setRowSubtitle(&selfImp);
}));
}
}
fn setRowTitle(selfImp: &WifiRouteEntryImpl) {
if selfImp.resetRouteAddress.text().is_empty() { return; }
if selfImp.resetRouteAddress.text().is_empty() {
return;
}
let address = selfImp.address.borrow();
let prefix = selfImp.prefix.get();
let title = match (address.0, prefix.0) {
(true, true) => { format!("{}/{}", address.1, prefix.1) },
(true, true) => {
format!("{}/{}", address.1, prefix.1)
}
(true, false) => "Prefix wrong".to_string(),
(false, true) => "Address wrong".to_string(),
(false, false) => "Address and Prefix wrong".to_string(),
};
selfImp.resetRouteRow.set_title(&*title);
selfImp.resetRouteRow.set_title(&title);
}
fn setRowSubtitle(selfImp: &WifiRouteEntryImpl) {
let gateway = selfImp.gateway.borrow().clone();
let metric = selfImp.metric.get();
let title = match (gateway, metric) {
(Some(gateway), Some(metric)) => { format!("{}, {}", gateway, metric) },
(Some(gateway), Some(metric)) => {
format!("{}, {}", gateway, metric)
}
(Some(gateway), None) => gateway,
(None, Some(metric)) => metric.to_string(),
(None, None) => String::default(),
};
selfImp.resetRouteRow.set_subtitle(&*title);
selfImp.resetRouteRow.set_subtitle(&title);
}

4
src/components/wifi/wifiRouteEntryImpl.rs
View file

@ -1,9 +1,9 @@
use std::cell::{Cell, RefCell};
use crate::components::wifi::utils::IpProtocol;
use crate::components::wifi::wifiRouteEntry;
use adw::{EntryRow, ExpanderRow};
use gtk::subclass::prelude::*;
use gtk::{glib, Button, CompositeTemplate};
use crate::components::wifi::utils::IpProtocol;
use std::cell::{Cell, RefCell};
#[allow(non_snake_case)]
#[derive(Default, CompositeTemplate)]

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

@ -4,14 +4,16 @@ use std::sync::Arc;
use crate::components::base::settingBox::SettingBox;
use crate::components::base::utils::{start_audio_listener, Listeners};
use crate::components::bluetooth::bluetoothBox::{start_bluetooth_listener, BluetoothBox, populate_conntected_bluetooth_devices};
use crate::components::bluetooth::bluetoothBox::{
populate_conntected_bluetooth_devices, start_bluetooth_listener, BluetoothBox,
};
use crate::components::input::sourceBox::{populate_sources, SourceBox};
use crate::components::output::sinkBox::{populate_sinks, SinkBox};
use crate::components::wifi::wifiBox::{
scanForWifi, show_stored_connections, start_event_listener, WifiBox,
};
use gtk::prelude::WidgetExt;
use gtk::{FlowBox, Frame, Label};
use gtk::{FlowBox, Frame};
pub const HANDLE_CONNECTIVITY_CLICK: fn(Arc<Listeners>, FlowBox) =
|listeners: Arc<Listeners>, resetMain: FlowBox| {
@ -58,17 +60,6 @@ pub const HANDLE_BLUETOOTH_CLICK: fn(Arc<Listeners>, FlowBox) =
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.stop_bluetooth_listener();
listeners.stop_audio_listener();
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(Arc<Listeners>, FlowBox) =
|listeners: Arc<Listeners>, resetMain: FlowBox| {
listeners.stop_network_listener();
@ -96,7 +87,9 @@ pub const HANDLE_VOLUME_CLICK: fn(Arc<Listeners>, FlowBox) =
listeners.stop_bluetooth_listener();
let audioOutput = Arc::new(SinkBox::new());
start_audio_listener(listeners.clone(), Some(audioOutput.clone()), None);
while !listeners.pulse_listener.load(Ordering::SeqCst) { std::hint::spin_loop() }
while !listeners.pulse_listener.load(Ordering::SeqCst) {
std::hint::spin_loop()
}
populate_sinks(audioOutput.clone());
let audioFrame = wrapInFrame(SettingBox::new(&*audioOutput));
resetMain.remove_all();
@ -117,50 +110,6 @@ pub const HANDLE_MICROPHONE_CLICK: fn(Arc<Listeners>, FlowBox) =
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.stop_audio_listener();
listeners.stop_bluetooth_listener();
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.stop_audio_listener();
listeners.stop_bluetooth_listener();
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.stop_audio_listener();
listeners.stop_bluetooth_listener();
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.stop_audio_listener();
listeners.stop_bluetooth_listener();
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(Arc<Listeners>, FlowBox) =
|listeners: Arc<Listeners>, resetMain: FlowBox| {
listeners.stop_network_listener();
@ -175,3 +124,60 @@ fn wrapInFrame(widget: SettingBox) -> Frame {
frame.add_css_class("resetSettingFrame");
frame
}
// for future implementations
// pub const HANDLE_VPN_CLICK: fn(Arc<Listeners>, FlowBox) =
// |listeners: Arc<Listeners>, resetMain: FlowBox| {
// listeners.stop_network_listener();
// listeners.stop_bluetooth_listener();
// listeners.stop_audio_listener();
// 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.stop_audio_listener();
// listeners.stop_bluetooth_listener();
// 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.stop_audio_listener();
// listeners.stop_bluetooth_listener();
// 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.stop_audio_listener();
// listeners.stop_bluetooth_listener();
// 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.stop_audio_listener();
// listeners.stop_bluetooth_listener();
// let label = Label::new(Some("not implemented yet"));
// resetMain.remove_all();
// resetMain.insert(&label, -1);
// resetMain.set_max_children_per_line(1);
// };
//