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

Implement wifiaddressentry

Browse source
This commit is contained in:
takotori 2023-12-02 12:24:16 +01:00
parent 29eea9ce4a
commit cd980350e4
10 changed files with 362 additions and 212 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
Cargo.toml
View file

@ -20,7 +20,8 @@ tokio = { version = "1.33.0", features = [
"sync",
] }
fork = "0.1.22"
regex = "1.10.2"
ipnetwork = "0.20.0"
once_cell = "1.18.0"
[build-dependencies]
glib-build-tools = "0.18.0"

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

@ -6,8 +6,15 @@ use std::collections::HashMap;
use std::time::Duration;
use ReSet_Lib::network::connection::Connection as ResetConnection;
#[derive(Default, Copy, Clone)]
pub enum IpProtocol {
#[default]
IPv4,
IPv6,
}
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();

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

@ -1,12 +1,19 @@
use std::cell::RefCell;
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
use std::rc::Rc;
use std::str::FromStr;
use adw::glib;
use adw::glib::Object;
use adw::prelude::PreferencesRowExt;
use glib::clone;
use glib::subclass::prelude::ObjectSubclassIsExt;
use gtk::prelude::EditableExt;
use ReSet_Lib::network::connection::Address;
use gtk::prelude::{ButtonExt, EditableExt, WidgetExt};
use ReSet_Lib::network::connection::{Address, Connection};
use crate::components::wifi::utils::IpProtocol;
use crate::components::wifi::wifiAddressEntryImpl;
use crate::components::wifi::wifiOptions::getValueFromKey;
use crate::components::wifi::wifiAddressEntryImpl::WifiAddressEntryImpl;
glib::wrapper! {
pub struct WifiAddressEntry(ObjectSubclass<wifiAddressEntryImpl::WifiAddressEntryImpl>)
@ -15,22 +22,126 @@ glib::wrapper! {
}
impl WifiAddressEntry {
pub fn new(address: Option<&Address>) -> Self {
pub fn new(address: Option<usize>, conn: Rc<RefCell<Connection>>, protocol: IpProtocol) -> Self {
let entry: WifiAddressEntry = Object::builder().build();
let entryImp = entry.imp();
if let Some(address) = address {
let entryImp = entry.imp();
let map = address.to_map();
let conn = conn.borrow();
let address = unsafe { conn.ipv4.address_data.get_unchecked(address) };
let addr = getValueFromKey(&map, "address");
let prefix = getValueFromKey(&map, "prefix-length");
entryImp.resetAddressAddress.set_text(&addr);
entryImp.resetAddressNetmask.set_text(&prefix);
entryImp
.resetAddressRow
.set_title(&format!("{}, {}", addr, prefix));
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);
entry
}
pub fn setupCallbacks(&self, connection: Rc<RefCell<Connection>>) {
let selfImp = self.imp();
let conn = connection.clone();
selfImp.resetAddressAddress.connect_changed(clone!(@weak selfImp, @weak self as what => move |entry| {
let addressInput = entry.text();
let mut conn = conn.borrow_mut();
if addressInput.is_empty() {
selfImp.resetAddressAddress.remove_css_class("error");
selfImp.resetAddressRow.set_title("Add new address");
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)),
};
match result {
Ok(ip_addr) => {
selfImp.resetAddressAddress.remove_css_class("error");
let addressData = match selfImp.protocol.get() {
IpProtocol::IPv4 => &mut conn.ipv4.address_data,
IpProtocol::IPv6 => &mut conn.ipv6.address_data,
};
addressData.push(Address::theBetterNew(ip_addr.to_string(), selfImp.prefix.get().1 as u32));
*selfImp.address.borrow_mut() = (true, ip_addr.to_string());
}
Err(_) => {
selfImp.resetAddressAddress.add_css_class("error");
*selfImp.address.borrow_mut() = (false, String::default());
}
}
setRowName(&selfImp);
}));
let conn = connection.clone();
selfImp.resetAddressPrefix.connect_changed(clone!(@weak selfImp => move |entry| {
let prefixInput = entry.text();
let prefix = prefixInput.parse::<u8>();
let mut conn = conn.borrow_mut();
let handleError = || {
if selfImp.resetAddressPrefix.text().is_empty() {
selfImp.resetAddressPrefix.remove_css_class("error");
} else {
selfImp.resetAddressPrefix.add_css_class("error");
}
selfImp.prefix.set((false, 0));
setRowName(&selfImp);
return;
};
if prefixInput.is_empty() || !prefix.is_ok() {
handleError();
return;
}
let prefix = prefix.unwrap();
match selfImp.protocol.get() {
IpProtocol::IPv4 if prefix < 32 => {
selfImp.prefix.set((true, prefix as u32));
selfImp.resetAddressPrefix.remove_css_class("error");
if let Ok(address2) = Ipv4Addr::from_str(selfImp.resetAddressAddress.text().as_str()) {
if let Some(addr) = conn.ipv4.address_data.iter_mut()
.find(|connAddr| *connAddr.address == address2.to_string()) {
addr.prefix_length = prefix as u32;
}
}
}
IpProtocol::IPv6 if prefix < 128 => {
selfImp.prefix.set((true, prefix as u32));
selfImp.resetAddressPrefix.remove_css_class("error");
if let Ok(address2) = Ipv6Addr::from_str(selfImp.resetAddressAddress.text().as_str()) {
if let Some(addr) = conn.ipv6.address_data.iter_mut()
.find(|connAddr| *connAddr.address == address2.to_string()) {
addr.prefix_length = prefix as u32;
}
}
}
_ => handleError()
}
setRowName(&selfImp);
}));
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();
}));
}
}
fn setRowName(selfImp: &WifiAddressEntryImpl) {
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, false) => "Prefix wrong".to_string(),
(false, true) => "Address wrong".to_string(),
(false, false) => "Address and Prefix wrong".to_string(),
};
selfImp.resetAddressRow.set_title(&*title);
}

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

