Xetibo/ReSet
1
0
Fork 0
mirror of https://github.com/Xetibo/ReSet.git synced 2025-07-01 15:57:46 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

chore: make all snake_case

Browse source
This commit is contained in:
Fabio Lenherr / DashieTM 2023-12-05 16:15:24 +01:00
parent 391182607d
commit d50ee65bdd
52 changed files with 766 additions and 783 deletions
Download patch file Download diff file Expand all files Collapse all files

7
src/components/base/popup_impl.rs
View file

@ -6,16 +6,15 @@ use gtk::{glib, Button, CompositeTemplate, Label, PasswordEntry, PasswordEntryBu
use super::popup;
#[allow(non_snake_case)]
#[derive(Default, CompositeTemplate)]
#[template(resource = "/org/Xetibo/ReSet/resetPopup.ui")]
pub struct Popup {
#[template_child]
pub resetPopupLabel: TemplateChild<Label>,
pub reset_popup_label: TemplateChild<Label>,
#[template_child]
pub resetPopupEntry: TemplateChild<PasswordEntry>,
pub reset_popup_entry: TemplateChild<PasswordEntry>,
#[template_child]
pub resetPopupButton: TemplateChild<Button>,
pub reset_popup_button: TemplateChild<Button>,
pub reset_popup_text: Arc<RefCell<PasswordEntryBuffer>>,
}

46
src/components/bluetooth/bluetooth_box.rs
View file

@ -45,26 +45,26 @@ fn setup_callbacks(
let bluetooth_box_ref = bluetooth_box.clone();
let imp = bluetooth_box.imp();
// let bluetooth_box_ref = bluetooth_box.clone();
imp.resetVisibility.set_activatable(true);
imp.resetVisibility.set_action_name(Some("navigation.push"));
imp.resetVisibility
imp.reset_visibility.set_activatable(true);
imp.reset_visibility.set_action_name(Some("navigation.push"));
imp.reset_visibility
.set_action_target_value(Some(&Variant::from("visibility")));
imp.resetBluetoothMainTab
imp.reset_bluetooth_main_tab
.set_action_name(Some("navigation.pop"));
// TODO add a manual search button here
imp.resetBluetoothSwitch.connect_state_set(move |_, state| {
imp.reset_bluetooth_switch.connect_state_set(move |_, state| {
if !state {
let imp = bluetooth_box_ref.imp();
for x in imp
.resetBluetoothConnectedDevices
.reset_bluetooth_connected_devices
.observe_children()
.iter::<Object>()
.flatten()
{
// todo test this
if let Some(item) = x.downcast_ref::<Widget>() {
imp.resetBluetoothAvailableDevices.remove(item);
imp.reset_bluetooth_available_devices.remove(item);
}
}
listeners.bluetooth_listener.store(false, Ordering::SeqCst);
@ -108,13 +108,13 @@ pub fn populate_conntected_bluetooth_devices(bluetooth_box: Arc<BluetoothBox>) {
let imp = ref_box.imp();
let list = imp.reset_model_list.read().unwrap();
imp.resetBluetoothAdapter.set_model(Some(&*list));
imp.reset_bluetooth_adapter.set_model(Some(&*list));
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);
imp.reset_bluetooth_adapter.set_selected(index.1);
}
imp.resetBluetoothAdapter.connect_selected_notify(
imp.reset_bluetooth_adapter.connect_selected_notify(
clone!(@weak imp => move |dropdown| {
let selected = dropdown.selected_item();
if selected.is_none() {
@ -142,9 +142,9 @@ pub fn populate_conntected_bluetooth_devices(bluetooth_box: Arc<BluetoothBox>) {
.borrow_mut()
.insert(path, (bluetooth_entry.clone(), entry.clone(), device));
if connected {
imp.resetBluetoothConnectedDevices.append(&*entry);
imp.reset_bluetooth_connected_devices.append(&*entry);
} else {
imp.resetBluetoothAvailableDevices.append(&*entry);
imp.reset_bluetooth_available_devices.append(&*entry);
}
}
});
@ -207,9 +207,9 @@ pub fn start_bluetooth_listener(listeners: Arc<Listeners>, bluetooth_box: Arc<Bl
(bluetooth_entry.clone(), entry.clone(), ir.bluetooth_device),
);
if connected {
imp.resetBluetoothConnectedDevices.append(&*entry);
imp.reset_bluetooth_connected_devices.append(&*entry);
} else {
imp.resetBluetoothAvailableDevices.append(&*entry);
imp.reset_bluetooth_available_devices.append(&*entry);
}
});
});
@ -228,7 +228,7 @@ pub fn start_bluetooth_listener(listeners: Arc<Listeners>, bluetooth_box: Arc<Bl
let imp = bluetooth_box.imp();
let map = imp.available_devices.borrow_mut();
if let Some(list_entry) = map.get(&ir.bluetooth_device) {
imp.resetBluetoothConnectedDevices.remove(&*list_entry.1);
imp.reset_bluetooth_connected_devices.remove(&*list_entry.1);
}
});
});
@ -249,18 +249,18 @@ pub fn start_bluetooth_listener(listeners: Arc<Listeners>, bluetooth_box: Arc<Bl
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 {
imp.resetBluetoothConnectedDevices.append(&*list_entry.1);
imp.resetBluetoothAvailableDevices.remove(&*list_entry.1);
imp.reset_bluetooth_connected_devices.append(&*list_entry.1);
imp.reset_bluetooth_available_devices.remove(&*list_entry.1);
} else {
imp.resetBluetoothAvailableDevices.append(&*list_entry.1);
imp.resetBluetoothConnectedDevices.remove(&*list_entry.1);
imp.reset_bluetooth_available_devices.append(&*list_entry.1);
imp.reset_bluetooth_connected_devices.remove(&*list_entry.1);
}
}
if list_entry.2.paired != ir.bluetooth_device.paired {
if ir.bluetooth_device.paired {
list_entry.0.imp().resetBluetoothButton.set_sensitive(true);
list_entry.0.imp().reset_bluetooth_button.set_sensitive(true);
} else {
list_entry.0.imp().resetBluetoothButton.set_sensitive(false);
list_entry.0.imp().reset_bluetooth_button.set_sensitive(false);
}
}
}
@ -285,13 +285,13 @@ pub fn start_bluetooth_listener(listeners: Arc<Listeners>, bluetooth_box: Arc<Bl
glib::idle_add_once(move || {
let imp = loop_box.imp();
for x in imp
.resetBluetoothAvailableDevices
.reset_bluetooth_available_devices
.observe_children()
.iter::<Object>()
.flatten()
{
if let Some(item) = x.downcast_ref::<Widget>() {
imp.resetBluetoothAvailableDevices.remove(item);
imp.reset_bluetooth_available_devices.remove(item);
}
}
});

15
src/components/bluetooth/bluetooth_box_impl.rs
View file

@ -15,24 +15,23 @@ use crate::components::bluetooth::bluetooth_entry::BluetoothEntry;
type BluetoothMap =
RefCell<HashMap<Path<'static>, (Arc<BluetoothEntry>, Arc<ListEntry>, BluetoothDevice)>>;
#[allow(non_snake_case)]
#[derive(Default, CompositeTemplate)]
#[template(resource = "/org/Xetibo/ReSet/resetBluetooth.ui")]
pub struct BluetoothBox {
#[template_child]
pub resetBluetoothSwitch: TemplateChild<Switch>,
pub reset_bluetooth_switch: TemplateChild<Switch>,
#[template_child]
pub resetBluetoothAvailableDevices: TemplateChild<gtk::Box>,
pub reset_bluetooth_available_devices: TemplateChild<gtk::Box>,
#[template_child]
pub resetBluetoothRefreshButton: TemplateChild<Button>,
pub reset_bluetooth_refresh_button: TemplateChild<Button>,
#[template_child]
pub resetBluetoothAdapter: TemplateChild<ComboRow>,
pub reset_bluetooth_adapter: TemplateChild<ComboRow>,
#[template_child]
pub resetBluetoothConnectedDevices: TemplateChild<gtk::Box>,
pub reset_bluetooth_connected_devices: TemplateChild<gtk::Box>,
#[template_child]
pub resetVisibility: TemplateChild<ActionRow>,
pub reset_visibility: TemplateChild<ActionRow>,
#[template_child]
pub resetBluetoothMainTab: TemplateChild<ListEntry>,
pub reset_bluetooth_main_tab: TemplateChild<ListEntry>,
pub available_devices: BluetoothMap,
pub connected_devices: BluetoothMap,
pub reset_bluetooth_adapters: Arc<RwLock<HashMap<String, (BluetoothAdapter, u32)>>>,

14
src/components/bluetooth/bluetooth_entry.rs
View file

@ -24,27 +24,27 @@ impl BluetoothEntry {
pub fn new(device: &BluetoothDevice) -> Self {
let entry: BluetoothEntry = Object::builder().build();
let entry_imp = entry.imp();
entry_imp.resetBluetoothLabel.get().set_text(&device.alias);
entry_imp.reset_bluetooth_label.get().set_text(&device.alias);
entry_imp
.resetBluetoothAddress
.reset_bluetooth_address
.get()
.set_text(&device.address);
if device.icon.is_empty() {
entry_imp
.resetBluetoothDeviceType
.reset_bluetooth_device_type
.set_icon_name(Some("dialog-question-symbolic"));
} else {
entry_imp
.resetBluetoothDeviceType
.reset_bluetooth_device_type
.set_icon_name(Some(&device.icon));
}
if device.paired {
entry_imp.resetBluetoothButton.set_sensitive(true);
entry_imp.reset_bluetooth_button.set_sensitive(true);
} else {
entry_imp.resetBluetoothButton.set_sensitive(false);
entry_imp.reset_bluetooth_button.set_sensitive(false);
}
let path = Arc::new(device.path.clone());
entry_imp.resetBluetoothButton.connect_clicked(move |_| {
entry_imp.reset_bluetooth_button.connect_clicked(move |_| {
remove_device_pairing((*path).clone());
});
let gesture = GestureClick::new();

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

@ -3,18 +3,17 @@ use gtk::subclass::prelude::*;
use gtk::{glib, Button, CompositeTemplate, Image, Label};
use std::cell::RefCell;
#[allow(non_snake_case)]
#[derive(Default, CompositeTemplate)]
#[template(resource = "/org/Xetibo/ReSet/resetBluetoothEntry.ui")]
pub struct BluetoothEntry {
#[template_child]
pub resetBluetoothDeviceType: TemplateChild<Image>,
pub reset_bluetooth_device_type: TemplateChild<Image>,
#[template_child]
pub resetBluetoothLabel: TemplateChild<Label>,
pub reset_bluetooth_label: TemplateChild<Label>,
#[template_child]
pub resetBluetoothAddress: TemplateChild<Label>,
pub reset_bluetooth_address: TemplateChild<Label>,
#[template_child]
pub resetBluetoothButton: TemplateChild<Button>,
pub reset_bluetooth_button: TemplateChild<Button>,
pub device_name: RefCell<String>,
}

26
src/components/input/output_stream_entry.rs
View file

@ -32,21 +32,21 @@ impl OutputStreamEntry {
let box_imp = source_box.imp();
let imp = obj.imp();
let name = stream.application_name.clone() + ": " + stream.name.as_str();
imp.resetSourceSelection.set_title(name.as_str());
imp.resetSourceSelection
imp.reset_source_selection.set_title(name.as_str());
imp.reset_source_selection
.set_factory(Some(&create_dropdown_label_factory()));
set_combo_row_ellipsis(imp.resetSourceSelection.get());
set_combo_row_ellipsis(imp.reset_source_selection.get());
let volume = stream.volume.first().unwrap_or(&0_u32);
let fraction = (*volume as f64 / 655.36).round();
let percentage = (fraction).to_string() + "%";
imp.resetVolumePercentage.set_text(&percentage);
imp.resetVolumeSlider.set_value(*volume as f64);
imp.reset_volume_percentage.set_text(&percentage);
imp.reset_volume_slider.set_value(*volume as f64);
imp.stream.replace(stream);
imp.resetVolumeSlider.connect_change_value(
imp.reset_volume_slider.connect_change_value(
clone!(@weak imp => @default-return Propagation::Stop, move |_, _, value| {
let fraction = (value / 655.36).round();
let percentage = (fraction).to_string() + "%";
imp.resetVolumePercentage.set_text(&percentage);
imp.reset_volume_percentage.set_text(&percentage);
let mut stream = imp.stream.try_borrow();
while stream.is_err() {
stream = imp.stream.try_borrow();
@ -69,7 +69,7 @@ impl OutputStreamEntry {
);
{
let list = box_imp.reset_model_list.read().unwrap();
imp.resetSourceSelection.set_model(Some(&*list));
imp.reset_source_selection.set_model(Some(&*list));
let map = box_imp.reset_source_map.write().unwrap();
let mut name = box_imp.reset_default_source.try_borrow();
while name.is_err() {
@ -79,10 +79,10 @@ impl OutputStreamEntry {
let name = &name.alias;
let index = map.get(name);
if let Some(index) = index {
imp.resetSourceSelection.set_selected(index.1);
imp.reset_source_selection.set_selected(index.1);
}
}
imp.resetSourceSelection.connect_selected_notify(
imp.reset_source_selection.connect_selected_notify(
clone!(@weak imp, @weak box_imp => move |dropdown| {
let selected = dropdown.selected_item();
if selected.is_none() {
@ -105,7 +105,7 @@ impl OutputStreamEntry {
set_source_of_output_stream(stream.index, source);
}),
);
imp.resetSourceMute
imp.reset_source_mute
.connect_clicked(clone!(@weak imp => move |_| {
let stream = imp.stream.clone();
let mut stream = stream.try_borrow_mut();
@ -117,10 +117,10 @@ impl OutputStreamEntry {
let muted = stream.muted;
let index = stream.index;
if muted {
imp.resetSourceMute
imp.reset_source_mute
.set_icon_name("microphone-disabled-symbolic");
} else {
imp.resetSourceMute
imp.reset_source_mute
.set_icon_name("audio-input-microphone-symbolic");
}
toggle_output_stream_mute(index, muted);

11
src/components/input/output_stream_entry_impl.rs
View file

@ -9,20 +9,19 @@ use gtk::subclass::prelude::*;
use gtk::{glib, Button, CompositeTemplate, Label, ProgressBar, Scale};
use ReSet_Lib::audio::audio::OutputStream;
#[allow(non_snake_case)]
#[derive(Default, CompositeTemplate)]
#[template(resource = "/org/Xetibo/ReSet/resetOutputStreamEntry.ui")]
pub struct OutputStreamEntry {
#[template_child]
pub resetSourceSelection: TemplateChild<ComboRow>,
pub reset_source_selection: TemplateChild<ComboRow>,
#[template_child]
pub resetSourceMute: TemplateChild<Button>,
pub reset_source_mute: TemplateChild<Button>,
#[template_child]
pub resetVolumeSlider: TemplateChild<Scale>,
pub reset_volume_slider: TemplateChild<Scale>,
#[template_child]
pub resetVolumePercentage: TemplateChild<Label>,
pub reset_volume_percentage: TemplateChild<Label>,
#[template_child]
pub resetVolumeMeter: TemplateChild<ProgressBar>,
pub reset_volume_meter: TemplateChild<ProgressBar>,
pub stream: Arc<RefCell<OutputStream>>,
pub associated_source: Arc<RefCell<(u32, String)>>,
pub volume_time_stamp: RefCell<Option<SystemTime>>,

84
src/components/input/source_box.rs
View file

@ -45,35 +45,35 @@ impl SourceBox {
pub fn setup_callbacks(&self) {
let self_imp = self.imp();
self_imp.resetSourceRow.set_activatable(true);
self_imp.reset_source_row.set_activatable(true);
self_imp
.resetSourceRow
.reset_source_row
.set_action_name(Some("navigation.push"));
self_imp
.resetSourceRow
.reset_source_row
.set_action_target_value(Some(&Variant::from("sources")));
self_imp.resetCardsRow.set_activatable(true);
self_imp.reset_cards_row.set_activatable(true);
self_imp
.resetCardsRow
.reset_cards_row
.set_action_name(Some("navigation.push"));
self_imp
.resetCardsRow
.reset_cards_row
.set_action_target_value(Some(&Variant::from("profileConfiguration")));
self_imp.resetOutputStreamButton.set_activatable(true);
self_imp.reset_output_stream_button.set_activatable(true);
self_imp
.resetOutputStreamButton
.reset_output_stream_button
.set_action_name(Some("navigation.pop"));
self_imp.resetInputCardsBackButton.set_activatable(true);
self_imp.reset_input_cards_back_button.set_activatable(true);
self_imp
.resetInputCardsBackButton
.reset_input_cards_back_button
.set_action_name(Some("navigation.pop"));
self_imp
.resetSourceDropdown
.reset_source_dropdown
.set_factory(Some(&create_dropdown_label_factory()));
set_combo_row_ellipsis(self_imp.resetSourceDropdown.get());
set_combo_row_ellipsis(self_imp.reset_source_dropdown.get());
}
}
@ -116,8 +116,8 @@ pub fn populate_sources(input_box: Arc<SourceBox>) {
let volume = source.volume.first().unwrap_or(&0_u32);
let fraction = (*volume as f64 / 655.36).round();
let percentage = (fraction).to_string() + "%";
output_box_imp.resetVolumePercentage.set_text(&percentage);
output_box_imp.resetVolumeSlider.set_value(*volume as f64);
output_box_imp.reset_volume_percentage.set_text(&percentage);
output_box_imp.reset_volume_slider.set_value(*volume as f64);
let mut list = output_box_imp.reset_source_list.write().unwrap();
for stream in sources {
let index = source.index;
@ -135,16 +135,16 @@ pub fn populate_sources(input_box: Arc<SourceBox>) {
let entry = Arc::new(ListEntry::new(&*source_entry));
entry.set_activatable(false);
list.insert(index, (entry.clone(), source_clone, alias));
output_box_imp.resetSources.append(&*entry);
output_box_imp.reset_sources.append(&*entry);
}
let list = output_box_imp.reset_model_list.read().unwrap();
output_box_imp.resetSourceDropdown.set_model(Some(&*list));
output_box_imp.reset_source_dropdown.set_model(Some(&*list));
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);
output_box_imp.reset_source_dropdown.set_selected(index.1);
}
output_box_imp.resetSourceDropdown.connect_selected_notify(
output_box_imp.reset_source_dropdown.connect_selected_notify(
clone!(@weak output_box_imp => move |dropdown| {
let selected = dropdown.selected_item();
if selected.is_none() {
@ -166,12 +166,12 @@ pub fn populate_sources(input_box: Arc<SourceBox>) {
}
output_box_ref
.imp()
.resetVolumeSlider
.reset_volume_slider
.connect_change_value(move |_, _, value| {
let imp = output_box_ref_slider.imp();
let fraction = (value / 655.36).round();
let percentage = (fraction).to_string() + "%";
imp.resetVolumePercentage.set_text(&percentage);
imp.reset_volume_percentage.set_text(&percentage);
let source = imp.reset_default_source.borrow();
let index = source.index;
let channels = source.channels;
@ -190,7 +190,7 @@ pub fn populate_sources(input_box: Arc<SourceBox>) {
output_box_ref
.imp()
.resetSourceMute
.reset_source_mute
.connect_clicked(move |_| {
let imp = output_box_ref_mute.imp();
let stream = imp.reset_default_source.clone();
@ -199,10 +199,10 @@ pub fn populate_sources(input_box: Arc<SourceBox>) {
let muted = stream.muted;
let index = stream.index;
if muted {
imp.resetSourceMute
imp.reset_source_mute
.set_icon_name("microphone-disabled-symbolic");
} else {
imp.resetSourceMute
imp.reset_source_mute
.set_icon_name("audio-input-microphone-symbolic");
}
toggle_source_mute(index, muted);
@ -228,7 +228,7 @@ pub fn populate_outputstreams(input_box: Arc<SourceBox>) {
let entry = Arc::new(ListEntry::new(&*input_stream));
entry.set_activatable(false);
list.insert(index, (entry.clone(), input_stream_clone));
input_box_imp.resetOutputStreams.append(&*entry);
input_box_imp.reset_output_streams.append(&*entry);
}
});
});
@ -243,7 +243,7 @@ pub fn populate_cards(input_box: Arc<SourceBox>) {
glib::idle_add_once(move || {
let imp = output_box_ref.imp();
for card in cards {
imp.resetCards.add(&CardEntry::new(card));
imp.reset_cards.add(&CardEntry::new(card));
}
});
});
@ -372,7 +372,7 @@ pub fn start_input_box_listener(conn: Connection, source_box: Arc<SourceBox>) ->
let entry = Arc::new(ListEntry::new(&*source_entry));
entry.set_activatable(false);
list.insert(source_index, (entry.clone(), source_clone, alias.clone()));
output_box_imp.resetSources.append(&*entry);
output_box_imp.reset_sources.append(&*entry);
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
@ -403,7 +403,7 @@ pub fn start_input_box_listener(conn: Connection, source_box: Arc<SourceBox>) ->
if entry.is_none() {
return;
}
output_box_imp.resetSources.remove(&*entry.unwrap().0);
output_box_imp.reset_sources.remove(&*entry.unwrap().0);
list.remove(&ir.index);
let alias = list.remove(&ir.index);
if alias.is_none() {
@ -449,16 +449,16 @@ pub fn start_input_box_listener(conn: Connection, source_box: Arc<SourceBox>) ->
}
let imp = entry.unwrap().1.imp();
if is_default {
output_box_imp.resetVolumePercentage.set_text(&percentage);
output_box_imp.resetVolumeSlider.set_value(*volume as f64);
imp.resetSelectedSource.set_active(true);
output_box_imp.reset_volume_percentage.set_text(&percentage);
output_box_imp.reset_volume_slider.set_value(*volume as f64);
imp.reset_selected_source.set_active(true);
} else {
imp.resetSelectedSource.set_active(false);
imp.reset_selected_source.set_active(false);
}
imp.resetSourceName
imp.reset_source_name
.set_title(ir.source.alias.clone().as_str());
imp.resetVolumePercentage.set_text(&percentage);
imp.resetVolumeSlider.set_value(*volume as f64);
imp.reset_volume_percentage.set_text(&percentage);
imp.reset_volume_slider.set_value(*volume as f64);
});
});
true
@ -481,7 +481,7 @@ pub fn start_input_box_listener(conn: Connection, source_box: Arc<SourceBox>) ->
let entry = Arc::new(ListEntry::new(&*output_stream));
entry.set_activatable(false);
list.insert(index, (entry.clone(), output_stream_clone));
output_box_imp.resetOutputStreams.append(&*entry);
output_box_imp.reset_output_streams.append(&*entry);
});
});
true
@ -520,22 +520,22 @@ pub fn start_input_box_listener(conn: Connection, source_box: Arc<SourceBox>) ->
}
let imp = entry.imp();
if ir.stream.muted {
imp.resetSourceMute
imp.reset_source_mute
.set_icon_name("microphone-disabled-symbolic");
} else {
imp.resetSourceMute
imp.reset_source_mute
.set_icon_name("audio-input-microphone-symbolic");
}
let name = ir.stream.application_name.clone() + ": " + ir.stream.name.as_str();
imp.resetSourceSelection.set_title(name.as_str());
imp.reset_source_selection.set_title(name.as_str());
let volume = ir.stream.volume.first().unwrap_or(&0_u32);
let fraction = (*volume as f64 / 655.36).round();
let percentage = (fraction).to_string() + "%";
imp.resetVolumePercentage.set_text(&percentage);
imp.resetVolumeSlider.set_value(*volume as f64);
imp.reset_volume_percentage.set_text(&percentage);
imp.reset_volume_slider.set_value(*volume as f64);
let map = output_box_imp.reset_source_map.read().unwrap();
if let Some(index) = map.get(&alias) {
imp.resetSourceSelection.set_selected(index.1);
imp.reset_source_selection.set_selected(index.1);
}
});
});
@ -560,7 +560,7 @@ pub fn start_input_box_listener(conn: Connection, source_box: Arc<SourceBox>) ->
if entry.is_none() {
return;
}
output_box_imp.resetOutputStreams.remove(&*entry.unwrap().0);
output_box_imp.reset_output_streams.remove(&*entry.unwrap().0);
});
});
true

25
src/components/input/source_box_impl.rs
View file

@ -18,34 +18,33 @@ type SourceEntryMap = Arc<RwLock<HashMap<u32, (Arc<ListEntry>, Arc<SourceEntry>,
type OutputStreamEntryMap = Arc<RwLock<HashMap<u32, (Arc<ListEntry>, Arc<OutputStreamEntry>)>>>;
type SourceMap = Arc<RwLock<HashMap<String, (u32, u32, String)>>>;
#[allow(non_snake_case)]
#[derive(Default, CompositeTemplate)]
#[template(resource = "/org/Xetibo/ReSet/resetAudioInput.ui")]
pub struct SourceBox {
#[template_child]
pub resetSourceRow: TemplateChild<ActionRow>,
pub reset_source_row: TemplateChild<ActionRow>,
#[template_child]
pub resetCardsRow: TemplateChild<ActionRow>,
pub reset_cards_row: TemplateChild<ActionRow>,
#[template_child]
pub resetSourceDropdown: TemplateChild<ComboRow>,
pub reset_source_dropdown: TemplateChild<ComboRow>,
#[template_child]
pub resetSourceMute: TemplateChild<Button>,
pub reset_source_mute: TemplateChild<Button>,
#[template_child]
pub resetVolumeSlider: TemplateChild<Scale>,
pub reset_volume_slider: TemplateChild<Scale>,
#[template_child]
pub resetVolumePercentage: TemplateChild<Label>,
pub reset_volume_percentage: TemplateChild<Label>,
#[template_child]
pub resetVolumeMeter: TemplateChild<ProgressBar>,
pub reset_volume_meter: TemplateChild<ProgressBar>,
#[template_child]
pub resetSources: TemplateChild<gtk::Box>,
pub reset_sources: TemplateChild<gtk::Box>,
#[template_child]
pub resetOutputStreamButton: TemplateChild<ActionRow>,
pub reset_output_stream_button: TemplateChild<ActionRow>,
#[template_child]
pub resetOutputStreams: TemplateChild<gtk::Box>,
pub reset_output_streams: TemplateChild<gtk::Box>,
#[template_child]
pub resetInputCardsBackButton: TemplateChild<ActionRow>,
pub reset_input_cards_back_button: TemplateChild<ActionRow>,
#[template_child]
pub resetCards: TemplateChild<PreferencesGroup>,
pub reset_cards: TemplateChild<PreferencesGroup>,
pub reset_default_check_button: Arc<CheckButton>,
pub reset_default_source: Arc<RefCell<Source>>,
pub reset_source_list: SourceEntryMap,

24
src/components/input/source_entry.rs
View file

@ -28,19 +28,19 @@ impl SourceEntry {
// TODO use event callback for progress bar -> this is the "im speaking" indicator
{
let imp = obj.imp();
imp.resetSourceName.set_title(stream.alias.clone().as_str());
imp.reset_source_name.set_title(stream.alias.clone().as_str());
let name = Arc::new(stream.name.clone());
let volume = stream.volume.first().unwrap_or(&0_u32);
let fraction = (*volume as f64 / 655.36).round();
let percentage = (fraction).to_string() + "%";
imp.resetVolumePercentage.set_text(&percentage);
imp.resetVolumeSlider.set_value(*volume as f64);
imp.reset_volume_percentage.set_text(&percentage);
imp.reset_volume_slider.set_value(*volume as f64);
imp.stream.replace(stream);
imp.resetVolumeSlider.connect_change_value(
imp.reset_volume_slider.connect_change_value(
clone!(@weak imp => @default-return Propagation::Stop, move |_, _, value| {
let fraction = (value / 655.36).round();
let percentage = (fraction).to_string() + "%";
imp.resetVolumePercentage.set_text(&percentage);
imp.reset_volume_percentage.set_text(&percentage);
let source = imp.stream.borrow();
let index = source.index;
let channels = source.channels;
@ -57,19 +57,19 @@ impl SourceEntry {
Propagation::Proceed
}),
);
imp.resetSelectedSource.set_group(Some(&*check_group));
imp.reset_selected_source.set_group(Some(&*check_group));
// check_group.set_group(Some(&*imp.resetSelectedSink));
if is_default {
imp.resetSelectedSource.set_active(true);
imp.reset_selected_source.set_active(true);
} else {
imp.resetSelectedSource.set_active(false);
imp.reset_selected_source.set_active(false);
}
imp.resetSelectedSource.connect_toggled(move |button| {
imp.reset_selected_source.connect_toggled(move |button| {
if button.is_active() {
set_default_source(name.clone());
}
});
imp.resetSourceMute
imp.reset_source_mute
.connect_clicked(clone!(@weak imp => move |_| {
let stream = imp.stream.clone();
let mut stream = stream.borrow_mut();
@ -77,10 +77,10 @@ impl SourceEntry {
let muted = stream.muted;
let index = stream.index;
if muted {
imp.resetSourceMute
imp.reset_source_mute
.set_icon_name("microphone-disabled-symbolic");
} else {
imp.resetSourceMute
imp.reset_source_mute
.set_icon_name("audio-input-microphone-symbolic");
}
toggle_source_mute(index, muted);

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

@ -10,22 +10,21 @@ use ReSet_Lib::audio::audio::Source;
use super::source_entry;
#[allow(non_snake_case)]
#[derive(Default, CompositeTemplate)]
#[template(resource = "/org/Xetibo/ReSet/resetSourceEntry.ui")]
pub struct SourceEntry {
#[template_child]
pub resetSourceName: TemplateChild<ActionRow>,
pub reset_source_name: TemplateChild<ActionRow>,
#[template_child]
pub resetSelectedSource: TemplateChild<CheckButton>,
pub reset_selected_source: TemplateChild<CheckButton>,
#[template_child]
pub resetSourceMute: TemplateChild<Button>,
pub reset_source_mute: TemplateChild<Button>,
#[template_child]
pub resetVolumeSlider: TemplateChild<Scale>,
pub reset_volume_slider: TemplateChild<Scale>,
#[template_child]
pub resetVolumePercentage: TemplateChild<Label>,
pub reset_volume_percentage: TemplateChild<Label>,
#[template_child]
pub resetVolumeMeter: TemplateChild<ProgressBar>,
pub reset_volume_meter: TemplateChild<ProgressBar>,
pub stream: Arc<RefCell<Source>>,
pub volume_time_stamp: RefCell<Option<SystemTime>>,
}

32
src/components/output/input_stream_entry.rs
View file

@ -33,32 +33,32 @@ impl InputStreamEntry {
let box_imp = sink_box.imp();
let imp = obj.imp();
if stream.muted {
imp.resetSinkMute
imp.reset_sink_mute
.set_icon_name("audio-volume-muted-symbolic");
} else {
imp.resetSinkMute
imp.reset_sink_mute
.set_icon_name("audio-volume-high-symbolic");
}
let name = stream.application_name.clone() + ": " + stream.name.as_str();
imp.resetSinkSelection.set_title(name.as_str());
imp.resetSinkSelection
imp.reset_sink_selection.set_title(name.as_str());
imp.reset_sink_selection
.set_factory(Some(&create_dropdown_label_factory()));
set_combo_row_ellipsis(imp.resetSinkSelection.get());
set_combo_row_ellipsis(imp.reset_sink_selection.get());
let volume = stream.volume.first().unwrap_or(&0_u32);
let fraction = (*volume as f64 / 655.36).round();
let percentage = (fraction).to_string() + "%";
imp.resetVolumePercentage.set_text(&percentage);
imp.resetVolumeSlider.set_value(*volume as f64);
imp.reset_volume_percentage.set_text(&percentage);
imp.reset_volume_slider.set_value(*volume as f64);
imp.stream.replace(stream);
{
let sink = box_imp.reset_default_sink.borrow();
imp.associated_sink.replace((sink.index, sink.name.clone()));
}
imp.resetVolumeSlider.connect_change_value(
imp.reset_volume_slider.connect_change_value(
clone!(@weak imp => @default-return Propagation::Stop, move |_, _, value| {
let fraction = (value / 655.36).round();
let percentage = (fraction).to_string() + "%";
imp.resetVolumePercentage.set_text(&percentage);
imp.reset_volume_percentage.set_text(&percentage);
let mut stream = imp.stream.try_borrow();
while stream.is_err() {
stream = imp.stream.try_borrow();
@ -83,7 +83,7 @@ impl InputStreamEntry {
// list = box_imp.resetModelList.try_borrow();
// }
// let list = list.unwrap();
imp.resetSinkSelection.set_model(Some(&*list));
imp.reset_sink_selection.set_model(Some(&*list));
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);
@ -91,7 +91,7 @@ impl InputStreamEntry {
let name = &name.2;
let index = map.get(name);
if let Some(index) = index {
imp.resetSinkSelection.set_selected(index.1);
imp.reset_sink_selection.set_selected(index.1);
}
} else {
let mut name = box_imp.reset_default_sink.try_borrow();
@ -101,11 +101,11 @@ impl InputStreamEntry {
let name = &name.unwrap().alias;
let index = map.get(name);
if let Some(index) = index {
imp.resetSinkSelection.set_selected(index.1);
imp.reset_sink_selection.set_selected(index.1);
}
}
}
imp.resetSinkSelection.connect_selected_notify(
imp.reset_sink_selection.connect_selected_notify(
clone!(@weak imp, @weak box_imp => move |dropdown| {
let selected = dropdown.selected_item();
if selected.is_none() {
@ -132,7 +132,7 @@ impl InputStreamEntry {
set_sink_of_input_stream(stream.index, sink);
}),
);
imp.resetSinkMute
imp.reset_sink_mute
.connect_clicked(clone!(@weak imp => move |_| {
let stream = imp.stream.clone();
let mut stream = stream.try_borrow_mut();
@ -144,10 +144,10 @@ impl InputStreamEntry {
let muted = stream.muted;
let index = stream.index;
if muted {
imp.resetSinkMute
imp.reset_sink_mute
.set_icon_name("audio-volume-muted-symbolic");
} else {
imp.resetSinkMute
imp.reset_sink_mute
.set_icon_name("audio-volume-high-symbolic");
}
toggle_input_stream_mute(index, muted);

11
src/components/output/input_stream_entry_impl.rs
View file

@ -10,20 +10,19 @@ use ReSet_Lib::audio::audio::InputStream;
use super::input_stream_entry;
#[allow(non_snake_case)]
#[derive(Default, CompositeTemplate)]
#[template(resource = "/org/Xetibo/ReSet/resetInputStreamEntry.ui")]
pub struct InputStreamEntry {
#[template_child]
pub resetSinkSelection: TemplateChild<ComboRow>,
pub reset_sink_selection: TemplateChild<ComboRow>,
#[template_child]
pub resetSinkMute: TemplateChild<Button>,
pub reset_sink_mute: TemplateChild<Button>,
#[template_child]
pub resetVolumeSlider: TemplateChild<Scale>,
pub reset_volume_slider: TemplateChild<Scale>,
#[template_child]
pub resetVolumePercentage: TemplateChild<Label>,
pub reset_volume_percentage: TemplateChild<Label>,
#[template_child]
pub resetVolumeMeter: TemplateChild<ProgressBar>,
pub reset_volume_meter: TemplateChild<ProgressBar>,
pub stream: Arc<RefCell<InputStream>>,
pub associated_sink: Arc<RefCell<(u32, String)>>,
pub volume_time_stamp: RefCell<Option<SystemTime>>,

86
src/components/output/sink_box.rs
View file

@ -49,36 +49,36 @@ impl SinkBox {
pub fn setup_callbacks(&self) {
let self_imp = self.imp();
self_imp.resetSinksRow.set_activatable(true);
self_imp.reset_sinks_row.set_activatable(true);
self_imp
.resetSinksRow
.reset_sinks_row
.set_action_name(Some("navigation.push"));
self_imp
.resetSinksRow
.reset_sinks_row
.set_action_target_value(Some(&Variant::from("outputDevices")));
self_imp.resetCardsRow.set_activatable(true);
self_imp.reset_cards_row.set_activatable(true);
self_imp
.resetCardsRow
.reset_cards_row
.set_action_name(Some("navigation.push"));
self_imp
.resetCardsRow
.reset_cards_row
.set_action_target_value(Some(&Variant::from("profileConfiguration")));
self_imp.resetCardsRow.connect_action_name_notify(|_| {});
self_imp.reset_cards_row.connect_action_name_notify(|_| {});
self_imp.resetInputStreamButton.set_activatable(true);
self_imp.reset_input_stream_button.set_activatable(true);
self_imp
.resetInputStreamButton
.reset_input_stream_button
.set_action_name(Some("navigation.pop"));
self_imp.resetInputCardsBackButton.set_activatable(true);
self_imp.reset_input_cards_back_button.set_activatable(true);
self_imp
.resetInputCardsBackButton
.reset_input_cards_back_button
.set_action_name(Some("navigation.pop"));
self_imp
.resetSinkDropdown
.reset_sink_dropdown
.set_factory(Some(&create_dropdown_label_factory()));
set_combo_row_ellipsis(self_imp.resetSinkDropdown.get());
set_combo_row_ellipsis(self_imp.reset_sink_dropdown.get());
}
}
@ -120,8 +120,8 @@ pub fn populate_sinks(output_box: Arc<SinkBox>) {
let volume = sink.volume.first().unwrap_or(&0);
let fraction = (*volume as f64 / 655.36).round();
let percentage = (fraction).to_string() + "%";
output_box_imp.resetVolumePercentage.set_text(&percentage);
output_box_imp.resetVolumeSlider.set_value(*volume as f64);
output_box_imp.reset_volume_percentage.set_text(&percentage);
output_box_imp.reset_volume_slider.set_value(*volume as f64);
let mut list = output_box_imp.reset_sink_list.write().unwrap();
for sink in sinks {
let index = sink.index;
@ -139,18 +139,18 @@ pub fn populate_sinks(output_box: Arc<SinkBox>) {
let entry = Arc::new(ListEntry::new(&*sink_entry));
entry.set_activatable(false);
list.insert(index, (entry.clone(), sink_clone, alias));
output_box_imp.resetSinks.append(&*entry);
output_box_imp.reset_sinks.append(&*entry);
}
let list = output_box_imp.reset_model_list.read().unwrap();
output_box_imp.resetSinkDropdown.set_model(Some(&*list));
output_box_imp.reset_sink_dropdown.set_model(Some(&*list));
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 {
output_box_imp.resetSinkDropdown.set_selected(index.1);
output_box_imp.reset_sink_dropdown.set_selected(index.1);
}
output_box_imp.resetSinkDropdown.connect_selected_notify(
output_box_imp.reset_sink_dropdown.connect_selected_notify(
clone!(@weak output_box_imp => move |dropdown| {
let selected = dropdown.selected_item();
if selected.is_none() {
@ -172,12 +172,12 @@ pub fn populate_sinks(output_box: Arc<SinkBox>) {
}
output_box_ref
.imp()
.resetVolumeSlider
.reset_volume_slider
.connect_change_value(move |_, _, value| {
let imp = output_box_ref_slider.imp();
let fraction = (value / 655.36).round();
let percentage = (fraction).to_string() + "%";
imp.resetVolumePercentage.set_text(&percentage);
imp.reset_volume_percentage.set_text(&percentage);
let sink = imp.reset_default_sink.borrow();
let index = sink.index;
let channels = sink.channels;
@ -195,7 +195,7 @@ pub fn populate_sinks(output_box: Arc<SinkBox>) {
});
output_box_ref
.imp()
.resetSinkMute
.reset_sink_mute
.connect_clicked(move |_| {
let imp = output_box_ref_mute.imp();
let stream = imp.reset_default_sink.clone();
@ -204,10 +204,10 @@ pub fn populate_sinks(output_box: Arc<SinkBox>) {
let muted = stream.muted;
let index = stream.index;
if muted {
imp.resetSinkMute
imp.reset_sink_mute
.set_icon_name("audio-volume-muted-symbolic");
} else {
imp.resetSinkMute
imp.reset_sink_mute
.set_icon_name("audio-volume-high-symbolic");
}
toggle_sink_mute(index, muted);
@ -232,7 +232,7 @@ pub fn populate_inputstreams(output_box: Arc<SinkBox>) {
let entry = Arc::new(ListEntry::new(&*input_stream));
entry.set_activatable(false);
list.insert(index, (entry.clone(), input_stream.clone()));
output_box_imp.resetInputStreams.append(&*entry);
output_box_imp.reset_input_streams.append(&*entry);
}
});
});
@ -247,7 +247,7 @@ pub fn populate_cards(output_box: Arc<SinkBox>) {
glib::idle_add_once(move || {
let imp = output_box_ref.imp();
for card in cards {
imp.resetCards.add(&CardEntry::new(card));
imp.reset_cards.add(&CardEntry::new(card));
}
});
});
@ -376,7 +376,7 @@ pub fn start_output_box_listener(conn: Connection, sink_box: Arc<SinkBox>) -> Co
let entry = Arc::new(ListEntry::new(&*sink_entry));
entry.set_activatable(false);
list.insert(sink_index, (entry.clone(), sink_clone, alias.clone()));
output_box_imp.resetSinks.append(&*entry);
output_box_imp.reset_sinks.append(&*entry);
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
@ -406,7 +406,7 @@ pub fn start_output_box_listener(conn: Connection, sink_box: Arc<SinkBox>) -> Co
if entry.is_none() {
return;
}
output_box_imp.resetSinks.remove(&*entry.unwrap().0);
output_box_imp.reset_sinks.remove(&*entry.unwrap().0);
let alias = list.remove(&ir.index);
if alias.is_none() {
return;
@ -452,15 +452,15 @@ pub fn start_output_box_listener(conn: Connection, sink_box: Arc<SinkBox>) -> Co
}
let imp = entry.unwrap().1.imp();
if is_default {
output_box_imp.resetVolumePercentage.set_text(&percentage);
output_box_imp.resetVolumeSlider.set_value(*volume as f64);
imp.resetSelectedSink.set_active(true);
output_box_imp.reset_volume_percentage.set_text(&percentage);
output_box_imp.reset_volume_slider.set_value(*volume as f64);
imp.reset_selected_sink.set_active(true);
} else {
imp.resetSelectedSink.set_active(false);
imp.reset_selected_sink.set_active(false);
}
imp.resetSinkName.set_title(ir.sink.alias.clone().as_str());
imp.resetVolumePercentage.set_text(&percentage);
imp.resetVolumeSlider.set_value(*volume as f64);
imp.reset_sink_name.set_title(ir.sink.alias.clone().as_str());
imp.reset_volume_percentage.set_text(&percentage);
imp.reset_volume_slider.set_value(*volume as f64);
});
});
true
@ -482,7 +482,7 @@ pub fn start_output_box_listener(conn: Connection, sink_box: Arc<SinkBox>) -> Co
let entry = Arc::new(ListEntry::new(&*input_stream));
entry.set_activatable(false);
list.insert(index, (entry.clone(), input_stream.clone()));
output_box_imp.resetInputStreams.append(&*entry);
output_box_imp.reset_input_streams.append(&*entry);
});
});
true
@ -520,23 +520,23 @@ pub fn start_output_box_listener(conn: Connection, sink_box: Arc<SinkBox>) -> Co
}
let imp = entry.imp();
if ir.stream.muted {
imp.resetSinkMute
imp.reset_sink_mute
.set_icon_name("audio-volume-muted-symbolic");
} else {
imp.resetSinkMute
imp.reset_sink_mute
.set_icon_name("audio-volume-high-symbolic");
}
let name = ir.stream.application_name.clone() + ": " + ir.stream.name.as_str();
imp.resetSinkSelection.set_title(name.as_str());
imp.reset_sink_selection.set_title(name.as_str());
let volume = ir.stream.volume.first().unwrap_or(&0_u32);
let fraction = (*volume as f64 / 655.36).round();
let percentage = (fraction).to_string() + "%";
imp.resetVolumePercentage.set_text(&percentage);
imp.resetVolumeSlider.set_value(*volume as f64);
imp.reset_volume_percentage.set_text(&percentage);
imp.reset_volume_slider.set_value(*volume as f64);
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);
imp.reset_sink_selection.set_selected(index.1);
}
});
});
@ -558,7 +558,7 @@ pub fn start_output_box_listener(conn: Connection, sink_box: Arc<SinkBox>) -> Co
if entry.is_none() {
return;
}
output_box_imp.resetInputStreams.remove(&*entry.unwrap().0);
output_box_imp.reset_input_streams.remove(&*entry.unwrap().0);
list.remove(&ir.index);
});
});

25
src/components/output/sink_box_impl.rs
View file

@ -18,34 +18,33 @@ type SinkEntryMap = Arc<RwLock<HashMap<u32, (Arc<ListEntry>, Arc<SinkEntry>, Str
type InputStreamEntryMap = Arc<RwLock<HashMap<u32, (Arc<ListEntry>, Arc<InputStreamEntry>)>>>;
type SinkMap = Arc<RwLock<HashMap<String, (u32, u32, String)>>>;
#[allow(non_snake_case)]
#[derive(Default, CompositeTemplate)]
#[template(resource = "/org/Xetibo/ReSet/resetAudioOutput.ui")]
pub struct SinkBox {
#[template_child]
pub resetSinksRow: TemplateChild<ActionRow>,
pub reset_sinks_row: TemplateChild<ActionRow>,
#[template_child]
pub resetCardsRow: TemplateChild<ActionRow>,
pub reset_cards_row: TemplateChild<ActionRow>,
#[template_child]
pub resetSinkDropdown: TemplateChild<ComboRow>,
pub reset_sink_dropdown: TemplateChild<ComboRow>,
#[template_child]
pub resetSinkMute: TemplateChild<Button>,
pub reset_sink_mute: TemplateChild<Button>,
#[template_child]
pub resetVolumeSlider: TemplateChild<Scale>,
pub reset_volume_slider: TemplateChild<Scale>,
#[template_child]
pub resetVolumePercentage: TemplateChild<Label>,
pub reset_volume_percentage: TemplateChild<Label>,
#[template_child]
pub resetVolumeMeter: TemplateChild<ProgressBar>,
pub reset_volume_meter: TemplateChild<ProgressBar>,
#[template_child]
pub resetSinks: TemplateChild<Box>,
pub reset_sinks: TemplateChild<Box>,
#[template_child]
pub resetInputStreamButton: TemplateChild<ActionRow>,
pub reset_input_stream_button: TemplateChild<ActionRow>,
#[template_child]
pub resetInputStreams: TemplateChild<Box>,
pub reset_input_streams: TemplateChild<Box>,
#[template_child]
pub resetInputCardsBackButton: TemplateChild<ActionRow>,
pub reset_input_cards_back_button: TemplateChild<ActionRow>,
#[template_child]
pub resetCards: TemplateChild<PreferencesGroup>,
pub reset_cards: TemplateChild<PreferencesGroup>,
pub reset_default_check_button: Arc<CheckButton>,
pub reset_default_sink: Arc<RefCell<Sink>>,
pub reset_sink_list: SinkEntryMap,

24
src/components/output/sink_entry.rs
View file

@ -28,19 +28,19 @@ impl SinkEntry {
// TODO use event callback for progress bar -> this is the "im speaking" indicator
{
let imp = obj.imp();
imp.resetSinkName.set_title(stream.alias.clone().as_str());
imp.reset_sink_name.set_title(stream.alias.clone().as_str());
let name = Arc::new(stream.name.clone());
let volume = stream.volume.first().unwrap_or(&0_u32);
let fraction = (*volume as f64 / 655.36).round();
let percentage = (fraction).to_string() + "%";
imp.resetVolumePercentage.set_text(&percentage);
imp.resetVolumeSlider.set_value(*volume as f64);
imp.reset_volume_percentage.set_text(&percentage);
imp.reset_volume_slider.set_value(*volume as f64);
imp.stream.replace(stream);
imp.resetVolumeSlider.connect_change_value(
imp.reset_volume_slider.connect_change_value(
clone!(@weak imp => @default-return Propagation::Stop, move |_, _, value| {
let fraction = (value / 655.36).round();
let percentage = (fraction).to_string() + "%";
imp.resetVolumePercentage.set_text(&percentage);
imp.reset_volume_percentage.set_text(&percentage);
let sink = imp.stream.borrow();
let index = sink.index;
let channels = sink.channels;
@ -55,18 +55,18 @@ impl SinkEntry {
Propagation::Proceed
}),
);
imp.resetSelectedSink.set_group(Some(&*check_group));
imp.reset_selected_sink.set_group(Some(&*check_group));
if is_default {
imp.resetSelectedSink.set_active(true);
imp.reset_selected_sink.set_active(true);
} else {
imp.resetSelectedSink.set_active(false);
imp.reset_selected_sink.set_active(false);
}
imp.resetSelectedSink.connect_toggled(move |button| {
imp.reset_selected_sink.connect_toggled(move |button| {
if button.is_active() {
set_default_sink(name.clone());
}
});
imp.resetSinkMute
imp.reset_sink_mute
.connect_clicked(clone!(@weak imp => move |_| {
let stream = imp.stream.clone();
let mut stream = stream.borrow_mut();
@ -74,10 +74,10 @@ impl SinkEntry {
let muted = stream.muted;
let index = stream.index;
if muted {
imp.resetSinkMute
imp.reset_sink_mute
.set_icon_name("audio-volume-muted-symbolic");
} else {
imp.resetSinkMute
imp.reset_sink_mute
.set_icon_name("audio-volume-high-symbolic");
}
toggle_sink_mute(index, muted);

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

@ -9,22 +9,21 @@ use gtk::subclass::prelude::*;
use gtk::{glib, Button, CheckButton, CompositeTemplate, Label, ProgressBar, Scale};
use ReSet_Lib::audio::audio::Sink;
#[allow(non_snake_case)]
#[derive(Default, CompositeTemplate)]
#[template(resource = "/org/Xetibo/ReSet/resetSinkEntry.ui")]
pub struct SinkEntry {
#[template_child]
pub resetSinkName: TemplateChild<ActionRow>,
pub reset_sink_name: TemplateChild<ActionRow>,
#[template_child]
pub resetSelectedSink: TemplateChild<CheckButton>,
pub reset_selected_sink: TemplateChild<CheckButton>,
#[template_child]
pub resetSinkMute: TemplateChild<Button>,
pub reset_sink_mute: TemplateChild<Button>,
#[template_child]
pub resetVolumeSlider: TemplateChild<Scale>,
pub reset_volume_slider: TemplateChild<Scale>,
#[template_child]
pub resetVolumePercentage: TemplateChild<Label>,
pub reset_volume_percentage: TemplateChild<Label>,
#[template_child]
pub resetVolumeMeter: TemplateChild<ProgressBar>,
pub reset_volume_meter: TemplateChild<ProgressBar>,
pub stream: Arc<RefCell<Sink>>,
pub volume_time_stamp: RefCell<Option<SystemTime>>,
}

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

@ -24,7 +24,7 @@ impl SavedWifiEntry {
entry.set_activatable(false);
let entry_imp = entry.imp();
entry_imp.resetEditSavedWifiButton.connect_clicked(
entry_imp.reset_edit_saved_wifi_button.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());
@ -32,9 +32,9 @@ impl SavedWifiEntry {
}),
);
entry_imp.resetSavedWifiLabel.set_text(name);
entry_imp.reset_saved_wifi_label.set_text(name);
entry_imp.reset_connection_path.set(path);
entry_imp.resetDeleteSavedWifiButton.connect_clicked(
entry_imp.reset_delete_saved_wifi_button.connect_clicked(
clone!(@weak entry as entry => move |_| {
delete_connection(entry.imp().reset_connection_path.take());
// TODO handle error

7
src/components/wifi/saved_wifi_entry_impl.rs
View file

@ -10,16 +10,15 @@ use ReSet_Lib::network::network::AccessPoint;
use super::saved_wifi_entry;
#[allow(non_snake_case)]
#[derive(Default, CompositeTemplate)]
#[template(resource = "/org/Xetibo/ReSet/resetSavedWifiEntry.ui")]
pub struct SavedWifiEntry {
#[template_child]
pub resetDeleteSavedWifiButton: TemplateChild<Button>,
pub reset_delete_saved_wifi_button: TemplateChild<Button>,
#[template_child]
pub resetEditSavedWifiButton: TemplateChild<Button>,
pub reset_edit_saved_wifi_button: TemplateChild<Button>,
#[template_child]
pub resetSavedWifiLabel: TemplateChild<Label>,
pub reset_saved_wifi_label: TemplateChild<Label>,
pub reset_connection_path: RefCell<Path<'static>>,
pub access_point: RefCell<AccessPoint>,
}

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

@ -34,12 +34,12 @@ impl WifiAddressEntry {
let conn = conn.borrow();
let address = unsafe { conn.ipv4.address_data.get_unchecked(address) };
entry_imp.resetAddressAddress.set_text(&address.address);
entry_imp.reset_address_address.set_text(&address.address);
entry_imp
.resetAddressPrefix
.reset_address_prefix
.set_text(&address.prefix_length.to_string());
entry_imp
.resetAddressRow
.reset_address_row
.set_title(&format!("{}/{}", &*address.address, address.prefix_length));
}
entry_imp.protocol.set(protocol);
@ -51,13 +51,13 @@ impl WifiAddressEntry {
let self_imp = self.imp();
let conn = connection.clone();
self_imp.resetAddressAddress.connect_changed(clone!(@weak self_imp => move |entry| {
self_imp.reset_address_address.connect_changed(clone!(@weak self_imp => move |entry| {
let address_input = entry.text();
let mut conn = conn.borrow_mut();
if address_input.is_empty() {
self_imp.resetAddressAddress.remove_css_class("error");
self_imp.resetAddressRow.set_title("Add new address");
self_imp.reset_address_address.remove_css_class("error");
self_imp.reset_address_row.set_title("Add new address");
return;
}
let result = match self_imp.protocol.get() {
@ -66,7 +66,7 @@ impl WifiAddressEntry {
};
match result {
Ok(ip_addr) => {
self_imp.resetAddressAddress.remove_css_class("error");
self_imp.reset_address_address.remove_css_class("error");
let address_data = match self_imp.protocol.get() {
IpProtocol::IPv4 => &mut conn.ipv4.address_data,
IpProtocol::IPv6 => &mut conn.ipv6.address_data,
@ -75,7 +75,7 @@ impl WifiAddressEntry {
*self_imp.address.borrow_mut() = (true, ip_addr.to_string());
}
Err(_) => {
self_imp.resetAddressAddress.add_css_class("error");
self_imp.reset_address_address.add_css_class("error");
*self_imp.address.borrow_mut() = (false, String::default());
}
}
@ -83,16 +83,16 @@ impl WifiAddressEntry {
}));
let conn = connection.clone();
self_imp.resetAddressPrefix.connect_changed(clone!(@weak self_imp => move |entry| {
self_imp.reset_address_prefix.connect_changed(clone!(@weak self_imp => move |entry| {
let prefix_input = entry.text();
let prefix = prefix_input.parse::<u8>();
let mut conn = conn.borrow_mut();
let handle_error = || {
if self_imp.resetAddressPrefix.text().is_empty() {
self_imp.resetAddressPrefix.remove_css_class("error");
if self_imp.reset_address_prefix.text().is_empty() {
self_imp.reset_address_prefix.remove_css_class("error");
} else {
self_imp.resetAddressPrefix.add_css_class("error");
self_imp.reset_address_prefix.add_css_class("error");
}
self_imp.prefix.set((false, 0));
set_row_name(&self_imp);
@ -107,8 +107,8 @@ impl WifiAddressEntry {
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()) {
self_imp.reset_address_prefix.remove_css_class("error");
if let Ok(address2) = Ipv4Addr::from_str(self_imp.reset_address_address.text().as_str()) {
if let Some(addr) = conn.ipv4.address_data.iter_mut()
.find(|conn_addr| *conn_addr.address == address2.to_string()) {
addr.prefix_length = prefix as u32;
@ -117,8 +117,8 @@ impl WifiAddressEntry {
}
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()) {
self_imp.reset_address_prefix.remove_css_class("error");
if let Ok(address2) = Ipv6Addr::from_str(self_imp.reset_address_address.text().as_str()) {
if let Some(addr) = conn.ipv6.address_data.iter_mut()
.find(|conn_addr| *conn_addr.address == address2.to_string()) {
addr.prefix_length = prefix as u32;
@ -131,9 +131,9 @@ impl WifiAddressEntry {
}));
let conn = connection.clone();
self_imp.resetAddressRemove.connect_clicked(
self_imp.reset_address_remove.connect_clicked(
clone!(@weak self_imp, @weak self as what => move |_| {
let address = self_imp.resetAddressAddress.text();
let address = self_imp.reset_address_address.text();
let mut conn = conn.borrow_mut();
conn.ipv4.address_data.retain(|addr| addr.address != address);
what.unparent();
@ -143,7 +143,7 @@ impl WifiAddressEntry {
}
fn set_row_name(self_imp: &WifiAddressEntryImpl) {
if self_imp.resetAddressAddress.text().is_empty() {
if self_imp.reset_address_address.text().is_empty() {
return;
}
let address = self_imp.address.borrow();
@ -156,5 +156,5 @@ fn set_row_name(self_imp: &WifiAddressEntryImpl) {
(false, true) => "Address wrong".to_string(),
(false, false) => "Address and Prefix wrong".to_string(),
};
self_imp.resetAddressRow.set_title(&title);
self_imp.reset_address_row.set_title(&title);
}

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

@ -5,18 +5,17 @@ use gtk::subclass::prelude::*;
use gtk::{glib, Button, CompositeTemplate};
use std::cell::{Cell, RefCell};
#[allow(non_snake_case)]
#[derive(Default, CompositeTemplate)]
#[template(resource = "/org/Xetibo/ReSet/resetWifiAddressEntry.ui")]
pub struct WifiAddressEntryImpl {
#[template_child]
pub resetAddressRow: TemplateChild<ExpanderRow>,
pub reset_address_row: TemplateChild<ExpanderRow>,
#[template_child]
pub resetAddressAddress: TemplateChild<EntryRow>,
pub reset_address_address: TemplateChild<EntryRow>,
#[template_child]
pub resetAddressPrefix: TemplateChild<EntryRow>,
pub reset_address_prefix: TemplateChild<EntryRow>,
#[template_child]
pub resetAddressRemove: TemplateChild<Button>,
pub reset_address_remove: TemplateChild<Button>,
pub address: RefCell<(bool, String)>,
pub prefix: Cell<(bool, u32)>,
pub protocol: Cell<IpProtocol>,

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

@ -50,23 +50,23 @@ impl WifiBox {
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
imp.reset_saved_networks.set_activatable(true);
imp.reset_saved_networks
.set_action_name(Some("navigation.push"));
imp.resetSavedNetworks
imp.reset_saved_networks
.set_action_target_value(Some(&Variant::from("saved")));
imp.resetAvailableNetworks.set_activatable(true);
imp.resetAvailableNetworks
imp.reset_available_networks.set_activatable(true);
imp.reset_available_networks
.set_action_name(Some("navigation.pop"));
set_combo_row_ellipsis(imp.resetWiFiDevice.get());
imp.resetWifiSwitch.connect_state_set(
set_combo_row_ellipsis(imp.reset_wifi_device.get());
imp.reset_wifi_switch.connect_state_set(
clone!(@weak imp => @default-return glib::Propagation::Proceed, move |_, value| {
set_wifi_enabled(value);
if !value {
let mut map = imp.wifi_entries.lock().unwrap();
for entry in map.iter() {
imp.resetWifiList.remove(&*(*entry.1));
imp.reset_wifi_list.remove(&*(*entry.1));
}
map.clear();
imp.wifi_entries_path.lock().unwrap().clear();
@ -114,13 +114,13 @@ pub fn scan_for_wifi(wifi_box: Arc<WifiBox>) {
let imp = wifibox_ref.imp();
let list = imp.reset_model_list.read().unwrap();
imp.resetWiFiDevice.set_model(Some(&*list));
imp.reset_wifi_device.set_model(Some(&*list));
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);
imp.reset_wifi_device.set_selected(index.1);
}
imp.resetWiFiDevice
imp.reset_wifi_device
.connect_selected_notify(clone!(@weak imp => move |dropdown| {
let selected = dropdown.selected_item();
if selected.is_none() {
@ -145,7 +145,7 @@ pub fn scan_for_wifi(wifi_box: Arc<WifiBox>) {
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);
imp.reset_wifi_list.add(&*entry);
}
});
});
@ -164,7 +164,7 @@ pub fn show_stored_connections(wifi_box: Arc<WifiBox>) {
let name =
&String::from_utf8(connection.1).unwrap_or_else(|_| String::from(""));
let entry = SavedWifiEntry::new(name, connection.0, self_imp);
self_imp.resetStoredWifiList.add(&entry);
self_imp.reset_stored_wifi_list.add(&entry);
}
});
});
@ -302,7 +302,7 @@ pub fn start_event_listener(listeners: Arc<Listeners>, wifi_box: Arc<WifiBox>) {
let entry = WifiEntry::new(connected, ir.access_point, imp);
wifi_entries.insert(ssid, entry.clone());
wifi_entries_path.insert(path, entry.clone());
imp.resetWifiList.add(&*entry);
imp.reset_wifi_list.add(&*entry);
});
});
true
@ -326,7 +326,7 @@ pub fn start_event_listener(listeners: Arc<Listeners>, wifi_box: Arc<WifiBox>) {
let entry = entry.unwrap();
let ssid = entry.imp().access_point.borrow().ssid.clone();
wifi_entries.remove(&ssid);
imp.resetWifiList.remove(&*entry);
imp.reset_wifi_list.remove(&*entry);
});
});
true
@ -354,11 +354,11 @@ pub fn start_event_listener(listeners: Arc<Listeners>, wifi_box: Arc<WifiBox>) {
let name_opt = String::from_utf8(ssid).unwrap_or_else(|_| String::from(""));
let name = name_opt.as_str();
entry_imp.wifi_strength.set(strength);
entry_imp.resetWifiLabel.get().set_text(name);
entry_imp.resetWifiEncrypted.set_visible(false);
entry_imp.reset_wifi_label.get().set_text(name);
entry_imp.reset_wifi_encrypted.set_visible(false);
// TODO handle encryption thing
entry_imp
.resetWifiStrength
.reset_wifi_strength
.get()
.set_from_icon_name(match strength {
WifiStrength::Excellent => {
@ -369,14 +369,14 @@ 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 {
entry_imp.resetWifiEditButton.set_sensitive(false);
entry_imp.reset_wifi_edit_button.set_sensitive(false);
}
if ir.access_point.dbus_path
== imp.reset_current_wifi_device.borrow().active_access_point
{
entry_imp.resetWifiConnected.set_text("Connected");
entry_imp.reset_wifi_connected.set_text("Connected");
} else {
entry_imp.resetWifiConnected.set_text("");
entry_imp.reset_wifi_connected.set_text("");
}
{
let mut wifi_name = entry_imp.wifi_name.borrow_mut();

17
src/components/wifi/wifi_box_impl.rs
View file

@ -12,26 +12,25 @@ use ReSet_Lib::network::network::WifiDevice;
use crate::components::base::list_entry::ListEntry;
use crate::components::wifi::wifi_entry::WifiEntry;
#[allow(non_snake_case)]
#[derive(Default, CompositeTemplate)]
#[template(resource = "/org/Xetibo/ReSet/resetWiFi.ui")]
pub struct WifiBox {
#[template_child]
pub resetWifiNavigation: TemplateChild<NavigationView>,
pub reset_wifi_navigation: TemplateChild<NavigationView>,
#[template_child]
pub resetWifiDetails: TemplateChild<PreferencesGroup>,
pub reset_wifi_details: TemplateChild<PreferencesGroup>,
#[template_child]
pub resetWiFiDevice: TemplateChild<ComboRow>,
pub reset_wifi_device: TemplateChild<ComboRow>,
#[template_child]
pub resetSavedNetworks: TemplateChild<ActionRow>,
pub reset_saved_networks: TemplateChild<ActionRow>,
#[template_child]
pub resetWifiSwitch: TemplateChild<Switch>,
pub reset_wifi_switch: TemplateChild<Switch>,
#[template_child]
pub resetWifiList: TemplateChild<PreferencesGroup>,
pub reset_wifi_list: TemplateChild<PreferencesGroup>,
#[template_child]
pub resetStoredWifiList: TemplateChild<PreferencesGroup>,
pub reset_stored_wifi_list: TemplateChild<PreferencesGroup>,
#[template_child]
pub resetAvailableNetworks: TemplateChild<ActionRow>,
pub reset_available_networks: TemplateChild<ActionRow>,
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>>>,

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

@ -37,12 +37,12 @@ impl WifiEntry {
let name_opt = String::from_utf8(ssid).unwrap_or_else(|_| String::from(""));
let name = name_opt.as_str();
entry_imp.wifi_strength.set(strength);
entry_imp.resetWifiLabel.get().set_text(name);
entry_imp.resetWifiEncrypted.set_visible(false);
entry_imp.reset_wifi_label.get().set_text(name);
entry_imp.reset_wifi_encrypted.set_visible(false);
entry_imp.connected.set(connected);
// TODO handle encryption thing
entry_imp
.resetWifiStrength
.reset_wifi_strength
.get()
.set_from_icon_name(match strength {
WifiStrength::Excellent => Some("network-wireless-signal-excellent-symbolic"),
@ -51,10 +51,10 @@ impl WifiEntry {
WifiStrength::None => Some("network-wireless-signal-none-symbolic"),
});
if !access_point.stored {
entry_imp.resetWifiEditButton.set_sensitive(false);
entry_imp.reset_wifi_edit_button.set_sensitive(false);
}
if connected {
entry_imp.resetWifiConnected.set_text("Connected");
entry_imp.reset_wifi_connected.set_text("Connected");
}
{
let mut wifi_name = entry_imp.wifi_name.borrow_mut();
@ -79,9 +79,9 @@ impl WifiEntry {
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 |_| {
self_imp.reset_wifi_edit_button.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()));
wifi_box.reset_wifi_navigation.push(&*WifiOptions::new(_option, self_imp.access_point.borrow().dbus_path.clone()));
}));
}
}
@ -107,7 +107,7 @@ pub fn click_disconnect(entry: Arc<WifiEntry>) {
imp.connected.replace(false);
return;
}
imp.resetWifiConnected.set_text("");
imp.reset_wifi_connected.set_text("");
imp.connected.replace(false);
glib::spawn_future(async move {
glib::idle_add_once(move || {
@ -149,7 +149,7 @@ pub fn click_stored_network(entry: Arc<WifiEntry>) {
return;
}
let imp = entry_ref.imp();
imp.resetWifiConnected.set_text("Connected");
imp.reset_wifi_connected.set_text("Connected");
imp.connected.replace(true);
});
});
@ -161,11 +161,11 @@ pub fn click_new_network(entry: Arc<WifiEntry>) {
let connect_new_network =
|entry: Arc<WifiEntry>, access_point: AccessPoint, password: String| {
let entry_ref = entry.clone();
let popup = entry.imp().resetWifiPopup.imp();
popup.resetPopupLabel.set_text("Connecting...");
popup.resetPopupLabel.set_visible(true);
popup.resetPopupEntry.set_sensitive(false);
popup.resetPopupButton.set_sensitive(false);
let popup = entry.imp().reset_wifi_popup.imp();
popup.reset_popup_label.set_text("Connecting...");
popup.reset_popup_label.set_visible(true);
popup.reset_popup_entry.set_sensitive(false);
popup.reset_popup_button.set_sensitive(false);
gio::spawn_blocking(move || {
let conn = Connection::new_session().unwrap();
@ -183,27 +183,27 @@ pub fn click_new_network(entry: Arc<WifiEntry>) {
glib::idle_add_once(move || {
if res.is_err() {
let imp = entry_ref.imp();
imp.resetWifiPopup
imp.reset_wifi_popup
.imp()
.resetPopupLabel
.reset_popup_label
.set_text("Could not connect to dbus.");
imp.connected.replace(false);
return;
}
if res.unwrap() == (false,) {
let imp = entry_ref.imp();
imp.resetWifiPopup
imp.reset_wifi_popup
.imp()
.resetPopupLabel
.reset_popup_label
.set_text("Could not connect to access point.");
imp.connected.replace(false);
return;
}
println!("worked?");
let imp = entry_ref.imp();
imp.resetWifiPopup.popdown();
imp.resetWifiEditButton.set_sensitive(true);
imp.resetWifiConnected.set_text("Connected");
imp.reset_wifi_popup.popdown();
imp.reset_wifi_edit_button.set_sensitive(true);
imp.reset_wifi_connected.set_text("Connected");
imp.connected.replace(true);
});
});
@ -212,17 +212,17 @@ pub fn click_new_network(entry: Arc<WifiEntry>) {
};
let entry_imp = entry.imp();
let popup_imp = entry_imp.resetWifiPopup.imp();
let popup_imp = entry_imp.reset_wifi_popup.imp();
popup_imp
.resetPopupEntry
.reset_popup_entry
.connect_activate(clone!(@weak entry as orig_entry, @weak entry_imp => move |entry| {
connect_new_network(orig_entry, entry_imp.access_point.clone().take(), entry.text().to_string());
}));
popup_imp.resetPopupButton.connect_clicked(
popup_imp.reset_popup_button.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();
let entry = entry_imp.reset_wifi_popup.imp().reset_popup_entry.text().to_string();
connect_new_network(orig_entry, entry_imp.access_point.clone().take(), entry);
}),
);
entry_imp.resetWifiPopup.popup();
entry_imp.reset_wifi_popup.popup();
}

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

@ -8,22 +8,21 @@ use gtk::{glib, Button, CompositeTemplate, Image, Label};
use std::cell::RefCell;
use ReSet_Lib::network::network::{AccessPoint, WifiStrength};
#[allow(non_snake_case)]
#[derive(Default, CompositeTemplate)]
#[template(resource = "/org/Xetibo/ReSet/resetWifiEntry.ui")]
pub struct WifiEntry {
#[template_child]
pub resetWifiStrength: TemplateChild<Image>,
pub reset_wifi_strength: TemplateChild<Image>,
#[template_child]
pub resetWifiEncrypted: TemplateChild<Image>,
pub reset_wifi_encrypted: TemplateChild<Image>,
#[template_child]
pub resetWifiLabel: TemplateChild<Label>,
pub reset_wifi_label: TemplateChild<Label>,
#[template_child]
pub resetWifiEditButton: TemplateChild<Button>,
pub reset_wifi_edit_button: TemplateChild<Button>,
#[template_child]
pub resetWifiConnected: TemplateChild<Label>,
pub reset_wifi_connected: TemplateChild<Label>,
#[template_child]
pub resetWifiPopup: TemplateChild<Popup>,
pub reset_wifi_popup: TemplateChild<Popup>,
pub wifi_name: RefCell<String>,
pub wifi_strength: RefCell<WifiStrength>,
pub access_point: RefCell<AccessPoint>,

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

@ -52,36 +52,36 @@ impl WifiOptions {
// General
self_imp
.resetWifiAutoConnect
.reset_wifi_auto_connect
.set_active(conn.settings.autoconnect);
self_imp
.resetWifiMetered
.reset_wifi_metered
.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.reset_wifi_link_speed.set_visible(false);
self_imp.reset_wifi_ip4_addr.set_visible(false);
self_imp.reset_wifi_ip6_addr.set_visible(false);
self_imp.reset_wifi_dns.set_visible(false);
self_imp.reset_wifi_gateway.set_visible(false);
self_imp.reset_wifi_last_used.set_visible(true);
self_imp.reset_wifi_mac.set_subtitle(&wifi.cloned_mac_address);
self_imp
.resetWifiName
.reset_wifi_name
.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.reset_wifi_link_speed.set_visible(true);
self_imp.reset_wifi_ip4_addr.set_visible(true);
self_imp.reset_wifi_ip6_addr.set_visible(true);
self_imp.reset_wifi_dns.set_visible(true);
self_imp.reset_wifi_gateway.set_visible(true);
self_imp.reset_wifi_last_used.set_visible(false);
self_imp
.resetWifiMac
.reset_wifi_mac
.set_subtitle(&ethernet.cloned_mac_address);
self_imp
.resetWifiLinkSpeed
.reset_wifi_link_speed
.set_subtitle(&ethernet.speed.to_string());
}
TypeSettings::VPN(_vpn) => {}
@ -89,7 +89,7 @@ impl WifiOptions {
};
// IPv4
self_imp
.resetIP4Method
.reset_ip4_method
.set_selected(conn.ipv4.dns_method.to_i32() as u32);
self.set_ip4_visibility(conn.ipv4.dns_method.to_i32() as u32);
@ -104,11 +104,11 @@ impl WifiOptions {
.join(".")
})
.collect();
self_imp.resetIP4DNS.set_text(&ipv4_dns.join(", "));
self_imp.resetIP4Gateway.set_text(&conn.ipv4.gateway);
self_imp.reset_ip4_dns.set_text(&ipv4_dns.join(", "));
self_imp.reset_ip4_gateway.set_text(&conn.ipv4.gateway);
// IPv6
self_imp
.resetIP6Method
.reset_ip6_method
.set_selected(conn.ipv6.dns_method.to_i32() as u32);
self.set_ip6_visibility(conn.ipv6.dns_method.to_i32() as u32);
@ -123,22 +123,22 @@ impl WifiOptions {
.join(":")
})
.collect();
self_imp.resetIP6DNS.set_text(&ipv6_dns.join(", "));
self_imp.resetIP6Gateway.set_text(&conn.ipv6.gateway);
self_imp.reset_ip6_dns.set_text(&ipv6_dns.join(", "));
self_imp.reset_ip6_gateway.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("");
self_imp.reset_wifi_security_dropdown.set_selected(0);
self_imp.reset_wifi_password.set_visible(false);
self_imp.reset_wifi_password.set_text("");
}
"wpa-psk" => {
self_imp.resetWifiSecurityDropdown.set_selected(1);
self_imp.resetWifiPassword.set_visible(true);
self_imp.reset_wifi_security_dropdown.set_selected(1);
self_imp.reset_wifi_password.set_visible(true);
self_imp
.resetWifiPassword
.reset_wifi_password
.set_text(&wifi.security_settings.psk);
}
_ => {}
@ -148,32 +148,32 @@ impl WifiOptions {
// IPv4
for i in 0..ip4_address_length {
let address = &WifiAddressEntry::new(Some(i), self_imp.connection.clone(), IPv4);
self_imp.resetIP4AddressGroup.add(address);
self_imp.reset_ip4_address_group.add(address);
}
let address = &WifiAddressEntry::new(None, self_imp.connection.clone(), IPv4);
self_imp.resetIP4AddressGroup.add(address);
self_imp.reset_ip4_address_group.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)
self_imp.reset_ip4_routes_group.add(route)
}
let route = &WifiRouteEntry::new(None, self_imp.connection.clone(), IPv4);
self_imp.resetIP4RoutesGroup.add(route);
self_imp.reset_ip4_routes_group.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);
self_imp.reset_ip6_address_group.add(address);
}
let address = &WifiAddressEntry::new(None, self_imp.connection.clone(), IPv6);
self_imp.resetIP6AddressGroup.add(address);
self_imp.reset_ip6_address_group.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);
self_imp.reset_ip6_routes_group.add(route);
}
let route = &WifiRouteEntry::new(None, self_imp.connection.clone(), IPv6);
self_imp.resetIP6RoutesGroup.add(route);
self_imp.reset_ip6_routes_group.add(route);
// Security
}
@ -182,20 +182,20 @@ impl WifiOptions {
match method {
0 => {
// auto
self_imp.resetIP4AddressGroup.set_visible(false);
self_imp.resetIP4RoutesGroup.set_visible(true);
self_imp.resetIP4Gateway.set_visible(false);
self_imp.reset_ip4_address_group.set_visible(false);
self_imp.reset_ip4_routes_group.set_visible(true);
self_imp.reset_ip4_gateway.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.reset_ip4_address_group.set_visible(true);
self_imp.reset_ip4_routes_group.set_visible(true);
self_imp.reset_ip4_gateway.set_visible(true);
}
_ => {
self_imp.resetIP4AddressGroup.set_visible(false);
self_imp.resetIP4RoutesGroup.set_visible(false);
self_imp.resetIP4Gateway.set_visible(false);
self_imp.reset_ip4_address_group.set_visible(false);
self_imp.reset_ip4_routes_group.set_visible(false);
self_imp.reset_ip4_gateway.set_visible(false);
}
}
}
@ -205,20 +205,20 @@ impl WifiOptions {
match method {
0 | 1 => {
// auto, dhcp
self_imp.resetIP6AddressGroup.set_visible(false);
self_imp.resetIP6RoutesGroup.set_visible(true);
self_imp.resetIP6Gateway.set_visible(false);
self_imp.reset_ip6_address_group.set_visible(false);
self_imp.reset_ip6_routes_group.set_visible(true);
self_imp.reset_ip6_gateway.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.reset_ip6_address_group.set_visible(true);
self_imp.reset_ip6_routes_group.set_visible(true);
self_imp.reset_ip6_gateway.set_visible(true);
}
_ => {
self_imp.resetIP6AddressGroup.set_visible(false);
self_imp.resetIP6RoutesGroup.set_visible(false);
self_imp.resetIP6Gateway.set_visible(false);
self_imp.reset_ip6_address_group.set_visible(false);
self_imp.reset_ip6_routes_group.set_visible(false);
self_imp.reset_ip6_gateway.set_visible(false);
}
}
}
@ -228,22 +228,22 @@ fn setup_callbacks(wifi_options: &Arc<WifiOptions>, path: Path<'static>) {
let imp = wifi_options.imp();
// General
imp.resetWifiAutoConnect
imp.reset_wifi_auto_connect
.connect_active_notify(clone!(@weak imp => move |x| {
imp.connection.borrow_mut().settings.autoconnect = x.is_active();
}));
imp.resetWifiMetered
imp.reset_wifi_metered
.connect_active_notify(clone!(@weak imp => move |x| {
imp.connection.borrow_mut().settings.metered = if x.is_active() { 1 } else { 2 };
}));
imp.wifiOptionsApplyButton
imp.wifi_options_apply_button
.connect_clicked(clone!(@weak imp => move |_| {
let prop = imp.connection.borrow().convert_to_propmap();
set_connection_settings(path.clone(), prop);
}));
// IPv4
let wifi_options_ip4 = wifi_options.clone();
imp.resetIP4Method
imp.reset_ip4_method
.connect_selected_notify(clone!(@weak imp => move |dropdown| {
let selected = dropdown.selected();
let mut conn = imp.connection.borrow_mut();
@ -251,49 +251,49 @@ fn setup_callbacks(wifi_options: &Arc<WifiOptions>, path: Path<'static>) {
wifi_options_ip4.set_ip4_visibility(selected);
}));
imp.resetIP4DNS
imp.reset_ip4_dns
.connect_changed(clone!(@weak imp => move |entry| {
let dns_input = entry.text();
let mut conn = imp.connection.borrow_mut();
conn.ipv4.dns.clear();
if dns_input.is_empty() {
imp.resetIP4DNS.remove_css_class("error");
imp.reset_ip4_dns.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");
imp.reset_ip4_dns.remove_css_class("error");
conn.ipv4.dns.push(addr.octets().to_vec());
} else {
imp.resetIP4DNS.add_css_class("error");
imp.reset_ip4_dns.add_css_class("error");
}
}
}));
imp.resetIP4AddressAddButton
imp.reset_ip4_address_add_button
.connect_clicked(clone!(@weak imp => move |_| {
let address = &WifiAddressEntry::new(None, imp.connection.clone(), IpProtocol::IPv4);
imp.resetIP4AddressGroup.add(address);
imp.reset_ip4_address_group.add(address);
}));
imp.resetIP4Gateway
imp.reset_ip4_gateway
.connect_changed(clone!(@weak imp => move |entry| {
let gateway_input = entry.text();
let mut conn = imp.connection.borrow_mut();
conn.ipv4.gateway.clear();
if gateway_input.is_empty() {
imp.resetIP4Gateway.remove_css_class("error");
imp.reset_ip4_gateway.remove_css_class("error");
return;
}
if Ipv4Addr::from_str(gateway_input.as_str()).is_ok() {
imp.resetIP4Gateway.remove_css_class("error");
imp.reset_ip4_gateway.remove_css_class("error");
conn.ipv4.gateway = gateway_input.to_string();
} else {
imp.resetIP4Gateway.add_css_class("error");
imp.reset_ip4_gateway.add_css_class("error");
}
}));
// IPv6
let wifi_options_ip6 = wifi_options.clone();
imp.resetIP6Method
imp.reset_ip6_method
.connect_selected_notify(clone!(@weak imp => move |dropdown| {
let selected = dropdown.selected();
let mut conn = imp.connection.borrow_mut();
@ -301,61 +301,61 @@ fn setup_callbacks(wifi_options: &Arc<WifiOptions>, path: Path<'static>) {
wifi_options_ip6.set_ip6_visibility(selected);
}));
imp.resetIP6DNS
imp.reset_ip6_dns
.connect_changed(clone!(@weak imp => move |entry| {
let dns_input = entry.text();
let mut conn = imp.connection.borrow_mut();
conn.ipv6.dns.clear();
if dns_input.is_empty() {
imp.resetIP6DNS.remove_css_class("error");
imp.reset_ip6_dns.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");
imp.reset_ip6_dns.remove_css_class("error");
conn.ipv6.dns.push(addr.octets().to_vec());
} else {
imp.resetIP6DNS.add_css_class("error");
imp.reset_ip6_dns.add_css_class("error");
}
}
}));
imp.resetIP6AddressAddButton
imp.reset_ip6_address_add_button
.connect_clicked(clone!(@weak imp => move |_| {
let address = &WifiAddressEntry::new(None, imp.connection.clone(), IpProtocol::IPv4);
imp.resetIP6AddressGroup.add(address);
imp.reset_ip6_address_group.add(address);
}));
imp.resetIP6Gateway
imp.reset_ip6_gateway
.connect_changed(clone!(@weak imp => move |entry| {
let gateway_input = entry.text();
let mut conn = imp.connection.borrow_mut();
conn.ipv6.gateway.clear();
if gateway_input.is_empty() {
imp.resetIP6Gateway.remove_css_class("error");
imp.reset_ip6_gateway.remove_css_class("error");
return;
}
if Ipv6Addr::from_str(gateway_input.as_str()).is_ok() {
imp.resetIP6Gateway.remove_css_class("error");
imp.reset_ip6_gateway.remove_css_class("error");
conn.ipv6.gateway = gateway_input.to_string();
} else {
imp.resetIP6Gateway.add_css_class("error");
imp.reset_ip6_gateway.add_css_class("error");
}
}));
// Security
imp.resetWifiSecurityDropdown
imp.reset_wifi_security_dropdown
.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);
imp.reset_wifi_password.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);
imp.reset_wifi_password.set_visible(true);
wifi.security_settings.key_management = String::from("wpa-psk");
wifi.security_settings.authentication_algorithm = String::from("");
},
@ -363,7 +363,7 @@ fn setup_callbacks(wifi_options: &Arc<WifiOptions>, path: Path<'static>) {
}
}));
imp.resetWifiPassword
imp.reset_wifi_password
.connect_changed(clone!(@weak imp => move |entry| {
let password_input = entry.text();
let mut conn = imp.connection.borrow_mut();

55
src/components/wifi/wifi_options_impl.rs
View file

@ -9,69 +9,68 @@ use std::cell::RefCell;
use std::rc::Rc;
use ReSet_Lib::network::connection::Connection;
#[allow(non_snake_case)]
#[derive(Default, CompositeTemplate)]
#[template(resource = "/org/Xetibo/ReSet/resetWifiOptions.ui")]
pub struct WifiOptions {
// General
#[template_child]
pub resetWifiName: TemplateChild<ActionRow>,
pub reset_wifi_name: TemplateChild<ActionRow>,
#[template_child]
pub resetWifiMac: TemplateChild<ActionRow>,
pub reset_wifi_mac: TemplateChild<ActionRow>,
#[template_child]
pub resetWifiLinkSpeed: TemplateChild<ActionRow>,
pub reset_wifi_link_speed: TemplateChild<ActionRow>,
#[template_child]
pub resetWifiIP4Addr: TemplateChild<ActionRow>,
pub reset_wifi_ip4_addr: TemplateChild<ActionRow>,
#[template_child]
pub resetWifiIP6Addr: TemplateChild<ActionRow>,
pub reset_wifi_ip6_addr: TemplateChild<ActionRow>,
#[template_child]
pub resetWifiGateway: TemplateChild<ActionRow>,
pub reset_wifi_gateway: TemplateChild<ActionRow>,
#[template_child]
pub resetWifiDNS: TemplateChild<ActionRow>,
pub reset_wifi_dns: TemplateChild<ActionRow>,
#[template_child]
pub resetWifiLastUsed: TemplateChild<ActionRow>,
pub reset_wifi_last_used: TemplateChild<ActionRow>,
#[template_child]
pub resetWifiAutoConnect: TemplateChild<SwitchRow>,
pub reset_wifi_auto_connect: TemplateChild<SwitchRow>,
#[template_child]
pub resetWifiMetered: TemplateChild<SwitchRow>,
pub reset_wifi_metered: TemplateChild<SwitchRow>,
// IPv4
#[template_child]
pub resetIP4Method: TemplateChild<ComboRow>,
pub reset_ip4_method: TemplateChild<ComboRow>,
#[template_child]
pub resetIP4DNS: TemplateChild<EntryRow>,
pub reset_ip4_dns: TemplateChild<EntryRow>,
#[template_child]
pub resetIP4Gateway: TemplateChild<EntryRow>,
pub reset_ip4_gateway: TemplateChild<EntryRow>,
#[template_child]
pub resetIP4AddressGroup: TemplateChild<PreferencesGroup>,
pub reset_ip4_address_group: TemplateChild<PreferencesGroup>,
#[template_child]
pub resetIP4AddressAddButton: TemplateChild<Button>,
pub reset_ip4_address_add_button: TemplateChild<Button>,
#[template_child]
pub resetIP4RoutesGroup: TemplateChild<PreferencesGroup>,
pub reset_ip4_routes_group: TemplateChild<PreferencesGroup>,
#[template_child]
pub resetIP4RouteAddButton: TemplateChild<Button>,
pub reset_ip4_route_add_button: TemplateChild<Button>,
// IPv6
#[template_child]
pub resetIP6Method: TemplateChild<ComboRow>,
pub reset_ip6_method: TemplateChild<ComboRow>,
#[template_child]
pub resetIP6DNS: TemplateChild<EntryRow>,
pub reset_ip6_dns: TemplateChild<EntryRow>,
#[template_child]
pub resetIP6Gateway: TemplateChild<EntryRow>,
pub reset_ip6_gateway: TemplateChild<EntryRow>,
#[template_child]
pub resetIP6AddressGroup: TemplateChild<PreferencesGroup>,
pub reset_ip6_address_group: TemplateChild<PreferencesGroup>,
#[template_child]
pub resetIP6AddressAddButton: TemplateChild<Button>,
pub reset_ip6_address_add_button: TemplateChild<Button>,
#[template_child]
pub resetIP6RoutesGroup: TemplateChild<PreferencesGroup>,
pub reset_ip6_routes_group: TemplateChild<PreferencesGroup>,
#[template_child]
pub resetIP6RouteAddButton: TemplateChild<Button>,
pub reset_ip6_route_add_button: TemplateChild<Button>,
// Security
#[template_child]
pub resetWifiSecurityDropdown: TemplateChild<ComboRow>,
pub reset_wifi_security_dropdown: TemplateChild<ComboRow>,
#[template_child]
pub resetWifiPassword: TemplateChild<PasswordEntryRow>,
pub reset_wifi_password: TemplateChild<PasswordEntryRow>,
// Misc
#[template_child]
pub wifiOptionsApplyButton: TemplateChild<Button>,
pub wifi_options_apply_button: TemplateChild<Button>,
pub connection: Rc<RefCell<Connection>>,
}

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

@ -33,18 +33,18 @@ impl WifiRouteEntry {
let conn = conn.borrow();
let address = unsafe { conn.ipv4.route_data.get_unchecked(address) };
entry_imp.resetRouteAddress.set_text(&address.address);
entry_imp.reset_route_address.set_text(&address.address);
entry_imp
.resetRoutePrefix
.reset_route_prefix
.set_text(&address.prefix_length.to_string());
if let Some(gateway) = &address.gateway {
entry_imp.resetRouteGateway.set_text(gateway);
entry_imp.reset_route_gateway.set_text(gateway);
}
if let Some(metric) = address.metric {
entry_imp.resetRouteMetric.set_text(&metric.to_string());
entry_imp.reset_route_metric.set_text(&metric.to_string());
}
entry_imp
.resetRouteRow
.reset_route_row
.set_title(&format!("{}/{}", &*address.address, address.prefix_length));
}
entry_imp.protocol.set(protocol);
@ -56,13 +56,13 @@ impl WifiRouteEntry {
let self_imp = self.imp();
let conn = connection.clone();
self_imp.resetRouteAddress.connect_changed(clone!(@weak self_imp => move |entry| {
self_imp.reset_route_address.connect_changed(clone!(@weak self_imp => move |entry| {
let address_input = entry.text();
let mut conn = conn.borrow_mut();
if address_input.is_empty() {
self_imp.resetRouteAddress.remove_css_class("error");
self_imp.resetRouteRow.set_title("Add new address");
self_imp.reset_route_address.remove_css_class("error");
self_imp.reset_route_row.set_title("Add new address");
return;
}
let result = match self_imp.protocol.get() {
@ -71,7 +71,7 @@ impl WifiRouteEntry {
};
match result {
Ok(ip_addr) => {
self_imp.resetRouteAddress.remove_css_class("error");
self_imp.reset_route_address.remove_css_class("error");
let address_data = match self_imp.protocol.get() {
IpProtocol::IPv4 => &mut conn.ipv4.route_data,
IpProtocol::IPv6 => &mut conn.ipv6.route_data,
@ -80,7 +80,7 @@ impl WifiRouteEntry {
*self_imp.address.borrow_mut() = (true, ip_addr.to_string());
}
Err(_) => {
self_imp.resetRouteAddress.add_css_class("error");
self_imp.reset_route_address.add_css_class("error");
*self_imp.address.borrow_mut() = (false, String::default());
}
}
@ -88,16 +88,16 @@ impl WifiRouteEntry {
}));
let conn = connection.clone();
self_imp.resetRoutePrefix.connect_changed(clone!(@weak self_imp => move |entry| {
self_imp.reset_route_prefix.connect_changed(clone!(@weak self_imp => move |entry| {
let prefix_input = entry.text();
let prefix = prefix_input.parse::<u8>();
let mut conn = conn.borrow_mut();
let handle_error = || {
if self_imp.resetRoutePrefix.text().is_empty() {
self_imp.resetRoutePrefix.remove_css_class("error");
if self_imp.reset_route_prefix.text().is_empty() {
self_imp.reset_route_prefix.remove_css_class("error");
} else {
self_imp.resetRoutePrefix.add_css_class("error");
self_imp.reset_route_prefix.add_css_class("error");
}
self_imp.prefix.set((false, 0));
set_row_title(&self_imp);
@ -112,8 +112,8 @@ impl WifiRouteEntry {
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()) {
self_imp.reset_route_prefix.remove_css_class("error");
if let Ok(address2) = Ipv4Addr::from_str(self_imp.reset_route_address.text().as_str()) {
if let Some(addr) = conn.ipv4.route_data.iter_mut()
.find(|conn_addr| *conn_addr.address == address2.to_string()) {
addr.prefix_length = prefix as u32;
@ -122,8 +122,8 @@ impl WifiRouteEntry {
}
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()) {
self_imp.reset_route_prefix.remove_css_class("error");
if let Ok(address2) = Ipv6Addr::from_str(self_imp.reset_route_address.text().as_str()) {
if let Some(addr) = conn.ipv6.route_data.iter_mut()
.find(|conn_addr| *conn_addr.address == address2.to_string()) {
addr.prefix_length = prefix as u32;
@ -137,13 +137,13 @@ impl WifiRouteEntry {
let conn = connection.clone();
self_imp
.resetRouteGateway
.reset_route_gateway
.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.reset_route_gateway.remove_css_class("error");
*self_imp.gateway.borrow_mut() = None;
set_row_subtitle(&self_imp);
return;
@ -154,19 +154,19 @@ impl WifiRouteEntry {
};
match result {
Ok(ip_addr) => {
self_imp.resetRouteGateway.remove_css_class("error");
self_imp.reset_route_gateway.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()) {
.find(|conn_addr| *conn_addr.address == self_imp.reset_route_address.text()) {
address.gateway = Some(ip_addr.to_string());
}
*self_imp.gateway.borrow_mut() = Some(ip_addr.to_string());
}
Err(_) => {
self_imp.resetRouteGateway.add_css_class("error");
self_imp.reset_route_gateway.add_css_class("error");
*self_imp.gateway.borrow_mut() = None;
}
}
@ -175,13 +175,13 @@ impl WifiRouteEntry {
let conn = connection.clone();
self_imp
.resetRouteMetric
.reset_route_metric
.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.reset_route_metric.remove_css_class("error");
self_imp.metric.set(None);
set_row_subtitle(&self_imp);
return;
@ -189,19 +189,19 @@ impl WifiRouteEntry {
let result = metric_input.parse::<u32>();
match result {
Ok(metric) => {
self_imp.resetRouteMetric.remove_css_class("error");
self_imp.reset_route_metric.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()) {
.find(|conn_addr| *conn_addr.address == self_imp.reset_route_address.text()) {
address.metric = Some(metric);
}
self_imp.metric.set(Some(metric));
}
Err(_) => {
self_imp.resetRouteMetric.add_css_class("error");
self_imp.reset_route_metric.add_css_class("error");
self_imp.metric.set(None);
}
}
@ -211,7 +211,7 @@ impl WifiRouteEntry {
}
fn set_row_title(self_imp: &WifiRouteEntryImpl) {
if self_imp.resetRouteAddress.text().is_empty() {
if self_imp.reset_route_address.text().is_empty() {
return;
}
let address = self_imp.address.borrow();
@ -224,7 +224,7 @@ fn set_row_title(self_imp: &WifiRouteEntryImpl) {
(false, true) => "Address wrong".to_string(),
(false, false) => "Address and Prefix wrong".to_string(),
};
self_imp.resetRouteRow.set_title(&title);
self_imp.reset_route_row.set_title(&title);
}
fn set_row_subtitle(self_imp: &WifiRouteEntryImpl) {
@ -238,5 +238,5 @@ fn set_row_subtitle(self_imp: &WifiRouteEntryImpl) {
(None, Some(metric)) => metric.to_string(),
(None, None) => String::default(),
};
self_imp.resetRouteRow.set_subtitle(&title);
self_imp.reset_route_row.set_subtitle(&title);
}

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

@ -5,22 +5,21 @@ use gtk::subclass::prelude::*;
use gtk::{glib, Button, CompositeTemplate};
use std::cell::{Cell, RefCell};
#[allow(non_snake_case)]
#[derive(Default, CompositeTemplate)]
#[template(resource = "/org/Xetibo/ReSet/resetWifiRouteEntry.ui")]
pub struct WifiRouteEntryImpl {
#[template_child]
pub resetRouteRow: TemplateChild<ExpanderRow>,
pub reset_route_row: TemplateChild<ExpanderRow>,
#[template_child]
pub resetRouteAddress: TemplateChild<EntryRow>,
pub reset_route_address: TemplateChild<EntryRow>,
#[template_child]
pub resetRoutePrefix: TemplateChild<EntryRow>,
pub reset_route_prefix: TemplateChild<EntryRow>,
#[template_child]
pub resetRouteGateway: TemplateChild<EntryRow>,
pub reset_route_gateway: TemplateChild<EntryRow>,
#[template_child]
pub resetRouteMetric: TemplateChild<EntryRow>,
pub reset_route_metric: TemplateChild<EntryRow>,
#[template_child]
pub resetRouteRemove: TemplateChild<Button>,
pub reset_route_remove: TemplateChild<Button>,
pub address: RefCell<(bool, String)>,
pub prefix: Cell<(bool, u32)>,
pub gateway: RefCell<Option<String>>,

50
src/components/window/reset_window.rs
View file

@ -29,28 +29,28 @@ impl ReSetWindow {
pub fn setup_callback(&self) {
let self_imp = self.imp();
self_imp.resetSearchEntry.connect_search_changed(
self_imp.reset_search_entry.connect_search_changed(
clone!(@ weak self as window => move |_| {
window.filter_list();
}),
);
self_imp
.resetSideBarToggle
.reset_sidebar_toggle
.connect_clicked(clone!(@ weak self as window => move |_| {
window.toggle_sidebar();
}));
self_imp.resetSidebarList.connect_row_activated(
self_imp.reset_sidebar_list.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());
(click_event)(flowbox.listeners.clone(), flowbox.reset_main.get());
}),
);
self_imp
.resetClose
.reset_close
.connect_clicked(clone!(@ weak self as window => move |_| {
window.close();
}));
@ -64,22 +64,22 @@ impl ReSetWindow {
pub fn handle_dynamic_sidebar(&self) {
let self_imp = self.imp();
self_imp
.resetSidebarBreakpoint
.reset_sidebar_breakpoint
.set_condition(BreakpointCondition::parse("max-width: 700sp").as_ref().ok());
self_imp.resetSidebarBreakpoint.add_setter(
&Object::from(self_imp.resetOverlaySplitView.get()),
self_imp.reset_sidebar_breakpoint.add_setter(
&Object::from(self_imp.reset_overlay_split_view.get()),
"collapsed",
&true.to_value(),
);
self_imp.resetSidebarBreakpoint.add_setter(
&Object::from(self_imp.resetSideBarToggle.get()),
self_imp.reset_sidebar_breakpoint.add_setter(
&Object::from(self_imp.reset_sidebar_toggle.get()),
"visible",
&true.to_value(),
);
}
pub fn filter_list(&self) {
let text = self.imp().resetSearchEntry.text().to_string();
let text = self.imp().reset_search_entry.text().to_string();
for (main_entry, sub_entriess) in self.imp().sidebar_entries.borrow().iter() {
if text.is_empty() {
main_entry.set_visible(true);
@ -117,10 +117,10 @@ impl ReSetWindow {
}
pub fn toggle_sidebar(&self) {
if self.imp().resetOverlaySplitView.shows_sidebar() {
self.imp().resetOverlaySplitView.set_show_sidebar(false);
if self.imp().reset_overlay_split_view.shows_sidebar() {
self.imp().reset_overlay_split_view.set_show_sidebar(false);
} else {
self.imp().resetOverlaySplitView.set_show_sidebar(true);
self.imp().reset_overlay_split_view.set_show_sidebar(true);
}
}
@ -227,28 +227,28 @@ impl ReSetWindow {
// ));
self_imp
.resetSidebarList
.reset_sidebar_list
.connect_row_activated(clone!(@ weak self_imp => move |_, _| {
self_imp.resetSearchEntry.set_text("");
self_imp.reset_search_entry.set_text("");
}));
for (main_entry, sub_entries) in sidebar_entries.iter() {
self_imp.resetSidebarList.append(main_entry);
self_imp.reset_sidebar_list.append(main_entry);
for sub_entry in sub_entries {
self_imp.resetSidebarList.append(sub_entry);
self_imp.reset_sidebar_list.append(sub_entry);
}
let separator = ListBoxRow::new();
separator.set_child(Some(&gtk::Separator::new(Orientation::Horizontal)));
separator.set_selectable(false);
separator.set_activatable(false);
self_imp.resetSidebarList.append(&separator);
self_imp.reset_sidebar_list.append(&separator);
}
}
pub fn setup_popover_buttons(&self) {
let self_imp = self.imp();
self_imp
.resetAboutButton
.reset_about_button
.connect_clicked(clone!(@ weak self as window => move |_| {
let dialog = adw::AboutWindow::builder()
.application_name("ReSet")
@ -265,21 +265,21 @@ impl ReSetWindow {
.developers(vec!["DashieTM".to_string(), "Takotori".to_string()])
.designers(vec!["DashieTM".to_string(), "Takotori".to_string()])
.build();
window.imp().resetPopoverMenu.popdown();
window.imp().reset_popover_menu.popdown();
dialog.present();
}));
self_imp
.resetPreferenceButton
.reset_preference_button
.connect_clicked(clone!(@weak self as window => move |_| {
let preferences = adw::PreferencesWindow::builder().build();
window.imp().resetPopoverMenu.popdown();
window.imp().reset_popover_menu.popdown();
preferences.present();
}));
self_imp
.resetShortcutsButton
.reset_shortcuts_button
.connect_clicked(clone!(@weak self as window => move |_| {
let shortcuts = gtk::ShortcutsWindow::builder().build();
window.imp().resetPopoverMenu.popdown();
window.imp().reset_popover_menu.popdown();
shortcuts.present();
}));
}

23
src/components/window/reset_window_impl.rs
View file

@ -13,32 +13,31 @@ 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)]
#[template(resource = "/org/Xetibo/ReSet/resetMainWindow.ui")]
pub struct ReSetWindow {
#[template_child]
pub resetMain: TemplateChild<FlowBox>,
pub reset_main: TemplateChild<FlowBox>,
#[template_child]
pub resetSidebarBreakpoint: TemplateChild<Breakpoint>,
pub reset_sidebar_breakpoint: TemplateChild<Breakpoint>,
#[template_child]
pub resetOverlaySplitView: TemplateChild<OverlaySplitView>,
pub reset_overlay_split_view: TemplateChild<OverlaySplitView>,
#[template_child]
pub resetSearchEntry: TemplateChild<SearchEntry>,
pub reset_search_entry: TemplateChild<SearchEntry>,
#[template_child]
pub resetSidebarList: TemplateChild<ListBox>,
pub reset_sidebar_list: TemplateChild<ListBox>,
#[template_child]
pub resetSideBarToggle: TemplateChild<Button>,
pub reset_sidebar_toggle: TemplateChild<Button>,
#[template_child]
pub resetPopoverMenu: TemplateChild<PopoverMenu>,
pub reset_popover_menu: TemplateChild<PopoverMenu>,
#[template_child]
pub resetClose: TemplateChild<Button>,
pub reset_close: TemplateChild<Button>,
#[template_child]
pub resetAboutButton: TemplateChild<Button>,
pub reset_about_button: TemplateChild<Button>,
#[template_child]
pub resetPreferenceButton: TemplateChild<Button>,
pub reset_preference_button: TemplateChild<Button>,
#[template_child]
pub resetShortcutsButton: TemplateChild<Button>,
pub reset_shortcuts_button: TemplateChild<Button>,
pub sidebar_entries: RefCell<Vec<(SidebarEntry, Vec<SidebarEntry>)>>,
pub listeners: Arc<Listeners>,
}

4
src/components/window/sidebar_entry.rs
View file

@ -24,9 +24,9 @@ impl SidebarEntry {
) -> Self {
let entry: SidebarEntry = Object::builder().build();
let entry_imp = entry.imp();
entry_imp.resetSidebarLabel.get().set_text(entry_name);
entry_imp.reset_sidebar_label.get().set_text(entry_name);
entry_imp
.resetSidebarImage
.reset_sidebar_image
.set_from_icon_name(Some(icon_name));
entry_imp.category.set(category);
entry_imp.is_subcategory.set(is_subcategory);

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

@ -18,14 +18,13 @@ pub enum Categories {
Misc,
}
#[allow(non_snake_case)]
#[derive(CompositeTemplate, Default)]
#[template(resource = "/org/Xetibo/ReSet/resetSidebarEntry.ui")]
pub struct SidebarEntry {
#[template_child]
pub resetSidebarLabel: TemplateChild<Label>,
pub reset_sidebar_label: TemplateChild<Label>,
#[template_child]
pub resetSidebarImage: TemplateChild<Image>,
pub reset_sidebar_image: TemplateChild<Image>,
pub category: Cell<Categories>,
pub is_subcategory: Cell<bool>,
pub on_click_event: RefCell<SidebarAction>,