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: snake_case all but UI templates

Browse source
This commit is contained in:
Fabio Lenherr / DashieTM 2023-12-05 15:30:04 +01:00
parent 9f0ca6e8bf
commit 391182607d
55 changed files with 1471 additions and 1427 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
src/components/base/cardEntry.rs → src/components/base/card_entry.rs
View file

@ -10,14 +10,14 @@ use glib::{clone, Cast};
use gtk::{gio, StringList, StringObject};
use ReSet_Lib::audio::audio::Card;
use components::utils::createDropdownLabelFactory;
use components::utils::create_dropdown_label_factory;
use crate::components;
use super::cardEntryImpl;
use super::card_entry_impl;
glib::wrapper! {
pub struct CardEntry(ObjectSubclass<cardEntryImpl::CardEntry>)
pub struct CardEntry(ObjectSubclass<card_entry_impl::CardEntry>)
@extends adw::ComboRow, gtk::Widget,
@implements gtk::Accessible, gtk::Buildable, gtk::ConstraintTarget, gtk::Orientable, adw::PreferencesRow;
}
@ -27,7 +27,7 @@ impl CardEntry {
let entry: CardEntry = Object::builder().build();
{
let imp = entry.imp();
let mut map = imp.resetCardMap.borrow_mut();
let mut map = imp.reset_card_map.borrow_mut();
entry.set_title(&card.name);
let mut index: u32 = 0;
let list = StringList::new(&[]);
@ -52,11 +52,11 @@ impl CardEntry {
let selected = selected.unwrap();
let selected = selected.downcast_ref::<StringObject>().unwrap();
let selected = selected.string().to_string();
let map = imp.resetCardMap.borrow();
let map = imp.reset_card_map.borrow();
let (device_index, profile_name) = map.get(&selected).unwrap();
set_card_profile_of_device(*device_index, profile_name.clone());
}));
entry.set_factory(Some(&createDropdownLabelFactory()));
entry.set_factory(Some(&create_dropdown_label_factory()));
}
entry
}

7
src/components/base/cardEntryImpl.rs → src/components/base/card_entry_impl.rs
View file