@ -1,7 +1,12 @@
use crate::components::wifi::wifiAddressEntry;
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, Button, CompositeTemplate};
use gtk::{glib, CompositeTemplate, Button};
use crate::components::wifi::utils::IpProtocol;
#[allow(non_snake_case)]
#[derive(Default, CompositeTemplate)]
@ -12,9 +17,12 @@ pub struct WifiAddressEntryImpl {
#[template_child]
pub resetAddressAddress: TemplateChild<EntryRow>,
#[template_child]
pub resetAddressNetmask: TemplateChild<EntryRow>,
pub resetAddressPrefix: TemplateChild<EntryRow>,
#[template_child]
pub resetAddressRemove: TemplateChild<Button>,
pub address: RefCell<(bool, String)>,
pub prefix: Cell<(bool, u32)>,
pub protocol: Cell<IpProtocol>,
}
#[glib::object_subclass]

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

@ -1,3 +1,5 @@
use std::net::{Ipv4Addr, Ipv6Addr};
use std::str::FromStr;
use std::sync::Arc;
use adw::glib;
@ -5,11 +7,12 @@ use adw::glib::Object;
use adw::prelude::{ActionRowExt, ComboRowExt, PreferencesGroupExt};
use adw::subclass::prelude::ObjectSubclassIsExt;
use dbus::arg::PropMap;
use glib::{clone, PropertySet};
use gtk::prelude::{EditableExt, WidgetExt};
use regex::Regex;
use ReSet_Lib::network::connection::{Connection, Enum, TypeSettings};
use glib::{clone, closure_local, ObjectExt, PropertySet};
use gtk::prelude::{ButtonExt, EditableExt, WidgetExt};
use gtk::Widget;
use ReSet_Lib::network::connection::{Connection, DNSMethod4, DNSMethod6, Enum, TypeSettings};
use crate::components::wifi::utils::IpProtocol;
use crate::components::wifi::wifiAddressEntry::WifiAddressEntry;
use crate::components::wifi::wifiOptionsImpl;
use crate::components::wifi::wifiRouteEntry::WifiRouteEntry;
@ -20,9 +23,6 @@ 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());
@ -34,139 +34,108 @@ impl WifiOptions {
pub fn initializeUI(&self) {
let selfImp = self.imp();
let conn = selfImp.connection.borrow();
// General
selfImp.resetWifiName.set_subtitle(&conn.settings.name);
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);
selfImp.resetWifiIP4Addr.set_visible(false);
selfImp.resetWifiIP6Addr.set_visible(false);
selfImp.resetWifiDNS.set_visible(false);
selfImp.resetWifiGateway.set_visible(false);
selfImp.resetWifiLastUsed.set_visible(true);
selfImp.resetWifiMac.set_subtitle(&wifi.cloned_mac_address);
}
TypeSettings::ETHERNET(ethernet) => {
selfImp.resetWifiLinkSpeed.set_visible(true);
selfImp.resetWifiIP4Addr.set_visible(true);
selfImp.resetWifiIP6Addr.set_visible(true);
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());
}
TypeSettings::VPN(_vpn) => {}
TypeSettings::None => {}
};
// IPv4
selfImp
.resetIP4Method
.set_selected(conn.ipv4.dns_method.to_i32() as u32);
self.setIP4Visibility(conn.ipv4.dns_method.to_i32() as u32);
let mut ip4AddressLength = 0;
let mut ip4RouteLength = 0;
let mut ip6AddressLength = 0;
let mut ip6RouteLength = 0;
{
let conn = selfImp.connection.borrow();
ip4AddressLength = conn.ipv4.address_data.len();
ip4RouteLength = conn.ipv4.route_data.len();
ip6AddressLength = conn.ipv4.address_data.len();
ip6RouteLength = conn.ipv4.route_data.len();
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);
// General
if conn.ipv4.address_data.is_empty() {
selfImp
.resetIP4AddressGroup
.add(&WifiAddressEntry::new(None))
} else {
for address in conn.ipv4.address_data.iter() {
selfImp
.resetIP4AddressGroup
.add(&WifiAddressEntry::new(Some(address)))
}
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);
selfImp.resetWifiIP4Addr.set_visible(false);
selfImp.resetWifiIP6Addr.set_visible(false);
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()));
}
TypeSettings::ETHERNET(ethernet) => {
selfImp.resetWifiLinkSpeed.set_visible(true);
selfImp.resetWifiIP4Addr.set_visible(true);
selfImp.resetWifiIP6Addr.set_visible(true);
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());
}
TypeSettings::VPN(_vpn) => {}
TypeSettings::None => {}
};
// IPv4
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();
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);
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();
selfImp.resetIP6DNS.set_text(&ipv6Dns.join(", "));
selfImp.resetIP6Gateway.set_text(&conn.ipv6.gateway);
dbg!(conn);
}
// IPv4
for i in 0..ip4AddressLength {
let address = &WifiAddressEntry::new(Some(i), selfImp.connection.clone(), IpProtocol::IPv4);
selfImp.resetIP4AddressGroup.add(address);
}
let address = &WifiAddressEntry::new(None, selfImp.connection.clone(), IpProtocol::IPv4);
selfImp.resetIP4AddressGroup.add(address);
if conn.ipv4.route_data.is_empty() {
selfImp.resetIP4RoutesGroup.add(&WifiRouteEntry::new(None))
if ip4RouteLength == 0 {
selfImp.resetIP4RoutesGroup.add(&WifiRouteEntry::new(None, selfImp.connection.clone(), IpProtocol::IPv4))
} else {
for address in conn.ipv4.route_data.iter() {
selfImp
.resetIP4RoutesGroup
.add(&WifiRouteEntry::new(Some(address)))
for address in 0..ip4RouteLength {
selfImp.resetIP4RoutesGroup.add(&WifiRouteEntry::new(Some(address), selfImp.connection.clone(), IpProtocol::IPv4))
}
}
// IPv6
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();
selfImp.resetIP6DNS.set_text(&ipv6Dns.join(", "));
selfImp.resetIP6Gateway.set_text(&conn.ipv6.gateway);
if conn.ipv6.address_data.is_empty() {
selfImp
.resetIP6AddressGroup
.add(&WifiAddressEntry::new(None))
} else {
for address in conn.ipv6.address_data.iter() {
selfImp
.resetIP6AddressGroup
.add(&WifiAddressEntry::new(Some(address)))
}
for address in 0..ip6AddressLength {
let address = &WifiAddressEntry::new(Some(address), selfImp.connection.clone(), IpProtocol::IPv6);
selfImp.resetIP6AddressGroup.add(address);
}
let address = &WifiAddressEntry::new(None, selfImp.connection.clone(), IpProtocol::IPv6);
selfImp.resetIP6AddressGroup.add(address);
if conn.ipv6.route_data.is_empty() {
selfImp.resetIP6RoutesGroup.add(&WifiRouteEntry::new(None))
if ip6RouteLength == 0 {
selfImp.resetIP6RoutesGroup.add(&WifiRouteEntry::new(None, selfImp.connection.clone(), IpProtocol::IPv6))
} else {
for address in conn.ipv6.route_data.iter() {
selfImp
.resetIP6RoutesGroup
.add(&WifiRouteEntry::new(Some(address)))
for address in 0..ip6RouteLength {
selfImp.resetIP6RoutesGroup.add(&WifiRouteEntry::new(Some(address), selfImp.connection.clone(), IpProtocol::IPv6))
}
}
// Security
dbg!(conn);
}
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);
@ -182,14 +151,12 @@ 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);
@ -207,57 +174,101 @@ 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.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();
}));
// IPv4
let wifiOptionsIP4 = wifiOptions.clone();
imp.resetIP4Method
.connect_selected_notify(clone!(@weak imp => move |dropdown| {
let selected = dropdown.selected();
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);
}));
let dnsRegex = Regex::new(r"^((25[0-5]|(2[0-4]|1\d|[1-9]|)\d)\.?\b){4}$").unwrap();
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.as_str().is_empty() {
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.remove_css_class("error");
return;
conn.ipv4.dns.push(addr.octets().to_vec());
} else {
imp.resetIP4DNS.add_css_class("error");
}
for dnsEntry in dnsInput.as_str().split(',').collect::<Vec<&str>>() {
if dnsRegex.is_match(dnsEntry) {
imp.resetIP4DNS.remove_css_class("error");
let dnsParts = dnsEntry.split('.')
.map(|s| s.parse::<u8>().unwrap())
.collect::<Vec<u8>>();
conn.ipv4.dns.push(dnsParts);
} 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");
}
}));
// IPv6
let wifiOptionsIP6 = wifiOptions.clone();
imp.resetIP6Method
.connect_selected_notify(clone!(@weak imp => move |dropdown| {
let selected = dropdown.selected();
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.remove_css_class("error");
conn.ipv6.dns.push(addr.octets().to_vec());
} else {
imp.resetIP6DNS.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 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");
}
}));
// Security
}
pub fn getValueFromKey(map: &PropMap, key: &str) -> String {
map.get(key).map_or_else(
|| "".to_string(),
|value| value.0.as_str().unwrap_or_default().trim().to_string(),
)
}

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

