Xetibo/ReSet
1
0
Fork 0
mirror of https://github.com/Xetibo/ReSet.git synced 2025-12-15 18:11:38 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

wip

Browse source
This commit is contained in:
DashieTM 2025-02-02 18:32:17 +01:00
parent f09ed75581
commit 5fc51ecda0
14 changed files with 596 additions and 498 deletions
Download patch file Download diff file Expand all files Collapse all files

35
src/components/wifi/saved_wifi_entry.rs
View file

@ -45,20 +45,31 @@ impl SavedWifiEntry {
suffix_box.append(&delete_button);
entry.add_suffix(&suffix_box);
edit_button.connect_clicked(
clone!(@ weak entry_imp, @ weak wifi_box => move |_| {
let _option = get_connection_settings(entry_imp.reset_connection_path.borrow().clone());
wifi_box.reset_wifi_navigation.push(&*WifiOptions::new(_option, entry_imp.reset_connection_path.borrow().clone()));
}),
);
edit_button.connect_clicked(clone!(
#[weak]
entry_imp,
#[weak]
wifi_box,
move |_| {
let _option =
get_connection_settings(entry_imp.reset_connection_path.borrow().clone());
wifi_box.reset_wifi_navigation.push(&*WifiOptions::new(
_option,
entry_imp.reset_connection_path.borrow().clone(),
));
}
));
let entry_ref = entry.clone();
delete_button.connect_clicked(clone!(@weak wifi_box => move |_| {
delete_connection(entry_ref.imp().reset_connection_path.take());
// FUTURE TODO: handle error
wifi_box.reset_stored_wifi_list.remove(&*entry_ref);
}));
delete_button.connect_clicked(clone!(
#[weak]
wifi_box,
move |_| {
delete_connection(entry_ref.imp().reset_connection_path.take());
// FUTURE TODO: handle error
wifi_box.reset_stored_wifi_list.remove(&*entry_ref);
}
));
entry
}
}

185
src/components/wifi/wifi_address_entry.rs
View file