@ -8,22 +8,21 @@ use std::collections::HashMap;
use gtk::subclass::prelude::*;
use gtk::{glib, CompositeTemplate};
use super::cardEntry;
use super::card_entry;
#[allow(non_snake_case)]
#[derive(Default, CompositeTemplate)]
#[template(resource = "/org/Xetibo/ReSet/resetCardEntry.ui")]
pub struct CardEntry {
// first string is the alias name, the first return string is the index of the adapter and the
// second the name of the profile
pub resetCardMap: RefCell<HashMap<String, (u32, String)>>,
pub reset_card_map: RefCell<HashMap<String, (u32, String)>>,
}
#[glib::object_subclass]
impl ObjectSubclass for CardEntry {
const ABSTRACT: bool = false;
const NAME: &'static str = "resetCardEntry";
type Type = cardEntry::CardEntry;
type Type = card_entry::CardEntry;
type ParentType = ComboRow;
fn class_init(klass: &mut Self::Class) {

4
src/components/base/listEntry.rs → src/components/base/list_entry.rs
View file

@ -1,11 +1,11 @@
use crate::components::base::listEntryImpl;
use crate::components::base::list_entry_impl;
use adw::glib;
use adw::glib::{IsA, Object};
use gtk::prelude::ListBoxRowExt;
use gtk::Widget;
glib::wrapper! {
pub struct ListEntry(ObjectSubclass<listEntryImpl::ListEntry>)
pub struct ListEntry(ObjectSubclass<list_entry_impl::ListEntry>)
@extends gtk::ListBoxRow, gtk::Widget,
@implements gtk::Accessible, gtk::Buildable, gtk::ConstraintTarget, gtk::Actionable;
}

5
src/components/base/listEntryImpl.rs → src/components/base/list_entry_impl.rs
View file

@ -1,8 +1,7 @@
use crate::components::base::listEntry;
use crate::components::base::list_entry;
use gtk::subclass::prelude::*;
use gtk::{glib, CompositeTemplate};
#[allow(non_snake_case)]
#[derive(Default, CompositeTemplate)]
#[template(resource = "/org/Xetibo/ReSet/resetListBoxRow.ui")]
pub struct ListEntry {}
@ -11,7 +10,7 @@ pub struct ListEntry {}
impl ObjectSubclass for ListEntry {
const ABSTRACT: bool = false;
const NAME: &'static str = "resetListBoxRow";
type Type = listEntry::ListEntry;
type Type = list_entry::ListEntry;
type ParentType = gtk::ListBoxRow;
fn class_init(klass: &mut Self::Class) {

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

@ -1,9 +1,9 @@
pub mod cardEntry;
pub mod cardEntryImpl;
pub mod listEntry;
pub mod listEntryImpl;
pub mod card_entry;
pub mod card_entry_impl;
pub mod list_entry;
pub mod list_entry_impl;
pub mod popup;
pub mod popupImpl;
pub mod settingBox;
pub mod settingBoxImpl;
pub mod popup_impl;
pub mod setting_box;
pub mod setting_box_impl;
pub mod utils;

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

@ -2,10 +2,10 @@ use adw::glib;
use adw::glib::Object;
use gtk::{gdk, Editable, Popover};
use super::popupImpl;
use super::popup_impl;
glib::wrapper! {
pub struct Popup(ObjectSubclass<popupImpl::Popup>)
pub struct Popup(ObjectSubclass<popup_impl::Popup>)
@extends Popover, gtk::Widget,
@implements Editable,gdk::Popup, gtk::Accessible, gtk::Buildable, gtk::ConstraintTarget, gtk::Orientable;
}

2
src/components/base/popupImpl.rs → src/components/base/popup_impl.rs
View file

@ -16,7 +16,7 @@ pub struct Popup {
pub resetPopupEntry: TemplateChild<PasswordEntry>,
#[template_child]
pub resetPopupButton: TemplateChild<Button>,
pub resetPopupText: Arc<RefCell<PasswordEntryBuffer>>,
pub reset_popup_text: Arc<RefCell<PasswordEntryBuffer>>,
}
unsafe impl Send for Popup {}

4
src/components/base/settingBox.rs → src/components/base/setting_box.rs
View file

@ -1,11 +1,11 @@
use crate::components::base::settingBoxImpl;
use crate::components::base::setting_box_impl;
use adw::glib;
use adw::glib::{IsA, Object};
use gtk::prelude::BoxExt;
use gtk::Widget;
glib::wrapper! {
pub struct SettingBox(ObjectSubclass<settingBoxImpl::SettingBox>)
pub struct SettingBox(ObjectSubclass<setting_box_impl::SettingBox>)
@extends gtk::Box, gtk::Widget,
@implements gtk::Accessible, gtk::Buildable, gtk::ConstraintTarget;
}

5
src/components/base/settingBoxImpl.rs → src/components/base/setting_box_impl.rs
View file

@ -1,8 +1,7 @@
use crate::components::base::settingBox;
use crate::components::base::setting_box;
use gtk::subclass::prelude::*;
use gtk::{glib, CompositeTemplate};
#[allow(non_snake_case)]
#[derive(Default, CompositeTemplate)]
#[template(resource = "/org/Xetibo/ReSet/resetSettingBox.ui")]
pub struct SettingBox {}
@ -11,7 +10,7 @@ pub struct SettingBox {}
impl ObjectSubclass for SettingBox {
const ABSTRACT: bool = false;
const NAME: &'static str = "resetSettingBox";
type Type = settingBox::SettingBox;
type Type = setting_box::SettingBox;
type ParentType = gtk::Box;
fn class_init(klass: &mut Self::Class) {

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

@ -19,8 +19,8 @@ use ReSet_Lib::{
};
use crate::components::{
input::sourceBox::{start_input_box_listener, SourceBox},
output::sinkBox::{start_output_box_listener, SinkBox},
input::source_box::{start_input_box_listener, SourceBox},
output::sink_box::{start_output_box_listener, SinkBox},
};
#[derive(Default)]

76
src/components/bluetooth/bluetoothBox.rs → src/components/bluetooth/bluetooth_box.rs
View file

@ -17,13 +17,13 @@ use gtk::{gio, StringObject, Widget};
use ReSet_Lib::bluetooth::bluetooth::{BluetoothAdapter, BluetoothDevice};
use ReSet_Lib::signals::{BluetoothDeviceAdded, BluetoothDeviceChanged, BluetoothDeviceRemoved};
use crate::components::base::listEntry::ListEntry;
use crate::components::base::list_entry::ListEntry;
use crate::components::base::utils::Listeners;
use crate::components::bluetooth::bluetoothBoxImpl;
use crate::components::bluetooth::bluetoothEntry::BluetoothEntry;
use crate::components::bluetooth::bluetooth_box_impl;
use crate::components::bluetooth::bluetooth_entry::BluetoothEntry;
glib::wrapper! {
pub struct BluetoothBox(ObjectSubclass<bluetoothBoxImpl::BluetoothBox>)
pub struct BluetoothBox(ObjectSubclass<bluetooth_box_impl::BluetoothBox>)
@extends gtk::Box, gtk::Widget,
@implements gtk::Accessible, gtk::Buildable, gtk::ConstraintTarget, gtk::Orientable;
}
@ -34,13 +34,11 @@ unsafe impl Sync for BluetoothBox {}
impl BluetoothBox {
pub fn new(listeners: Arc<Listeners>) -> Arc<Self> {
let obj: Arc<Self> = Arc::new(Object::builder().build());
setupCallbacks(listeners, obj)
setup_callbacks(listeners, obj)
}
pub fn setupCallbacks(&self) {}
}
fn setupCallbacks(
fn setup_callbacks(
listeners: Arc<Listeners>,
bluetooth_box: Arc<BluetoothBox>,
) -> Arc<BluetoothBox> {
@ -58,21 +56,28 @@ fn setupCallbacks(
imp.resetBluetoothSwitch.connect_state_set(move |_, state| {
if !state {
let imp = bluetooth_box_ref.imp();
for x in imp.resetBluetoothConnectedDevices.observe_children().iter::<Object>() {
if let Ok(entry) = x { // todo test this
if let Some(item) = entry.downcast_ref::<Widget>() {
imp.resetBluetoothAvailableDevices.remove(item);
}
for x in imp
.resetBluetoothConnectedDevices
.observe_children()
.iter::<Object>()
.flatten()
{
// todo test this
if let Some(item) = x.downcast_ref::<Widget>() {
imp.resetBluetoothAvailableDevices.remove(item);
}
};
}
listeners.bluetooth_listener.store(false, Ordering::SeqCst);
set_adapter_enabled(
imp.resetCurrentBluetoothAdapter.borrow().path.clone(),
imp.reset_current_bluetooth_adapter.borrow().path.clone(),
false,
);
} else {
let imp = bluetooth_box_ref.imp();
set_adapter_enabled(imp.resetCurrentBluetoothAdapter.borrow().path.clone(), true);
set_adapter_enabled(
imp.reset_current_bluetooth_adapter.borrow().path.clone(),
true,
);
start_bluetooth_listener(listeners.clone(), bluetooth_box_ref.clone());
}
glib::Propagation::Proceed
@ -87,10 +92,10 @@ pub fn populate_conntected_bluetooth_devices(bluetooth_box: Arc<BluetoothBox>) {
let adapters = get_bluetooth_adapters();
{
let imp = bluetooth_box.imp();
let list = imp.resetModelList.write().unwrap();
let mut model_index = imp.resetModelIndex.write().unwrap();
let mut map = imp.resetBluetoothAdapters.write().unwrap();
imp.resetCurrentBluetoothAdapter
let list = imp.reset_model_list.write().unwrap();
let mut model_index = imp.reset_model_index.write().unwrap();
let mut map = imp.reset_bluetooth_adapters.write().unwrap();
imp.reset_current_bluetooth_adapter
.replace(adapters.last().unwrap().clone());
for (index, adapter) in adapters.into_iter().enumerate() {
list.append(&adapter.alias);
@ -102,10 +107,10 @@ pub fn populate_conntected_bluetooth_devices(bluetooth_box: Arc<BluetoothBox>) {
glib::idle_add_once(move || {
let imp = ref_box.imp();
let list = imp.resetModelList.read().unwrap();
let list = imp.reset_model_list.read().unwrap();
imp.resetBluetoothAdapter.set_model(Some(&*list));
let map = imp.resetBluetoothAdapters.read().unwrap();
let device = imp.resetCurrentBluetoothAdapter.borrow();
let map = imp.reset_bluetooth_adapters.read().unwrap();
let device = imp.reset_current_bluetooth_adapter.borrow();
if let Some(index) = map.get(&device.alias) {
imp.resetBluetoothAdapter.set_selected(index.1);
}
@ -119,7 +124,7 @@ pub fn populate_conntected_bluetooth_devices(bluetooth_box: Arc<BluetoothBox>) {
let selected = selected.downcast_ref::<StringObject>().unwrap();
let selected = selected.string().to_string();
let device = imp.resetBluetoothAdapters.read().unwrap();
let device = imp.reset_bluetooth_adapters.read().unwrap();
let device = device.get(&selected);
if device.is_none() {
return;
@ -133,7 +138,7 @@ pub fn populate_conntected_bluetooth_devices(bluetooth_box: Arc<BluetoothBox>) {
let connected = device.connected;
let bluetooth_entry = Arc::new(BluetoothEntry::new(&device));
let entry = Arc::new(ListEntry::new(&*bluetooth_entry));
imp.availableDevices
imp.available_devices
.borrow_mut()
.insert(path, (bluetooth_entry.clone(), entry.clone(), device));
if connected {
@ -197,7 +202,7 @@ pub fn start_bluetooth_listener(listeners: Arc<Listeners>, bluetooth_box: Arc<Bl
let connected = ir.bluetooth_device.connected;
let bluetooth_entry = Arc::new(BluetoothEntry::new(&ir.bluetooth_device));
let entry = Arc::new(ListEntry::new(&*bluetooth_entry));
imp.availableDevices.borrow_mut().insert(
imp.available_devices.borrow_mut().insert(
path,
(bluetooth_entry.clone(), entry.clone(), ir.bluetooth_device),
);
@ -221,7 +226,7 @@ pub fn start_bluetooth_listener(listeners: Arc<Listeners>, bluetooth_box: Arc<Bl
glib::spawn_future(async move {
glib::idle_add_once(move || {
let imp = bluetooth_box.imp();
let map = imp.availableDevices.borrow_mut();
let map = imp.available_devices.borrow_mut();
if let Some(list_entry) = map.get(&ir.bluetooth_device) {
imp.resetBluetoothConnectedDevices.remove(&*list_entry.1);
}
@ -240,7 +245,7 @@ pub fn start_bluetooth_listener(listeners: Arc<Listeners>, bluetooth_box: Arc<Bl
glib::spawn_future(async move {
glib::idle_add_once(move || {
let imp = bluetooth_box.imp();
let map = imp.availableDevices.borrow_mut();
let map = imp.available_devices.borrow_mut();
if let Some(list_entry) = map.get(&ir.bluetooth_device.path) {
if list_entry.2.connected != ir.bluetooth_device.connected {
if ir.bluetooth_device.connected {
@ -279,13 +284,16 @@ pub fn start_bluetooth_listener(listeners: Arc<Listeners>, bluetooth_box: Arc<Bl
glib::spawn_future(async move {
glib::idle_add_once(move || {
let imp = loop_box.imp();
for x in imp.resetBluetoothAvailableDevices.observe_children().iter::<Object>() {
if let Ok(entry) = x { // todo test this
if let Some(item) = entry.downcast_ref::<Widget>() {
imp.resetBluetoothAvailableDevices.remove(item);
}
for x in imp
.resetBluetoothAvailableDevices
.observe_children()
.iter::<Object>()
.flatten()
{
if let Some(item) = x.downcast_ref::<Widget>() {
imp.resetBluetoothAvailableDevices.remove(item);
}
};
}
});
});
println!("stopping bluetooth listener");

24
src/components/bluetooth/bluetoothBoxImpl.rs → src/components/bluetooth/bluetooth_box_impl.rs
View file

@ -1,16 +1,16 @@
use adw::{ActionRow, ComboRow};
use dbus::Path;
use gtk::subclass::prelude::*;
use gtk::{glib, CompositeTemplate, ListBox, Switch, Button};
use gtk::{glib, Button, CompositeTemplate, Switch};
use gtk::{prelude::*, StringList};
use std::cell::RefCell;
use std::collections::HashMap;
use std::sync::{Arc, RwLock};
use ReSet_Lib::bluetooth::bluetooth::{BluetoothAdapter, BluetoothDevice};
use crate::components::base::listEntry::ListEntry;
use crate::components::bluetooth::bluetoothBox;
use crate::components::bluetooth::bluetoothEntry::BluetoothEntry;
use crate::components::base::list_entry::ListEntry;
use crate::components::bluetooth::bluetooth_box;
use crate::components::bluetooth::bluetooth_entry::BluetoothEntry;
type BluetoothMap =
RefCell<HashMap<Path<'static>, (Arc<BluetoothEntry>, Arc<ListEntry>, BluetoothDevice)>>;
@ -33,19 +33,19 @@ pub struct BluetoothBox {
pub resetVisibility: TemplateChild<ActionRow>,
#[template_child]
pub resetBluetoothMainTab: TemplateChild<ListEntry>,
pub availableDevices: BluetoothMap,
pub connectedDevices: BluetoothMap,
pub resetBluetoothAdapters: Arc<RwLock<HashMap<String, (BluetoothAdapter, u32)>>>,
pub resetCurrentBluetoothAdapter: Arc<RefCell<BluetoothAdapter>>,
pub resetModelList: Arc<RwLock<StringList>>,
pub resetModelIndex: Arc<RwLock<u32>>,
pub available_devices: BluetoothMap,
pub connected_devices: BluetoothMap,
pub reset_bluetooth_adapters: Arc<RwLock<HashMap<String, (BluetoothAdapter, u32)>>>,
pub reset_current_bluetooth_adapter: Arc<RefCell<BluetoothAdapter>>,
pub reset_model_list: Arc<RwLock<StringList>>,
pub reset_model_index: Arc<RwLock<u32>>,
}
#[glib::object_subclass]
impl ObjectSubclass for BluetoothBox {
const ABSTRACT: bool = false;
const NAME: &'static str = "resetBluetooth";
type Type = bluetoothBox::BluetoothBox;
type Type = bluetooth_box::BluetoothBox;
type ParentType = gtk::Box;
fn class_init(klass: &mut Self::Class) {
@ -62,8 +62,6 @@ impl ObjectSubclass for BluetoothBox {
impl ObjectImpl for BluetoothBox {
fn constructed(&self) {
self.parent_constructed();
let obj = self.obj();
obj.setupCallbacks();
}
}

20
src/components/bluetooth/bluetoothEntry.rs → src/components/bluetooth/bluetooth_entry.rs
View file

@ -1,7 +1,7 @@
use std::sync::Arc;
use std::time::Duration;
use crate::components::bluetooth::bluetoothEntryImpl;
use crate::components::bluetooth::bluetooth_entry_impl;
use adw::glib;
use adw::glib::Object;
use adw::subclass::prelude::ObjectSubclassIsExt;
@ -12,7 +12,7 @@ use gtk::{gio, GestureClick};
use ReSet_Lib::bluetooth::bluetooth::BluetoothDevice;
glib::wrapper! {
pub struct BluetoothEntry(ObjectSubclass<bluetoothEntryImpl::BluetoothEntry>)
pub struct BluetoothEntry(ObjectSubclass<bluetooth_entry_impl::BluetoothEntry>)
@extends gtk::Box, gtk::Widget,
@implements gtk::Accessible, gtk::Buildable, gtk::Actionable, gtk::ConstraintTarget;
}
@ -23,28 +23,28 @@ unsafe impl Sync for BluetoothEntry {}
impl BluetoothEntry {
pub fn new(device: &BluetoothDevice) -> Self {
let entry: BluetoothEntry = Object::builder().build();
let entryImp = entry.imp();
entryImp.resetBluetoothLabel.get().set_text(&device.alias);
entryImp
let entry_imp = entry.imp();
entry_imp.resetBluetoothLabel.get().set_text(&device.alias);
entry_imp
.resetBluetoothAddress
.get()
.set_text(&device.address);
if device.icon.is_empty() {
entryImp
entry_imp
.resetBluetoothDeviceType
.set_icon_name(Some("dialog-question-symbolic"));
} else {
entryImp
entry_imp
.resetBluetoothDeviceType
.set_icon_name(Some(&device.icon));
}
if device.paired {
entryImp.resetBluetoothButton.set_sensitive(true);
entry_imp.resetBluetoothButton.set_sensitive(true);
} else {
entryImp.resetBluetoothButton.set_sensitive(false);
entry_imp.resetBluetoothButton.set_sensitive(false);
}
let path = Arc::new(device.path.clone());
entryImp.resetBluetoothButton.connect_clicked(move |_| {
entry_imp.resetBluetoothButton.connect_clicked(move |_| {
remove_device_pairing((*path).clone());
});
let gesture = GestureClick::new();

6
src/components/bluetooth/bluetoothEntryImpl.rs → src/components/bluetooth/bluetooth_entry_impl.rs
View file

@ -1,4 +1,4 @@
use crate::components::bluetooth::bluetoothEntry;
use crate::components::bluetooth::bluetooth_entry;
use gtk::subclass::prelude::*;
use gtk::{glib, Button, CompositeTemplate, Image, Label};
use std::cell::RefCell;
@ -15,14 +15,14 @@ pub struct BluetoothEntry {
pub resetBluetoothAddress: TemplateChild<Label>,
#[template_child]
pub resetBluetoothButton: TemplateChild<Button>,
pub deviceName: RefCell<String>,
pub device_name: RefCell<String>,
}
#[glib::object_subclass]
impl ObjectSubclass for BluetoothEntry {
const ABSTRACT: bool = false;
const NAME: &'static str = "resetBluetoothEntry";
type Type = bluetoothEntry::BluetoothEntry;
type Type = bluetooth_entry::BluetoothEntry;
type ParentType = gtk::Box;
fn class_init(klass: &mut Self::Class) {

9
src/components/bluetooth/mod.rs
View file

@ -1,5 +1,4 @@
#![allow(non_snake_case)]
pub mod bluetoothBox;
pub mod bluetoothBoxImpl;
pub mod bluetoothEntry;
pub mod bluetoothEntryImpl;
pub mod bluetooth_box;
pub mod bluetooth_box_impl;
pub mod bluetooth_entry;
pub mod bluetooth_entry_impl;

13
src/components/input/mod.rs
View file

@ -1,7 +1,6 @@
#![allow(non_snake_case)]
pub mod outputStreamEntry;
pub mod outputStreamEntryImpl;
pub mod sourceBox;
pub mod sourceBoxImpl;
pub mod sourceEntry;
pub mod sourceEntryImpl;
pub mod output_stream_entry;
pub mod output_stream_entry_impl;
pub mod source_box;
pub mod source_box_impl;
pub mod source_entry;
pub mod source_entry_impl;

24
src/components/input/outputStreamEntry.rs → src/components/input/output_stream_entry.rs
View file

@ -1,7 +1,7 @@
use std::sync::Arc;
use std::time::{Duration, SystemTime};
use crate::components::utils::{createDropdownLabelFactory, setComboRowEllipsis};
use crate::components::utils::{create_dropdown_label_factory, set_combo_row_ellipsis};
use adw::glib;
use adw::glib::Object;
use adw::prelude::{ButtonExt, ComboRowExt, PreferencesRowExt, RangeExt};
@ -12,11 +12,11 @@ use glib::{clone, Cast, Propagation};
use gtk::{gio, StringObject};
use ReSet_Lib::audio::audio::OutputStream;
use super::outputStreamEntryImpl;
use super::sourceBox::SourceBox;
use super::output_stream_entry_impl;
use super::source_box::SourceBox;
glib::wrapper! {
pub struct OutputStreamEntry(ObjectSubclass<outputStreamEntryImpl::OutputStreamEntry>)
pub struct OutputStreamEntry(ObjectSubclass<output_stream_entry_impl::OutputStreamEntry>)
@extends adw::PreferencesGroup, gtk::Widget,
@implements gtk::Accessible, gtk::Buildable, gtk::ConstraintTarget, gtk::Orientable;
}
@ -34,8 +34,8 @@ impl OutputStreamEntry {
let name = stream.application_name.clone() + ": " + stream.name.as_str();
imp.resetSourceSelection.set_title(name.as_str());
imp.resetSourceSelection
.set_factory(Some(&createDropdownLabelFactory()));
setComboRowEllipsis(imp.resetSourceSelection.get());
.set_factory(Some(&create_dropdown_label_factory()));
set_combo_row_ellipsis(imp.resetSourceSelection.get());
let volume = stream.volume.first().unwrap_or(&0_u32);
let fraction = (*volume as f64 / 655.36).round();
let percentage = (fraction).to_string() + "%";
@ -55,7 +55,7 @@ impl OutputStreamEntry {
let index = stream.index;
let channels = stream.channels;
{
let mut time = imp.volumeTimeStamp.borrow_mut();
let mut time = imp.volume_time_stamp.borrow_mut();
if time.is_some()
&& time.unwrap().elapsed().unwrap() < Duration::from_millis(50)
{
@ -68,12 +68,12 @@ impl OutputStreamEntry {
}),
);
{
let list = box_imp.resetModelList.read().unwrap();
let list = box_imp.reset_model_list.read().unwrap();
imp.resetSourceSelection.set_model(Some(&*list));
let map = box_imp.resetSourceMap.write().unwrap();
let mut name = box_imp.resetDefaultSource.try_borrow();
let map = box_imp.reset_source_map.write().unwrap();
let mut name = box_imp.reset_default_source.try_borrow();
while name.is_err() {
name = box_imp.resetDefaultSource.try_borrow();
name = box_imp.reset_default_source.try_borrow();
}
let name = name.unwrap();
let name = &name.alias;
@ -91,7 +91,7 @@ impl OutputStreamEntry {
let selected = selected.unwrap();
let selected = selected.downcast_ref::<StringObject>().unwrap();
let selected = selected.string().to_string();
let source = box_imp.resetSourceMap.write().unwrap();
let source = box_imp.reset_source_map.write().unwrap();
let source = source.get(&selected);
if source.is_none() {
return;

8
src/components/input/outputStreamEntryImpl.rs → src/components/input/output_stream_entry_impl.rs
View file

@ -4,7 +4,7 @@ use std::cell::RefCell;
use std::sync::Arc;
use std::time::SystemTime;
use crate::components::input::outputStreamEntry;
use crate::components::input::output_stream_entry;
use gtk::subclass::prelude::*;
use gtk::{glib, Button, CompositeTemplate, Label, ProgressBar, Scale};
use ReSet_Lib::audio::audio::OutputStream;
@ -24,15 +24,15 @@ pub struct OutputStreamEntry {
#[template_child]
pub resetVolumeMeter: TemplateChild<ProgressBar>,
pub stream: Arc<RefCell<OutputStream>>,
pub associatedSource: Arc<RefCell<(u32, String)>>,
pub volumeTimeStamp: RefCell<Option<SystemTime>>,
pub associated_source: Arc<RefCell<(u32, String)>>,
pub volume_time_stamp: RefCell<Option<SystemTime>>,
}
#[glib::object_subclass]
impl ObjectSubclass for OutputStreamEntry {
const ABSTRACT: bool = false;
const NAME: &'static str = "resetOutputStreamEntry";
type Type = outputStreamEntry::OutputStreamEntry;
type Type = output_stream_entry::OutputStreamEntry;
type ParentType = PreferencesGroup;
fn class_init(klass: &mut Self::Class) {

110
src/components/input/sourceBox.rs → src/components/input/source_box.rs
View file

@ -16,21 +16,21 @@ use gtk::prelude::ActionableExt;
use gtk::{gio, StringObject};
use ReSet_Lib::audio::audio::{Card, OutputStream, Source};
use crate::components::base::cardEntry::CardEntry;
use crate::components::base::listEntry::ListEntry;
use crate::components::base::card_entry::CardEntry;
use crate::components::base::list_entry::ListEntry;
use crate::components::base::utils::{
OutputStreamAdded, OutputStreamChanged, OutputStreamRemoved, SourceAdded, SourceChanged,
SourceRemoved,
};
use crate::components::input::sourceBoxImpl;
use crate::components::input::sourceEntry::set_source_volume;
use crate::components::utils::{createDropdownLabelFactory, setComboRowEllipsis};
use crate::components::input::source_box_impl;
use crate::components::input::source_entry::set_source_volume;
use crate::components::utils::{create_dropdown_label_factory, set_combo_row_ellipsis};
use super::outputStreamEntry::OutputStreamEntry;
use super::sourceEntry::{set_default_source, toggle_source_mute, SourceEntry};
use super::output_stream_entry::OutputStreamEntry;
use super::source_entry::{set_default_source, toggle_source_mute, SourceEntry};
glib::wrapper! {
pub struct SourceBox(ObjectSubclass<sourceBoxImpl::SourceBox>)
pub struct SourceBox(ObjectSubclass<source_box_impl::SourceBox>)
@extends gtk::Box, gtk::Widget,
@implements gtk::Accessible, gtk::Buildable, gtk::ConstraintTarget, gtk::Orientable;
}
@ -43,37 +43,37 @@ impl SourceBox {
Object::builder().build()
}
pub fn setupCallbacks(&self) {
let selfImp = self.imp();
selfImp.resetSourceRow.set_activatable(true);
selfImp
pub fn setup_callbacks(&self) {
let self_imp = self.imp();
self_imp.resetSourceRow.set_activatable(true);
self_imp
.resetSourceRow
.set_action_name(Some("navigation.push"));
selfImp
self_imp
.resetSourceRow
.set_action_target_value(Some(&Variant::from("sources")));
selfImp.resetCardsRow.set_activatable(true);
selfImp
self_imp.resetCardsRow.set_activatable(true);
self_imp
.resetCardsRow
.set_action_name(Some("navigation.push"));
selfImp
self_imp
.resetCardsRow
.set_action_target_value(Some(&Variant::from("profileConfiguration")));
selfImp.resetOutputStreamButton.set_activatable(true);
selfImp
self_imp.resetOutputStreamButton.set_activatable(true);
self_imp
.resetOutputStreamButton
.set_action_name(Some("navigation.pop"));
selfImp.resetInputCardsBackButton.set_activatable(true);
selfImp
self_imp.resetInputCardsBackButton.set_activatable(true);
self_imp
.resetInputCardsBackButton
.set_action_name(Some("navigation.pop"));
selfImp
self_imp
.resetSourceDropdown
.set_factory(Some(&createDropdownLabelFactory()));
setComboRowEllipsis(selfImp.resetSourceDropdown.get());
.set_factory(Some(&create_dropdown_label_factory()));
set_combo_row_ellipsis(self_imp.resetSourceDropdown.get());
}
}
@ -88,9 +88,9 @@ pub fn populate_sources(input_box: Arc<SourceBox>) {
let output_box_imp = input_box.imp();
let sources = get_sources();
{
let list = output_box_imp.resetModelList.write().unwrap();
let mut map = output_box_imp.resetSourceMap.write().unwrap();
let mut model_index = output_box_imp.resetModelIndex.write().unwrap();
let list = output_box_imp.reset_model_list.write().unwrap();
let mut map = output_box_imp.reset_source_map.write().unwrap();
let mut model_index = output_box_imp.reset_model_index.write().unwrap();
for (i, source) in (0_u32..).zip(sources.iter()) {
list.append(&source.alias);
map.insert(source.alias.clone(), (source.index, i, source.name.clone()));
@ -98,7 +98,7 @@ pub fn populate_sources(input_box: Arc<SourceBox>) {
}
}
output_box_imp
.resetDefaultSource
.reset_default_source
.replace(get_default_source());
populate_outputstreams(input_box.clone());
@ -110,7 +110,7 @@ pub fn populate_sources(input_box: Arc<SourceBox>) {
let output_box_ref = input_box.clone();
{
let output_box_imp = output_box_ref.imp();
let default_sink = output_box_imp.resetDefaultSource.clone();
let default_sink = output_box_imp.reset_default_source.clone();
let source = default_sink.borrow();
let volume = source.volume.first().unwrap_or(&0_u32);
@ -118,17 +118,17 @@ pub fn populate_sources(input_box: Arc<SourceBox>) {
let percentage = (fraction).to_string() + "%";
output_box_imp.resetVolumePercentage.set_text(&percentage);
output_box_imp.resetVolumeSlider.set_value(*volume as f64);
let mut list = output_box_imp.resetSourceList.write().unwrap();
let mut list = output_box_imp.reset_source_list.write().unwrap();
for stream in sources {
let index = source.index;
let alias = source.alias.clone();
let mut is_default = false;
if output_box_imp.resetDefaultSource.borrow().name == stream.name {
if output_box_imp.reset_default_source.borrow().name == stream.name {
is_default = true;
}
let source_entry = Arc::new(SourceEntry::new(
is_default,
output_box_imp.resetDefaultCheckButton.clone(),
output_box_imp.reset_default_check_button.clone(),
stream,
));
let source_clone = source_entry.clone();
@ -137,10 +137,10 @@ pub fn populate_sources(input_box: Arc<SourceBox>) {
list.insert(index, (entry.clone(), source_clone, alias));
output_box_imp.resetSources.append(&*entry);
}
let list = output_box_imp.resetModelList.read().unwrap();
let list = output_box_imp.reset_model_list.read().unwrap();
output_box_imp.resetSourceDropdown.set_model(Some(&*list));
let map = output_box_imp.resetSourceMap.read().unwrap();
let name = output_box_imp.resetDefaultSource.borrow();
let map = output_box_imp.reset_source_map.read().unwrap();
let name = output_box_imp.reset_default_source.borrow();
if let Some(index) = map.get(&name.alias) {
output_box_imp.resetSourceDropdown.set_selected(index.1);
}
@ -154,7 +154,7 @@ pub fn populate_sources(input_box: Arc<SourceBox>) {
let selected = selected.downcast_ref::<StringObject>().unwrap();
let selected = selected.string().to_string();
let source = output_box_imp.resetSourceMap.read().unwrap();
let source = output_box_imp.reset_source_map.read().unwrap();
let source = source.get(&selected);
if source.is_none() {
return;
@ -172,11 +172,11 @@ pub fn populate_sources(input_box: Arc<SourceBox>) {
let fraction = (value / 655.36).round();
let percentage = (fraction).to_string() + "%";
imp.resetVolumePercentage.set_text(&percentage);
let source = imp.resetDefaultSource.borrow();
let source = imp.reset_default_source.borrow();
let index = source.index;
let channels = source.channels;
{
let mut time = imp.volumeTimeStamp.borrow_mut();
let mut time = imp.volume_time_stamp.borrow_mut();
if time.is_some()
&& time.unwrap().elapsed().unwrap() < Duration::from_millis(50)
{
@ -193,7 +193,7 @@ pub fn populate_sources(input_box: Arc<SourceBox>) {
.resetSourceMute
.connect_clicked(move |_| {
let imp = output_box_ref_mute.imp();
let stream = imp.resetDefaultSource.clone();
let stream = imp.reset_default_source.clone();
let mut stream = stream.borrow_mut();
stream.muted = !stream.muted;
let muted = stream.muted;
@ -220,7 +220,7 @@ pub fn populate_outputstreams(input_box: Arc<SourceBox>) {
glib::spawn_future(async move {
glib::idle_add_once(move || {
let input_box_imp = input_box_ref.imp();
let mut list = input_box_imp.resetOutputStreamList.write().unwrap();
let mut list = input_box_imp.reset_output_stream_list.write().unwrap();
for stream in streams {
let index = stream.index;
let input_stream = Arc::new(OutputStreamEntry::new(input_box.clone(), stream));
@ -355,17 +355,17 @@ pub fn start_input_box_listener(conn: Connection, source_box: Arc<SourceBox>) ->
glib::idle_add_once(move || {
let output_box = source_box.clone();
let output_box_imp = output_box.imp();
let mut list = output_box_imp.resetSourceList.write().unwrap();
let mut list = output_box_imp.reset_source_list.write().unwrap();
let source_index = ir.source.index;
let alias = ir.source.alias.clone();
let name = ir.source.name.clone();
let mut is_default = false;
if output_box_imp.resetDefaultSource.borrow().name == ir.source.name {
if output_box_imp.reset_default_source.borrow().name == ir.source.name {
is_default = true;
}
let source_entry = Arc::new(SourceEntry::new(
is_default,
output_box_imp.resetDefaultCheckButton.clone(),
output_box_imp.reset_default_check_button.clone(),
ir.source,
));
let source_clone = source_entry.clone();
@ -373,10 +373,10 @@ pub fn start_input_box_listener(conn: Connection, source_box: Arc<SourceBox>) ->
entry.set_activatable(false);
list.insert(source_index, (entry.clone(), source_clone, alias.clone()));
output_box_imp.resetSources.append(&*entry);
let mut map = output_box_imp.resetSourceMap.write().unwrap();
let mut index = output_box_imp.resetModelIndex.write().unwrap();
let mut map = output_box_imp.reset_source_map.write().unwrap();
let mut index = output_box_imp.reset_model_index.write().unwrap();
output_box_imp
.resetModelList
.reset_model_list
.write()
.unwrap()
.append(&alias);
@ -398,7 +398,7 @@ pub fn start_input_box_listener(conn: Connection, source_box: Arc<SourceBox>) ->
glib::idle_add_once(move || {
let output_box = source_box.clone();
let output_box_imp = output_box.imp();
let mut list = output_box_imp.resetSourceList.write().unwrap();
let mut list = output_box_imp.reset_source_list.write().unwrap();
let entry = list.get(&ir.index);
if entry.is_none() {
return;
@ -409,16 +409,16 @@ pub fn start_input_box_listener(conn: Connection, source_box: Arc<SourceBox>) ->
if alias.is_none() {
return;
}
let mut map = output_box_imp.resetSourceMap.write().unwrap();
let mut map = output_box_imp.reset_source_map.write().unwrap();
let entry_index = map.remove(&alias.unwrap().2);
if let Some(entry_index) = entry_index {
output_box_imp
.resetModelList
.reset_model_list
.write()
.unwrap()
.remove(entry_index.1);
}
let mut index = output_box_imp.resetModelIndex.write().unwrap();
let mut index = output_box_imp.reset_model_index.write().unwrap();
if *index != 0 {
*index -= 1;
}
@ -442,7 +442,7 @@ pub fn start_input_box_listener(conn: Connection, source_box: Arc<SourceBox>) ->
let volume = ir.source.volume.first().unwrap_or(&0_u32);
let fraction = (*volume as f64 / 655.36).round();
let percentage = (fraction).to_string() + "%";
let list = output_box_imp.resetSourceList.read().unwrap();
let list = output_box_imp.reset_source_list.read().unwrap();
let entry = list.get(&ir.source.index);
if entry.is_none() {
return;
@ -474,7 +474,7 @@ pub fn start_input_box_listener(conn: Connection, source_box: Arc<SourceBox>) ->
glib::idle_add_once(move || {
let output_box = source_box.clone();
let output_box_imp = output_box.imp();
let mut list = output_box_imp.resetOutputStreamList.write().unwrap();
let mut list = output_box_imp.reset_output_stream_list.write().unwrap();
let index = ir.stream.index;
let output_stream = Arc::new(OutputStreamEntry::new(output_box.clone(), ir.stream));
let output_stream_clone = output_stream.clone();
@ -497,7 +497,7 @@ pub fn start_input_box_listener(conn: Connection, source_box: Arc<SourceBox>) ->
let imp = output_stream_changed_box.imp();
let alias: String;
{
let source_list = imp.resetSourceList.read().unwrap();
let source_list = imp.reset_source_list.read().unwrap();
if let Some(alias_opt) = source_list.get(&ir.stream.source_index) {
alias = alias_opt.2.clone();
} else {
@ -511,7 +511,7 @@ pub fn start_input_box_listener(conn: Connection, source_box: Arc<SourceBox>) ->
let output_box_imp = output_box.imp();
let entry: Arc<OutputStreamEntry>;
{
let list = output_box_imp.resetOutputStreamList.read().unwrap();
let list = output_box_imp.reset_output_stream_list.read().unwrap();
let entry_opt = list.get(&ir.stream.index);
if entry_opt.is_none() {
return;
@ -533,7 +533,7 @@ pub fn start_input_box_listener(conn: Connection, source_box: Arc<SourceBox>) ->
let percentage = (fraction).to_string() + "%";
imp.resetVolumePercentage.set_text(&percentage);
imp.resetVolumeSlider.set_value(*volume as f64);
let map = output_box_imp.resetSourceMap.read().unwrap();
let map = output_box_imp.reset_source_map.read().unwrap();
if let Some(index) = map.get(&alias) {
imp.resetSourceSelection.set_selected(index.1);
}
@ -555,7 +555,7 @@ pub fn start_input_box_listener(conn: Connection, source_box: Arc<SourceBox>) ->
glib::idle_add_once(move || {
let output_box = source_box.clone();
let output_box_imp = output_box.imp();
let mut list = output_box_imp.resetOutputStreamList.write().unwrap();
let mut list = output_box_imp.reset_output_stream_list.write().unwrap();
let entry = list.remove(&ir.index);
if entry.is_none() {
return;

28
src/components/input/sourceBoxImpl.rs → src/components/input/source_box_impl.rs
View file

@ -4,15 +4,15 @@ use std::collections::HashMap;
use std::sync::{Arc, RwLock};
use std::time::SystemTime;
use crate::components::base::listEntry::ListEntry;
use crate::components::input::sourceBox;
use crate::components::base::list_entry::ListEntry;
use crate::components::input::source_box;
use gtk::subclass::prelude::*;
use gtk::{glib, CheckButton, CompositeTemplate, StringList, TemplateChild};
use gtk::{prelude::*, Button, Label, ProgressBar, Scale};
use ReSet_Lib::audio::audio::Source;
use super::outputStreamEntry::OutputStreamEntry;
use super::sourceEntry::SourceEntry;
use super::output_stream_entry::OutputStreamEntry;
use super::source_entry::SourceEntry;
type SourceEntryMap = Arc<RwLock<HashMap<u32, (Arc<ListEntry>, Arc<SourceEntry>, String)>>>;
type OutputStreamEntryMap = Arc<RwLock<HashMap<u32, (Arc<ListEntry>, Arc<OutputStreamEntry>)>>>;
@ -46,23 +46,23 @@ pub struct SourceBox {
pub resetInputCardsBackButton: TemplateChild<ActionRow>,
#[template_child]
pub resetCards: TemplateChild<PreferencesGroup>,
pub resetDefaultCheckButton: Arc<CheckButton>,
pub resetDefaultSource: Arc<RefCell<Source>>,
pub resetSourceList: SourceEntryMap,
pub resetOutputStreamList: OutputStreamEntryMap,
pub resetModelList: Arc<RwLock<StringList>>,
pub resetModelIndex: Arc<RwLock<u32>>,
pub reset_default_check_button: Arc<CheckButton>,
pub reset_default_source: Arc<RefCell<Source>>,
pub reset_source_list: SourceEntryMap,
pub reset_output_stream_list: OutputStreamEntryMap,
pub reset_model_list: Arc<RwLock<StringList>>,
pub reset_model_index: Arc<RwLock<u32>>,
// first u32 is the index of the source, the second the index in the model list and the third is
// the full name
pub resetSourceMap: SourceMap,
pub volumeTimeStamp: RefCell<Option<SystemTime>>,
pub reset_source_map: SourceMap,
pub volume_time_stamp: RefCell<Option<SystemTime>>,
}
#[glib::object_subclass]
impl ObjectSubclass for SourceBox {
const ABSTRACT: bool = false;
const NAME: &'static str = "resetAudioInput";
type Type = sourceBox::SourceBox;
type Type = source_box::SourceBox;
type ParentType = gtk::Box;
fn class_init(klass: &mut Self::Class) {
@ -82,7 +82,7 @@ impl BoxImpl for SourceBox {}
impl ObjectImpl for SourceBox {
fn constructed(&self) {
let obj = self.obj();
obj.setupCallbacks();
obj.setup_callbacks();
}
}

6
src/components/input/sourceEntry.rs → src/components/input/source_entry.rs
View file

@ -11,10 +11,10 @@ use glib::{clone, Propagation};
use gtk::{gio, CheckButton};
use ReSet_Lib::audio::audio::Source;
use super::sourceEntryImpl;
use super::source_entry_impl;
glib::wrapper! {
pub struct SourceEntry(ObjectSubclass<sourceEntryImpl::SourceEntry>)
pub struct SourceEntry(ObjectSubclass<source_entry_impl::SourceEntry>)
@extends adw::PreferencesGroup, gtk::Widget,
@implements gtk::Accessible, gtk::Buildable, gtk::ConstraintTarget, gtk::Orientable;
}
@ -45,7 +45,7 @@ impl SourceEntry {
let index = source.index;
let channels = source.channels;
{
let mut time = imp.volumeTimeStamp.borrow_mut();
let mut time = imp.volume_time_stamp.borrow_mut();
if time.is_some()
&& time.unwrap().elapsed().unwrap() < Duration::from_millis(50)
{

6
src/components/input/sourceEntryImpl.rs → src/components/input/source_entry_impl.rs
View file

@ -8,7 +8,7 @@ use gtk::subclass::prelude::*;
use gtk::{glib, Button, CheckButton, CompositeTemplate, Label, ProgressBar, Scale};
use ReSet_Lib::audio::audio::Source;
use super::sourceEntry;
use super::source_entry;
#[allow(non_snake_case)]
#[derive(Default, CompositeTemplate)]
@ -27,14 +27,14 @@ pub struct SourceEntry {
#[template_child]
pub resetVolumeMeter: TemplateChild<ProgressBar>,
pub stream: Arc<RefCell<Source>>,
pub volumeTimeStamp: RefCell<Option<SystemTime>>,
pub volume_time_stamp: RefCell<Option<SystemTime>>,
}
#[glib::object_subclass]
impl ObjectSubclass for SourceEntry {
const ABSTRACT: bool = false;
const NAME: &'static str = "resetSourceEntry";
type Type = sourceEntry::SourceEntry;
type Type = source_entry::SourceEntry;
type ParentType = PreferencesGroup;
fn class_init(klass: &mut Self::Class) {

30
src/components/output/inputStreamEntry.rs → src/components/output/input_stream_entry.rs
View file

@ -1,7 +1,7 @@
use std::sync::Arc;
use std::time::{Duration, SystemTime};
use crate::components::utils::{createDropdownLabelFactory, setComboRowEllipsis};
use crate::components::utils::{create_dropdown_label_factory, set_combo_row_ellipsis};
use adw::glib;
use adw::glib::Object;
use adw::prelude::{ButtonExt, ComboRowExt, PreferencesRowExt, RangeExt};
@ -12,11 +12,11 @@ use glib::{clone, Cast, Propagation};
use gtk::{gio, StringObject};
use ReSet_Lib::audio::audio::InputStream;
use super::inputStreamEntryImpl;
use super::sinkBox::SinkBox;
use super::input_stream_entry_impl;
use super::sink_box::SinkBox;
glib::wrapper! {
pub struct InputStreamEntry(ObjectSubclass<inputStreamEntryImpl::InputStreamEntry>)
pub struct InputStreamEntry(ObjectSubclass<input_stream_entry_impl::InputStreamEntry>)
@extends adw::PreferencesGroup, gtk::Widget,
@implements gtk::Accessible, gtk::Buildable, gtk::ConstraintTarget, gtk::Orientable;
}
@ -42,8 +42,8 @@ impl InputStreamEntry {
let name = stream.application_name.clone() + ": " + stream.name.as_str();
imp.resetSinkSelection.set_title(name.as_str());
imp.resetSinkSelection
.set_factory(Some(&createDropdownLabelFactory()));
setComboRowEllipsis(imp.resetSinkSelection.get());
.set_factory(Some(&create_dropdown_label_factory()));
set_combo_row_ellipsis(imp.resetSinkSelection.get());
let volume = stream.volume.first().unwrap_or(&0_u32);
let fraction = (*volume as f64 / 655.36).round();
let percentage = (fraction).to_string() + "%";
@ -51,8 +51,8 @@ impl InputStreamEntry {
imp.resetVolumeSlider.set_value(*volume as f64);
imp.stream.replace(stream);
{
let sink = box_imp.resetDefaultSink.borrow();
imp.associatedSink.replace((sink.index, sink.name.clone()));
let sink = box_imp.reset_default_sink.borrow();
imp.associated_sink.replace((sink.index, sink.name.clone()));
}
imp.resetVolumeSlider.connect_change_value(
clone!(@weak imp => @default-return Propagation::Stop, move |_, _, value| {
@ -67,7 +67,7 @@ impl InputStreamEntry {
let index = stream.index;
let channels = stream.channels;
{
let mut time = imp.volumeTimeStamp.borrow_mut();
let mut time = imp.volume_time_stamp.borrow_mut();
if time.is_some() && time.unwrap().elapsed().unwrap() < Duration::from_millis(50) {
return Propagation::Proceed;
}
@ -78,14 +78,14 @@ impl InputStreamEntry {
}),
);
{
let list = box_imp.resetModelList.read().unwrap();
let list = box_imp.reset_model_list.read().unwrap();
// while list.is_err() {
// list = box_imp.resetModelList.try_borrow();
// }
// let list = list.unwrap();
imp.resetSinkSelection.set_model(Some(&*list));
let map = box_imp.resetSinkMap.read().unwrap();
let sink_list = box_imp.resetSinkList.read().unwrap();
let map = box_imp.reset_sink_map.read().unwrap();
let sink_list = box_imp.reset_sink_list.read().unwrap();
let name = sink_list.get(&index);
if let Some(name) = name {
let name = &name.2;
@ -94,9 +94,9 @@ impl InputStreamEntry {
imp.resetSinkSelection.set_selected(index.1);
}
} else {
let mut name = box_imp.resetDefaultSink.try_borrow();
let mut name = box_imp.reset_default_sink.try_borrow();
while name.is_err() {
name = box_imp.resetDefaultSink.try_borrow();
name = box_imp.reset_default_sink.try_borrow();
}
let name = &name.unwrap().alias;
let index = map.get(name);
@ -114,7 +114,7 @@ impl InputStreamEntry {
let selected = selected.unwrap();
let selected = selected.downcast_ref::<StringObject>().unwrap();
let selected = selected.string().to_string();
let sink = box_imp.resetSinkMap.read().unwrap();
let sink = box_imp.reset_sink_map.read().unwrap();
// if sink.is_err() {
// return;
// }

8
src/components/output/inputStreamEntryImpl.rs → src/components/output/input_stream_entry_impl.rs
View file

@ -8,7 +8,7 @@ use gtk::subclass::prelude::*;
use gtk::{glib, Button, CompositeTemplate, Label, ProgressBar, Scale};
use ReSet_Lib::audio::audio::InputStream;
use super::inputStreamEntry;
use super::input_stream_entry;
#[allow(non_snake_case)]
#[derive(Default, CompositeTemplate)]
@ -25,15 +25,15 @@ pub struct InputStreamEntry {
#[template_child]
pub resetVolumeMeter: TemplateChild<ProgressBar>,
pub stream: Arc<RefCell<InputStream>>,
pub associatedSink: Arc<RefCell<(u32, String)>>,
pub volumeTimeStamp: RefCell<Option<SystemTime>>,
pub associated_sink: Arc<RefCell<(u32, String)>>,
pub volume_time_stamp: RefCell<Option<SystemTime>>,
}
#[glib::object_subclass]
impl ObjectSubclass for InputStreamEntry {
const ABSTRACT: bool = false;
const NAME: &'static str = "resetInputStreamEntry";
type Type = inputStreamEntry::InputStreamEntry;
type Type = input_stream_entry::InputStreamEntry;
type ParentType = PreferencesGroup;
fn class_init(klass: &mut Self::Class) {

13
src/components/output/mod.rs
View file

@ -1,7 +1,6 @@
#![allow(non_snake_case)]
pub mod inputStreamEntry;
pub mod inputStreamEntryImpl;
pub mod sinkBox;
pub mod sinkBoxImpl;
pub mod sinkEntry;
pub mod sinkEntryImpl;
pub mod input_stream_entry;
pub mod input_stream_entry_impl;
pub mod sink_box;
pub mod sink_box_impl;
pub mod sink_entry;
pub mod sink_entry_impl;

116
src/components/output/sinkBox.rs → src/components/output/sink_box.rs
View file

@ -15,20 +15,20 @@ use gtk::prelude::ActionableExt;
use gtk::{gio, StringObject};
use ReSet_Lib::audio::audio::{Card, InputStream, Sink};
use crate::components::base::cardEntry::CardEntry;
use crate::components::base::listEntry::ListEntry;
use crate::components::base::card_entry::CardEntry;
use crate::components::base::list_entry::ListEntry;
use crate::components::base::utils::{
InputStreamAdded, InputStreamChanged, InputStreamRemoved, SinkAdded, SinkChanged, SinkRemoved,
};
use crate::components::output::sinkEntry::set_sink_volume;
use crate::components::utils::{createDropdownLabelFactory, setComboRowEllipsis};
use crate::components::output::sink_entry::set_sink_volume;
use crate::components::utils::{create_dropdown_label_factory, set_combo_row_ellipsis};
use super::inputStreamEntry::InputStreamEntry;
use super::sinkBoxImpl;
use super::sinkEntry::{set_default_sink, toggle_sink_mute, SinkEntry};
use super::input_stream_entry::InputStreamEntry;
use super::sink_box_impl;
use super::sink_entry::{set_default_sink, toggle_sink_mute, SinkEntry};
glib::wrapper! {
pub struct SinkBox(ObjectSubclass<sinkBoxImpl::SinkBox>)
pub struct SinkBox(ObjectSubclass<sink_box_impl::SinkBox>)
@extends gtk::Box, gtk::Widget,
@implements gtk::Accessible, gtk::Buildable, gtk::ConstraintTarget, gtk::Orientable;
}
@ -41,44 +41,44 @@ impl SinkBox {
let obj: Self = Object::builder().build();
{
let imp = obj.imp();
let mut model_index = imp.resetModelIndex.write().unwrap();
let mut model_index = imp.reset_model_index.write().unwrap();
*model_index = 0;
}
obj
}
pub fn setupCallbacks(&self) {
let selfImp = self.imp();
selfImp.resetSinksRow.set_activatable(true);
selfImp
pub fn setup_callbacks(&self) {
let self_imp = self.imp();
self_imp.resetSinksRow.set_activatable(true);
self_imp
.resetSinksRow
.set_action_name(Some("navigation.push"));
selfImp
self_imp
.resetSinksRow
.set_action_target_value(Some(&Variant::from("outputDevices")));
selfImp.resetCardsRow.set_activatable(true);
selfImp
self_imp.resetCardsRow.set_activatable(true);
self_imp
.resetCardsRow
.set_action_name(Some("navigation.push"));
selfImp
self_imp
.resetCardsRow
.set_action_target_value(Some(&Variant::from("profileConfiguration")));
selfImp.resetCardsRow.connect_action_name_notify(|_| {});
self_imp.resetCardsRow.connect_action_name_notify(|_| {});
selfImp.resetInputStreamButton.set_activatable(true);
selfImp
self_imp.resetInputStreamButton.set_activatable(true);
self_imp
.resetInputStreamButton
.set_action_name(Some("navigation.pop"));
selfImp.resetInputCardsBackButton.set_activatable(true);
selfImp
self_imp.resetInputCardsBackButton.set_activatable(true);
self_imp
.resetInputCardsBackButton
.set_action_name(Some("navigation.pop"));
selfImp
self_imp
.resetSinkDropdown
.set_factory(Some(&createDropdownLabelFactory()));
setComboRowEllipsis(selfImp.resetSinkDropdown.get());
.set_factory(Some(&create_dropdown_label_factory()));
set_combo_row_ellipsis(self_imp.resetSinkDropdown.get());
}
}
@ -94,10 +94,12 @@ pub fn populate_sinks(output_box: Arc<SinkBox>) {
let sinks = get_sinks();
{
let output_box_imp = output_box.imp();
let mut map = output_box_imp.resetSinkMap.write().unwrap();
let list = output_box_imp.resetModelList.write().unwrap();
let mut model_index = output_box_imp.resetModelIndex.write().unwrap();
output_box_imp.resetDefaultSink.replace(get_default_sink());
let mut map = output_box_imp.reset_sink_map.write().unwrap();
let list = output_box_imp.reset_model_list.write().unwrap();
let mut model_index = output_box_imp.reset_model_index.write().unwrap();
output_box_imp
.reset_default_sink
.replace(get_default_sink());
for (i, sink) in (0_u32..).zip(sinks.iter()) {
list.append(&sink.alias);
map.insert(sink.alias.clone(), (sink.index, i, sink.name.clone()));
@ -112,7 +114,7 @@ pub fn populate_sinks(output_box: Arc<SinkBox>) {
let output_box_ref_mute = output_box.clone();
{
let output_box_imp = output_box_ref.imp();
let default_sink = output_box_imp.resetDefaultSink.clone();
let default_sink = output_box_imp.reset_default_sink.clone();
let sink = default_sink.borrow();
let volume = sink.volume.first().unwrap_or(&0);
@ -120,17 +122,17 @@ pub fn populate_sinks(output_box: Arc<SinkBox>) {
let percentage = (fraction).to_string() + "%";
output_box_imp.resetVolumePercentage.set_text(&percentage);
output_box_imp.resetVolumeSlider.set_value(*volume as f64);
let mut list = output_box_imp.resetSinkList.write().unwrap();
let mut list = output_box_imp.reset_sink_list.write().unwrap();
for sink in sinks {
let index = sink.index;
let alias = sink.alias.clone();
let mut is_default = false;
if output_box_imp.resetDefaultSink.borrow().name == sink.name {
if output_box_imp.reset_default_sink.borrow().name == sink.name {
is_default = true;
}
let sink_entry = Arc::new(SinkEntry::new(
is_default,
output_box_imp.resetDefaultCheckButton.clone(),
output_box_imp.reset_default_check_button.clone(),
sink,
));
let sink_clone = sink_entry.clone();
@ -139,10 +141,10 @@ pub fn populate_sinks(output_box: Arc<SinkBox>) {
list.insert(index, (entry.clone(), sink_clone, alias));
output_box_imp.resetSinks.append(&*entry);
}
let list = output_box_imp.resetModelList.read().unwrap();
let list = output_box_imp.reset_model_list.read().unwrap();
output_box_imp.resetSinkDropdown.set_model(Some(&*list));
let map = output_box_imp.resetSinkMap.read().unwrap();
let name = output_box_imp.resetDefaultSink.borrow();
let map = output_box_imp.reset_sink_map.read().unwrap();
let name = output_box_imp.reset_default_sink.borrow();
let name = &name.alias;
let index = map.get(name);
if let Some(index) = index {
@ -158,7 +160,7 @@ pub fn populate_sinks(output_box: Arc<SinkBox>) {
let selected = selected.downcast_ref::<StringObject>().unwrap();
let selected = selected.string().to_string();
let sink = output_box_imp.resetSinkMap.read().unwrap();
let sink = output_box_imp.reset_sink_map.read().unwrap();
let sink = sink.get(&selected);
if sink.is_none() {
return;
@ -176,11 +178,11 @@ pub fn populate_sinks(output_box: Arc<SinkBox>) {
let fraction = (value / 655.36).round();
let percentage = (fraction).to_string() + "%";
imp.resetVolumePercentage.set_text(&percentage);
let sink = imp.resetDefaultSink.borrow();
let sink = imp.reset_default_sink.borrow();
let index = sink.index;
let channels = sink.channels;
{
let mut time = imp.volumeTimeStamp.borrow_mut();
let mut time = imp.volume_time_stamp.borrow_mut();
if time.is_some()
&& time.unwrap().elapsed().unwrap() < Duration::from_millis(50)
{
@ -196,7 +198,7 @@ pub fn populate_sinks(output_box: Arc<SinkBox>) {
.resetSinkMute
.connect_clicked(move |_| {
let imp = output_box_ref_mute.imp();
let stream = imp.resetDefaultSink.clone();
let stream = imp.reset_default_sink.clone();
let mut stream = stream.borrow_mut();
stream.muted = !stream.muted;
let muted = stream.muted;
@ -223,7 +225,7 @@ pub fn populate_inputstreams(output_box: Arc<SinkBox>) {
glib::spawn_future(async move {
glib::idle_add_once(move || {
let output_box_imp = output_box_ref.imp();
let mut list = output_box_imp.resetInputStreamList.write().unwrap();
let mut list = output_box_imp.reset_input_stream_list.write().unwrap();
for stream in streams {
let index = stream.index;
let input_stream = Arc::new(InputStreamEntry::new(output_box.clone(), stream));
@ -357,17 +359,17 @@ pub fn start_output_box_listener(conn: Connection, sink_box: Arc<SinkBox>) -> Co
glib::idle_add_once(move || {
let output_box = sink_box.clone();
let output_box_imp = output_box.imp();
let mut list = output_box_imp.resetSinkList.write().unwrap();
let mut list = output_box_imp.reset_sink_list.write().unwrap();
let sink_index = ir.sink.index;
let alias = ir.sink.alias.clone();
let name = ir.sink.name.clone();
let mut is_default = false;
if output_box_imp.resetDefaultSink.borrow().name == ir.sink.name {
if output_box_imp.reset_default_sink.borrow().name == ir.sink.name {
is_default = true;
}
let sink_entry = Arc::new(SinkEntry::new(
is_default,
output_box_imp.resetDefaultCheckButton.clone(),
output_box_imp.reset_default_check_button.clone(),
ir.sink,
));
let sink_clone = sink_entry.clone();
@ -375,10 +377,10 @@ pub fn start_output_box_listener(conn: Connection, sink_box: Arc<SinkBox>) -> Co
entry.set_activatable(false);
list.insert(sink_index, (entry.clone(), sink_clone, alias.clone()));
output_box_imp.resetSinks.append(&*entry);
let mut map = output_box_imp.resetSinkMap.write().unwrap();
let mut index = output_box_imp.resetModelIndex.write().unwrap();
let mut map = output_box_imp.reset_sink_map.write().unwrap();
let mut index = output_box_imp.reset_model_index.write().unwrap();
output_box_imp
.resetModelList
.reset_model_list
.write()
.unwrap()
.append(&alias);
@ -399,7 +401,7 @@ pub fn start_output_box_listener(conn: Connection, sink_box: Arc<SinkBox>) -> Co
glib::idle_add_once(move || {
let output_box = sink_box.clone();
let output_box_imp = output_box.imp();
let mut list = output_box_imp.resetSinkList.write().unwrap();
let mut list = output_box_imp.reset_sink_list.write().unwrap();
let entry = list.get(&ir.index);
if entry.is_none() {
return;
@ -409,16 +411,16 @@ pub fn start_output_box_listener(conn: Connection, sink_box: Arc<SinkBox>) -> Co
if alias.is_none() {
return;
}
let mut map = output_box_imp.resetSinkMap.write().unwrap();
let mut map = output_box_imp.reset_sink_map.write().unwrap();
let entry_index = map.remove(&alias.unwrap().2);
if let Some(entry_index) = entry_index {
output_box_imp
.resetModelList
.reset_model_list
.write()
.unwrap()
.remove(entry_index.1);
}
let mut index = output_box_imp.resetModelIndex.write().unwrap();
let mut index = output_box_imp.reset_model_index.write().unwrap();
if *index != 0 {
*index -= 1;
}
@ -443,7 +445,7 @@ pub fn start_output_box_listener(conn: Connection, sink_box: Arc<SinkBox>) -> Co
let fraction = (*volume as f64 / 655.36).round();
let percentage = (fraction).to_string() + "%";
let list = output_box_imp.resetSinkList.read().unwrap();
let list = output_box_imp.reset_sink_list.read().unwrap();
let entry = list.get(&ir.sink.index);
if entry.is_none() {
return;
@ -474,7 +476,7 @@ pub fn start_output_box_listener(conn: Connection, sink_box: Arc<SinkBox>) -> Co
glib::idle_add_once(move || {
let output_box = sink_box.clone();
let output_box_imp = output_box.imp();
let mut list = output_box_imp.resetInputStreamList.write().unwrap();
let mut list = output_box_imp.reset_input_stream_list.write().unwrap();
let index = ir.stream.index;
let input_stream = Arc::new(InputStreamEntry::new(output_box.clone(), ir.stream));
let entry = Arc::new(ListEntry::new(&*input_stream));
@ -494,7 +496,7 @@ pub fn start_output_box_listener(conn: Connection, sink_box: Arc<SinkBox>) -> Co
let imp = input_stream_changed_box.imp();
let alias: String;
{
let sink_list = imp.resetSinkList.read().unwrap();
let sink_list = imp.reset_sink_list.read().unwrap();
let alias_opt = sink_list.get(&ir.stream.sink_index);
if let Some(alias_opt) = alias_opt {
alias = alias_opt.2.clone();
@ -509,7 +511,7 @@ pub fn start_output_box_listener(conn: Connection, sink_box: Arc<SinkBox>) -> Co
let output_box_imp = output_box.imp();
let entry: Arc<InputStreamEntry>;
{
let list = output_box_imp.resetInputStreamList.read().unwrap();
let list = output_box_imp.reset_input_stream_list.read().unwrap();
let entry_opt = list.get(&ir.stream.index);
if entry_opt.is_none() {
return;
@ -531,7 +533,7 @@ pub fn start_output_box_listener(conn: Connection, sink_box: Arc<SinkBox>) -> Co
let percentage = (fraction).to_string() + "%";
imp.resetVolumePercentage.set_text(&percentage);
imp.resetVolumeSlider.set_value(*volume as f64);
let map = output_box_imp.resetSinkMap.read().unwrap();
let map = output_box_imp.reset_sink_map.read().unwrap();
let index = map.get(&alias);
if let Some(index) = index {
imp.resetSinkSelection.set_selected(index.1);
@ -551,7 +553,7 @@ pub fn start_output_box_listener(conn: Connection, sink_box: Arc<SinkBox>) -> Co
glib::idle_add_once(move || {
let output_box = sink_box.clone();
let output_box_imp = output_box.imp();
let mut list = output_box_imp.resetInputStreamList.write().unwrap();
let mut list = output_box_imp.reset_input_stream_list.write().unwrap();
let entry = list.get(&ir.index);
if entry.is_none() {
return;

28
src/components/output/sinkBoxImpl.rs → src/components/output/sink_box_impl.rs
View file

@ -4,15 +4,15 @@ use std::collections::HashMap;
use std::sync::{Arc, RwLock};
use std::time::SystemTime;
use crate::components::base::listEntry::ListEntry;
use crate::components::output::inputStreamEntry::InputStreamEntry;
use crate::components::base::list_entry::ListEntry;
use crate::components::output::input_stream_entry::InputStreamEntry;
use gtk::subclass::prelude::*;
use gtk::{glib, Box, Button, CheckButton, CompositeTemplate, Label, StringList, TemplateChild};
use gtk::{prelude::*, ProgressBar, Scale};
use ReSet_Lib::audio::audio::Sink;
use super::sinkBox;
use super::sinkEntry::SinkEntry;
use super::sink_box;
use super::sink_entry::SinkEntry;
type SinkEntryMap = Arc<RwLock<HashMap<u32, (Arc<ListEntry>, Arc<SinkEntry>, String)>>>;
type InputStreamEntryMap = Arc<RwLock<HashMap<u32, (Arc<ListEntry>, Arc<InputStreamEntry>)>>>;
@ -46,23 +46,23 @@ pub struct SinkBox {
pub resetInputCardsBackButton: TemplateChild<ActionRow>,
#[template_child]
pub resetCards: TemplateChild<PreferencesGroup>,
pub resetDefaultCheckButton: Arc<CheckButton>,
pub resetDefaultSink: Arc<RefCell<Sink>>,
pub resetSinkList: SinkEntryMap,
pub resetInputStreamList: InputStreamEntryMap,
pub resetModelList: Arc<RwLock<StringList>>,
pub resetModelIndex: Arc<RwLock<u32>>,
pub reset_default_check_button: Arc<CheckButton>,
pub reset_default_sink: Arc<RefCell<Sink>>,
pub reset_sink_list: SinkEntryMap,
pub reset_input_stream_list: InputStreamEntryMap,
pub reset_model_list: Arc<RwLock<StringList>>,
pub reset_model_index: Arc<RwLock<u32>>,
// first u32 is the index of the sink, the second the index in the model list and the third is
// the full name
pub resetSinkMap: SinkMap,
pub volumeTimeStamp: RefCell<Option<SystemTime>>,
pub reset_sink_map: SinkMap,
pub volume_time_stamp: RefCell<Option<SystemTime>>,
}
#[glib::object_subclass]
impl ObjectSubclass for SinkBox {
const ABSTRACT: bool = false;
const NAME: &'static str = "resetAudioOutput";
type Type = sinkBox::SinkBox;
type Type = sink_box::SinkBox;
type ParentType = gtk::Box;
fn class_init(klass: &mut Self::Class) {
@ -82,7 +82,7 @@ impl BoxImpl for SinkBox {}
impl ObjectImpl for SinkBox {
fn constructed(&self) {
let obj = self.obj();
obj.setupCallbacks();
obj.setup_callbacks();
}
}

6
src/components/output/sinkEntry.rs → src/components/output/sink_entry.rs
View file

@ -11,10 +11,10 @@ use glib::{clone, Propagation};
use gtk::{gio, CheckButton};
use ReSet_Lib::audio::audio::Sink;
use super::sinkEntryImpl;
use super::sink_entry_impl;
glib::wrapper! {
pub struct SinkEntry(ObjectSubclass<sinkEntryImpl::SinkEntry>)
pub struct SinkEntry(ObjectSubclass<sink_entry_impl::SinkEntry>)
@extends adw::PreferencesGroup, gtk::Widget,
@implements gtk::Accessible, gtk::Buildable, gtk::ConstraintTarget, gtk::Orientable;
}
@ -45,7 +45,7 @@ impl SinkEntry {
let index = sink.index;
let channels = sink.channels;
{
let mut time = imp.volumeTimeStamp.borrow_mut();
let mut time = imp.volume_time_stamp.borrow_mut();
if time.is_some() && time.unwrap().elapsed().unwrap() < Duration::from_millis(50) {
return Propagation::Proceed;
}

6
src/components/output/sinkEntryImpl.rs → src/components/output/sink_entry_impl.rs
View file

@ -4,7 +4,7 @@ use std::cell::RefCell;
use std::sync::Arc;
use std::time::SystemTime;
use crate::components::output::sinkEntry;
use crate::components::output::sink_entry;
use gtk::subclass::prelude::*;
use gtk::{glib, Button, CheckButton, CompositeTemplate, Label, ProgressBar, Scale};
use ReSet_Lib::audio::audio::Sink;
@ -26,14 +26,14 @@ pub struct SinkEntry {
#[template_child]
pub resetVolumeMeter: TemplateChild<ProgressBar>,
pub stream: Arc<RefCell<Sink>>,
pub volumeTimeStamp: RefCell<Option<SystemTime>>,
pub volume_time_stamp: RefCell<Option<SystemTime>>,
}
#[glib::object_subclass]
impl ObjectSubclass for SinkEntry {
const ABSTRACT: bool = false;
const NAME: &'static str = "resetSinkEntry";
type Type = sinkEntry::SinkEntry;
type Type = sink_entry::SinkEntry;
type ParentType = PreferencesGroup;
fn class_init(klass: &mut Self::Class) {

4
src/components/utils.rs
View file

@ -5,7 +5,7 @@ use glib::{Cast, Object};
use gtk::prelude::{GObjectPropertyExpressionExt, ListBoxRowExt, ListItemExt, WidgetExt};
use gtk::{Align, SignalListItemFactory, StringObject};
pub fn createDropdownLabelFactory() -> SignalListItemFactory {
pub fn create_dropdown_label_factory() -> SignalListItemFactory {
let factory = SignalListItemFactory::new();
factory.connect_setup(|_, item| {
let item = item.downcast_ref::<gtk::ListItem>().unwrap();
@ -19,7 +19,7 @@ pub fn createDropdownLabelFactory() -> SignalListItemFactory {
factory
}
pub fn setComboRowEllipsis(element: ComboRow) {
pub fn set_combo_row_ellipsis(element: ComboRow) {
for (i, child) in element
.child()
.unwrap()

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

@ -1,14 +1,13 @@
#![allow(non_snake_case)]
pub mod savedWifiEntry;
pub mod savedWifiEntryImpl;
pub mod saved_wifi_entry;
pub mod saved_wifi_entry_impl;
pub mod utils;
pub mod wifiAddressEntry;
pub mod wifiAddressEntryImpl;
pub mod wifiBox;
pub mod wifiBoxImpl;
pub mod wifiEntry;
pub mod wifiEntryImpl;
pub mod wifiOptions;
pub mod wifiOptionsImpl;
pub mod wifiRouteEntry;
pub mod wifiRouteEntryImpl;
pub mod wifi_address_entry;
pub mod wifi_address_entry_impl;
pub mod wifi_box;
pub mod wifi_box_impl;
pub mod wifi_entry;
pub mod wifi_entry_impl;
pub mod wifi_options;
pub mod wifi_options_impl;
pub mod wifi_route_entry;
pub mod wifi_route_entry_impl;

22
src/components/wifi/savedWifiEntry.rs → src/components/wifi/saved_wifi_entry.rs
View file

@ -1,7 +1,7 @@
use std::time::Duration;
use crate::components::wifi::savedWifiEntryImpl;
use crate::components::wifi::wifiBoxImpl::WifiBox;
use crate::components::wifi::saved_wifi_entry_impl;
use crate::components::wifi::wifi_box_impl::WifiBox;
use adw::glib;
use adw::glib::Object;
use adw::prelude::{ButtonExt, WidgetExt};
@ -13,30 +13,30 @@ use gtk::gio;
use gtk::prelude::ListBoxRowExt;
glib::wrapper! {
pub struct SavedWifiEntry(ObjectSubclass<savedWifiEntryImpl::SavedWifiEntry>)
pub struct SavedWifiEntry(ObjectSubclass<saved_wifi_entry_impl::SavedWifiEntry>)
@extends adw::ActionRow, gtk::Widget,
@implements gtk::Accessible, gtk::Buildable, gtk::Actionable, gtk::ConstraintTarget, gtk::ListBoxRow;
}
impl SavedWifiEntry {
pub fn new(name: &str, path: Path<'static>, wifiBox: &WifiBox) -> Self {
pub fn new(name: &str, path: Path<'static>, wifi_box: &WifiBox) -> Self {
let entry: SavedWifiEntry = Object::builder().build();
entry.set_activatable(false);
let entryImp = entry.imp();
let entry_imp = entry.imp();
entryImp.resetEditSavedWifiButton.connect_clicked(
clone!(@ weak entryImp, @ weak wifiBox => move |_| {
entry_imp.resetEditSavedWifiButton.connect_clicked(
clone!(@ weak entry_imp, @ weak wifi_box => move |_| {
// TODO accesspoint has to be saved somewhere i guess
// let _option = getConnectionSettings(entryImp.accessPoint.borrow().associated_connection.clone());
// wifiBox.resetWifiNavigation.push(&*WifiOptions::new(_option));
}),
);
entryImp.resetSavedWifiLabel.set_text(name);
entryImp.resetConnectionPath.set(path);
entryImp.resetDeleteSavedWifiButton.connect_clicked(
entry_imp.resetSavedWifiLabel.set_text(name);
entry_imp.reset_connection_path.set(path);
entry_imp.resetDeleteSavedWifiButton.connect_clicked(
clone!(@weak entry as entry => move |_| {
delete_connection(entry.imp().resetConnectionPath.take());
delete_connection(entry.imp().reset_connection_path.take());
// TODO handle error
let parent = entry.parent().unwrap();
parent.set_visible(false);

8
src/components/wifi/savedWifiEntryImpl.rs → src/components/wifi/saved_wifi_entry_impl.rs
View file

@ -8,7 +8,7 @@ use gtk::subclass::prelude::*;
use gtk::{glib, Button, CompositeTemplate, Label};
use ReSet_Lib::network::network::AccessPoint;
use super::savedWifiEntry;
use super::saved_wifi_entry;
#[allow(non_snake_case)]
#[derive(Default, CompositeTemplate)]
@ -20,8 +20,8 @@ pub struct SavedWifiEntry {
pub resetEditSavedWifiButton: TemplateChild<Button>,
#[template_child]
pub resetSavedWifiLabel: TemplateChild<Label>,
pub resetConnectionPath: RefCell<Path<'static>>,
pub accessPoint: RefCell<AccessPoint>,
pub reset_connection_path: RefCell<Path<'static>>,
pub access_point: RefCell<AccessPoint>,
}
unsafe impl Send for SavedWifiEntry {}
@ -31,7 +31,7 @@ unsafe impl Sync for SavedWifiEntry {}
impl ObjectSubclass for SavedWifiEntry {
const ABSTRACT: bool = false;
const NAME: &'static str = "resetSavedWifiEntry";
type Type = savedWifiEntry::SavedWifiEntry;
type Type = saved_wifi_entry::SavedWifiEntry;
type ParentType = ActionRow;
fn class_init(klass: &mut Self::Class) {

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

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

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

@ -1,160 +0,0 @@
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::{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::wifiAddressEntryImpl::WifiAddressEntryImpl;
glib::wrapper! {
pub struct WifiAddressEntry(ObjectSubclass<wifiAddressEntryImpl::WifiAddressEntryImpl>)
@extends gtk::Box, gtk::Widget,
@implements gtk::Accessible, gtk::Buildable, gtk::ConstraintTarget, gtk::Orientable;
}
impl WifiAddressEntry {
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 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.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 => 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(IpAddr::V4),
IpProtocol::IPv6 => Ipv6Addr::from_str(addressInput.as_str()).map(IpAddr::V6),
};
match result {
Ok(ipAddr) => {
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(ipAddr.to_string(), selfImp.prefix.get().1 as u32));
*selfImp.address.borrow_mut() = (true, ipAddr.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);
};
if prefixInput.is_empty() || prefix.is_err() {
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);
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);
}

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

@ -1,342 +0,0 @@
use std::net::{Ipv4Addr, Ipv6Addr};
use std::str::FromStr;
use std::sync::Arc;
use std::time::Duration;
use adw::{gio, glib};
use adw::glib::Object;
use adw::prelude::{ActionRowExt, ComboRowExt, PreferencesGroupExt};
use adw::subclass::prelude::ObjectSubclassIsExt;
use dbus::{Error, Path};
use dbus::arg::PropMap;
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 crate::components::wifi::utils::IpProtocol;
use crate::components::wifi::wifiAddressEntry::WifiAddressEntry;
use crate::components::wifi::wifiOptionsImpl;
use crate::components::wifi::wifiRouteEntry::WifiRouteEntry;
glib::wrapper! {
pub struct WifiOptions(ObjectSubclass<wifiOptionsImpl::WifiOptions>)
@extends adw::NavigationPage, gtk::Widget,
@implements gtk::Accessible, gtk::Buildable, gtk::ConstraintTarget;
}
unsafe impl Send for WifiOptions {}
unsafe impl Sync for WifiOptions {}
impl WifiOptions {
pub fn new(connection: Connection, accessPoint: Path<'static>) -> Arc<Self> {
let wifiOption: Arc<WifiOptions> = Arc::new(Object::builder().build());
wifiOption.imp().connection.set(connection);
wifiOption.initializeUI();
setupCallbacks(&wifiOption, accessPoint);
wifiOption
}
pub fn initializeUI(&self) {
let selfImp = self.imp();
let ip4AddressLength;
let ip4RouteLength;
let ip6AddressLength;
let ip6RouteLength;
{
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();
// General
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);
// Security
if let TypeSettings::WIFI(wifi) = &conn.device {
match wifi.security_settings.key_management.as_str() {
"none" => {
selfImp.resetWifiSecurityDropdown.set_selected(0);
selfImp.resetWifiPassword.set_visible(false);
selfImp.resetWifiPassword.set_text("");
}
"wpa-psk" => {
selfImp.resetWifiSecurityDropdown.set_selected(1);
selfImp.resetWifiPassword.set_visible(true);
selfImp.resetWifiPassword.set_text(&wifi.security_settings.psk);
}
_ => {}
}
}
}
// IPv4
for i in 0..ip4AddressLength {
let address = &WifiAddressEntry::new(Some(i), selfImp.connection.clone(), IPv4);
selfImp.resetIP4AddressGroup.add(address);
}
let address = &WifiAddressEntry::new(None, selfImp.connection.clone(), IPv4);
selfImp.resetIP4AddressGroup.add(address);
for i in 0..ip4RouteLength {
let route = &WifiRouteEntry::new(Some(i), selfImp.connection.clone(), IPv4);
selfImp.resetIP4RoutesGroup.add(route)
}
let route = &WifiRouteEntry::new(None, selfImp.connection.clone(), IPv4);
selfImp.resetIP4RoutesGroup.add(route);
// IPv6
for i in 0..ip6AddressLength {
let address = &WifiAddressEntry::new(Some(i), selfImp.connection.clone(), IPv6);
selfImp.resetIP6AddressGroup.add(address);
}
let address = &WifiAddressEntry::new(None, selfImp.connection.clone(), IPv6);
selfImp.resetIP6AddressGroup.add(address);
for i in 0..ip6RouteLength {
let route = &WifiRouteEntry::new(Some(i), selfImp.connection.clone(), IPv6);
selfImp.resetIP6RoutesGroup.add(route);
}
let route = &WifiRouteEntry::new(None, selfImp.connection.clone(), IPv6);
selfImp.resetIP6RoutesGroup.add(route);
// Security
}
pub fn setIP4Visibility(&self, method: u32) {
let selfImp = self.imp();
match method {
0 => { // auto
selfImp.resetIP4AddressGroup.set_visible(false);
selfImp.resetIP4RoutesGroup.set_visible(true);
selfImp.resetIP4Gateway.set_visible(false);
}
1 => { // manual
selfImp.resetIP4AddressGroup.set_visible(true);
selfImp.resetIP4RoutesGroup.set_visible(true);
selfImp.resetIP4Gateway.set_visible(true);
}
_ => {
selfImp.resetIP4AddressGroup.set_visible(false);
selfImp.resetIP4RoutesGroup.set_visible(false);
selfImp.resetIP4Gateway.set_visible(false);
}
}
}
pub fn setIP6Visibility(&self, method: u32) {
let selfImp = self.imp();
match method {
0 | 1 => { // auto, dhcp
selfImp.resetIP6AddressGroup.set_visible(false);
selfImp.resetIP6RoutesGroup.set_visible(true);
selfImp.resetIP6Gateway.set_visible(false);
}
2 => { // manual
selfImp.resetIP6AddressGroup.set_visible(true);
selfImp.resetIP6RoutesGroup.set_visible(true);
selfImp.resetIP6Gateway.set_visible(true);
}
_ => {
selfImp.resetIP6AddressGroup.set_visible(false);
selfImp.resetIP6RoutesGroup.set_visible(false);
selfImp.resetIP6Gateway.set_visible(false);
}
}
}
}
fn setupCallbacks(wifiOptions: &Arc<WifiOptions>, path: Path<'static>) {
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();
setConnectionSettings(path.clone(), prop);
}));
// 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.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");
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");
}
}));
// 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.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.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");
}
}));
// Security
imp.resetWifiSecurityDropdown.connect_selected_notify(clone!(@weak imp => move |dropdown| {
let selected = dropdown.selected();
let mut conn = imp.connection.borrow_mut();
match (selected, &mut conn.device) {
(0 , TypeSettings::WIFI(wifi)) => { // None
imp.resetWifiPassword.set_visible(false);
wifi.security_settings.key_management = String::from("none");
wifi.security_settings.authentication_algorithm = String::from("open");
},
(1 , TypeSettings::WIFI(wifi)) => { // WPA/WPA2 Personal
imp.resetWifiPassword.set_visible(true);
wifi.security_settings.key_management = String::from("wpa-psk");
wifi.security_settings.authentication_algorithm = String::from("");
},
(_, _) => {}
}
}));
imp.resetWifiPassword.connect_changed(clone!(@weak imp => move |entry| {
let passwordInput = entry.text();
let mut conn = imp.connection.borrow_mut();
if let TypeSettings::WIFI(wifi) = &mut conn.device {
wifi.security_settings.psk = passwordInput.to_string();
}
}));
}
fn setConnectionSettings(path: Path<'static>, prop: PropMap) {
gio::spawn_blocking(move || {
let conn = dbus::blocking::Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSetDaemon",
"/org/Xetibo/ReSetDaemon",
Duration::from_millis(1000),
);
let _: Result<(bool,), Error> = proxy.method_call(
"org.Xetibo.ReSetWireless",
"SetConnectionSettings",
(path, prop),
);
});
}

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

@ -1,242 +0,0 @@
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::wifiRouteEntryImpl;
use crate::components::wifi::wifiRouteEntryImpl::WifiRouteEntryImpl;
glib::wrapper! {
pub struct WifiRouteEntry(ObjectSubclass<wifiRouteEntryImpl::WifiRouteEntryImpl>)
@extends gtk::Box, gtk::Widget,
@implements gtk::Accessible, gtk::Buildable, gtk::ConstraintTarget, gtk::Orientable;
}
impl WifiRouteEntry {
pub fn new(
address: Option<usize>,
conn: Rc<RefCell<Connection>>,
protocol: IpProtocol,
) -> Self {
let entry: WifiRouteEntry = Object::builder().build();
let entryImp = entry.imp();
if let Some(address) = address {
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());
if let Some(gateway) = &address.gateway {
entryImp.resetRouteGateway.set_text(gateway);
}
if let Some(metric) = address.metric {
entryImp.resetRouteMetric.set_text(&metric.to_string());
}
entryImp
.resetRouteRow
.set_title(&format!("{}/{}", &*address.address, address.prefix_length));
}
entryImp.protocol.set(protocol);
entry.setupCallbacks(conn);
entry
}
fn setupCallbacks(&self, connection: Rc<RefCell<Connection>>) {
let selfImp = self.imp();
let conn = connection.clone();
selfImp.resetRouteAddress.connect_changed(clone!(@weak selfImp => move |entry| {
let addressInput = entry.text();
let mut conn = conn.borrow_mut();
if addressInput.is_empty() {
selfImp.resetRouteAddress.remove_css_class("error");
selfImp.resetRouteRow.set_title("Add new address");
return;
}
let result = match selfImp.protocol.get() {
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) => {
selfImp.resetRouteAddress.remove_css_class("error");
let addressData = match selfImp.protocol.get() {
IpProtocol::IPv4 => &mut conn.ipv4.route_data,
IpProtocol::IPv6 => &mut conn.ipv6.route_data,
};
addressData.push(Address::new(ipAddr.to_string(), selfImp.prefix.get().1 as u32, selfImp.gateway.borrow().clone(), selfImp.metric.get()));
*selfImp.address.borrow_mut() = (true, ipAddr.to_string());
}
Err(_) => {
selfImp.resetRouteAddress.add_css_class("error");
*selfImp.address.borrow_mut() = (false, String::default());
}
}
setRowTitle(&selfImp);
}));
let conn = connection.clone();
selfImp.resetRoutePrefix.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.resetRoutePrefix.text().is_empty() {
selfImp.resetRoutePrefix.remove_css_class("error");
} else {
selfImp.resetRoutePrefix.add_css_class("error");
}
selfImp.prefix.set((false, 0));
setRowTitle(&selfImp);
};
if prefixInput.is_empty() || prefix.is_err() {
handleError();
return;
}
let prefix = prefix.unwrap();
match selfImp.protocol.get() {
IpProtocol::IPv4 if prefix <= 32 => {
selfImp.prefix.set((true, prefix as u32));
selfImp.resetRoutePrefix.remove_css_class("error");
if let Ok(address2) = Ipv4Addr::from_str(selfImp.resetRouteAddress.text().as_str()) {
if let Some(addr) = conn.ipv4.route_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.resetRoutePrefix.remove_css_class("error");
if let Ok(address2) = Ipv6Addr::from_str(selfImp.resetRouteAddress.text().as_str()) {
if let Some(addr) = conn.ipv6.route_data.iter_mut()
.find(|connAddr| *connAddr.address == address2.to_string()) {
addr.prefix_length = prefix as u32;
}
}
}
_ => handleError()
}
setRowTitle(&selfImp);
}));
let conn = connection.clone();
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(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();
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) => {
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;
}
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.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), None) => gateway,
(None, Some(metric)) => metric.to_string(),
(None, None) => String::default(),
};
selfImp.resetRouteRow.set_subtitle(&title);
}

160
src/components/wifi/wifi_address_entry.rs Normal file
View file

@ -0,0 +1,160 @@
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::{ButtonExt, EditableExt, WidgetExt};
use ReSet_Lib::network::connection::{Address, Connection};
use crate::components::wifi::utils::IpProtocol;
use crate::components::wifi::wifi_address_entry_impl;
use crate::components::wifi::wifi_address_entry_impl::WifiAddressEntryImpl;
glib::wrapper! {
pub struct WifiAddressEntry(ObjectSubclass<wifi_address_entry_impl::WifiAddressEntryImpl>)
@extends gtk::Box, gtk::Widget,
@implements gtk::Accessible, gtk::Buildable, gtk::ConstraintTarget, gtk::Orientable;
}
impl WifiAddressEntry {
pub fn new(
address: Option<usize>,
conn: Rc<RefCell<Connection>>,
protocol: IpProtocol,
) -> Self {
let entry: WifiAddressEntry = Object::builder().build();
let entry_imp = entry.imp();
if let Some(address) = address {
let conn = conn.borrow();
let address = unsafe { conn.ipv4.address_data.get_unchecked(address) };
entry_imp.resetAddressAddress.set_text(&address.address);
entry_imp
.resetAddressPrefix
.set_text(&address.prefix_length.to_string());
entry_imp
.resetAddressRow
.set_title(&format!("{}/{}", &*address.address, address.prefix_length));
}
entry_imp.protocol.set(protocol);
entry.setup_callbacks(conn);
entry
}
pub fn setup_callbacks(&self, connection: Rc<RefCell<Connection>>) {
let self_imp = self.imp();
let conn = connection.clone();
self_imp.resetAddressAddress.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.resetAddressAddress.remove_css_class("error");
self_imp.resetAddressRow.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) => {
self_imp.resetAddressAddress.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::theBetterNew(ip_addr.to_string(), self_imp.prefix.get().1 as u32));
*self_imp.address.borrow_mut() = (true, ip_addr.to_string());
}
Err(_) => {
self_imp.resetAddressAddress.add_css_class("error");
*self_imp.address.borrow_mut() = (false, String::default());
}
}
set_row_name(&self_imp);
}));
let conn = connection.clone();
self_imp.resetAddressPrefix.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.resetAddressPrefix.text().is_empty() {
self_imp.resetAddressPrefix.remove_css_class("error");
} else {
self_imp.resetAddressPrefix.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.resetAddressPrefix.remove_css_class("error");
if let Ok(address2) = Ipv4Addr::from_str(self_imp.resetAddressAddress.text().as_str()) {
if let Some(addr) = conn.ipv4.address_data.iter_mut()
.find(|conn_addr| *conn_addr.address == address2.to_string()) {
addr.prefix_length = prefix as u32;
}
}
}
IpProtocol::IPv6 if prefix <= 128 => {
self_imp.prefix.set((true, prefix as u32));
self_imp.resetAddressPrefix.remove_css_class("error");
if let Ok(address2) = Ipv6Addr::from_str(self_imp.resetAddressAddress.text().as_str()) {
if let Some(addr) = conn.ipv6.address_data.iter_mut()
.find(|conn_addr| *conn_addr.address == address2.to_string()) {
addr.prefix_length = prefix as u32;
}
}
}
_ => handle_error()
}
set_row_name(&self_imp);
}));
let conn = connection.clone();
self_imp.resetAddressRemove.connect_clicked(
clone!(@weak self_imp, @weak self as what => move |_| {
let address = self_imp.resetAddressAddress.text();
let mut conn = conn.borrow_mut();
conn.ipv4.address_data.retain(|addr| addr.address != address);
what.unparent();
}),
);
}
}
fn set_row_name(self_imp: &WifiAddressEntryImpl) {
if self_imp.resetAddressAddress.text().is_empty() {
return;
}
let address = self_imp.address.borrow();
let prefix = self_imp.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(),
};
self_imp.resetAddressRow.set_title(&title);
}

4
src/components/wifi/wifiAddressEntryImpl.rs → src/components/wifi/wifi_address_entry_impl.rs
View file

@ -1,5 +1,5 @@
use crate::components::wifi::utils::IpProtocol;
use crate::components::wifi::wifiAddressEntry;
use crate::components::wifi::wifi_address_entry;
use adw::{EntryRow, ExpanderRow};
use gtk::subclass::prelude::*;
use gtk::{glib, Button, CompositeTemplate};
@ -26,7 +26,7 @@ pub struct WifiAddressEntryImpl {
impl ObjectSubclass for WifiAddressEntryImpl {
const ABSTRACT: bool = false;
const NAME: &'static str = "resetWifiAddressEntry";
type Type = wifiAddressEntry::WifiAddressEntry;
type Type = wifi_address_entry::WifiAddressEntry;
type ParentType = gtk::Box;
fn class_init(klass: &mut Self::Class) {

153
src/components/wifi/wifiBox.rs → src/components/wifi/wifi_box.rs
View file

@ -5,7 +5,7 @@ use std::sync::Arc;
use std::time::Duration;
use crate::components::base::utils::Listeners;
use crate::components::utils::setComboRowEllipsis;
use crate::components::utils::set_combo_row_ellipsis;
use adw::glib;
use adw::glib::Object;
use adw::prelude::{ComboRowExt, ListBoxRowExt, PreferencesGroupExt};
@ -16,19 +16,19 @@ use dbus::Error;
use dbus::Path;
use glib::{clone, Cast, PropertySet};
use gtk::glib::Variant;
use gtk::prelude::{ActionableExt, WidgetExt, BoxExt};
use gtk::prelude::{ActionableExt, WidgetExt};
use gtk::{gio, StringObject};
use ReSet_Lib::network::network::{AccessPoint, WifiDevice, WifiStrength};
use ReSet_Lib::signals::{AccessPointAdded, WifiDeviceChanged};
use ReSet_Lib::signals::{AccessPointChanged, AccessPointRemoved};
use crate::components::wifi::wifiBoxImpl;
use crate::components::wifi::wifiEntry::WifiEntry;
use crate::components::wifi::wifi_box_impl;
use crate::components::wifi::wifi_entry::WifiEntry;
use super::savedWifiEntry::SavedWifiEntry;
use super::saved_wifi_entry::SavedWifiEntry;
glib::wrapper! {
pub struct WifiBox(ObjectSubclass<wifiBoxImpl::WifiBox>)
pub struct WifiBox(ObjectSubclass<wifi_box_impl::WifiBox>)
@extends gtk::Box, gtk::Widget,
@implements gtk::Accessible, gtk::Buildable, gtk::ConstraintTarget, gtk::Orientable;
}
@ -41,15 +41,15 @@ unsafe impl Sync for WifiBox {}
impl WifiBox {
pub fn new(listeners: Arc<Listeners>) -> Arc<Self> {
let obj: Arc<WifiBox> = Arc::new(Object::builder().build());
setupCallbacks(listeners, obj)
setup_callbacks(listeners, obj)
}
pub fn setupCallbacks(&self) {}
pub fn setup_callbacks(&self) {}
}
fn setupCallbacks(listeners: Arc<Listeners>, wifiBox: Arc<WifiBox>) -> Arc<WifiBox> {
let imp = wifiBox.imp();
let wifibox_ref = wifiBox.clone();
fn setup_callbacks(listeners: Arc<Listeners>, wifi_box: Arc<WifiBox>) -> Arc<WifiBox> {
let imp = wifi_box.imp();
let wifibox_ref = wifi_box.clone();
imp.resetSavedNetworks.set_activatable(true);
imp.resetSavedNetworks
.set_action_name(Some("navigation.push"));
@ -59,44 +59,44 @@ fn setupCallbacks(listeners: Arc<Listeners>, wifiBox: Arc<WifiBox>) -> Arc<WifiB
imp.resetAvailableNetworks.set_activatable(true);
imp.resetAvailableNetworks
.set_action_name(Some("navigation.pop"));
setComboRowEllipsis(imp.resetWiFiDevice.get());
set_combo_row_ellipsis(imp.resetWiFiDevice.get());
imp.resetWifiSwitch.connect_state_set(
clone!(@weak imp => @default-return glib::Propagation::Proceed, move |_, value| {
set_wifi_enabled(value);
if !value {
let mut map = imp.wifiEntries.lock().unwrap();
let mut map = imp.wifi_entries.lock().unwrap();
for entry in map.iter() {
imp.resetWifiList.remove(&*(*entry.1));
}
map.clear();
imp.wifiEntriesPath.lock().unwrap().clear();
imp.wifi_entries_path.lock().unwrap().clear();
listeners.network_listener.store(false, Ordering::SeqCst);
} else {
start_event_listener(listeners.clone(), wifibox_ref.clone());
show_stored_connections(wifibox_ref.clone());
scanForWifi(wifibox_ref.clone());
scan_for_wifi(wifibox_ref.clone());
}
glib::Propagation::Proceed
}),
);
wifiBox
wifi_box
}
pub fn scanForWifi(wifiBox: Arc<WifiBox>) {
let wifibox_ref = wifiBox.clone();
let _wifibox_ref_listener = wifiBox.clone();
let wifiEntries = wifiBox.imp().wifiEntries.clone();
let wifiEntriesPath = wifiBox.imp().wifiEntriesPath.clone();
pub fn scan_for_wifi(wifi_box: Arc<WifiBox>) {
let wifibox_ref = wifi_box.clone();
let _wifibox_ref_listener = wifi_box.clone();
let wifi_entries = wifi_box.imp().wifi_entries.clone();
let wifi_entries_path = wifi_box.imp().wifi_entries_path.clone();
gio::spawn_blocking(move || {
let accessPoints = get_access_points();
let access_points = get_access_points();
let devices = get_wifi_devices();
{
let imp = wifibox_ref.imp();
let list = imp.resetModelList.write().unwrap();
let mut model_index = imp.resetModelIndex.write().unwrap();
let mut map = imp.resetWifiDevices.write().unwrap();
imp.resetCurrentWifiDevice
let list = imp.reset_model_list.write().unwrap();
let mut model_index = imp.reset_model_index.write().unwrap();
let mut map = imp.reset_wifi_devices.write().unwrap();
imp.reset_current_wifi_device
.replace(devices.last().unwrap().clone());
for (index, device) in devices.into_iter().enumerate() {
list.append(&device.name);
@ -104,19 +104,19 @@ pub fn scanForWifi(wifiBox: Arc<WifiBox>) {
*model_index += 1;
}
}
let wifiEntries = wifiEntries.clone();
let wifiEntriesPath = wifiEntriesPath.clone();
let wifi_entries = wifi_entries.clone();
let wifi_entries_path = wifi_entries_path.clone();
dbus_start_network_events();
glib::spawn_future(async move {
glib::idle_add_once(move || {
let mut wifiEntries = wifiEntries.lock().unwrap();
let mut wifiEntriesPath = wifiEntriesPath.lock().unwrap();
let mut wifi_entries = wifi_entries.lock().unwrap();
let mut wifi_entries_path = wifi_entries_path.lock().unwrap();
let imp = wifibox_ref.imp();
let list = imp.resetModelList.read().unwrap();
let list = imp.reset_model_list.read().unwrap();
imp.resetWiFiDevice.set_model(Some(&*list));
let map = imp.resetWifiDevices.read().unwrap();
let device = imp.resetCurrentWifiDevice.borrow();
let map = imp.reset_wifi_devices.read().unwrap();
let device = imp.reset_current_wifi_device.borrow();
if let Some(index) = map.get(&device.name) {
imp.resetWiFiDevice.set_selected(index.1);
}
@ -130,20 +130,21 @@ pub fn scanForWifi(wifiBox: Arc<WifiBox>) {
let selected = selected.downcast_ref::<StringObject>().unwrap();
let selected = selected.string().to_string();
let device = imp.resetWifiDevices.read().unwrap();
let device = imp.reset_wifi_devices.read().unwrap();
let device = device.get(&selected);
if device.is_none() {
return;
}
set_wifi_device(device.unwrap().0.path.clone());
}));
for accessPoint in accessPoints {
let ssid = accessPoint.ssid.clone();
let path = accessPoint.dbus_path.clone();
let connected = imp.resetCurrentWifiDevice.borrow().active_access_point == path;
let entry = WifiEntry::new(connected, accessPoint, imp);
wifiEntries.insert(ssid, entry.clone());
wifiEntriesPath.insert(path, entry.clone());
for access_point in access_points {
let ssid = access_point.ssid.clone();
let path = access_point.dbus_path.clone();
let connected =
imp.reset_current_wifi_device.borrow().active_access_point == path;
let entry = WifiEntry::new(connected, access_point, imp);
wifi_entries.insert(ssid, entry.clone());
wifi_entries_path.insert(path, entry.clone());
imp.resetWifiList.add(&*entry);
}
});
@ -151,19 +152,19 @@ pub fn scanForWifi(wifiBox: Arc<WifiBox>) {
});
}
pub fn show_stored_connections(wifiBox: Arc<WifiBox>) {
let wifibox_ref = wifiBox.clone();
pub fn show_stored_connections(wifi_box: Arc<WifiBox>) {
let wifibox_ref = wifi_box.clone();
gio::spawn_blocking(move || {
let connections = get_stored_connections();
glib::spawn_future(async move {
glib::idle_add_once(move || {
let selfImp = wifibox_ref.imp();
let self_imp = wifibox_ref.imp();
for connection in connections {
// TODO include button for settings
let name =
&String::from_utf8(connection.1).unwrap_or_else(|_| String::from(""));
let entry = SavedWifiEntry::new(name, connection.0, selfImp);
selfImp.resetStoredWifiList.add(&entry);
let entry = SavedWifiEntry::new(name, connection.0, self_imp);
self_imp.resetStoredWifiList.add(&entry);
}
});
});
@ -193,8 +194,8 @@ pub fn get_access_points() -> Vec<AccessPoint> {
if res.is_err() {
return Vec::new();
}
let (accessPoints,) = res.unwrap();
accessPoints
let (access_points,) = res.unwrap();
access_points
}
pub fn set_wifi_device(path: Path<'static>) {
@ -289,18 +290,18 @@ pub fn start_event_listener(listeners: Arc<Listeners>, wifi_box: Arc<WifiBox>) {
glib::spawn_future(async move {
glib::idle_add_once(move || {
let imp = wifi_box.imp();
let mut wifiEntries = imp.wifiEntries.lock().unwrap();
let mut wifiEntriesPath = imp.wifiEntriesPath.lock().unwrap();
let mut wifi_entries = imp.wifi_entries.lock().unwrap();
let mut wifi_entries_path = imp.wifi_entries_path.lock().unwrap();
let ssid = ir.access_point.ssid.clone();
let path = ir.access_point.dbus_path.clone();
if wifiEntries.get(&ssid).is_some() {
if wifi_entries.get(&ssid).is_some() {
return;
}
let connected = imp.resetCurrentWifiDevice.borrow().active_access_point
let connected = imp.reset_current_wifi_device.borrow().active_access_point
== ir.access_point.dbus_path;
let entry = WifiEntry::new(connected, ir.access_point, imp);
wifiEntries.insert(ssid, entry.clone());
wifiEntriesPath.insert(path, entry.clone());
wifi_entries.insert(ssid, entry.clone());
wifi_entries_path.insert(path, entry.clone());
imp.resetWifiList.add(&*entry);
});
});
@ -316,15 +317,15 @@ pub fn start_event_listener(listeners: Arc<Listeners>, wifi_box: Arc<WifiBox>) {
glib::spawn_future(async move {
glib::idle_add_once(move || {
let imp = wifi_box.imp();
let mut wifiEntries = imp.wifiEntries.lock().unwrap();
let mut wifiEntriesPath = imp.wifiEntriesPath.lock().unwrap();
let entry = wifiEntriesPath.remove(&ir.access_point);
let mut wifi_entries = imp.wifi_entries.lock().unwrap();
let mut wifi_entries_path = imp.wifi_entries_path.lock().unwrap();
let entry = wifi_entries_path.remove(&ir.access_point);
if entry.is_none() {
return;
}
let entry = entry.unwrap();
let ssid = entry.imp().accessPoint.borrow().ssid.clone();
wifiEntries.remove(&ssid);
let ssid = entry.imp().access_point.borrow().ssid.clone();
wifi_entries.remove(&ssid);
imp.resetWifiList.remove(&*entry);
});
});
@ -341,22 +342,22 @@ pub fn start_event_listener(listeners: Arc<Listeners>, wifi_box: Arc<WifiBox>) {
glib::spawn_future(async move {
glib::idle_add_local_once(move || {
let imp = wifi_box.imp();
let wifiEntries = imp.wifiEntries.lock().unwrap();
let entry = wifiEntries.get(&ir.access_point.ssid);
let wifi_entries = imp.wifi_entries.lock().unwrap();
let entry = wifi_entries.get(&ir.access_point.ssid);
if entry.is_none() {
return;
}
let entry = entry.unwrap();
let entryImp = entry.imp();
let entry_imp = entry.imp();
let strength = WifiStrength::from_u8(ir.access_point.strength);
let ssid = ir.access_point.ssid.clone();
let name_opt = String::from_utf8(ssid).unwrap_or_else(|_| String::from(""));
let name = name_opt.as_str();
entryImp.wifiStrength.set(strength);
entryImp.resetWifiLabel.get().set_text(name);
entryImp.resetWifiEncrypted.set_visible(false);
entry_imp.wifi_strength.set(strength);
entry_imp.resetWifiLabel.get().set_text(name);
entry_imp.resetWifiEncrypted.set_visible(false);
// TODO handle encryption thing
entryImp
entry_imp
.resetWifiStrength
.get()
.set_from_icon_name(match strength {
@ -368,18 +369,18 @@ pub fn start_event_listener(listeners: Arc<Listeners>, wifi_box: Arc<WifiBox>) {
WifiStrength::None => Some("network-wireless-signal-none-symbolic"),
});
if !ir.access_point.stored {
entryImp.resetWifiEditButton.set_sensitive(false);
entry_imp.resetWifiEditButton.set_sensitive(false);
}
if ir.access_point.dbus_path
== imp.resetCurrentWifiDevice.borrow().active_access_point
== imp.reset_current_wifi_device.borrow().active_access_point
{
entryImp.resetWifiConnected.set_text("Connected");
entry_imp.resetWifiConnected.set_text("Connected");
} else {
entryImp.resetWifiConnected.set_text("");
entry_imp.resetWifiConnected.set_text("");
}
{
let mut wifiName = entryImp.wifiName.borrow_mut();
*wifiName = String::from(name);
let mut wifi_name = entry_imp.wifi_name.borrow_mut();
*wifi_name = String::from(name);
}
});
});
@ -395,17 +396,17 @@ pub fn start_event_listener(listeners: Arc<Listeners>, wifi_box: Arc<WifiBox>) {
glib::spawn_future(async move {
glib::idle_add_once(move || {
let imp = wifi_box.imp();
let mut current_device = imp.resetCurrentWifiDevice.borrow_mut();
let mut current_device = imp.reset_current_wifi_device.borrow_mut();
if current_device.path == ir.wifi_device.path {
current_device.active_access_point = ir.wifi_device.active_access_point;
} else {
*current_device = ir.wifi_device;
}
let mut wifiEntries = imp.wifiEntries.lock().unwrap();
for entry in wifiEntries.iter_mut() {
let mut wifi_entries = imp.wifi_entries.lock().unwrap();
for entry in wifi_entries.iter_mut() {
let imp = entry.1.imp();
let mut connected = imp.connected.borrow_mut();
*connected = imp.accessPoint.borrow().dbus_path == current_device.path;
*connected = imp.access_point.borrow().dbus_path == current_device.path;
}
});
});

24
src/components/wifi/wifiBoxImpl.rs → src/components/wifi/wifi_box_impl.rs
View file

@ -1,4 +1,4 @@
use crate::components::wifi::wifiBox;
use crate::components::wifi::wifi_box;
use adw::{ActionRow, ComboRow, NavigationView, PreferencesGroup};
use dbus::Path;
use gtk::subclass::prelude::*;
@ -9,8 +9,8 @@ use std::collections::HashMap;
use std::sync::{Arc, Mutex, RwLock};
use ReSet_Lib::network::network::WifiDevice;
use crate::components::base::listEntry::ListEntry;
use crate::components::wifi::wifiEntry::WifiEntry;
use crate::components::base::list_entry::ListEntry;
use crate::components::wifi::wifi_entry::WifiEntry;
#[allow(non_snake_case)]
#[derive(Default, CompositeTemplate)]
@ -32,13 +32,13 @@ pub struct WifiBox {
pub resetStoredWifiList: TemplateChild<PreferencesGroup>,
#[template_child]
pub resetAvailableNetworks: TemplateChild<ActionRow>,
pub wifiEntries: Arc<Mutex<HashMap<Vec<u8>, Arc<WifiEntry>>>>,
pub wifiEntriesPath: Arc<Mutex<HashMap<Path<'static>, Arc<WifiEntry>>>>,
pub savedWifiEntries: Arc<Mutex<Vec<ListEntry>>>,
pub resetWifiDevices: Arc<RwLock<HashMap<String, (WifiDevice, u32)>>>,
pub resetCurrentWifiDevice: Arc<RefCell<WifiDevice>>,
pub resetModelList: Arc<RwLock<StringList>>,
pub resetModelIndex: Arc<RwLock<u32>>,
pub wifi_entries: Arc<Mutex<HashMap<Vec<u8>, Arc<WifiEntry>>>>,
pub wifi_entries_path: Arc<Mutex<HashMap<Path<'static>, Arc<WifiEntry>>>>,
pub saved_wifi_entries: Arc<Mutex<Vec<ListEntry>>>,
pub reset_wifi_devices: Arc<RwLock<HashMap<String, (WifiDevice, u32)>>>,
pub reset_current_wifi_device: Arc<RefCell<WifiDevice>>,
pub reset_model_list: Arc<RwLock<StringList>>,
pub reset_model_index: Arc<RwLock<u32>>,
}
unsafe impl Send for WifiBox {}
@ -48,7 +48,7 @@ unsafe impl Sync for WifiBox {}
impl ObjectSubclass for WifiBox {
const ABSTRACT: bool = false;
const NAME: &'static str = "resetWifi";
type Type = wifiBox::WifiBox;
type Type = wifi_box::WifiBox;
type ParentType = gtk::Box;
fn class_init(klass: &mut Self::Class) {
@ -67,7 +67,7 @@ impl ObjectImpl for WifiBox {
self.parent_constructed();
let obj = self.obj();
obj.setupCallbacks();
obj.setup_callbacks();
}
}

77
src/components/wifi/wifiEntry.rs → src/components/wifi/wifi_entry.rs
View file

@ -1,7 +1,7 @@
use std::sync::Arc;
use std::time::Duration;
use crate::components::wifi::utils::getConnectionSettings;
use crate::components::wifi::utils::get_connection_settings;
use adw::glib;
use adw::glib::{Object, PropertySet};
use adw::prelude::{ActionRowExt, ButtonExt, EditableExt, PopoverExt};
@ -13,12 +13,12 @@ use gtk::gio;
use gtk::prelude::{ListBoxRowExt, WidgetExt};
use ReSet_Lib::network::network::{AccessPoint, WifiStrength};
use crate::components::wifi::wifiBoxImpl::WifiBox;
use crate::components::wifi::wifiEntryImpl;
use crate::components::wifi::wifiOptions::WifiOptions;
use crate::components::wifi::wifi_box_impl::WifiBox;
use crate::components::wifi::wifi_entry_impl;
use crate::components::wifi::wifi_options::WifiOptions;
glib::wrapper! {
pub struct WifiEntry(ObjectSubclass<wifiEntryImpl::WifiEntry>)
pub struct WifiEntry(ObjectSubclass<wifi_entry_impl::WifiEntry>)
@extends adw::ActionRow, gtk::Widget,
@implements gtk::Accessible, gtk::Buildable, gtk::Actionable, gtk::ConstraintTarget, gtk::ListBoxRow;
}
@ -27,21 +27,21 @@ unsafe impl Send for WifiEntry {}
unsafe impl Sync for WifiEntry {}
impl WifiEntry {
pub fn new(connected: bool, access_point: AccessPoint, wifiBox: &WifiBox) -> Arc<Self> {
pub fn new(connected: bool, access_point: AccessPoint, wifi_box: &WifiBox) -> Arc<Self> {
let entry: Arc<WifiEntry> = Arc::new(Object::builder().build());
let stored_entry = entry.clone();
let new_entry = entry.clone();
let entryImp = entry.imp();
let entry_imp = entry.imp();
let strength = WifiStrength::from_u8(access_point.strength);
let ssid = access_point.ssid.clone();
let name_opt = String::from_utf8(ssid).unwrap_or_else(|_| String::from(""));
let name = name_opt.as_str();
entryImp.wifiStrength.set(strength);
entryImp.resetWifiLabel.get().set_text(name);
entryImp.resetWifiEncrypted.set_visible(false);
entryImp.connected.set(connected);
entry_imp.wifi_strength.set(strength);
entry_imp.resetWifiLabel.get().set_text(name);
entry_imp.resetWifiEncrypted.set_visible(false);
entry_imp.connected.set(connected);
// TODO handle encryption thing
entryImp
entry_imp
.resetWifiStrength
.get()
.set_from_icon_name(match strength {
@ -51,22 +51,21 @@ impl WifiEntry {
WifiStrength::None => Some("network-wireless-signal-none-symbolic"),
});
if !access_point.stored {
entryImp.resetWifiEditButton.set_sensitive(false);
entry_imp.resetWifiEditButton.set_sensitive(false);
}
if connected {
entryImp
.resetWifiConnected.set_text("Connected");
entry_imp.resetWifiConnected.set_text("Connected");
}
{
let mut wifiName = entryImp.wifiName.borrow_mut();
*wifiName = String::from(name);
let mut wifi_name = entry_imp.wifi_name.borrow_mut();
*wifi_name = String::from(name);
}
entryImp.accessPoint.set(access_point);
entry_imp.access_point.set(access_point);
entry.set_activatable(true);
entry.connect_activated(clone!(@weak entryImp => move |_| {
let access_point = entryImp.accessPoint.borrow();
if *entryImp.connected.borrow() {
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());
@ -74,15 +73,15 @@ impl WifiEntry {
click_new_network(new_entry.clone());
}
}));
entry.setupCallbacks(wifiBox);
entry.setup_callbacks(wifi_box);
entry
}
pub fn setupCallbacks(&self, wifiBox: &WifiBox) {
let selfImp = self.imp();
selfImp.resetWifiEditButton.connect_clicked(clone!(@ weak selfImp, @ weak wifiBox => move |_| {
let _option = getConnectionSettings(selfImp.accessPoint.borrow().associated_connection.clone());
wifiBox.resetWifiNavigation.push(&*WifiOptions::new(_option, selfImp.accessPoint.borrow().dbus_path.clone()));
pub fn setup_callbacks(&self, wifi_box: &WifiBox) {
let self_imp = self.imp();
self_imp.resetWifiEditButton.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.resetWifiNavigation.push(&*WifiOptions::new(_option, self_imp.access_point.borrow().dbus_path.clone()));
}));
}
}
@ -119,8 +118,8 @@ pub fn click_disconnect(entry: Arc<WifiEntry>) {
}
pub fn click_stored_network(entry: Arc<WifiEntry>) {
let entryImp = entry.imp();
let access_point = entryImp.accessPoint.borrow().clone();
let entry_imp = entry.imp();
let access_point = entry_imp.access_point.borrow().clone();
let entry_ref = entry.clone();
entry.set_activatable(false);
gio::spawn_blocking(move || {
@ -212,18 +211,18 @@ pub fn click_new_network(entry: Arc<WifiEntry>) {
// TODO crate spinner animation and block UI
};
let entryImp = entry.imp();
let popupImp = entryImp.resetWifiPopup.imp();
popupImp
let entry_imp = entry.imp();
let popup_imp = entry_imp.resetWifiPopup.imp();
popup_imp
.resetPopupEntry
.connect_activate(clone!(@weak entry as origEntry, @weak entryImp => move |entry| {
connect_new_network(origEntry, entryImp.accessPoint.clone().take(), entry.text().to_string());
.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());
}));
popupImp.resetPopupButton.connect_clicked(
clone!(@weak entry as origEntry,@weak entryImp, @weak popupImp => move |_| {
let entry = entryImp.resetWifiPopup.imp().resetPopupEntry.text().to_string();
connect_new_network(origEntry, entryImp.accessPoint.clone().take(), entry);
popup_imp.resetPopupButton.connect_clicked(
clone!(@weak entry as orig_entry,@weak entry_imp, @weak popup_imp => move |_| {
let entry = entry_imp.resetWifiPopup.imp().resetPopupEntry.text().to_string();
connect_new_network(orig_entry, entry_imp.access_point.clone().take(), entry);
}),
);
entryImp.resetWifiPopup.popup();
entry_imp.resetWifiPopup.popup();
}

10
src/components/wifi/wifiEntryImpl.rs → src/components/wifi/wifi_entry_impl.rs
View file

@ -1,5 +1,5 @@
use crate::components::base::popup::Popup;
use crate::components::wifi::wifiEntry;
use crate::components::wifi::wifi_entry;
use adw::subclass::preferences_row::PreferencesRowImpl;
use adw::subclass::prelude::ActionRowImpl;
use adw::ActionRow;
@ -24,9 +24,9 @@ pub struct WifiEntry {
pub resetWifiConnected: TemplateChild<Label>,
#[template_child]
pub resetWifiPopup: TemplateChild<Popup>,
pub wifiName: RefCell<String>,
pub wifiStrength: RefCell<WifiStrength>,
pub accessPoint: RefCell<AccessPoint>,
pub wifi_name: RefCell<String>,
pub wifi_strength: RefCell<WifiStrength>,
pub access_point: RefCell<AccessPoint>,
pub connected: RefCell<bool>,
}
@ -37,7 +37,7 @@ unsafe impl Sync for WifiEntry {}
impl ObjectSubclass for WifiEntry {
const ABSTRACT: bool = false;
const NAME: &'static str = "resetWifiEntry";
type Type = wifiEntry::WifiEntry;
type Type = wifi_entry::WifiEntry;
type ParentType = ActionRow;
fn class_init(klass: &mut Self::Class) {

390
src/components/wifi/wifi_options.rs Normal file
View file

@ -0,0 +1,390 @@
use std::net::{Ipv4Addr, Ipv6Addr};
use std::str::FromStr;
use std::sync::Arc;
use std::time::Duration;
use adw::glib::Object;
use adw::prelude::{ActionRowExt, ComboRowExt, PreferencesGroupExt};
use adw::subclass::prelude::ObjectSubclassIsExt;
use adw::{gio, glib};
use dbus::arg::PropMap;
use dbus::{Error, Path};
use glib::{clone, PropertySet};
use gtk::prelude::{ButtonExt, EditableExt, WidgetExt};
use IpProtocol::{IPv4, IPv6};
use ReSet_Lib::network::connection::{Connection, DNSMethod4, DNSMethod6, Enum, TypeSettings};
use crate::components::wifi::utils::IpProtocol;
use crate::components::wifi::wifi_address_entry::WifiAddressEntry;
use crate::components::wifi::wifi_options_impl;
use crate::components::wifi::wifi_route_entry::WifiRouteEntry;
glib::wrapper! {
pub struct WifiOptions(ObjectSubclass<wifi_options_impl::WifiOptions>)
@extends adw::NavigationPage, gtk::Widget,
@implements gtk::Accessible, gtk::Buildable, gtk::ConstraintTarget;
}
unsafe impl Send for WifiOptions {}
unsafe impl Sync for WifiOptions {}
impl WifiOptions {
pub fn new(connection: Connection, access_point: Path<'static>) -> Arc<Self> {
let wifi_option: Arc<WifiOptions> = Arc::new(Object::builder().build());
wifi_option.imp().connection.set(connection);
wifi_option.initialize_ui();
setup_callbacks(&wifi_option, access_point);
wifi_option
}
pub fn initialize_ui(&self) {
let self_imp = self.imp();
let ip4_address_length;
let ip4_route_length;
let ip6_address_length;
let ip6_route_length;
{
let conn = self_imp.connection.borrow();
ip4_address_length = conn.ipv4.address_data.len();
ip4_route_length = conn.ipv4.route_data.len();
ip6_address_length = conn.ipv4.address_data.len();
ip6_route_length = conn.ipv4.route_data.len();
// General
self_imp
.resetWifiAutoConnect
.set_active(conn.settings.autoconnect);
self_imp
.resetWifiMetered
.set_active(conn.settings.metered != -1);
match &conn.device {
TypeSettings::WIFI(wifi) => {
self_imp.resetWifiLinkSpeed.set_visible(false);
self_imp.resetWifiIP4Addr.set_visible(false);
self_imp.resetWifiIP6Addr.set_visible(false);
self_imp.resetWifiDNS.set_visible(false);
self_imp.resetWifiGateway.set_visible(false);
self_imp.resetWifiLastUsed.set_visible(true);
self_imp.resetWifiMac.set_subtitle(&wifi.cloned_mac_address);
self_imp
.resetWifiName
.set_subtitle(&String::from_utf8(wifi.ssid.clone()).unwrap_or_default());
}
TypeSettings::ETHERNET(ethernet) => {
self_imp.resetWifiLinkSpeed.set_visible(true);
self_imp.resetWifiIP4Addr.set_visible(true);
self_imp.resetWifiIP6Addr.set_visible(true);
self_imp.resetWifiDNS.set_visible(true);
self_imp.resetWifiGateway.set_visible(true);
self_imp.resetWifiLastUsed.set_visible(false);
self_imp
.resetWifiMac
.set_subtitle(&ethernet.cloned_mac_address);
self_imp
.resetWifiLinkSpeed
.set_subtitle(&ethernet.speed.to_string());
}
TypeSettings::VPN(_vpn) => {}
TypeSettings::None => {}
};
// IPv4
self_imp
.resetIP4Method
.set_selected(conn.ipv4.dns_method.to_i32() as u32);
self.set_ip4_visibility(conn.ipv4.dns_method.to_i32() as u32);
let ipv4_dns: Vec<String> = conn
.ipv4
.dns
.iter()
.map(|addr| {
addr.iter()
.map(|octet| octet.to_string())
.collect::<Vec<String>>()
.join(".")
})
.collect();
self_imp.resetIP4DNS.set_text(&ipv4_dns.join(", "));
self_imp.resetIP4Gateway.set_text(&conn.ipv4.gateway);
// IPv6
self_imp
.resetIP6Method
.set_selected(conn.ipv6.dns_method.to_i32() as u32);
self.set_ip6_visibility(conn.ipv6.dns_method.to_i32() as u32);
let ipv6_dns: Vec<String> = conn
.ipv6
.dns
.iter()
.map(|addr| {
addr.iter()
.map(|octet| octet.to_string())
.collect::<Vec<String>>()
.join(":")
})
.collect();
self_imp.resetIP6DNS.set_text(&ipv6_dns.join(", "));
self_imp.resetIP6Gateway.set_text(&conn.ipv6.gateway);
// Security
if let TypeSettings::WIFI(wifi) = &conn.device {
match wifi.security_settings.key_management.as_str() {
"none" => {
self_imp.resetWifiSecurityDropdown.set_selected(0);
self_imp.resetWifiPassword.set_visible(false);
self_imp.resetWifiPassword.set_text("");
}
"wpa-psk" => {
self_imp.resetWifiSecurityDropdown.set_selected(1);
self_imp.resetWifiPassword.set_visible(true);
self_imp
.resetWifiPassword
.set_text(&wifi.security_settings.psk);
}
_ => {}
}
}
}
// IPv4
for i in 0..ip4_address_length {
let address = &WifiAddressEntry::new(Some(i), self_imp.connection.clone(), IPv4);
self_imp.resetIP4AddressGroup.add(address);
}
let address = &WifiAddressEntry::new(None, self_imp.connection.clone(), IPv4);
self_imp.resetIP4AddressGroup.add(address);
for i in 0..ip4_route_length {
let route = &WifiRouteEntry::new(Some(i), self_imp.connection.clone(), IPv4);
self_imp.resetIP4RoutesGroup.add(route)
}
let route = &WifiRouteEntry::new(None, self_imp.connection.clone(), IPv4);
self_imp.resetIP4RoutesGroup.add(route);
// IPv6
for i in 0..ip6_address_length {
let address = &WifiAddressEntry::new(Some(i), self_imp.connection.clone(), IPv6);
self_imp.resetIP6AddressGroup.add(address);
}
let address = &WifiAddressEntry::new(None, self_imp.connection.clone(), IPv6);
self_imp.resetIP6AddressGroup.add(address);
for i in 0..ip6_route_length {
let route = &WifiRouteEntry::new(Some(i), self_imp.connection.clone(), IPv6);
self_imp.resetIP6RoutesGroup.add(route);
}
let route = &WifiRouteEntry::new(None, self_imp.connection.clone(), IPv6);
self_imp.resetIP6RoutesGroup.add(route);
// Security
}
pub fn set_ip4_visibility(&self, method: u32) {
let self_imp = self.imp();
match method {
0 => {
// auto
self_imp.resetIP4AddressGroup.set_visible(false);
self_imp.resetIP4RoutesGroup.set_visible(true);
self_imp.resetIP4Gateway.set_visible(false);
}
1 => {
// manual
self_imp.resetIP4AddressGroup.set_visible(true);
self_imp.resetIP4RoutesGroup.set_visible(true);
self_imp.resetIP4Gateway.set_visible(true);
}
_ => {
self_imp.resetIP4AddressGroup.set_visible(false);
self_imp.resetIP4RoutesGroup.set_visible(false);
self_imp.resetIP4Gateway.set_visible(false);
}
}
}
pub fn set_ip6_visibility(&self, method: u32) {
let self_imp = self.imp();
match method {
0 | 1 => {
// auto, dhcp
self_imp.resetIP6AddressGroup.set_visible(false);
self_imp.resetIP6RoutesGroup.set_visible(true);
self_imp.resetIP6Gateway.set_visible(false);
}
2 => {
// manual
self_imp.resetIP6AddressGroup.set_visible(true);
self_imp.resetIP6RoutesGroup.set_visible(true);
self_imp.resetIP6Gateway.set_visible(true);
}
_ => {
self_imp.resetIP6AddressGroup.set_visible(false);
self_imp.resetIP6RoutesGroup.set_visible(false);
self_imp.resetIP6Gateway.set_visible(false);
}
}
}
}
fn setup_callbacks(wifi_options: &Arc<WifiOptions>, path: Path<'static>) {
let imp = wifi_options.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();
set_connection_settings(path.clone(), prop);
}));
// IPv4
let wifi_options_ip4 = wifi_options.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);
wifi_options_ip4.set_ip4_visibility(selected);
}));
imp.resetIP4DNS
.connect_changed(clone!(@weak imp => move |entry| {
let dns_input = entry.text();
let mut conn = imp.connection.borrow_mut();
conn.ipv4.dns.clear();
if dns_input.is_empty() {
imp.resetIP4DNS.remove_css_class("error");
return;
}
for dns_entry in dns_input.as_str().split(',').map(|s| s.trim()) {
if let Ok(addr) = Ipv4Addr::from_str(dns_entry) {
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 gateway_input = entry.text();
let mut conn = imp.connection.borrow_mut();
conn.ipv4.gateway.clear();
if gateway_input.is_empty() {
imp.resetIP4Gateway.remove_css_class("error");
return;
}
if Ipv4Addr::from_str(gateway_input.as_str()).is_ok() {
imp.resetIP4Gateway.remove_css_class("error");
conn.ipv4.gateway = gateway_input.to_string();
} else {
imp.resetIP4Gateway.add_css_class("error");
}
}));
// IPv6
let wifi_options_ip6 = wifi_options.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);
wifi_options_ip6.set_ip6_visibility(selected);
}));
imp.resetIP6DNS
.connect_changed(clone!(@weak imp => move |entry| {
let dns_input = entry.text();
let mut conn = imp.connection.borrow_mut();
conn.ipv6.dns.clear();
if dns_input.is_empty() {
imp.resetIP6DNS.remove_css_class("error");
return;
}
for dns_entry in dns_input.as_str().split(',').map(|s| s.trim()) {
if let Ok(addr) = Ipv6Addr::from_str(dns_entry) {
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 gateway_input = entry.text();
let mut conn = imp.connection.borrow_mut();
conn.ipv6.gateway.clear();
if gateway_input.is_empty() {
imp.resetIP6Gateway.remove_css_class("error");
return;
}
if Ipv6Addr::from_str(gateway_input.as_str()).is_ok() {
imp.resetIP6Gateway.remove_css_class("error");
conn.ipv6.gateway = gateway_input.to_string();
} else {
imp.resetIP6Gateway.add_css_class("error");
}
}));
// Security
imp.resetWifiSecurityDropdown
.connect_selected_notify(clone!(@weak imp => move |dropdown| {
let selected = dropdown.selected();
let mut conn = imp.connection.borrow_mut();
match (selected, &mut conn.device) {
(0 , TypeSettings::WIFI(wifi)) => { // None
imp.resetWifiPassword.set_visible(false);
wifi.security_settings.key_management = String::from("none");
wifi.security_settings.authentication_algorithm = String::from("open");
},
(1 , TypeSettings::WIFI(wifi)) => { // WPA/WPA2 Personal
imp.resetWifiPassword.set_visible(true);
wifi.security_settings.key_management = String::from("wpa-psk");
wifi.security_settings.authentication_algorithm = String::from("");
},
(_, _) => {}
}
}));
imp.resetWifiPassword
.connect_changed(clone!(@weak imp => move |entry| {
let password_input = entry.text();
let mut conn = imp.connection.borrow_mut();
if let TypeSettings::WIFI(wifi) = &mut conn.device {
wifi.security_settings.psk = password_input.to_string();
}
}));
}
fn set_connection_settings(path: Path<'static>, prop: PropMap) {
gio::spawn_blocking(move || {
let conn = dbus::blocking::Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSetDaemon",
"/org/Xetibo/ReSetDaemon",
Duration::from_millis(1000),
);
let _: Result<(bool,), Error> = proxy.method_call(
"org.Xetibo.ReSetWireless",
"SetConnectionSettings",
(path, prop),
);
});
}

9
src/components/wifi/wifiOptionsImpl.rs → src/components/wifi/wifi_options_impl.rs
View file

@ -1,12 +1,13 @@
use crate::components::wifi::wifiOptions;
use crate::components::wifi::wifi_options;
use adw::subclass::prelude::NavigationPageImpl;
use adw::{ActionRow, ComboRow, EntryRow, NavigationPage, PasswordEntryRow, PreferencesGroup, SwitchRow};
use adw::{
ActionRow, ComboRow, EntryRow, NavigationPage, PasswordEntryRow, PreferencesGroup, SwitchRow,
};
use gtk::subclass::prelude::*;
use gtk::{glib, Button, CompositeTemplate};
use std::cell::RefCell;
use std::rc::Rc;
use ReSet_Lib::network::connection::Connection;
use ReSet_Lib::network::network::AccessPoint;
#[allow(non_snake_case)]
#[derive(Default, CompositeTemplate)]
@ -78,7 +79,7 @@ pub struct WifiOptions {
impl ObjectSubclass for WifiOptions {
const ABSTRACT: bool = false;
const NAME: &'static str = "resetWifiOptions";
type Type = wifiOptions::WifiOptions;
type Type = wifi_options::WifiOptions;
type ParentType = NavigationPage;
fn class_init(klass: &mut Self::Class) {

242
src/components/wifi/wifi_route_entry.rs Normal file
View file

@ -0,0 +1,242 @@
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::wifi_route_entry_impl;
use crate::components::wifi::wifi_route_entry_impl::WifiRouteEntryImpl;
glib::wrapper! {
pub struct WifiRouteEntry(ObjectSubclass<wifi_route_entry_impl::WifiRouteEntryImpl>)
@extends gtk::Box, gtk::Widget,
@implements gtk::Accessible, gtk::Buildable, gtk::ConstraintTarget, gtk::Orientable;
}
impl WifiRouteEntry {
pub fn new(
address: Option<usize>,
conn: Rc<RefCell<Connection>>,
protocol: IpProtocol,
) -> Self {
let entry: WifiRouteEntry = Object::builder().build();
let entry_imp = entry.imp();
if let Some(address) = address {
let conn = conn.borrow();
let address = unsafe { conn.ipv4.route_data.get_unchecked(address) };
entry_imp.resetRouteAddress.set_text(&address.address);
entry_imp
.resetRoutePrefix
.set_text(&address.prefix_length.to_string());
if let Some(gateway) = &address.gateway {
entry_imp.resetRouteGateway.set_text(gateway);
}
if let Some(metric) = address.metric {
entry_imp.resetRouteMetric.set_text(&metric.to_string());
}
entry_imp
.resetRouteRow
.set_title(&format!("{}/{}", &*address.address, address.prefix_length));
}
entry_imp.protocol.set(protocol);
entry.setup_callbacks(conn);
entry
}
fn setup_callbacks(&self, connection: Rc<RefCell<Connection>>) {
let self_imp = self.imp();
let conn = connection.clone();
self_imp.resetRouteAddress.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.resetRouteAddress.remove_css_class("error");
self_imp.resetRouteRow.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) => {
self_imp.resetRouteAddress.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());
}
Err(_) => {
self_imp.resetRouteAddress.add_css_class("error");
*self_imp.address.borrow_mut() = (false, String::default());
}
}
set_row_title(&self_imp);
}));
let conn = connection.clone();
self_imp.resetRoutePrefix.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.resetRoutePrefix.text().is_empty() {
self_imp.resetRoutePrefix.remove_css_class("error");
} else {
self_imp.resetRoutePrefix.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.resetRoutePrefix.remove_css_class("error");
if let Ok(address2) = Ipv4Addr::from_str(self_imp.resetRouteAddress.text().as_str()) {
if let Some(addr) = conn.ipv4.route_data.iter_mut()
.find(|conn_addr| *conn_addr.address == address2.to_string()) {
addr.prefix_length = prefix as u32;
}
}
}
IpProtocol::IPv6 if prefix <= 128 => {
self_imp.prefix.set((true, prefix as u32));
self_imp.resetRoutePrefix.remove_css_class("error");
if let Ok(address2) = Ipv6Addr::from_str(self_imp.resetRouteAddress.text().as_str()) {
if let Some(addr) = conn.ipv6.route_data.iter_mut()
.find(|conn_addr| *conn_addr.address == address2.to_string()) {
addr.prefix_length = prefix as u32;
}
}
}
_ => handle_error()
}
set_row_title(&self_imp);
}));
let conn = connection.clone();
self_imp
.resetRouteGateway
.connect_changed(clone!(@weak self_imp => move |entry| {
let gateway_input = entry.text();
let mut conn = conn.borrow_mut();
if gateway_input.is_empty() {
self_imp.resetRouteGateway.remove_css_class("error");
*self_imp.gateway.borrow_mut() = None;
set_row_subtitle(&self_imp);
return;
}
let result = match self_imp.protocol.get() {
IpProtocol::IPv4 => Ipv4Addr::from_str(gateway_input.as_str()).map(IpAddr::V4),
IpProtocol::IPv6 => Ipv6Addr::from_str(gateway_input.as_str()).map(IpAddr::V6),
};
match result {
Ok(ip_addr) => {
self_imp.resetRouteGateway.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,
};
if let Some(address) = address_data.iter_mut()
.find(|conn_addr| *conn_addr.address == self_imp.resetRouteAddress.text()) {
address.gateway = Some(ip_addr.to_string());
}
*self_imp.gateway.borrow_mut() = Some(ip_addr.to_string());
}
Err(_) => {
self_imp.resetRouteGateway.add_css_class("error");
*self_imp.gateway.borrow_mut() = None;
}
}
set_row_subtitle(&self_imp);
}));
let conn = connection.clone();
self_imp
.resetRouteMetric
.connect_changed(clone!(@weak self_imp => move |entry| {
let metric_input = entry.text();
let mut conn = conn.borrow_mut();
if metric_input.is_empty() {
self_imp.resetRouteMetric.remove_css_class("error");
self_imp.metric.set(None);
set_row_subtitle(&self_imp);
return;
}
let result = metric_input.parse::<u32>();
match result {
Ok(metric) => {
self_imp.resetRouteMetric.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,
};
if let Some(address) = address_data.iter_mut()
.find(|conn_addr| *conn_addr.address == self_imp.resetRouteAddress.text()) {
address.metric = Some(metric);
}
self_imp.metric.set(Some(metric));
}
Err(_) => {
self_imp.resetRouteMetric.add_css_class("error");
self_imp.metric.set(None);
}
}
set_row_subtitle(&self_imp);
}));
}
}
fn set_row_title(self_imp: &WifiRouteEntryImpl) {
if self_imp.resetRouteAddress.text().is_empty() {
return;
}
let address = self_imp.address.borrow();
let prefix = self_imp.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(),
};
self_imp.resetRouteRow.set_title(&title);
}
fn set_row_subtitle(self_imp: &WifiRouteEntryImpl) {
let gateway = self_imp.gateway.borrow().clone();
let metric = self_imp.metric.get();
let title = match (gateway, metric) {
(Some(gateway), Some(metric)) => {
format!("{}, {}", gateway, metric)
}
(Some(gateway), None) => gateway,
(None, Some(metric)) => metric.to_string(),
(None, None) => String::default(),
};
self_imp.resetRouteRow.set_subtitle(&title);
}

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

@ -1,5 +1,5 @@
use crate::components::wifi::utils::IpProtocol;
use crate::components::wifi::wifiRouteEntry;
use crate::components::wifi::wifi_route_entry;
use adw::{EntryRow, ExpanderRow};
use gtk::subclass::prelude::*;
use gtk::{glib, Button, CompositeTemplate};
@ -32,7 +32,7 @@ pub struct WifiRouteEntryImpl {
impl ObjectSubclass for WifiRouteEntryImpl {
const ABSTRACT: bool = false;
const NAME: &'static str = "resetWifiRouteEntry";
type Type = wifiRouteEntry::WifiRouteEntry;
type Type = wifi_route_entry::WifiRouteEntry;
type ParentType = gtk::Box;
fn class_init(klass: &mut Self::Class) {

126
src/components/window/handleSidebarClick.rs → src/components/window/handle_sidebar_click.rs
View file

@ -2,123 +2,123 @@ use gtk::prelude::FrameExt;
use std::sync::atomic::Ordering;
use std::sync::Arc;
use crate::components::base::settingBox::SettingBox;
use crate::components::base::setting_box::SettingBox;
use crate::components::base::utils::{start_audio_listener, Listeners};
use crate::components::bluetooth::bluetoothBox::{
use crate::components::bluetooth::bluetooth_box::{
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 crate::components::input::source_box::{populate_sources, SourceBox};
use crate::components::output::sink_box::{populate_sinks, SinkBox};
use crate::components::wifi::wifi_box::{
scan_for_wifi, show_stored_connections, start_event_listener, WifiBox,
};
use gtk::prelude::WidgetExt;
use gtk::{FlowBox, Frame};
pub const HANDLE_CONNECTIVITY_CLICK: fn(Arc<Listeners>, FlowBox) =
|listeners: Arc<Listeners>, resetMain: FlowBox| {
|listeners: Arc<Listeners>, reset_main: FlowBox| {
listeners.stop_audio_listener();
let wifiBox = WifiBox::new(listeners.clone());
start_event_listener(listeners.clone(), wifiBox.clone());
show_stored_connections(wifiBox.clone());
scanForWifi(wifiBox.clone());
let wifiFrame = wrapInFrame(SettingBox::new(&*wifiBox));
let wifi_box = WifiBox::new(listeners.clone());
start_event_listener(listeners.clone(), wifi_box.clone());
show_stored_connections(wifi_box.clone());
scan_for_wifi(wifi_box.clone());
let wifi_frame = wrap_in_frame(SettingBox::new(&*wifi_box));
let bluetooth_box = BluetoothBox::new(listeners.clone());
populate_conntected_bluetooth_devices(bluetooth_box.clone());
start_bluetooth_listener(listeners.clone(), bluetooth_box.clone());
let bluetoothFrame = wrapInFrame(SettingBox::new(&*bluetooth_box));
resetMain.remove_all();
resetMain.insert(&wifiFrame, -1);
resetMain.insert(&bluetoothFrame, -1);
resetMain.set_max_children_per_line(2);
let bluetooth_frame = wrap_in_frame(SettingBox::new(&*bluetooth_box));
reset_main.remove_all();
reset_main.insert(&wifi_frame, -1);
reset_main.insert(&bluetooth_frame, -1);
reset_main.set_max_children_per_line(2);
};
pub const HANDLE_WIFI_CLICK: fn(Arc<Listeners>, FlowBox) =
|listeners: Arc<Listeners>, resetMain: FlowBox| {
|listeners: Arc<Listeners>, reset_main: FlowBox| {
listeners.stop_audio_listener();
listeners.stop_bluetooth_listener();
let wifiBox = WifiBox::new(listeners.clone());
start_event_listener(listeners.clone(), wifiBox.clone());
show_stored_connections(wifiBox.clone());
scanForWifi(wifiBox.clone());
let wifiFrame = wrapInFrame(SettingBox::new(&*wifiBox));
resetMain.remove_all();
resetMain.insert(&wifiFrame, -1);
resetMain.set_max_children_per_line(1);
let wifi_box = WifiBox::new(listeners.clone());
start_event_listener(listeners.clone(), wifi_box.clone());
show_stored_connections(wifi_box.clone());
scan_for_wifi(wifi_box.clone());
let wifi_frame = wrap_in_frame(SettingBox::new(&*wifi_box));
reset_main.remove_all();
reset_main.insert(&wifi_frame, -1);
reset_main.set_max_children_per_line(1);
};
pub const HANDLE_BLUETOOTH_CLICK: fn(Arc<Listeners>, FlowBox) =
|listeners: Arc<Listeners>, resetMain: FlowBox| {
|listeners: Arc<Listeners>, reset_main: FlowBox| {
listeners.stop_network_listener();
listeners.stop_audio_listener();
let bluetooth_box = BluetoothBox::new(listeners.clone());
start_bluetooth_listener(listeners.clone(), bluetooth_box.clone());
populate_conntected_bluetooth_devices(bluetooth_box.clone());
let bluetoothFrame = wrapInFrame(SettingBox::new(&*bluetooth_box));
resetMain.remove_all();
resetMain.insert(&bluetoothFrame, -1);
resetMain.set_max_children_per_line(1);
let bluetooth_frame = wrap_in_frame(SettingBox::new(&*bluetooth_box));
reset_main.remove_all();
reset_main.insert(&bluetooth_frame, -1);
reset_main.set_max_children_per_line(1);
};
pub const HANDLE_AUDIO_CLICK: fn(Arc<Listeners>, FlowBox) =
|listeners: Arc<Listeners>, resetMain: FlowBox| {
|listeners: Arc<Listeners>, reset_main: FlowBox| {
listeners.stop_network_listener();
listeners.stop_bluetooth_listener();
let audioOutput = Arc::new(SinkBox::new());
let audioInput = Arc::new(SourceBox::new());
let audio_output = Arc::new(SinkBox::new());
let audio_input = Arc::new(SourceBox::new());
start_audio_listener(
listeners.clone(),
Some(audioOutput.clone()),
Some(audioInput.clone()),
Some(audio_output.clone()),
Some(audio_input.clone()),
);
populate_sinks(audioOutput.clone());
let audioFrame = wrapInFrame(SettingBox::new(&*audioOutput));
populate_sources(audioInput.clone());
let sourceFrame = wrapInFrame(SettingBox::new(&*audioInput));
resetMain.remove_all();
resetMain.insert(&audioFrame, -1);
resetMain.insert(&sourceFrame, -1);
resetMain.set_max_children_per_line(2);
populate_sinks(audio_output.clone());
let audio_frame = wrap_in_frame(SettingBox::new(&*audio_output));
populate_sources(audio_input.clone());
let source_frame = wrap_in_frame(SettingBox::new(&*audio_input));
reset_main.remove_all();
reset_main.insert(&audio_frame, -1);
reset_main.insert(&source_frame, -1);
reset_main.set_max_children_per_line(2);
};
pub const HANDLE_VOLUME_CLICK: fn(Arc<Listeners>, FlowBox) =
|listeners: Arc<Listeners>, resetMain: FlowBox| {
|listeners: Arc<Listeners>, reset_main: FlowBox| {
listeners.stop_network_listener();
listeners.stop_bluetooth_listener();
let audioOutput = Arc::new(SinkBox::new());
start_audio_listener(listeners.clone(), Some(audioOutput.clone()), None);
let audio_output = Arc::new(SinkBox::new());
start_audio_listener(listeners.clone(), Some(audio_output.clone()), None);
while !listeners.pulse_listener.load(Ordering::SeqCst) {
std::hint::spin_loop()
}
populate_sinks(audioOutput.clone());
let audioFrame = wrapInFrame(SettingBox::new(&*audioOutput));
resetMain.remove_all();
resetMain.insert(&audioFrame, -1);
resetMain.set_max_children_per_line(1);
populate_sinks(audio_output.clone());
let audio_frame = wrap_in_frame(SettingBox::new(&*audio_output));
reset_main.remove_all();
reset_main.insert(&audio_frame, -1);
reset_main.set_max_children_per_line(1);
};
pub const HANDLE_MICROPHONE_CLICK: fn(Arc<Listeners>, FlowBox) =
|listeners: Arc<Listeners>, resetMain: FlowBox| {
|listeners: Arc<Listeners>, reset_main: FlowBox| {
listeners.stop_network_listener();
listeners.stop_bluetooth_listener();
let audioInput = Arc::new(SourceBox::new());
start_audio_listener(listeners.clone(), None, Some(audioInput.clone()));
populate_sources(audioInput.clone());
let sourceFrame = wrapInFrame(SettingBox::new(&*audioInput));
resetMain.remove_all();
resetMain.insert(&sourceFrame, -1);
resetMain.set_max_children_per_line(1);
let audio_input = Arc::new(SourceBox::new());
start_audio_listener(listeners.clone(), None, Some(audio_input.clone()));
populate_sources(audio_input.clone());
let source_frame = wrap_in_frame(SettingBox::new(&*audio_input));
reset_main.remove_all();
reset_main.insert(&source_frame, -1);
reset_main.set_max_children_per_line(1);
};
pub const HANDLE_HOME: fn(Arc<Listeners>, FlowBox) =
|listeners: Arc<Listeners>, resetMain: FlowBox| {
|listeners: Arc<Listeners>, reset_main: FlowBox| {
listeners.stop_network_listener();
listeners.stop_audio_listener();
listeners.stop_bluetooth_listener();
resetMain.remove_all();
reset_main.remove_all();
};
fn wrapInFrame(widget: SettingBox) -> Frame {
fn wrap_in_frame(widget: SettingBox) -> Frame {
let frame = Frame::new(None);
frame.set_child(Some(&widget));
frame.add_css_class("resetSettingFrame");

11
src/components/window/mod.rs
View file

@ -1,6 +1,5 @@
#![allow(non_snake_case)]
pub mod handleSidebarClick;
pub mod resetWindow;
pub mod resetWindowImpl;
pub mod sidebarEntry;
pub mod sidebarEntryImpl;
pub mod handle_sidebar_click;
pub mod reset_window;
pub mod reset_window_impl;
pub mod sidebar_entry;
pub mod sidebar_entry_impl;

137
src/components/window/resetWindow.rs → src/components/window/reset_window.rs
View file

@ -5,13 +5,13 @@ use glib::Object;
use gtk::prelude::*;
use gtk::{gio, glib, Application, ListBoxRow, Orientation};
use crate::components::window::handleSidebarClick::*;
use crate::components::window::resetWindowImpl;
use crate::components::window::sidebarEntry::SidebarEntry;
use crate::components::window::sidebarEntryImpl::Categories;
use crate::components::window::handle_sidebar_click::*;
use crate::components::window::reset_window_impl;
use crate::components::window::sidebar_entry::SidebarEntry;
use crate::components::window::sidebar_entry_impl::Categories;
glib::wrapper! {
pub struct ReSetWindow(ObjectSubclass<resetWindowImpl::ReSetWindow>)
pub struct ReSetWindow(ObjectSubclass<reset_window_impl::ReSetWindow>)
@extends gtk::ApplicationWindow, gtk::Window, gtk::Widget,
@implements gio::ActionGroup, gio::ActionMap, gtk::Accessible, gtk::Buildable,
gtk::ConstraintTarget, gtk::Native, gtk::Root, gtk::ShortcutManager;
@ -21,36 +21,35 @@ unsafe impl Send for ReSetWindow {}
unsafe impl Sync for ReSetWindow {}
#[allow(non_snake_case)]
impl ReSetWindow {
pub fn new(app: &Application) -> Self {
Object::builder().property("application", app).build()
}
pub fn setupCallback(&self) {
let selfImp = self.imp();
pub fn setup_callback(&self) {
let self_imp = self.imp();
selfImp
.resetSearchEntry
.connect_search_changed(clone!(@ weak self as window => move |_| {
window.filterList();
}));
selfImp
.resetSideBarToggle
.connect_clicked(clone!(@ weak self as window => move |_| {
window.toggleSidebar();
}));
selfImp.resetSidebarList.connect_row_activated(
clone!(@ weak selfImp as flowbox => move |_, y| {
let result = y.downcast_ref::<SidebarEntry>().unwrap();
let clickEvent = result.imp().onClickEvent.borrow().onClickEvent;
(clickEvent)(flowbox.listeners.clone(), flowbox.resetMain.get());
self_imp.resetSearchEntry.connect_search_changed(
clone!(@ weak self as window => move |_| {
window.filter_list();
}),
);
selfImp
self_imp
.resetSideBarToggle
.connect_clicked(clone!(@ weak self as window => move |_| {
window.toggle_sidebar();
}));
self_imp.resetSidebarList.connect_row_activated(
clone!(@ weak self_imp as flowbox => move |_, y| {
let result = y.downcast_ref::<SidebarEntry>().unwrap();
let click_event = result.imp().on_click_event.borrow().on_click_event;
(click_event)(flowbox.listeners.clone(), flowbox.resetMain.get());
}),
);
self_imp
.resetClose
.connect_clicked(clone!(@ weak self as window => move |_| {
window.close();
@ -62,62 +61,62 @@ impl ReSetWindow {
// });
}
pub fn handleDynamicSidebar(&self) {
let selfImp = self.imp();
selfImp
pub fn handle_dynamic_sidebar(&self) {
let self_imp = self.imp();
self_imp
.resetSidebarBreakpoint
.set_condition(BreakpointCondition::parse("max-width: 700sp").as_ref().ok());
selfImp.resetSidebarBreakpoint.add_setter(
&Object::from(selfImp.resetOverlaySplitView.get()),
self_imp.resetSidebarBreakpoint.add_setter(
&Object::from(self_imp.resetOverlaySplitView.get()),
"collapsed",
&true.to_value(),
);
selfImp.resetSidebarBreakpoint.add_setter(
&Object::from(selfImp.resetSideBarToggle.get()),
self_imp.resetSidebarBreakpoint.add_setter(
&Object::from(self_imp.resetSideBarToggle.get()),
"visible",
&true.to_value(),
);
}
pub fn filterList(&self) {
pub fn filter_list(&self) {
let text = self.imp().resetSearchEntry.text().to_string();
for (mainEntry, subEntries) in self.imp().sidebarEntries.borrow().iter() {
for (main_entry, sub_entriess) in self.imp().sidebar_entries.borrow().iter() {
if text.is_empty() {
mainEntry.set_visible(true);
for subEntry in subEntries {
subEntry.set_visible(true);
main_entry.set_visible(true);
for sub_entry in sub_entriess {
sub_entry.set_visible(true);
}
continue;
}
if mainEntry
if main_entry
.imp()
.name
.borrow()
.to_lowercase()
.contains(&text.to_lowercase())
{
mainEntry.set_visible(true);
main_entry.set_visible(true);
} else {
mainEntry.set_visible(false);
main_entry.set_visible(false);
}
for subEntry in subEntries {
if subEntry
for sub_entry in sub_entriess {
if sub_entry
.imp()
.name
.borrow()
.to_lowercase()
.contains(&text.to_lowercase())
{
subEntry.set_visible(true);
mainEntry.set_visible(true);
sub_entry.set_visible(true);
main_entry.set_visible(true);
} else {
subEntry.set_visible(false);
sub_entry.set_visible(false);
}
}
}
}
pub fn toggleSidebar(&self) {
pub fn toggle_sidebar(&self) {
if self.imp().resetOverlaySplitView.shows_sidebar() {
self.imp().resetOverlaySplitView.set_show_sidebar(false);
} else {
@ -125,11 +124,11 @@ impl ReSetWindow {
}
}
pub fn setupSidebarEntries(&self) {
let selfImp = self.imp();
let mut sidebarEntries = selfImp.sidebarEntries.borrow_mut();
pub fn setup_sidebar_entries(&self) {
let self_imp = self.imp();
let mut sidebar_entries = self_imp.sidebar_entries.borrow_mut();
let connectivityList = vec![
let connectivity_list = vec![
SidebarEntry::new(
"WiFi",
"network-wireless-symbolic",
@ -153,7 +152,7 @@ impl ReSetWindow {
// ),
];
sidebarEntries.push((
sidebar_entries.push((
SidebarEntry::new(
"Connectivity",
"network-wired-symbolic",
@ -161,10 +160,10 @@ impl ReSetWindow {
false,
HANDLE_CONNECTIVITY_CLICK,
),
connectivityList,
connectivity_list,
));
let audioList = vec![
let audio_list = vec![
SidebarEntry::new(
"Output",
"audio-volume-high-symbolic",
@ -181,7 +180,7 @@ impl ReSetWindow {
),
];
sidebarEntries.push((
sidebar_entries.push((
SidebarEntry::new(
"Audio",
"audio-headset-symbolic",
@ -189,7 +188,7 @@ impl ReSetWindow {
false,
HANDLE_AUDIO_CLICK,
),
audioList,
audio_list,
));
// let peripheralsList = vec![
@ -227,28 +226,28 @@ impl ReSetWindow {
// peripheralsList,
// ));
selfImp
self_imp
.resetSidebarList
.connect_row_activated(clone!(@ weak selfImp => move |_, _| {
selfImp.resetSearchEntry.set_text("");
.connect_row_activated(clone!(@ weak self_imp => move |_, _| {
self_imp.resetSearchEntry.set_text("");
}));
for (mainEntry, subEntries) in sidebarEntries.iter() {
selfImp.resetSidebarList.append(mainEntry);
for subEntry in subEntries {
selfImp.resetSidebarList.append(subEntry);
for (main_entry, sub_entries) in sidebar_entries.iter() {
self_imp.resetSidebarList.append(main_entry);
for sub_entry in sub_entries {
self_imp.resetSidebarList.append(sub_entry);
}
let separator = ListBoxRow::new();
separator.set_child(Some(&gtk::Separator::new(Orientation::Horizontal)));
separator.set_selectable(false);
separator.set_activatable(false);
selfImp.resetSidebarList.append(&separator);
self_imp.resetSidebarList.append(&separator);
}
}
pub fn setupPopoverButtons(&self) {
let selfImp = self.imp();
selfImp
pub fn setup_popover_buttons(&self) {
let self_imp = self.imp();
self_imp
.resetAboutButton
.connect_clicked(clone!(@ weak self as window => move |_| {
let dialog = adw::AboutWindow::builder()
@ -269,14 +268,14 @@ impl ReSetWindow {
window.imp().resetPopoverMenu.popdown();
dialog.present();
}));
selfImp
self_imp
.resetPreferenceButton
.connect_clicked(clone!(@weak self as window => move |_| {
let preferences = adw::PreferencesWindow::builder().build();
window.imp().resetPopoverMenu.popdown();
preferences.present();
}));
selfImp
self_imp
.resetShortcutsButton
.connect_clicked(clone!(@weak self as window => move |_| {
let shortcuts = gtk::ShortcutsWindow::builder().build();

18
src/components/window/resetWindowImpl.rs → src/components/window/reset_window_impl.rs
View file

@ -9,9 +9,9 @@ use gtk::subclass::prelude::*;
use gtk::{glib, Button, CompositeTemplate, FlowBox, ListBox, PopoverMenu, SearchEntry};
use crate::components::base::utils::Listeners;
use crate::components::wifi::wifiBox::WifiBox;
use crate::components::window::resetWindow;
use crate::components::window::sidebarEntry::SidebarEntry;
use crate::components::wifi::wifi_box::WifiBox;
use crate::components::window::reset_window;
use crate::components::window::sidebar_entry::SidebarEntry;
#[allow(non_snake_case)]
#[derive(CompositeTemplate, Default)]
@ -39,7 +39,7 @@ pub struct ReSetWindow {
pub resetPreferenceButton: TemplateChild<Button>,
#[template_child]
pub resetShortcutsButton: TemplateChild<Button>,
pub sidebarEntries: RefCell<Vec<(SidebarEntry, Vec<SidebarEntry>)>>,
pub sidebar_entries: RefCell<Vec<(SidebarEntry, Vec<SidebarEntry>)>>,
pub listeners: Arc<Listeners>,
}
@ -50,7 +50,7 @@ unsafe impl Sync for ReSetWindow {}
impl ObjectSubclass for ReSetWindow {
const ABSTRACT: bool = false;
const NAME: &'static str = "resetUI";
type Type = resetWindow::ReSetWindow;
type Type = reset_window::ReSetWindow;
type ParentType = adw::ApplicationWindow;
fn class_init(klass: &mut Self::Class) {
@ -68,10 +68,10 @@ impl ObjectImpl for ReSetWindow {
self.parent_constructed();
let obj = self.obj();
obj.setupCallback();
obj.setupPopoverButtons();
obj.handleDynamicSidebar();
obj.setupSidebarEntries();
obj.setup_callback();
obj.setup_popover_buttons();
obj.handle_dynamic_sidebar();
obj.setup_sidebar_entries();
}
}

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

@ -1,51 +0,0 @@
use std::sync::Arc;
use crate::components::base::utils::Listeners;
use crate::components::window::sidebarEntryImpl;
use crate::components::window::sidebarEntryImpl::{Categories, SidebarAction};
use adw::subclass::prelude::ObjectSubclassIsExt;
use glib::Object;
use gtk::prelude::*;
use gtk::{glib, FlowBox};
glib::wrapper! {
pub struct SidebarEntry(ObjectSubclass<sidebarEntryImpl::SidebarEntry>)
@extends gtk::ListBoxRow, gtk::Widget,
@implements gtk::Accessible, gtk::Actionable, gtk::Buildable, gtk::ConstraintTarget;
}
impl SidebarEntry {
pub fn new(
entryName: &str,
iconName: &str,
category: Categories,
isSubcategory: bool,
clickEvent: fn(Arc<Listeners>, FlowBox),
) -> Self {
let entry: SidebarEntry = Object::builder().build();
let entryImp = entry.imp();
entryImp.resetSidebarLabel.get().set_text(entryName);
entryImp
.resetSidebarImage
.set_from_icon_name(Some(iconName));
entryImp.category.set(category);
entryImp.isSubcategory.set(isSubcategory);
{
let mut name = entryImp.name.borrow_mut();
*name = String::from(entryName);
let mut action = entryImp.onClickEvent.borrow_mut();
*action = SidebarAction {
onClickEvent: clickEvent,
};
}
Self::setMargin(&entry);
entry
}
fn setMargin(entry: &SidebarEntry) {
if entry.imp().isSubcategory.get() {
let option = entry.child().unwrap();
option.set_margin_start(30);
}
}
}

51
src/components/window/sidebar_entry.rs Normal file
View file

@ -0,0 +1,51 @@
use std::sync::Arc;
use crate::components::base::utils::Listeners;
use crate::components::window::sidebar_entry_impl;
use crate::components::window::sidebar_entry_impl::{Categories, SidebarAction};
use adw::subclass::prelude::ObjectSubclassIsExt;
use glib::Object;
use gtk::prelude::*;
use gtk::{glib, FlowBox};
glib::wrapper! {
pub struct SidebarEntry(ObjectSubclass<sidebar_entry_impl::SidebarEntry>)
@extends gtk::ListBoxRow, gtk::Widget,
@implements gtk::Accessible, gtk::Actionable, gtk::Buildable, gtk::ConstraintTarget;
}
impl SidebarEntry {
pub fn new(
entry_name: &str,
icon_name: &str,
category: Categories,
is_subcategory: bool,
click_event: fn(Arc<Listeners>, FlowBox),
) -> Self {
let entry: SidebarEntry = Object::builder().build();
let entry_imp = entry.imp();
entry_imp.resetSidebarLabel.get().set_text(entry_name);
entry_imp
.resetSidebarImage
.set_from_icon_name(Some(icon_name));
entry_imp.category.set(category);
entry_imp.is_subcategory.set(is_subcategory);
{
let mut name = entry_imp.name.borrow_mut();
*name = String::from(entry_name);
let mut action = entry_imp.on_click_event.borrow_mut();
*action = SidebarAction {
on_click_event: click_event,
};
}
Self::set_margin(&entry);
entry
}
fn set_margin(entry: &SidebarEntry) {
if entry.imp().is_subcategory.get() {
let option = entry.child().unwrap();
option.set_margin_start(30);
}
}
}

15
src/components/window/sidebarEntryImpl.rs → src/components/window/sidebar_entry_impl.rs
View file

@ -6,8 +6,8 @@ use gtk::subclass::prelude::*;
use gtk::{glib, CompositeTemplate, FlowBox, Image, Label, ListBoxRow};
use crate::components::base::utils::Listeners;
use crate::components::window::handleSidebarClick::HANDLE_HOME;
use crate::components::window::sidebarEntry;
use crate::components::window::handle_sidebar_click::HANDLE_HOME;
use crate::components::window::sidebar_entry;
#[derive(Default)]
pub enum Categories {
@ -27,20 +27,19 @@ pub struct SidebarEntry {
#[template_child]
pub resetSidebarImage: TemplateChild<Image>,
pub category: Cell<Categories>,
pub isSubcategory: Cell<bool>,
pub onClickEvent: RefCell<SidebarAction>,
pub is_subcategory: Cell<bool>,
pub on_click_event: RefCell<SidebarAction>,
pub name: RefCell<String>,
}
#[allow(non_snake_case)]
pub struct SidebarAction {
pub onClickEvent: fn(Arc<Listeners>, FlowBox),
pub on_click_event: fn(Arc<Listeners>, FlowBox),
}
impl Default for SidebarAction {
fn default() -> Self {
Self {
onClickEvent: HANDLE_HOME,
on_click_event: HANDLE_HOME,
}
}
}
@ -49,7 +48,7 @@ impl Default for SidebarAction {
impl ObjectSubclass for SidebarEntry {
const ABSTRACT: bool = false;
const NAME: &'static str = "resetSidebarEntry";
type Type = sidebarEntry::SidebarEntry;
type Type = sidebar_entry::SidebarEntry;
type ParentType = ListBoxRow;
fn class_init(klass: &mut Self::Class) {

13
src/main.rs
View file

@ -1,9 +1,7 @@
#![allow(non_snake_case)]
use std::thread;
use std::time::Duration;
use components::window::resetWindow::ReSetWindow;
use components::window::reset_window::ReSetWindow;
use dbus::blocking::Connection;
use dbus::Error;
use gtk::gdk::Display;
@ -27,15 +25,15 @@ async fn main() {
app.connect_startup(move |_| {
adw::init().unwrap();
loadCss();
load_css();
});
app.connect_activate(buildUI);
app.connect_activate(build_ui);
app.connect_shutdown(shutdown);
app.run();
}
fn loadCss() {
fn load_css() {
let provider = CssProvider::new();
provider.load_from_resource("/org/Xetibo/ReSet/style/style.css");
@ -46,8 +44,7 @@ fn loadCss() {
);
}
#[allow(non_snake_case)]
fn buildUI(app: &Application) {
fn build_ui(app: &Application) {
let window = ReSetWindow::new(app);
window.present();
}