From eccd5c60938757716ac0093801b6330d0829d275 Mon Sep 17 00:00:00 2001 From: Fabio Lenherr / DashieTM Date: Tue, 12 Mar 2024 11:14:49 +0100 Subject: [PATCH] chore: Use uniform naming for audio boxes --- src/components/input/source_box.rs | 24 ++--- src/components/input/source_box_handlers.rs | 106 +++++++++--------- src/components/input/source_box_utils.rs | 100 ++++++++--------- src/components/output/sink_box.rs | 24 ++--- src/components/output/sink_box_handlers.rs | 114 ++++++++++---------- src/components/output/sink_box_utils.rs | 102 +++++++++--------- 6 files changed, 234 insertions(+), 236 deletions(-) diff --git a/src/components/input/source_box.rs b/src/components/input/source_box.rs index b055e83..b39df38 100644 --- a/src/components/input/source_box.rs +++ b/src/components/input/source_box.rs @@ -96,17 +96,17 @@ impl Default for SourceBox { } } -pub fn populate_sources(input_box: Arc) { +pub fn populate_sources(source_box: Arc) { gio::spawn_blocking(move || { - let sources = get_sources(input_box.clone()); + let sources = get_sources(source_box.clone()); { - let input_box_imp = input_box.imp(); - let list = input_box_imp.reset_model_list.write().unwrap(); - let mut map = input_box_imp.reset_source_map.write().unwrap(); - let mut model_index = input_box_imp.reset_model_index.write().unwrap(); - input_box_imp + let source_box_imp = source_box.imp(); + let list = source_box_imp.reset_model_list.write().unwrap(); + let mut map = source_box_imp.reset_source_map.write().unwrap(); + let mut model_index = source_box_imp.reset_model_index.write().unwrap(); + source_box_imp .reset_default_source - .replace(get_default_source(input_box.clone())); + .replace(get_default_source(source_box.clone())); for source in sources.iter() { list.append(&source.alias); map.insert(source.alias.clone(), (source.index, source.name.clone())); @@ -114,13 +114,13 @@ pub fn populate_sources(input_box: Arc) { } } - populate_outputstreams(input_box.clone()); - populate_cards(input_box.clone()); - populate_source_information(input_box, sources); + populate_outputstreams(source_box.clone()); + populate_cards(source_box.clone()); + populate_source_information(source_box, sources); }); } -pub fn start_input_box_listener(conn: Connection, source_box: Arc) -> Connection { +pub fn start_source_box_listener(conn: Connection, source_box: Arc) -> Connection { let source_added = SourceAdded::match_rule(Some(&BASE.into()), Some(&Path::from(DBUS_PATH))).static_clone(); let source_removed = diff --git a/src/components/input/source_box_handlers.rs b/src/components/input/source_box_handlers.rs index f4878b1..939385f 100644 --- a/src/components/input/source_box_handlers.rs +++ b/src/components/input/source_box_handlers.rs @@ -27,40 +27,40 @@ use super::{ pub fn source_added_handler(source_box: Arc, ir: SourceAdded) -> bool { glib::spawn_future(async move { glib::idle_add_once(move || { - let input_box = source_box.clone(); - let input_box_imp = input_box.imp(); + let source_box = source_box.clone(); + let source_box_imp = source_box.imp(); let source_index = ir.source.index; let alias = ir.source.alias.clone(); let name = ir.source.name.clone(); let mut is_default = false; - if input_box_imp.reset_default_source.borrow().name == ir.source.name { + if source_box_imp.reset_default_source.borrow().name == ir.source.name { is_default = true; } let source_entry = Arc::new(SourceEntry::new( is_default, - input_box_imp.reset_default_check_button.clone(), + source_box_imp.reset_default_check_button.clone(), ir.source, - input_box.clone(), + source_box.clone(), )); let source_clone = source_entry.clone(); let entry = Arc::new(ListEntry::new(&*source_entry)); entry.set_activatable(false); - let mut list = input_box_imp.reset_source_list.write().unwrap(); + let mut list = source_box_imp.reset_source_list.write().unwrap(); list.insert(source_index, (entry.clone(), source_clone, alias.clone())); - input_box_imp.reset_sources.append(&*entry); - let mut map = input_box_imp.reset_source_map.write().unwrap(); - let mut index = input_box_imp.reset_model_index.write().unwrap(); - let model_list = input_box_imp.reset_model_list.write().unwrap(); + source_box_imp.reset_sources.append(&*entry); + let mut map = source_box_imp.reset_source_map.write().unwrap(); + let mut index = source_box_imp.reset_model_index.write().unwrap(); + let model_list = source_box_imp.reset_model_list.write().unwrap(); if model_list.string(*index - 1) == Some("Monitor of Dummy Output".into()) { model_list.append(&alias); model_list.remove(*index - 1); map.insert(alias, (source_index, name)); - input_box_imp.reset_source_dropdown.set_selected(0); + source_box_imp.reset_source_dropdown.set_selected(0); } else { model_list.append(&alias); map.insert(alias.clone(), (source_index, name)); if alias == "Monitor of Dummy Output" { - input_box_imp.reset_source_dropdown.set_selected(0); + source_box_imp.reset_source_dropdown.set_selected(0); } *index += 1; } @@ -72,24 +72,24 @@ pub fn source_added_handler(source_box: Arc, ir: SourceAdded) -> bool pub fn source_removed_handler(source_box: Arc, ir: SourceRemoved) -> bool { glib::spawn_future(async move { glib::idle_add_once(move || { - let input_box = source_box.clone(); - let input_box_imp = input_box.imp(); + let source_box = source_box.clone(); + let source_box_imp = source_box.imp(); let entry: Option<(Arc, Arc, String)>; { - let mut list = input_box_imp.reset_source_list.write().unwrap(); + let mut list = source_box_imp.reset_source_list.write().unwrap(); entry = list.remove(&ir.index); if entry.is_none() { return; } } - input_box_imp + source_box_imp .reset_sources .remove(&*entry.clone().unwrap().0); - let mut map = input_box_imp.reset_source_map.write().unwrap(); + let mut map = source_box_imp.reset_source_map.write().unwrap(); let alias = entry.unwrap().2; map.remove(&alias); - let mut index = input_box_imp.reset_model_index.write().unwrap(); - let model_list = input_box_imp.reset_model_list.write().unwrap(); + let mut index = source_box_imp.reset_model_index.write().unwrap(); + let model_list = source_box_imp.reset_model_list.write().unwrap(); if *index == 1 { model_list.append("Monitor of Dummy Output"); @@ -112,31 +112,31 @@ pub fn source_changed_handler(source_box: Arc, ir: SourceChanged) -> let default_source = get_default_source_name(source_box.clone()); glib::spawn_future(async move { glib::idle_add_once(move || { - let input_box = source_box.clone(); - let input_box_imp = input_box.imp(); + let source_box = source_box.clone(); + let source_box_imp = source_box.imp(); let is_default = ir.source.name == default_source; let volume = ir.source.volume.first().unwrap_or(&0_u32); let fraction = (*volume as f64 / 655.36).round(); let percentage = (fraction).to_string() + "%"; - let list = input_box_imp.reset_source_list.read().unwrap(); + let list = source_box_imp.reset_source_list.read().unwrap(); let entry = list.get(&ir.source.index); if entry.is_none() { return; } let imp = entry.unwrap().1.imp(); if is_default { - input_box_imp.reset_volume_percentage.set_text(&percentage); - input_box_imp.reset_volume_slider.set_value(*volume as f64); - input_box_imp + source_box_imp.reset_volume_percentage.set_text(&percentage); + source_box_imp.reset_volume_slider.set_value(*volume as f64); + source_box_imp .reset_default_source .replace(ir.source.clone()); if ir.source.muted { - input_box_imp + source_box_imp .reset_source_mute .set_icon_name("microphone-disabled-symbolic"); } else { - input_box_imp + source_box_imp .reset_source_mute .set_icon_name("audio-input-microphone-symbolic"); } @@ -163,15 +163,15 @@ pub fn source_changed_handler(source_box: Arc, ir: SourceChanged) -> pub fn output_stream_added_handler(source_box: Arc, ir: OutputStreamAdded) -> bool { glib::spawn_future(async move { glib::idle_add_once(move || { - let input_box = source_box.clone(); - let input_box_imp = input_box.imp(); - let mut list = input_box_imp.reset_output_stream_list.write().unwrap(); + let source_box = source_box.clone(); + let source_box_imp = source_box.imp(); + let mut list = source_box_imp.reset_output_stream_list.write().unwrap(); let index = ir.stream.index; - let output_stream = Arc::new(OutputStreamEntry::new(input_box.clone(), ir.stream)); + let output_stream = Arc::new(OutputStreamEntry::new(source_box.clone(), ir.stream)); let entry = Arc::new(ListEntry::new(&*output_stream)); entry.set_activatable(false); list.insert(index, (entry.clone(), output_stream.clone())); - input_box_imp.reset_output_streams.append(&*entry); + source_box_imp.reset_output_streams.append(&*entry); }); }); true @@ -190,11 +190,11 @@ pub fn output_stream_changed_handler(source_box: Arc, ir: OutputStrea } glib::spawn_future(async move { glib::idle_add_once(move || { - let input_box = source_box.clone(); - let input_box_imp = input_box.imp(); + let source_box = source_box.clone(); + let source_box_imp = source_box.imp(); let entry: Arc; { - let list = input_box_imp.reset_output_stream_list.read().unwrap(); + let list = source_box_imp.reset_output_stream_list.read().unwrap(); let entry_opt = list.get(&ir.stream.index); if entry_opt.is_none() { return; @@ -216,8 +216,8 @@ pub fn output_stream_changed_handler(source_box: Arc, ir: OutputStrea let percentage = (fraction).to_string() + "%"; imp.reset_volume_percentage.set_text(&percentage); imp.reset_volume_slider.set_value(*volume as f64); - let index = input_box_imp.reset_model_index.read().unwrap(); - let model_list = input_box_imp.reset_model_list.read().unwrap(); + let index = source_box_imp.reset_model_index.read().unwrap(); + let model_list = source_box_imp.reset_model_list.read().unwrap(); for entry in 0..*index { if model_list.string(entry) == Some(alias.clone().into()) { imp.reset_source_selection.set_selected(entry); @@ -232,14 +232,14 @@ pub fn output_stream_changed_handler(source_box: Arc, ir: OutputStrea pub fn output_stream_removed_handler(source_box: Arc, ir: OutputStreamRemoved) -> bool { glib::spawn_future(async move { glib::idle_add_once(move || { - let input_box = source_box.clone(); - let input_box_imp = input_box.imp(); - let mut list = input_box_imp.reset_output_stream_list.write().unwrap(); + let source_box = source_box.clone(); + let source_box_imp = source_box.imp(); + let mut list = source_box_imp.reset_output_stream_list.write().unwrap(); let entry = list.remove(&ir.index); if entry.is_none() { return; } - input_box_imp + source_box_imp .reset_output_streams .remove(&*entry.unwrap().0); }); @@ -247,9 +247,9 @@ pub fn output_stream_removed_handler(source_box: Arc, ir: OutputStrea true } -pub fn dropdown_handler(input_box: Arc, dropdown: &adw::ComboRow) -> ControlFlow { - let input_box_imp = input_box.imp(); - let input_box_ref = input_box.clone(); +pub fn dropdown_handler(source_box: Arc, dropdown: &adw::ComboRow) -> ControlFlow { + let source_box_imp = source_box.imp(); + let source_box_ref = source_box.clone(); let selected = dropdown.selected_item(); if selected.is_none() { return ControlFlow::Break; @@ -257,25 +257,25 @@ pub fn dropdown_handler(input_box: Arc, dropdown: &adw::ComboRow) -> let selected = selected.unwrap(); let selected = selected.downcast_ref::().unwrap(); let selected = selected.string().to_string(); - let source = input_box_imp.reset_source_map.read().unwrap(); + let source = source_box_imp.reset_source_map.read().unwrap(); let source = source.get(&selected); if source.is_none() { return ControlFlow::Break; } let source = Arc::new(source.unwrap().1.clone()); gio::spawn_blocking(move || { - let result = set_default_source(source, input_box_ref.clone()); + let result = set_default_source(source, source_box_ref.clone()); if result.is_none() { return ControlFlow::Break; } - refresh_default_source(result.unwrap(), input_box_ref.clone(), false); + refresh_default_source(result.unwrap(), source_box_ref.clone(), false); ControlFlow::Continue }); ControlFlow::Continue } -pub fn volume_slider_handler(input_box: Arc, value: f64) -> Propagation { - let imp = input_box.imp(); +pub fn volume_slider_handler(source_box: Arc, value: f64) -> Propagation { + let imp = source_box.imp(); let fraction = (value / 655.36).round(); let percentage = (fraction).to_string() + "%"; imp.reset_volume_percentage.set_text(&percentage); @@ -289,12 +289,12 @@ pub fn volume_slider_handler(input_box: Arc, value: f64) -> Propagati } *time = Some(SystemTime::now()); } - set_source_volume(value, index, channels, input_box.clone()); + set_source_volume(value, index, channels, source_box.clone()); Propagation::Proceed } -pub fn mute_clicked_handler(input_box_ref_mute: Arc) { - let imp = input_box_ref_mute.imp(); +pub fn mute_clicked_handler(source_box_ref_mute: Arc) { + let imp = source_box_ref_mute.imp(); let mut source = imp.reset_default_source.borrow_mut(); source.muted = !source.muted; if source.muted { @@ -304,5 +304,5 @@ pub fn mute_clicked_handler(input_box_ref_mute: Arc) { imp.reset_source_mute .set_icon_name("audio-input-microphone-symbolic"); } - toggle_source_mute(source.index, source.muted, input_box_ref_mute.clone()); + toggle_source_mute(source.index, source.muted, source_box_ref_mute.clone()); } diff --git a/src/components/input/source_box_utils.rs b/src/components/input/source_box_utils.rs index 8e37d90..2669229 100644 --- a/src/components/input/source_box_utils.rs +++ b/src/components/input/source_box_utils.rs @@ -21,22 +21,22 @@ use super::{ source_entry::SourceEntry, }; -pub fn populate_source_information(input_box: Arc, sources: Vec) { +pub fn populate_source_information(source_box: Arc, sources: Vec) { glib::spawn_future(async move { glib::idle_add_once(move || { - let input_box_ref_slider = input_box.clone(); - let input_box_ref_toggle = input_box.clone(); - let input_box_ref_mute = input_box.clone(); - let input_box_imp = input_box.imp(); - let default_sink = input_box_imp.reset_default_source.clone(); + let source_box_ref_slider = source_box.clone(); + let source_box_ref_toggle = source_box.clone(); + let source_box_ref_mute = source_box.clone(); + let source_box_imp = source_box.imp(); + let default_sink = source_box_imp.reset_default_source.clone(); let source = default_sink.borrow(); if source.muted { - input_box_imp + source_box_imp .reset_source_mute .set_icon_name("microphone-disabled-symbolic"); } else { - input_box_imp + source_box_imp .reset_source_mute .set_icon_name("audio-input-microphone-symbolic"); } @@ -44,65 +44,65 @@ pub fn populate_source_information(input_box: Arc, sources: Vec, entry: bool) { +pub fn refresh_default_source(new_source: Source, source_box: Arc, entry: bool) { let volume = *new_source.volume.first().unwrap_or(&0_u32); let fraction = (volume as f64 / 655.36).round(); let percentage = (fraction).to_string() + "%"; glib::spawn_future(async move { glib::idle_add_once(move || { - let imp = input_box.imp(); + let imp = source_box.imp(); if !entry { let list = imp.reset_source_list.read().unwrap(); let entry = list.get(&new_source.index); @@ -134,36 +134,36 @@ pub fn refresh_default_source(new_source: Source, input_box: Arc, ent }); } -pub fn populate_outputstreams(input_box: Arc) { - let input_box_ref = input_box.clone(); +pub fn populate_outputstreams(source_box: Arc) { + let source_box_ref = source_box.clone(); gio::spawn_blocking(move || { - let streams = get_output_streams(input_box.clone()); + let streams = get_output_streams(source_box.clone()); glib::spawn_future(async move { glib::idle_add_once(move || { - let input_box_imp = input_box_ref.imp(); - let mut list = input_box_imp.reset_output_stream_list.write().unwrap(); + let source_box_imp = source_box_ref.imp(); + let mut list = source_box_imp.reset_output_stream_list.write().unwrap(); for stream in streams { let index = stream.index; - let input_stream = Arc::new(OutputStreamEntry::new(input_box.clone(), stream)); + let input_stream = Arc::new(OutputStreamEntry::new(source_box.clone(), stream)); let input_stream_clone = input_stream.clone(); let entry = Arc::new(ListEntry::new(&*input_stream)); entry.set_activatable(false); list.insert(index, (entry.clone(), input_stream_clone)); - input_box_imp.reset_output_streams.append(&*entry); + source_box_imp.reset_output_streams.append(&*entry); } }); }); }); } -pub fn populate_cards(input_box: Arc) { +pub fn populate_cards(source_box: Arc) { gio::spawn_blocking(move || { - let input_box_ref = input_box.clone(); - let cards = get_cards(input_box.clone()); + let source_box_ref = source_box.clone(); + let cards = get_cards(source_box.clone()); glib::spawn_future(async move { glib::idle_add_once(move || { - let imp = input_box_ref.imp(); + let imp = source_box_ref.imp(); for card in cards { imp.reset_cards.add(&CardEntry::new(card)); } @@ -172,57 +172,57 @@ pub fn populate_cards(input_box: Arc) { }); } -pub fn get_output_streams(input_box: Arc) -> Vec { +pub fn get_output_streams(source_box: Arc) -> Vec { let conn = Connection::new_session().unwrap(); let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000)); let res: Result<(Vec,), Error> = proxy.method_call(AUDIO, "ListOutputStreams", ()); if res.is_err() { - show_error::(input_box.clone(), "Failed to get output streams"); + show_error::(source_box.clone(), "Failed to get output streams"); return Vec::new(); } res.unwrap().0 } -pub fn get_sources(input_box: Arc) -> Vec { +pub fn get_sources(source_box: Arc) -> Vec { let conn = Connection::new_session().unwrap(); let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000)); let res: Result<(Vec,), Error> = proxy.method_call(AUDIO, "ListSources", ()); if res.is_err() { - show_error::(input_box.clone(), "Failed to get sources"); + show_error::(source_box.clone(), "Failed to get sources"); return Vec::new(); } res.unwrap().0 } -pub fn get_cards(input_box: Arc) -> Vec { +pub fn get_cards(source_box: Arc) -> Vec { let conn = Connection::new_session().unwrap(); let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000)); let res: Result<(Vec,), Error> = proxy.method_call(AUDIO, "ListCards", ()); if res.is_err() { - show_error::(input_box.clone(), "Failed to get profiles"); + show_error::(source_box.clone(), "Failed to get profiles"); return Vec::new(); } res.unwrap().0 } -pub fn get_default_source_name(input_box: Arc) -> String { +pub fn get_default_source_name(source_box: Arc) -> String { let conn = Connection::new_session().unwrap(); let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000)); let res: Result<(String,), Error> = proxy.method_call(AUDIO, "GetDefaultSourceName", ()); if res.is_err() { - show_error::(input_box.clone(), "Failed to get default source name"); + show_error::(source_box.clone(), "Failed to get default source name"); return String::from(""); } res.unwrap().0 } -pub fn get_default_source(input_box: Arc) -> Source { +pub fn get_default_source(source_box: Arc) -> Source { let conn = Connection::new_session().unwrap(); let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000)); let res: Result<(Source,), Error> = proxy.method_call(AUDIO, "GetDefaultSource", ()); if res.is_err() { - show_error::(input_box.clone(), "Failed to get default source"); + show_error::(source_box.clone(), "Failed to get default source"); return Source::default(); } res.unwrap().0 diff --git a/src/components/output/sink_box.rs b/src/components/output/sink_box.rs index 810e0e3..c5ca269 100644 --- a/src/components/output/sink_box.rs +++ b/src/components/output/sink_box.rs @@ -103,30 +103,30 @@ impl Default for SinkBox { } } -pub fn populate_sinks(output_box: Arc) { +pub fn populate_sinks(sink_box: Arc) { gio::spawn_blocking(move || { - let sinks = get_sinks(output_box.clone()); + let sinks = get_sinks(sink_box.clone()); { - let output_box_imp = output_box.imp(); - let list = output_box_imp.reset_model_list.write().unwrap(); - let mut map = output_box_imp.reset_sink_map.write().unwrap(); - let mut model_index = output_box_imp.reset_model_index.write().unwrap(); - output_box_imp + let sink_box_imp = sink_box.imp(); + let list = sink_box_imp.reset_model_list.write().unwrap(); + let mut map = sink_box_imp.reset_sink_map.write().unwrap(); + let mut model_index = sink_box_imp.reset_model_index.write().unwrap(); + sink_box_imp .reset_default_sink - .replace(get_default_sink(output_box.clone())); + .replace(get_default_sink(sink_box.clone())); for sink in sinks.iter() { list.append(&sink.alias); map.insert(sink.alias.clone(), (sink.index, sink.name.clone())); *model_index += 1; } } - populate_inputstreams(output_box.clone()); - populate_cards(output_box.clone()); - populate_sink_information(output_box, sinks); + populate_inputstreams(sink_box.clone()); + populate_cards(sink_box.clone()); + populate_sink_information(sink_box, sinks); }); } -pub fn start_output_box_listener(conn: Connection, sink_box: Arc) -> Connection { +pub fn start_sink_box_listener(conn: Connection, sink_box: Arc) -> Connection { let sink_added = SinkAdded::match_rule(Some(&BASE.into()), Some(&Path::from(DBUS_PATH))).static_clone(); let sink_removed = diff --git a/src/components/output/sink_box_handlers.rs b/src/components/output/sink_box_handlers.rs index 42c41ad..1352bd9 100644 --- a/src/components/output/sink_box_handlers.rs +++ b/src/components/output/sink_box_handlers.rs @@ -26,9 +26,9 @@ use super::{ sink_entry::{set_default_sink, set_sink_volume, toggle_sink_mute, SinkEntry}, }; -pub fn drop_down_handler(output_box: Arc, dropdown: &ComboRow) { - let output_box_ref = output_box.clone(); - let output_box_imp = output_box.imp(); +pub fn drop_down_handler(sink_box: Arc, dropdown: &ComboRow) { + let sink_box_ref = sink_box.clone(); + let sink_box_imp = sink_box.imp(); let selected = dropdown.selected_item(); if selected.is_none() { return; @@ -37,24 +37,24 @@ pub fn drop_down_handler(output_box: Arc, dropdown: &ComboRow) { let selected = selected.downcast_ref::().unwrap(); let selected = selected.string().to_string(); - let sink = output_box_imp.reset_sink_map.read().unwrap(); + let sink = sink_box_imp.reset_sink_map.read().unwrap(); let sink = sink.get(&selected); if sink.is_none() { return; } let new_sink_name = Arc::new(sink.unwrap().1.clone()); gio::spawn_blocking(move || { - let result = set_default_sink(new_sink_name, output_box_ref.clone()); + let result = set_default_sink(new_sink_name, sink_box_ref.clone()); if result.is_none() { return; } let new_sink = result.unwrap(); - refresh_default_sink(new_sink, output_box_ref, false); + refresh_default_sink(new_sink, sink_box_ref, false); }); } -pub fn volume_slider_handler(output_box: Arc, value: f64) -> glib::Propagation { - let imp = output_box.imp(); +pub fn volume_slider_handler(sink_box: Arc, value: f64) -> glib::Propagation { + let imp = sink_box.imp(); let fraction = (value / 655.36).round(); let percentage = (fraction).to_string() + "%"; imp.reset_volume_percentage.set_text(&percentage); @@ -68,12 +68,12 @@ pub fn volume_slider_handler(output_box: Arc, value: f64) -> glib::Prop } *time = Some(SystemTime::now()); } - set_sink_volume(value, index, channels, output_box.clone()); + set_sink_volume(value, index, channels, sink_box.clone()); Propagation::Proceed } -pub fn mute_handler(output_box: Arc) { - let imp = output_box.imp(); +pub fn mute_handler(sink_box: Arc) { + let imp = sink_box.imp(); let mut stream = imp.reset_default_sink.borrow_mut(); stream.muted = !stream.muted; if stream.muted { @@ -83,46 +83,46 @@ pub fn mute_handler(output_box: Arc) { imp.reset_sink_mute .set_icon_name("audio-volume-high-symbolic"); } - toggle_sink_mute(stream.index, stream.muted, output_box.clone()); + toggle_sink_mute(stream.index, stream.muted, sink_box.clone()); } -pub fn sink_added_handler(output_box: Arc, ir: SinkAdded) -> bool { +pub fn sink_added_handler(sink_box: Arc, ir: SinkAdded) -> bool { glib::spawn_future(async move { glib::idle_add_once(move || { - let output_box_imp = output_box.imp(); + let sink_box_imp = sink_box.imp(); let sink_index = ir.sink.index; let alias = ir.sink.alias.clone(); let name = ir.sink.name.clone(); let mut is_default = false; - if output_box_imp.reset_default_sink.borrow().name == ir.sink.name { + if sink_box_imp.reset_default_sink.borrow().name == ir.sink.name { is_default = true; } let sink_entry = Arc::new(SinkEntry::new( is_default, - output_box_imp.reset_default_check_button.clone(), + sink_box_imp.reset_default_check_button.clone(), ir.sink, - output_box.clone(), + sink_box.clone(), )); let sink_clone = sink_entry.clone(); let entry = Arc::new(ListEntry::new(&*sink_entry)); entry.set_activatable(false); - let mut list = output_box_imp.reset_sink_list.write().unwrap(); + let mut list = sink_box_imp.reset_sink_list.write().unwrap(); list.insert(sink_index, (entry.clone(), sink_clone, alias.clone())); - 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(); - let model_list = output_box_imp.reset_model_list.write().unwrap(); + sink_box_imp.reset_sinks.append(&*entry); + let mut map = sink_box_imp.reset_sink_map.write().unwrap(); + let mut index = sink_box_imp.reset_model_index.write().unwrap(); + let model_list = sink_box_imp.reset_model_list.write().unwrap(); if model_list.string(*index - 1) == Some("Dummy Output".into()) { model_list.append(&alias); model_list.remove(*index - 1); map.insert(alias, (sink_index, name)); - output_box_imp.reset_sink_dropdown.set_selected(0); + sink_box_imp.reset_sink_dropdown.set_selected(0); } else { model_list.append(&alias); map.insert(alias.clone(), (sink_index, name)); if alias == "Dummy Output" { - output_box_imp.reset_sink_dropdown.set_selected(0); + sink_box_imp.reset_sink_dropdown.set_selected(0); } *index += 1; } @@ -131,32 +131,32 @@ pub fn sink_added_handler(output_box: Arc, ir: SinkAdded) -> bool { true } -pub fn sink_removed_handler(output_box: Arc, ir: SinkRemoved) -> bool { +pub fn sink_removed_handler(sink_box: Arc, ir: SinkRemoved) -> bool { glib::spawn_future(async move { glib::idle_add_once(move || { - let output_box_imp = output_box.imp(); + let sink_box_imp = sink_box.imp(); let entry: Option<(Arc, Arc, String)>; { - let mut list = output_box_imp.reset_sink_list.write().unwrap(); + let mut list = sink_box_imp.reset_sink_list.write().unwrap(); entry = list.remove(&ir.index); if entry.is_none() { return; } } - output_box_imp + sink_box_imp .reset_sinks .remove(&*entry.clone().unwrap().0); let alias = entry.unwrap().2; - let mut index = output_box_imp.reset_model_index.write().unwrap(); - let model_list = output_box_imp.reset_model_list.write().unwrap(); + let mut index = sink_box_imp.reset_model_index.write().unwrap(); + let model_list = sink_box_imp.reset_model_list.write().unwrap(); // add dummy entry when no other devices are available if *index == 1 { model_list.append("Dummy Output"); } - let mut map = output_box_imp.reset_sink_map.write().unwrap(); + let mut map = sink_box_imp.reset_sink_map.write().unwrap(); map.remove(&alias); for entry in 0..*index { @@ -175,32 +175,32 @@ pub fn sink_removed_handler(output_box: Arc, ir: SinkRemoved) -> bool { true } -pub fn sink_changed_handler(output_box: Arc, ir: SinkChanged) -> bool { +pub fn sink_changed_handler(sink_box: Arc, ir: SinkChanged) -> bool { glib::spawn_future(async move { glib::idle_add_once(move || { - let default_sink = get_default_sink_name(output_box.clone()); - let output_box_imp = output_box.imp(); + let default_sink = get_default_sink_name(sink_box.clone()); + let sink_box_imp = sink_box.imp(); let is_default = ir.sink.name == default_sink; let volume = ir.sink.volume.first().unwrap_or(&0_u32); let fraction = (*volume as f64 / 655.36).round(); let percentage = (fraction).to_string() + "%"; - let list = output_box_imp.reset_sink_list.read().unwrap(); + let list = sink_box_imp.reset_sink_list.read().unwrap(); let entry = list.get(&ir.sink.index); if entry.is_none() { return; } let imp = entry.unwrap().1.imp(); if is_default { - output_box_imp.reset_volume_percentage.set_text(&percentage); - output_box_imp.reset_volume_slider.set_value(*volume as f64); - output_box_imp.reset_default_sink.replace(ir.sink.clone()); + sink_box_imp.reset_volume_percentage.set_text(&percentage); + sink_box_imp.reset_volume_slider.set_value(*volume as f64); + sink_box_imp.reset_default_sink.replace(ir.sink.clone()); if ir.sink.muted { - output_box_imp + sink_box_imp .reset_sink_mute .set_icon_name("audio-volume-muted-symbolic"); } else { - output_box_imp + sink_box_imp .reset_sink_mute .set_icon_name("audio-volume-high-symbolic"); } @@ -224,32 +224,32 @@ pub fn sink_changed_handler(output_box: Arc, ir: SinkChanged) -> bool { true } -pub fn input_stream_added_handler(output_box: Arc, ir: InputStreamAdded) -> bool { +pub fn input_stream_added_handler(sink_box: Arc, ir: InputStreamAdded) -> bool { glib::spawn_future(async move { glib::idle_add_once(move || { - let output_box_imp = output_box.imp(); - let mut list = output_box_imp.reset_input_stream_list.write().unwrap(); + let sink_box_imp = sink_box.imp(); + let mut list = sink_box_imp.reset_input_stream_list.write().unwrap(); let index = ir.stream.index; - let input_stream = Arc::new(InputStreamEntry::new(output_box.clone(), ir.stream)); + let input_stream = Arc::new(InputStreamEntry::new(sink_box.clone(), ir.stream)); let entry = Arc::new(ListEntry::new(&*input_stream)); entry.set_activatable(false); list.insert(index, (entry.clone(), input_stream.clone())); - output_box_imp.reset_input_streams.append(&*entry); + sink_box_imp.reset_input_streams.append(&*entry); }); }); true } -pub fn input_stream_removed_handler(output_box: Arc, ir: InputStreamRemoved) -> bool { +pub fn input_stream_removed_handler(sink_box: Arc, ir: InputStreamRemoved) -> bool { glib::spawn_future(async move { glib::idle_add_once(move || { - let output_box_imp = output_box.imp(); - let mut list = output_box_imp.reset_input_stream_list.write().unwrap(); + let sink_box_imp = sink_box.imp(); + let mut list = sink_box_imp.reset_input_stream_list.write().unwrap(); let entry = list.remove(&ir.index); if entry.is_none() { return; } - output_box_imp + sink_box_imp .reset_input_streams .remove(&*entry.unwrap().0); }); @@ -257,8 +257,8 @@ pub fn input_stream_removed_handler(output_box: Arc, ir: InputStreamRem true } -pub fn input_stream_changed_handler(output_box: Arc, ir: InputStreamChanged) -> bool { - let imp = output_box.imp(); +pub fn input_stream_changed_handler(sink_box: Arc, ir: InputStreamChanged) -> bool { + let imp = sink_box.imp(); let alias: String; { let sink_list = imp.reset_sink_list.read().unwrap(); @@ -268,14 +268,14 @@ pub fn input_stream_changed_handler(output_box: Arc, ir: InputStreamCha alias = String::from(""); } } - let sink_box = output_box.clone(); + let sink_box = sink_box.clone(); glib::spawn_future(async move { glib::idle_add_once(move || { - let output_box = sink_box.clone(); - let output_box_imp = output_box.imp(); + let sink_box = sink_box.clone(); + let sink_box_imp = sink_box.imp(); let entry: Arc; { - let list = output_box_imp.reset_input_stream_list.read().unwrap(); + let list = sink_box_imp.reset_input_stream_list.read().unwrap(); let entry_opt = list.get(&ir.stream.index); if entry_opt.is_none() { return; @@ -297,8 +297,8 @@ pub fn input_stream_changed_handler(output_box: Arc, ir: InputStreamCha let percentage = (fraction).to_string() + "%"; imp.reset_volume_percentage.set_text(&percentage); imp.reset_volume_slider.set_value(*volume as f64); - let index = output_box_imp.reset_model_index.read().unwrap(); - let model_list = output_box_imp.reset_model_list.read().unwrap(); + let index = sink_box_imp.reset_model_index.read().unwrap(); + let model_list = sink_box_imp.reset_model_list.read().unwrap(); for entry in 0..*index { if model_list.string(entry) == Some(alias.clone().into()) { imp.reset_sink_selection.set_selected(entry); diff --git a/src/components/output/sink_box_utils.rs b/src/components/output/sink_box_utils.rs index 7a4bb7e..9b32ef5 100644 --- a/src/components/output/sink_box_utils.rs +++ b/src/components/output/sink_box_utils.rs @@ -21,24 +21,24 @@ use super::{ sink_entry::SinkEntry, }; -pub fn populate_sink_information(output_box: Arc, sinks: Vec) { +pub fn populate_sink_information(sink_box: Arc, sinks: Vec) { glib::spawn_future(async move { glib::idle_add_once(move || { - let output_box_ref_select = output_box.clone(); - let output_box_ref_slider = output_box.clone(); - let output_box_ref_mute = output_box.clone(); - let output_box_ref = output_box.clone(); + let sink_box_ref_select = sink_box.clone(); + let sink_box_ref_slider = sink_box.clone(); + let sink_box_ref_mute = sink_box.clone(); + let sink_box_ref = sink_box.clone(); { - let output_box_imp = output_box_ref.imp(); - let default_sink = output_box_imp.reset_default_sink.clone(); + let sink_box_imp = sink_box_ref.imp(); + let default_sink = sink_box_imp.reset_default_sink.clone(); let sink = default_sink.borrow(); if sink.muted { - output_box_imp + sink_box_imp .reset_sink_mute .set_icon_name("audio-volume-muted-symbolic"); } else { - output_box_imp + sink_box_imp .reset_sink_mute .set_icon_name("audio-volume-high-symbolic"); } @@ -46,69 +46,69 @@ pub fn populate_sink_information(output_box: Arc, sinks: Vec) { let volume = sink.volume.first().unwrap_or(&0); let fraction = (*volume as f64 / 655.36).round(); let percentage = (fraction).to_string() + "%"; - 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(); + sink_box_imp.reset_volume_percentage.set_text(&percentage); + sink_box_imp.reset_volume_slider.set_value(*volume as f64); + let mut list = sink_box_imp.reset_sink_list.write().unwrap(); for sink in sinks { let index = sink.index; let alias = sink.alias.clone(); let mut is_default = false; - if output_box_imp.reset_default_sink.borrow().name == sink.name { + if sink_box_imp.reset_default_sink.borrow().name == sink.name { is_default = true; } let sink_entry = Arc::new(SinkEntry::new( is_default, - output_box_imp.reset_default_check_button.clone(), + sink_box_imp.reset_default_check_button.clone(), sink, - output_box.clone(), + sink_box.clone(), )); let sink_clone = sink_entry.clone(); let entry = Arc::new(ListEntry::new(&*sink_entry)); entry.set_activatable(false); list.insert(index, (entry.clone(), sink_clone, alias)); - output_box_imp.reset_sinks.append(&*entry); + sink_box_imp.reset_sinks.append(&*entry); } - let list = output_box_imp.reset_model_list.read().unwrap(); - output_box_imp.reset_sink_dropdown.set_model(Some(&*list)); - let name = output_box_imp.reset_default_sink.borrow(); + let list = sink_box_imp.reset_model_list.read().unwrap(); + sink_box_imp.reset_sink_dropdown.set_model(Some(&*list)); + let name = sink_box_imp.reset_default_sink.borrow(); - let index = output_box_imp.reset_model_index.read().unwrap(); - let model_list = output_box_imp.reset_model_list.read().unwrap(); + let index = sink_box_imp.reset_model_index.read().unwrap(); + let model_list = sink_box_imp.reset_model_list.read().unwrap(); for entry in 0..*index { if model_list.string(entry) == Some(name.alias.clone().into()) { - output_box_imp.reset_sink_dropdown.set_selected(entry); + sink_box_imp.reset_sink_dropdown.set_selected(entry); break; } } - output_box_imp + sink_box_imp .reset_sink_dropdown .connect_selected_notify(move |dropdown| { - drop_down_handler(output_box_ref_select.clone(), dropdown); + drop_down_handler(sink_box_ref_select.clone(), dropdown); }); } - output_box_ref + sink_box_ref .imp() .reset_volume_slider .connect_change_value(move |_, _, value| { - volume_slider_handler(output_box_ref_slider.clone(), value) + volume_slider_handler(sink_box_ref_slider.clone(), value) }); - output_box_ref + sink_box_ref .imp() .reset_sink_mute .connect_clicked(move |_| { - mute_handler(output_box_ref_mute.clone()); + mute_handler(sink_box_ref_mute.clone()); }); }); }); } -pub fn refresh_default_sink(new_sink: Sink, output_box: Arc, entry: bool) { +pub fn refresh_default_sink(new_sink: Sink, sink_box: Arc, entry: bool) { let volume = *new_sink.volume.first().unwrap_or(&0_u32); let fraction = (volume as f64 / 655.36).round(); let percentage = (fraction).to_string() + "%"; glib::spawn_future(async move { glib::idle_add_once(move || { - let imp = output_box.imp(); + let imp = sink_box.imp(); if !entry { let list = imp.reset_sink_list.read().unwrap(); let entry = list.get(&new_sink.index); @@ -141,35 +141,33 @@ pub fn refresh_default_sink(new_sink: Sink, output_box: Arc, entry: boo }); } -pub fn populate_inputstreams(output_box: Arc) { - let output_box_ref = output_box.clone(); - +pub fn populate_inputstreams(sink_box: Arc) { gio::spawn_blocking(move || { - let streams = get_input_streams(output_box.clone()); + let streams = get_input_streams(sink_box.clone()); glib::spawn_future(async move { glib::idle_add_once(move || { - let output_box_imp = output_box_ref.imp(); - let mut list = output_box_imp.reset_input_stream_list.write().unwrap(); + let sink_box_imp = sink_box.imp(); + let mut list = sink_box_imp.reset_input_stream_list.write().unwrap(); for stream in streams { let index = stream.index; - let input_stream = Arc::new(InputStreamEntry::new(output_box.clone(), stream)); + let input_stream = Arc::new(InputStreamEntry::new(sink_box.clone(), stream)); let entry = Arc::new(ListEntry::new(&*input_stream)); entry.set_activatable(false); list.insert(index, (entry.clone(), input_stream.clone())); - output_box_imp.reset_input_streams.append(&*entry); + sink_box_imp.reset_input_streams.append(&*entry); } }); }); }); } -pub fn populate_cards(output_box: Arc) { +pub fn populate_cards(sink_box: Arc) { gio::spawn_blocking(move || { - let output_box_ref = output_box.clone(); - let cards = get_cards(output_box.clone()); + let sink_box_ref = sink_box.clone(); + let cards = get_cards(sink_box.clone()); glib::spawn_future(async move { glib::idle_add_once(move || { - let imp = output_box_ref.imp(); + let imp = sink_box_ref.imp(); for card in cards { imp.reset_cards.add(&CardEntry::new(card)); } @@ -178,56 +176,56 @@ pub fn populate_cards(output_box: Arc) { }); } -pub fn get_input_streams(output_box: Arc) -> Vec { +pub fn get_input_streams(sink_box: Arc) -> Vec { let conn = Connection::new_session().unwrap(); let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000)); let res: Result<(Vec,), Error> = proxy.method_call(AUDIO, "ListInputStreams", ()); if res.is_err() { - show_error::(output_box.clone(), "Failed to list input streams"); + show_error::(sink_box.clone(), "Failed to list input streams"); return Vec::new(); } res.unwrap().0 } -pub fn get_sinks(output_box: Arc) -> Vec { +pub fn get_sinks(sink_box: Arc) -> Vec { let conn = Connection::new_session().unwrap(); let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000)); let res: Result<(Vec,), Error> = proxy.method_call(AUDIO, "ListSinks", ()); if res.is_err() { - show_error::(output_box.clone(), "Failed to list sinks"); + show_error::(sink_box.clone(), "Failed to list sinks"); return Vec::new(); } res.unwrap().0 } -pub fn get_cards(output_box: Arc) -> Vec { +pub fn get_cards(sink_box: Arc) -> Vec { let conn = Connection::new_session().unwrap(); let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000)); let res: Result<(Vec,), Error> = proxy.method_call(AUDIO, "ListCards", ()); if res.is_err() { - show_error::(output_box.clone(), "Failed to list profiles"); + show_error::(sink_box.clone(), "Failed to list profiles"); return Vec::new(); } res.unwrap().0 } -pub fn get_default_sink_name(output_box: Arc) -> String { +pub fn get_default_sink_name(sink_box: Arc) -> String { let conn = Connection::new_session().unwrap(); let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000)); let res: Result<(String,), Error> = proxy.method_call(AUDIO, "GetDefaultSinkName", ()); if res.is_err() { - show_error::(output_box.clone(), "Failed to get default sink name"); + show_error::(sink_box.clone(), "Failed to get default sink name"); return String::from(""); } res.unwrap().0 } -pub fn get_default_sink(output_box: Arc) -> Sink { +pub fn get_default_sink(sink_box: Arc) -> Sink { let conn = Connection::new_session().unwrap(); let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000)); let res: Result<(Sink,), Error> = proxy.method_call(AUDIO, "GetDefaultSink", ()); if res.is_err() { - show_error::(output_box.clone(), "Failed to get default sink"); + show_error::(sink_box.clone(), "Failed to get default sink"); return Sink::default(); } res.unwrap().0