@ -51,94 +51,123 @@ impl WifiAddressEntry {
let self_imp = self.imp();
let conn = connection.clone();
self_imp.reset_address_address.connect_changed(clone!(@weak self_imp => move |entry| {
let address_input = entry.text();
let mut conn = conn.borrow_mut();
self_imp.reset_address_address.connect_changed(clone!(
#[weak]
self_imp,
move |entry| {
let address_input = entry.text();
let mut conn = conn.borrow_mut();
if address_input.is_empty() {
self_imp.reset_address_address.remove_css_class("error");
self_imp.reset_address_row.set_title("Add new address");
return;
}
let result = match self_imp.protocol.get() {
IpProtocol::IPv4 => Ipv4Addr::from_str(address_input.as_str()).map(IpAddr::V4),
IpProtocol::IPv6 => Ipv6Addr::from_str(address_input.as_str()).map(IpAddr::V6),
};
match result {
Ok(ip_addr) => {
if address_input.is_empty() {
self_imp.reset_address_address.remove_css_class("error");
let address_data = match self_imp.protocol.get() {
IpProtocol::IPv4 => &mut conn.ipv4.address_data,
IpProtocol::IPv6 => &mut conn.ipv6.address_data,
};
address_data.push(Address::new_no_options(ip_addr.to_string(), self_imp.prefix.get().1));
*self_imp.address.borrow_mut() = (true, ip_addr.to_string());
self_imp.reset_address_row.set_title("Add new address");
return;
}
Err(_) => {
self_imp.reset_address_address.add_css_class("error");
*self_imp.address.borrow_mut() = (false, String::default());
let result = match self_imp.protocol.get() {
IpProtocol::IPv4 => Ipv4Addr::from_str(address_input.as_str()).map(IpAddr::V4),
IpProtocol::IPv6 => Ipv6Addr::from_str(address_input.as_str()).map(IpAddr::V6),
};
match result {
Ok(ip_addr) => {
self_imp.reset_address_address.remove_css_class("error");
let address_data = match self_imp.protocol.get() {
IpProtocol::IPv4 => &mut conn.ipv4.address_data,
IpProtocol::IPv6 => &mut conn.ipv6.address_data,
};
address_data.push(Address::new_no_options(
ip_addr.to_string(),
self_imp.prefix.get().1,
));
*self_imp.address.borrow_mut() = (true, ip_addr.to_string());
}
Err(_) => {
self_imp.reset_address_address.add_css_class("error");
*self_imp.address.borrow_mut() = (false, String::default());
}
}
}
set_row_name(&self_imp);
}));
let conn = connection.clone();
self_imp.reset_address_prefix.connect_changed(clone!(@weak self_imp => move |entry| {
let prefix_input = entry.text();
let prefix = prefix_input.parse::<u8>();
let mut conn = conn.borrow_mut();
let handle_error = || {
if self_imp.reset_address_prefix.text().is_empty() {
self_imp.reset_address_prefix.remove_css_class("error");
} else {
self_imp.reset_address_prefix.add_css_class("error");
}
self_imp.prefix.set((false, 0));
set_row_name(&self_imp);
};
if prefix_input.is_empty() || prefix.is_err() {
handle_error();
return;
}
let prefix = prefix.unwrap();
match self_imp.protocol.get() {
IpProtocol::IPv4 if prefix <= 32 => {
self_imp.prefix.set((true, prefix as u32));
self_imp.reset_address_prefix.remove_css_class("error");
if let Ok(address2) = Ipv4Addr::from_str(self_imp.reset_address_address.text().as_str()) {
if let Some(addr) = conn.ipv4.address_data.iter_mut()
.find(|conn_addr| *conn_addr.address == address2.to_string()) {
addr.prefix = prefix as u32;
}
}
}
IpProtocol::IPv6 if prefix <= 128 => {
self_imp.prefix.set((true, prefix as u32));
self_imp.reset_address_prefix.remove_css_class("error");
if let Ok(address2) = Ipv6Addr::from_str(self_imp.reset_address_address.text().as_str()) {
if let Some(addr) = conn.ipv6.address_data.iter_mut()
.find(|conn_addr| *conn_addr.address == address2.to_string()) {
addr.prefix = prefix as u32;
}
}
}
_ => handle_error()
}
set_row_name(&self_imp);
}));
));
let conn = connection.clone();
self_imp.reset_address_remove.connect_clicked(
clone!(@weak self_imp, @weak self as what => move |_| {
self_imp.reset_address_prefix.connect_changed(clone!(
#[weak]
self_imp,
move |entry| {
let prefix_input = entry.text();
let prefix = prefix_input.parse::<u8>();
let mut conn = conn.borrow_mut();
let handle_error = || {
if self_imp.reset_address_prefix.text().is_empty() {
self_imp.reset_address_prefix.remove_css_class("error");
} else {
self_imp.reset_address_prefix.add_css_class("error");
}
self_imp.prefix.set((false, 0));
set_row_name(&self_imp);
};
if prefix_input.is_empty() || prefix.is_err() {
handle_error();
return;
}
let prefix = prefix.unwrap();
match self_imp.protocol.get() {
IpProtocol::IPv4 if prefix <= 32 => {
self_imp.prefix.set((true, prefix as u32));
self_imp.reset_address_prefix.remove_css_class("error");
if let Ok(address2) =
Ipv4Addr::from_str(self_imp.reset_address_address.text().as_str())
{
if let Some(addr) = conn
.ipv4
.address_data
.iter_mut()
.find(|conn_addr| *conn_addr.address == address2.to_string())
{
addr.prefix = prefix as u32;
}
}
}
IpProtocol::IPv6 if prefix <= 128 => {
self_imp.prefix.set((true, prefix as u32));
self_imp.reset_address_prefix.remove_css_class("error");
if let Ok(address2) =
Ipv6Addr::from_str(self_imp.reset_address_address.text().as_str())
{
if let Some(addr) = conn
.ipv6
.address_data
.iter_mut()
.find(|conn_addr| *conn_addr.address == address2.to_string())
{
addr.prefix = prefix as u32;
}
}
}
_ => handle_error(),
}
set_row_name(&self_imp);
}
));
let conn = connection.clone();
self_imp.reset_address_remove.connect_clicked(clone!(
#[weak]
self_imp,
#[weak(rename_to = entry)]
self,
move |_| {
let address = self_imp.reset_address_address.text();
let mut conn = conn.borrow_mut();
conn.ipv4.address_data.retain(|addr| addr.address != address);
what.unparent();
}),
);
conn.ipv4
.address_data
.retain(|addr| addr.address != address);
entry.unparent();
}
));
}
}

12
src/components/wifi/wifi_box.rs
View file

@ -82,8 +82,12 @@ fn setup_callbacks(listeners: Arc<Listeners>, wifi_box: Arc<WifiBox>) -> Arc<Wif
imp.reset_available_networks
.set_action_name(Some("navigation.pop"));
set_combo_row_ellipsis(imp.reset_wifi_device.get());
imp.reset_wifi_switch.connect_state_set(
clone!(@weak imp => @default-return glib::Propagation::Proceed, move |_, value| {
imp.reset_wifi_switch.connect_state_set(clone!(
#[weak]
imp,
#[upgrade_or]
glib::Propagation::Proceed,
move |_, value| {
if imp.reset_switch_initial.load(Ordering::SeqCst) {
return glib::Propagation::Proceed;
}
@ -105,8 +109,8 @@ fn setup_callbacks(listeners: Arc<Listeners>, wifi_box: Arc<WifiBox>) -> Arc<Wif
scan_for_wifi(wifibox_ref.clone());
}
glib::Propagation::Proceed
}),
);
}
));
wifi_box
}