@ -42,6 +42,8 @@ pub struct WifiOptions {
#[template_child]
pub resetIP4AddressGroup: TemplateChild<PreferencesGroup>,
#[template_child]
pub resetIP4AddressAddButton: TemplateChild<Button>,
#[template_child]
pub resetIP4RoutesGroup: TemplateChild<PreferencesGroup>,
// IPv6
#[template_child]

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

@ -1,10 +1,9 @@
use crate::components::wifi::wifiOptions::getValueFromKey;
use std::cell::RefCell;
use std::rc::Rc;
use adw::glib;
use adw::glib::Object;
use adw::prelude::PreferencesRowExt;
use glib::subclass::prelude::ObjectSubclassIsExt;
use gtk::prelude::EditableExt;
use ReSet_Lib::network::connection::Address;
use ReSet_Lib::network::connection::{Connection};
use crate::components::wifi::utils::IpProtocol;
use crate::components::wifi::wifiRouteEntryImpl;
@ -15,25 +14,24 @@ glib::wrapper! {
}
impl WifiRouteEntry {
pub fn new(address: Option<&Address>) -> Self {
pub fn new(address: Option<usize>, rc: Rc<RefCell<Connection>>, protocol: IpProtocol) -> Self {
let entry: WifiRouteEntry = Object::builder().build();
if let Some(address) = address {
let entryImp = entry.imp();
let map = address.to_map();
let addr = getValueFromKey(&map, "address");
let prefix = getValueFromKey(&map, "prefix-length");
let gateway = getValueFromKey(&map, "gateway");
let metric = getValueFromKey(&map, "metric");
entryImp.resetRouteAddress.set_text(&addr);
entryImp.resetRouteNetmask.set_text(&prefix);
entryImp.resetRouteGateway.set_text(&gateway);
entryImp.resetRouteMetric.set_text(&metric);
entryImp
.resetRouteRow
.set_title(&format!("{}, {}, {}, {}", addr, prefix, gateway, metric));
}
// if let Some(address) = address {
// let entryImp = entry.imp();
// let map = address.to_map();
//
// let addr = getValueFromKey(&map, "address");
// let prefix = getValueFromKey(&map, "prefix-length");
// let gateway = getValueFromKey(&map, "gateway");
// let metric = getValueFromKey(&map, "metric");
//
// entryImp.resetRouteAddress.set_text(&addr);
// entryImp.resetRouteNetmask.set_text(&prefix);
// entryImp.resetRouteGateway.set_text(&gateway);
// entryImp.resetRouteMetric.set_text(&metric);
// entryImp.resetRouteRow.set_title(&format!("{}, {}, {}, {}", addr, prefix, gateway, metric));
// }
entry
}
}

9
src/resources/resetUI.cmb
View file

@ -300,10 +300,11 @@
(21,96,"AdwPasswordEntryRow",None,92,None,None,None,2,None),
(21,97,"GtkLabel",None,53,None,"tab",None,7,None),
(21,98,"GtkButton","wifiOptionsApplyButton",52,None,None,None,1,None),
(21,99,"GtkButton","resetIP4AddressAddButton",73,None,None,None,-1,None),
(22,1,"GtkBox","resetWifiAddressEntry",None,None,None,None,-1,None),
(22,2,"AdwExpanderRow","resetAddressRow",1,None,None,None,-1,None),
(22,3,"AdwEntryRow","resetAddressAddress",2,None,None,None,-1,None),
(22,4,"AdwEntryRow","resetAddressNetmask",2,None,None,None,1,None),
(22,4,"AdwEntryRow","resetAddressPrefix",2,None,None,None,1,None),
(22,5,"GtkButton","resetAddressRemove",1,None,None,None,-1,None),
(23,1,"GtkBox","resetWifiRouteEntry",None,None,None,None,None,None),
(23,2,"AdwExpanderRow","resetRouteRow",1,None,None,None,None,None),
@ -824,6 +825,7 @@
(21,69,"AdwPreferencesRow","title","IPv4 Method",None,None,None,None,None,None,None,None,None),
(21,71,"AdwPreferencesRow","title","DNS (separate IP by comma, empty for automatic)",None,None,None,None,None,None,None,None,None),
(21,72,"AdwPreferencesRow","title","Gateway",None,None,None,None,None,None,None,None,None),
(21,73,"AdwPreferencesGroup","header-suffix",None,None,None,None,None,99,None,None,None,None),
(21,73,"AdwPreferencesGroup","title","Addresses",None,None,None,None,None,None,None,None,None),
(21,73,"GtkWidget","margin-top","10",None,None,None,None,None,None,None,None,None),
(21,74,"AdwPreferencesGroup","header-suffix",None,None,None,None,None,75,None,None,None,None),
@ -856,10 +858,13 @@
(21,98,"GtkButton","label","Apply",None,None,None,None,None,None,None,None,None),
(21,98,"GtkWidget","halign","end",None,None,None,None,None,None,None,None,None),
(21,98,"GtkWidget","margin-top","10",None,None,None,None,None,None,None,None,None),
(21,99,"GtkButton","icon-name","list-add-symbolic",None,None,None,None,None,None,None,None,None),
(22,1,"GtkWidget","margin-bottom","2",None,None,None,None,None,None,None,None,None),
(22,1,"GtkWidget","margin-top","2",None,None,None,None,None,None,None,None,None),
(22,2,"AdwPreferencesRow","title","Add new Address",None,None,None,None,None,None,None,None,None),
(22,2,"GtkWidget","hexpand","True",None,None,None,None,None,None,None,None,None),
(22,3,"AdwPreferencesRow","title","Address",None,None,None,None,None,None,None,None,None),
(22,4,"AdwPreferencesRow","title","Netmask",None,None,None,None,None,None,None,None,None),
(22,4,"AdwPreferencesRow","title","Prefix",None,None,None,None,None,None,None,None,None),
(22,5,"GtkButton","icon-name","edit-delete-symbolic",None,None,None,None,None,None,None,None,None),
(22,5,"GtkWidget","height-request","55",None,None,None,None,None,None,None,None,None),
(22,5,"GtkWidget","valign","start",None,None,None,None,None,None,None,None,None),

6
src/resources/resetWifiAddressEntry.ui
View file

@ -4,6 +4,8 @@
<requires lib="gtk" version="4.12"/>
<requires lib="libadwaita" version="1.2"/>
<template class="resetWifiAddressEntry" parent="GtkBox">
<property name="margin-bottom">2</property>
<property name="margin-top">2</property>
<child>
<object class="AdwExpanderRow" id="resetAddressRow">
<property name="hexpand">True</property>
@ -14,8 +16,8 @@
</object>
</child>
<child>
<object class="AdwEntryRow" id="resetAddressNetmask">
<property name="title">Netmask</property>
<object class="AdwEntryRow" id="resetAddressPrefix">
<property name="title">Prefix</property>
</object>
</child>
</object>

5
src/resources/resetWifiOptions.ui
View file

@ -118,6 +118,11 @@
</child>
<child>
<object class="AdwPreferencesGroup" id="resetIP4AddressGroup">
<property name="header-suffix">
<object class="GtkButton" id="resetIP4AddressAddButton">
<property name="icon-name">list-add-symbolic</property>
</object>
</property>
<property name="margin-top">10</property>
<property name="title">Addresses</property>
</object>