83
src/components/wifi/wifi_entry.rs
View file

@ -94,26 +94,44 @@ impl WifiEntry {
entry_imp.access_point.set(access_point);
entry.set_activatable(true);
entry.connect_activated(clone!(@weak entry_imp => move |_| {
let access_point = entry_imp.access_point.borrow();
if *entry_imp.connected.borrow() {
click_disconnect(stored_entry.clone());
} else if access_point.stored {
click_stored_network(stored_entry.clone());
} else {
click_new_network(new_entry.clone());
entry.connect_activated(clone!(
#[weak]
entry_imp,
move |_| {
let access_point = entry_imp.access_point.borrow();
if *entry_imp.connected.borrow() {
click_disconnect(stored_entry.clone());
} else if access_point.stored {
click_stored_network(stored_entry.clone());
} else {
click_new_network(new_entry.clone());
}
}
}));
));
entry.setup_callbacks(wifi_box);
entry
}
pub fn setup_callbacks(&self, wifi_box: &WifiBox) {
let self_imp = self.imp();
self_imp.reset_wifi_edit_button.borrow().connect_clicked(clone!(@ weak self_imp, @ weak wifi_box => move |_| {
let _option = get_connection_settings(self_imp.access_point.borrow().associated_connection.clone());
wifi_box.reset_wifi_navigation.push(&*WifiOptions::new(_option, self_imp.access_point.borrow().associated_connection.clone()));
}));
self_imp
.reset_wifi_edit_button
.borrow()
.connect_clicked(clone!(
#[weak]
self_imp,
#[weak]
wifi_box,
move |_| {
let _option = get_connection_settings(
self_imp.access_point.borrow().associated_connection.clone(),
);
wifi_box.reset_wifi_navigation.push(&*WifiOptions::new(
_option,
self_imp.access_point.borrow().associated_connection.clone(),
));
}
));
}
}
@ -233,16 +251,33 @@ pub fn click_new_network(entry: Arc<WifiEntry>) {
let entry_imp = entry.imp();
let popup_imp = entry_imp.reset_wifi_popup.imp();
popup_imp
.reset_popup_entry
.connect_activate(clone!(@weak entry as orig_entry, @weak entry_imp => move |entry| {
connect_new_network(orig_entry, entry_imp.access_point.clone().take(), entry.text().to_string());
}));
popup_imp.reset_popup_button.connect_clicked(
clone!(@weak entry as orig_entry,@weak entry_imp, @weak popup_imp => move |_| {
let entry = entry_imp.reset_wifi_popup.imp().reset_popup_entry.text().to_string();
connect_new_network(orig_entry, entry_imp.access_point.clone().take(), entry);
}),
);
popup_imp.reset_popup_entry.connect_activate(clone!(
#[weak(rename_to = orig_entry)]
entry,
#[weak]
entry_imp,
move |entry| {
connect_new_network(
orig_entry,
entry_imp.access_point.clone().take(),
entry.text().to_string(),
);
}
));
popup_imp.reset_popup_button.connect_clicked(clone!(
#[weak(rename_to = orig_entry)]
entry,
#[weak]
entry_imp,
move |_| {
let entry = entry_imp
.reset_wifi_popup
.imp()
.reset_popup_entry
.text()
.to_string();
connect_new_network(orig_entry, entry_imp.access_point.clone().take(), entry);
}
));
entry_imp.reset_wifi_popup.popup();
}

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

@ -76,7 +76,7 @@ pub fn access_point_changed_handler(wifi_box: Arc<WifiBox>, ir: AccessPointChang
entry_imp
.reset_wifi_strength
.borrow()
.set_from_icon_name(match strength {
.set_icon_name(match strength {
WifiStrength::Excellent => Some("network-wireless-signal-excellent-symbolic"),
WifiStrength::Ok => Some("network-wireless-signal-ok-symbolic"),
WifiStrength::Weak => Some("network-wireless-signal-weak-symbolic"),

146
src/components/wifi/wifi_options.rs
View file

@ -235,31 +235,45 @@ fn setup_callbacks(wifi_options: &Arc<WifiOptions>, path: Path<'static>) {
let imp = wifi_options.imp();
// General
imp.reset_wifi_auto_connect
.connect_active_notify(clone!(@weak imp => move |x| {
imp.reset_wifi_auto_connect.connect_active_notify(clone!(
#[weak]
imp,
move |x| {
imp.connection.borrow_mut().settings.autoconnect = x.is_active();
}));
imp.reset_wifi_metered
.connect_active_notify(clone!(@weak imp => move |x| {
}
));
imp.reset_wifi_metered.connect_active_notify(clone!(
#[weak]
imp,
move |x| {
imp.connection.borrow_mut().settings.metered = if x.is_active() { 1 } else { 2 };
}));
imp.wifi_options_apply_button
.connect_clicked(clone!(@weak imp => move |_| {
}
));
imp.wifi_options_apply_button.connect_clicked(clone!(
#[weak]
imp,
move |_| {
let prop = imp.connection.borrow().convert_to_propmap();
set_connection_settings(path.clone(), prop);
}));
}
));
// IPv4
let wifi_options_ip4 = wifi_options.clone();
imp.reset_ip4_method
.connect_selected_notify(clone!(@weak imp => move |dropdown| {
imp.reset_ip4_method.connect_selected_notify(clone!(
#[weak]
imp,
move |dropdown| {
let selected = dropdown.selected();
let mut conn = imp.connection.borrow_mut();
conn.ipv4.method = DNSMethod4::from_i32(selected as i32);
wifi_options_ip4.set_ip4_visibility(selected);
}));
}
));
imp.reset_ip4_dns
.connect_changed(clone!(@weak imp => move |entry| {
imp.reset_ip4_dns.connect_changed(clone!(
#[weak]
imp,
move |entry| {
let dns_input = entry.text();
let mut conn = imp.connection.borrow_mut();
conn.ipv4.dns.clear();
@ -275,15 +289,21 @@ fn setup_callbacks(wifi_options: &Arc<WifiOptions>, path: Path<'static>) {
imp.reset_ip4_dns.add_css_class("error");
}
}
}));
imp.reset_ip4_address_add_button
.connect_clicked(clone!(@weak imp => move |_| {
}
));
imp.reset_ip4_address_add_button.connect_clicked(clone!(
#[weak]
imp,
move |_| {
let address = &WifiAddressEntry::new(None, imp.connection.clone(), IPv4);
imp.reset_ip4_address_group.add(address);
}));
}
));
imp.reset_ip4_gateway
.connect_changed(clone!(@weak imp => move |entry| {
imp.reset_ip4_gateway.connect_changed(clone!(
#[weak]
imp,
move |entry| {
let gateway_input = entry.text();
let mut conn = imp.connection.borrow_mut();
conn.ipv4.gateway.clear();
@ -297,19 +317,25 @@ fn setup_callbacks(wifi_options: &Arc<WifiOptions>, path: Path<'static>) {
} else {
imp.reset_ip4_gateway.add_css_class("error");
}
}));
}
));
// IPv6
let wifi_options_ip6 = wifi_options.clone();
imp.reset_ip6_method
.connect_selected_notify(clone!(@weak imp => move |dropdown| {
imp.reset_ip6_method.connect_selected_notify(clone!(
#[weak]
imp,
move |dropdown| {
let selected = dropdown.selected();
let mut conn = imp.connection.borrow_mut();
conn.ipv6.method = DNSMethod6::from_i32(selected as i32);
wifi_options_ip6.set_ip6_visibility(selected);
}));
}
));
imp.reset_ip6_dns
.connect_changed(clone!(@weak imp => move |entry| {
imp.reset_ip6_dns.connect_changed(clone!(
#[weak]
imp,
move |entry| {
let dns_input = entry.text();
let mut conn = imp.connection.borrow_mut();
conn.ipv6.dns.clear();
@ -325,15 +351,21 @@ fn setup_callbacks(wifi_options: &Arc<WifiOptions>, path: Path<'static>) {
imp.reset_ip6_dns.add_css_class("error");
}
}
}));
imp.reset_ip6_address_add_button
.connect_clicked(clone!(@weak imp => move |_| {
}
));
imp.reset_ip6_address_add_button.connect_clicked(clone!(
#[weak]
imp,
move |_| {
let address = &WifiAddressEntry::new(None, imp.connection.clone(), IPv4);
imp.reset_ip6_address_group.add(address);
}));
}
));
imp.reset_ip6_gateway
.connect_changed(clone!(@weak imp => move |entry| {
imp.reset_ip6_gateway.connect_changed(clone!(
#[weak]
imp,
move |entry| {
let gateway_input = entry.text();
let mut conn = imp.connection.borrow_mut();
conn.ipv6.gateway.clear();
@ -347,31 +379,40 @@ fn setup_callbacks(wifi_options: &Arc<WifiOptions>, path: Path<'static>) {
} else {
imp.reset_ip6_gateway.add_css_class("error");
}
}));
}
));
// Security
imp.reset_wifi_security_dropdown
.connect_selected_notify(clone!(@weak imp => move |dropdown| {
let selected = dropdown.selected();
let mut conn = imp.connection.borrow_mut();
.connect_selected_notify(clone!(
#[weak]
imp,
move |dropdown| {
let selected = dropdown.selected();
let mut conn = imp.connection.borrow_mut();
match selected {
0 => { // None
imp.reset_wifi_password.set_visible(false);
conn.security.key_management = KeyManagement::NONE;
conn.security.authentication_algorithm = String::from("none");
},
1 => { // WPA/WPA2 Personal
imp.reset_wifi_password.set_visible(true);
conn.security.key_management = KeyManagement::WPAPSK;
conn.security.authentication_algorithm = String::from("none");
},
_ => {}
match selected {
0 => {
// None
imp.reset_wifi_password.set_visible(false);
conn.security.key_management = KeyManagement::NONE;
conn.security.authentication_algorithm = String::from("none");
}
1 => {
// WPA/WPA2 Personal
imp.reset_wifi_password.set_visible(true);
conn.security.key_management = KeyManagement::WPAPSK;
conn.security.authentication_algorithm = String::from("none");
}
_ => {}
}
}
}));
));
imp.reset_wifi_password
.connect_changed(clone!(@weak imp => move |entry| {
imp.reset_wifi_password.connect_changed(clone!(
#[weak]
imp,
move |entry| {
let password_input = entry.text();
if password_input.len() < 8 && !password_input.is_empty() {
entry.add_css_class("error");
@ -380,7 +421,8 @@ fn setup_callbacks(wifi_options: &Arc<WifiOptions>, path: Path<'static>) {
}
let mut conn = imp.connection.borrow_mut();
conn.security.psk = password_input.to_string();
}));
}
));
imp.reset_available_networks.set_activatable(true);
imp.reset_available_networks

199
src/components/wifi/wifi_route_entry.rs
View file

@ -54,89 +54,115 @@ impl WifiRouteEntry {
fn setup_callbacks(&self, connection: Rc<RefCell<Connection>>) {
let self_imp = self.imp();
let conn = connection.clone();
self_imp.reset_route_address.connect_changed(clone!(@weak self_imp => move |entry| {
let address_input = entry.text();
let mut conn = conn.borrow_mut();
self_imp.reset_route_address.connect_changed(clone!(
#[weak]
self_imp,
move |entry| {
let address_input = entry.text();
let mut conn = conn.borrow_mut();
if address_input.is_empty() {
self_imp.reset_route_address.remove_css_class("error");
self_imp.reset_route_row.set_title("Add new address");
return;
}
let result = match self_imp.protocol.get() {
IpProtocol::IPv4 => Ipv4Addr::from_str(address_input.as_str()).map(IpAddr::V4),
IpProtocol::IPv6 => Ipv6Addr::from_str(address_input.as_str()).map(IpAddr::V6),
};
match result {
Ok(ip_addr) => {
if address_input.is_empty() {
self_imp.reset_route_address.remove_css_class("error");
let address_data = match self_imp.protocol.get() {
IpProtocol::IPv4 => &mut conn.ipv4.route_data,
IpProtocol::IPv6 => &mut conn.ipv6.route_data,
};
address_data.push(Address::new(ip_addr.to_string(), self_imp.prefix.get().1 as u32,self_imp.gateway.borrow().clone() ,self_imp.metric.get()));
*self_imp.address.borrow_mut() = (true, ip_addr.to_string());
self_imp.reset_route_row.set_title("Add new address");
return;
}
Err(_) => {
self_imp.reset_route_address.add_css_class("error");
*self_imp.address.borrow_mut() = (false, String::default());
let result = match self_imp.protocol.get() {
IpProtocol::IPv4 => Ipv4Addr::from_str(address_input.as_str()).map(IpAddr::V4),
IpProtocol::IPv6 => Ipv6Addr::from_str(address_input.as_str()).map(IpAddr::V6),
};
match result {
Ok(ip_addr) => {
self_imp.reset_route_address.remove_css_class("error");
let address_data = match self_imp.protocol.get() {
IpProtocol::IPv4 => &mut conn.ipv4.route_data,
IpProtocol::IPv6 => &mut conn.ipv6.route_data,
};
address_data.push(Address::new(
ip_addr.to_string(),
self_imp.prefix.get().1,
self_imp.gateway.borrow().clone(),
self_imp.metric.get(),
));
*self_imp.address.borrow_mut() = (true, ip_addr.to_string());
}
Err(_) => {
self_imp.reset_route_address.add_css_class("error");
*self_imp.address.borrow_mut() = (false, String::default());
}
}
}
set_row_title(&self_imp);
}));
let conn = connection.clone();
self_imp.reset_route_prefix.connect_changed(clone!(@weak self_imp => move |entry| {
let prefix_input = entry.text();
let prefix = prefix_input.parse::<u8>();
let mut conn = conn.borrow_mut();
let handle_error = || {
if self_imp.reset_route_prefix.text().is_empty() {
self_imp.reset_route_prefix.remove_css_class("error");
} else {
self_imp.reset_route_prefix.add_css_class("error");
}
self_imp.prefix.set((false, 0));
set_row_title(&self_imp);
};
if prefix_input.is_empty() || prefix.is_err() {
handle_error();
return;
}
let prefix = prefix.unwrap();
match self_imp.protocol.get() {
IpProtocol::IPv4 if prefix <= 32 => {
self_imp.prefix.set((true, prefix as u32));
self_imp.reset_route_prefix.remove_css_class("error");
if let Ok(address2) = Ipv4Addr::from_str(self_imp.reset_route_address.text().as_str()) {
if let Some(addr) = conn.ipv4.route_data.iter_mut()
.find(|conn_addr| *conn_addr.address == address2.to_string()) {
addr.prefix = prefix as u32;
}
}
}
IpProtocol::IPv6 if prefix <= 128 => {
self_imp.prefix.set((true, prefix as u32));
self_imp.reset_route_prefix.remove_css_class("error");
if let Ok(address2) = Ipv6Addr::from_str(self_imp.reset_route_address.text().as_str()) {
if let Some(addr) = conn.ipv6.route_data.iter_mut()
.find(|conn_addr| *conn_addr.address == address2.to_string()) {
addr.prefix = prefix as u32;
}
}
}
_ => handle_error()
}
set_row_title(&self_imp);
}));
));
let conn = connection.clone();
self_imp
.reset_route_gateway
.connect_changed(clone!(@weak self_imp => move |entry| {
self_imp.reset_route_prefix.connect_changed(clone!(
#[weak]
self_imp,
move |entry| {
let prefix_input = entry.text();
let prefix = prefix_input.parse::<u8>();
let mut conn = conn.borrow_mut();
let handle_error = || {
if self_imp.reset_route_prefix.text().is_empty() {
self_imp.reset_route_prefix.remove_css_class("error");
} else {
self_imp.reset_route_prefix.add_css_class("error");
}
self_imp.prefix.set((false, 0));
set_row_title(&self_imp);
};
if prefix_input.is_empty() || prefix.is_err() {
handle_error();
return;
}
let prefix = prefix.unwrap();
match self_imp.protocol.get() {
IpProtocol::IPv4 if prefix <= 32 => {
self_imp.prefix.set((true, prefix as u32));
self_imp.reset_route_prefix.remove_css_class("error");
if let Ok(address2) =
Ipv4Addr::from_str(self_imp.reset_route_address.text().as_str())
{
if let Some(addr) = conn
.ipv4
.route_data
.iter_mut()
.find(|conn_addr| *conn_addr.address == address2.to_string())
{
addr.prefix = prefix as u32;
}
}
}
IpProtocol::IPv6 if prefix <= 128 => {
self_imp.prefix.set((true, prefix as u32));
self_imp.reset_route_prefix.remove_css_class("error");
if let Ok(address2) =
Ipv6Addr::from_str(self_imp.reset_route_address.text().as_str())
{
if let Some(addr) = conn
.ipv6
.route_data
.iter_mut()
.find(|conn_addr| *conn_addr.address == address2.to_string())
{
addr.prefix = prefix as u32;
}
}
}
_ => handle_error(),
}
set_row_title(&self_imp);
}
));
let conn = connection.clone();
self_imp.reset_route_gateway.connect_changed(clone!(
#[weak]
self_imp,
move |entry| {
let gateway_input = entry.text();
let mut conn = conn.borrow_mut();
@ -157,8 +183,9 @@ impl WifiRouteEntry {
IpProtocol::IPv4 => &mut conn.ipv4.route_data,
IpProtocol::IPv6 => &mut conn.ipv6.route_data,
};
if let Some(address) = address_data.iter_mut()
.find(|conn_addr| *conn_addr.address == self_imp.reset_route_address.text()) {
if let Some(address) = address_data.iter_mut().find(|conn_addr| {
*conn_addr.address == self_imp.reset_route_address.text()
}) {
address.gateway = Some(ip_addr.to_string());
}
*self_imp.gateway.borrow_mut() = Some(ip_addr.to_string());
@ -169,12 +196,14 @@ impl WifiRouteEntry {
}
}
set_row_subtitle(&self_imp);
}));
}
));
let conn = connection.clone();
self_imp
.reset_route_metric
.connect_changed(clone!(@weak self_imp => move |entry| {
self_imp.reset_route_metric.connect_changed(clone!(
#[weak]
self_imp,
move |entry| {
let metric_input = entry.text();
let mut conn = conn.borrow_mut();
@ -192,8 +221,9 @@ impl WifiRouteEntry {
IpProtocol::IPv4 => &mut conn.ipv4.route_data,
IpProtocol::IPv6 => &mut conn.ipv6.route_data,
};
if let Some(address) = address_data.iter_mut()
.find(|conn_addr| *conn_addr.address == self_imp.reset_route_address.text()) {
if let Some(address) = address_data.iter_mut().find(|conn_addr| {
*conn_addr.address == self_imp.reset_route_address.text()
}) {
address.metric = Some(metric);
}
self_imp.metric.set(Some(metric));
@ -204,7 +234,8 @@ impl WifiRouteEntry {
}
}
set_row_subtitle(&self_imp);
}));
}
));
}
}