Xetibo/ReSet
1
0
Fork 0
mirror of https://github.com/Xetibo/ReSet.git synced 2025-04-17 10:18:32 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity

chore: Use uniform naming for audio boxes

Browse source
This commit is contained in:
Fabio Lenherr / DashieTM 2024-03-12 11:14:49 +01:00
parent fae04a811f
commit eccd5c6093
6 changed files with 234 additions and 236 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -96,17 +96,17 @@ impl Default for SourceBox {
} }
} }
pub fn populate_sources(input_box: Arc<SourceBox>) { pub fn populate_sources(source_box: Arc<SourceBox>) {
gio::spawn_blocking(move || { 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 source_box_imp = source_box.imp();
let list = input_box_imp.reset_model_list.write().unwrap(); let list = source_box_imp.reset_model_list.write().unwrap();
let mut map = input_box_imp.reset_source_map.write().unwrap(); let mut map = source_box_imp.reset_source_map.write().unwrap();
let mut model_index = input_box_imp.reset_model_index.write().unwrap(); let mut model_index = source_box_imp.reset_model_index.write().unwrap();
input_box_imp source_box_imp
.reset_default_source .reset_default_source
.replace(get_default_source(input_box.clone())); .replace(get_default_source(source_box.clone()));
for source in sources.iter() { for source in sources.iter() {
list.append(&source.alias); list.append(&source.alias);
map.insert(source.alias.clone(), (source.index, source.name.clone())); map.insert(source.alias.clone(), (source.index, source.name.clone()));
@ -114,13 +114,13 @@ pub fn populate_sources(input_box: Arc<SourceBox>) {
} }
} }
populate_outputstreams(input_box.clone()); populate_outputstreams(source_box.clone());
populate_cards(input_box.clone()); populate_cards(source_box.clone());
populate_source_information(input_box, sources); populate_source_information(source_box, sources);
}); });
} }
pub fn start_input_box_listener(conn: Connection, source_box: Arc<SourceBox>) -> Connection { pub fn start_source_box_listener(conn: Connection, source_box: Arc<SourceBox>) -> Connection {
let source_added = let source_added =
SourceAdded::match_rule(Some(&BASE.into()), Some(&Path::from(DBUS_PATH))).static_clone(); SourceAdded::match_rule(Some(&BASE.into()), Some(&Path::from(DBUS_PATH))).static_clone();
let source_removed = let source_removed =

106
src/components/input/source_box_handlers.rs
View file

@ -27,40 +27,40 @@ use super::{
pub fn source_added_handler(source_box: Arc<SourceBox>, ir: SourceAdded) -> bool { pub fn source_added_handler(source_box: Arc<SourceBox>, ir: SourceAdded) -> bool {
glib::spawn_future(async move { glib::spawn_future(async move {
glib::idle_add_once(move || { glib::idle_add_once(move || {
let input_box = source_box.clone(); let source_box = source_box.clone();
let input_box_imp = input_box.imp(); let source_box_imp = source_box.imp();
let source_index = ir.source.index; let source_index = ir.source.index;
let alias = ir.source.alias.clone(); let alias = ir.source.alias.clone();
let name = ir.source.name.clone(); let name = ir.source.name.clone();
let mut is_default = false; 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; is_default = true;
} }
let source_entry = Arc::new(SourceEntry::new( let source_entry = Arc::new(SourceEntry::new(
is_default, is_default,
input_box_imp.reset_default_check_button.clone(), source_box_imp.reset_default_check_button.clone(),
ir.source, ir.source,
input_box.clone(), source_box.clone(),
)); ));
let source_clone = source_entry.clone(); let source_clone = source_entry.clone();
let entry = Arc::new(ListEntry::new(&*source_entry)); let entry = Arc::new(ListEntry::new(&*source_entry));
entry.set_activatable(false); 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())); list.insert(source_index, (entry.clone(), source_clone, alias.clone()));
input_box_imp.reset_sources.append(&*entry); source_box_imp.reset_sources.append(&*entry);
let mut map = input_box_imp.reset_source_map.write().unwrap(); let mut map = source_box_imp.reset_source_map.write().unwrap();
let mut index = input_box_imp.reset_model_index.write().unwrap(); let mut index = source_box_imp.reset_model_index.write().unwrap();
let model_list = input_box_imp.reset_model_list.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()) { if model_list.string(*index - 1) == Some("Monitor of Dummy Output".into()) {
model_list.append(&alias); model_list.append(&alias);
model_list.remove(*index - 1); model_list.remove(*index - 1);
map.insert(alias, (source_index, name)); 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 { } else {
model_list.append(&alias); model_list.append(&alias);
map.insert(alias.clone(), (source_index, name)); map.insert(alias.clone(), (source_index, name));
if alias == "Monitor of Dummy Output" { 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; *index += 1;
} }
@ -72,24 +72,24 @@ pub fn source_added_handler(source_box: Arc<SourceBox>, ir: SourceAdded) -> bool
pub fn source_removed_handler(source_box: Arc<SourceBox>, ir: SourceRemoved) -> bool { pub fn source_removed_handler(source_box: Arc<SourceBox>, ir: SourceRemoved) -> bool {
glib::spawn_future(async move { glib::spawn_future(async move {
glib::idle_add_once(move || { glib::idle_add_once(move || {
let input_box = source_box.clone(); let source_box = source_box.clone();
let input_box_imp = input_box.imp(); let source_box_imp = source_box.imp();
let entry: Option<(Arc<ListEntry>, Arc<SourceEntry>, String)>; let entry: Option<(Arc<ListEntry>, Arc<SourceEntry>, 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); entry = list.remove(&ir.index);
if entry.is_none() { if entry.is_none() {
return; return;
} }
} }
input_box_imp source_box_imp
.reset_sources .reset_sources
.remove(&*entry.clone().unwrap().0); .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; let alias = entry.unwrap().2;
map.remove(&alias); map.remove(&alias);
let mut index = input_box_imp.reset_model_index.write().unwrap(); let mut index = source_box_imp.reset_model_index.write().unwrap();
let model_list = input_box_imp.reset_model_list.write().unwrap(); let model_list = source_box_imp.reset_model_list.write().unwrap();
if *index == 1 { if *index == 1 {
model_list.append("Monitor of Dummy Output"); model_list.append("Monitor of Dummy Output");
@ -112,31 +112,31 @@ pub fn source_changed_handler(source_box: Arc<SourceBox>, ir: SourceChanged) ->
let default_source = get_default_source_name(source_box.clone()); let default_source = get_default_source_name(source_box.clone());
glib::spawn_future(async move { glib::spawn_future(async move {
glib::idle_add_once(move || { glib::idle_add_once(move || {
let input_box = source_box.clone(); let source_box = source_box.clone();
let input_box_imp = input_box.imp(); let source_box_imp = source_box.imp();
let is_default = ir.source.name == default_source; let is_default = ir.source.name == default_source;
let volume = ir.source.volume.first().unwrap_or(&0_u32); let volume = ir.source.volume.first().unwrap_or(&0_u32);
let fraction = (*volume as f64 / 655.36).round(); let fraction = (*volume as f64 / 655.36).round();
let percentage = (fraction).to_string() + "%"; 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); let entry = list.get(&ir.source.index);
if entry.is_none() { if entry.is_none() {
return; return;
} }
let imp = entry.unwrap().1.imp(); let imp = entry.unwrap().1.imp();
if is_default { if is_default {
input_box_imp.reset_volume_percentage.set_text(&percentage); source_box_imp.reset_volume_percentage.set_text(&percentage);
input_box_imp.reset_volume_slider.set_value(*volume as f64); source_box_imp.reset_volume_slider.set_value(*volume as f64);
input_box_imp source_box_imp
.reset_default_source .reset_default_source
.replace(ir.source.clone()); .replace(ir.source.clone());
if ir.source.muted { if ir.source.muted {
input_box_imp source_box_imp
.reset_source_mute .reset_source_mute
.set_icon_name("microphone-disabled-symbolic"); .set_icon_name("microphone-disabled-symbolic");
} else { } else {
input_box_imp source_box_imp
.reset_source_mute .reset_source_mute
.set_icon_name("audio-input-microphone-symbolic"); .set_icon_name("audio-input-microphone-symbolic");
} }
@ -163,15 +163,15 @@ pub fn source_changed_handler(source_box: Arc<SourceBox>, ir: SourceChanged) ->
pub fn output_stream_added_handler(source_box: Arc<SourceBox>, ir: OutputStreamAdded) -> bool { pub fn output_stream_added_handler(source_box: Arc<SourceBox>, ir: OutputStreamAdded) -> bool {
glib::spawn_future(async move { glib::spawn_future(async move {
glib::idle_add_once(move || { glib::idle_add_once(move || {
let input_box = source_box.clone(); let source_box = source_box.clone();
let input_box_imp = input_box.imp(); let source_box_imp = source_box.imp();
let mut list = input_box_imp.reset_output_stream_list.write().unwrap(); let mut list = source_box_imp.reset_output_stream_list.write().unwrap();
let index = ir.stream.index; 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)); let entry = Arc::new(ListEntry::new(&*output_stream));
entry.set_activatable(false); entry.set_activatable(false);
list.insert(index, (entry.clone(), output_stream.clone())); 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 true
@ -190,11 +190,11 @@ pub fn output_stream_changed_handler(source_box: Arc<SourceBox>, ir: OutputStrea
} }
glib::spawn_future(async move { glib::spawn_future(async move {
glib::idle_add_once(move || { glib::idle_add_once(move || {
let input_box = source_box.clone(); let source_box = source_box.clone();
let input_box_imp = input_box.imp(); let source_box_imp = source_box.imp();
let entry: Arc<OutputStreamEntry>; let entry: Arc<OutputStreamEntry>;
{ {
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); let entry_opt = list.get(&ir.stream.index);
if entry_opt.is_none() { if entry_opt.is_none() {
return; return;
@ -216,8 +216,8 @@ pub fn output_stream_changed_handler(source_box: Arc<SourceBox>, ir: OutputStrea
let percentage = (fraction).to_string() + "%"; let percentage = (fraction).to_string() + "%";
imp.reset_volume_percentage.set_text(&percentage); imp.reset_volume_percentage.set_text(&percentage);
imp.reset_volume_slider.set_value(*volume as f64); imp.reset_volume_slider.set_value(*volume as f64);
let index = input_box_imp.reset_model_index.read().unwrap(); let index = source_box_imp.reset_model_index.read().unwrap();
let model_list = input_box_imp.reset_model_list.read().unwrap(); let model_list = source_box_imp.reset_model_list.read().unwrap();
for entry in 0..*index { for entry in 0..*index {
if model_list.string(entry) == Some(alias.clone().into()) { if model_list.string(entry) == Some(alias.clone().into()) {
imp.reset_source_selection.set_selected(entry); imp.reset_source_selection.set_selected(entry);
@ -232,14 +232,14 @@ pub fn output_stream_changed_handler(source_box: Arc<SourceBox>, ir: OutputStrea
pub fn output_stream_removed_handler(source_box: Arc<SourceBox>, ir: OutputStreamRemoved) -> bool { pub fn output_stream_removed_handler(source_box: Arc<SourceBox>, ir: OutputStreamRemoved) -> bool {
glib::spawn_future(async move { glib::spawn_future(async move {
glib::idle_add_once(move || { glib::idle_add_once(move || {
let input_box = source_box.clone(); let source_box = source_box.clone();
let input_box_imp = input_box.imp(); let source_box_imp = source_box.imp();
let mut list = input_box_imp.reset_output_stream_list.write().unwrap(); let mut list = source_box_imp.reset_output_stream_list.write().unwrap();
let entry = list.remove(&ir.index); let entry = list.remove(&ir.index);
if entry.is_none() { if entry.is_none() {
return; return;
} }
input_box_imp source_box_imp
.reset_output_streams .reset_output_streams
.remove(&*entry.unwrap().0); .remove(&*entry.unwrap().0);
}); });
@ -247,9 +247,9 @@ pub fn output_stream_removed_handler(source_box: Arc<SourceBox>, ir: OutputStrea
true true
} }
pub fn dropdown_handler(input_box: Arc<SourceBox>, dropdown: &adw::ComboRow) -> ControlFlow { pub fn dropdown_handler(source_box: Arc<SourceBox>, dropdown: &adw::ComboRow) -> ControlFlow {
let input_box_imp = input_box.imp(); let source_box_imp = source_box.imp();
let input_box_ref = input_box.clone(); let source_box_ref = source_box.clone();
let selected = dropdown.selected_item(); let selected = dropdown.selected_item();
if selected.is_none() { if selected.is_none() {
return ControlFlow::Break; return ControlFlow::Break;
@ -257,25 +257,25 @@ pub fn dropdown_handler(input_box: Arc<SourceBox>, dropdown: &adw::ComboRow) ->
let selected = selected.unwrap(); let selected = selected.unwrap();
let selected = selected.downcast_ref::<StringObject>().unwrap(); let selected = selected.downcast_ref::<StringObject>().unwrap();
let selected = selected.string().to_string(); 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); let source = source.get(&selected);
if source.is_none() { if source.is_none() {
return ControlFlow::Break; return ControlFlow::Break;
} }
let source = Arc::new(source.unwrap().1.clone()); let source = Arc::new(source.unwrap().1.clone());
gio::spawn_blocking(move || { 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() { if result.is_none() {
return ControlFlow::Break; 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
}); });
ControlFlow::Continue ControlFlow::Continue
} }
pub fn volume_slider_handler(input_box: Arc<SourceBox>, value: f64) -> Propagation { pub fn volume_slider_handler(source_box: Arc<SourceBox>, value: f64) -> Propagation {
let imp = input_box.imp(); let imp = source_box.imp();
let fraction = (value / 655.36).round(); let fraction = (value / 655.36).round();
let percentage = (fraction).to_string() + "%"; let percentage = (fraction).to_string() + "%";
imp.reset_volume_percentage.set_text(&percentage); imp.reset_volume_percentage.set_text(&percentage);
@ -289,12 +289,12 @@ pub fn volume_slider_handler(input_box: Arc<SourceBox>, value: f64) -> Propagati
} }
*time = Some(SystemTime::now()); *time = Some(SystemTime::now());
} }
set_source_volume(value, index, channels, input_box.clone()); set_source_volume(value, index, channels, source_box.clone());
Propagation::Proceed Propagation::Proceed
} }
pub fn mute_clicked_handler(input_box_ref_mute: Arc<SourceBox>) { pub fn mute_clicked_handler(source_box_ref_mute: Arc<SourceBox>) {
let imp = input_box_ref_mute.imp(); let imp = source_box_ref_mute.imp();
let mut source = imp.reset_default_source.borrow_mut(); let mut source = imp.reset_default_source.borrow_mut();
source.muted = !source.muted; source.muted = !source.muted;
if source.muted { if source.muted {
@ -304,5 +304,5 @@ pub fn mute_clicked_handler(input_box_ref_mute: Arc<SourceBox>) {
imp.reset_source_mute imp.reset_source_mute
.set_icon_name("audio-input-microphone-symbolic"); .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());
} }

100
src/components/input/source_box_utils.rs
View file

@ -21,22 +21,22 @@ use super::{
source_entry::SourceEntry, source_entry::SourceEntry,
}; };
pub fn populate_source_information(input_box: Arc<SourceBox>, sources: Vec<Source>) { pub fn populate_source_information(source_box: Arc<SourceBox>, sources: Vec<Source>) {
glib::spawn_future(async move { glib::spawn_future(async move {
glib::idle_add_once(move || { glib::idle_add_once(move || {
let input_box_ref_slider = input_box.clone(); let source_box_ref_slider = source_box.clone();
let input_box_ref_toggle = input_box.clone(); let source_box_ref_toggle = source_box.clone();
let input_box_ref_mute = input_box.clone(); let source_box_ref_mute = source_box.clone();
let input_box_imp = input_box.imp(); let source_box_imp = source_box.imp();
let default_sink = input_box_imp.reset_default_source.clone(); let default_sink = source_box_imp.reset_default_source.clone();
let source = default_sink.borrow(); let source = default_sink.borrow();
if source.muted { if source.muted {
input_box_imp source_box_imp
.reset_source_mute .reset_source_mute
.set_icon_name("microphone-disabled-symbolic"); .set_icon_name("microphone-disabled-symbolic");
} else { } else {
input_box_imp source_box_imp
.reset_source_mute .reset_source_mute
.set_icon_name("audio-input-microphone-symbolic"); .set_icon_name("audio-input-microphone-symbolic");
} }
@ -44,65 +44,65 @@ pub fn populate_source_information(input_box: Arc<SourceBox>, sources: Vec<Sourc
let volume = source.volume.first().unwrap_or(&0_u32); let volume = source.volume.first().unwrap_or(&0_u32);
let fraction = (*volume as f64 / 655.36).round(); let fraction = (*volume as f64 / 655.36).round();
let percentage = (fraction).to_string() + "%"; let percentage = (fraction).to_string() + "%";
input_box_imp.reset_volume_percentage.set_text(&percentage); source_box_imp.reset_volume_percentage.set_text(&percentage);
input_box_imp.reset_volume_slider.set_value(*volume as f64); source_box_imp.reset_volume_slider.set_value(*volume as f64);
let mut list = input_box_imp.reset_source_list.write().unwrap(); let mut list = source_box_imp.reset_source_list.write().unwrap();
for source in sources { for source in sources {
let index = source.index; let index = source.index;
let alias = source.alias.clone(); let alias = source.alias.clone();
let mut is_default = false; let mut is_default = false;
if input_box_imp.reset_default_source.borrow().name == source.name { if source_box_imp.reset_default_source.borrow().name == source.name {
is_default = true; is_default = true;
} }
let source_entry = Arc::new(SourceEntry::new( let source_entry = Arc::new(SourceEntry::new(
is_default, is_default,
input_box_imp.reset_default_check_button.clone(), source_box_imp.reset_default_check_button.clone(),
source, source,
input_box.clone(), source_box.clone(),
)); ));
let source_clone = source_entry.clone(); let source_clone = source_entry.clone();
let entry = Arc::new(ListEntry::new(&*source_entry)); let entry = Arc::new(ListEntry::new(&*source_entry));
entry.set_activatable(false); entry.set_activatable(false);
list.insert(index, (entry.clone(), source_clone, alias)); list.insert(index, (entry.clone(), source_clone, alias));
input_box_imp.reset_sources.append(&*entry); source_box_imp.reset_sources.append(&*entry);
} }
let list = input_box_imp.reset_model_list.read().unwrap(); let list = source_box_imp.reset_model_list.read().unwrap();
input_box_imp.reset_source_dropdown.set_model(Some(&*list)); source_box_imp.reset_source_dropdown.set_model(Some(&*list));
let name = input_box_imp.reset_default_source.borrow(); let name = source_box_imp.reset_default_source.borrow();
let index = input_box_imp.reset_model_index.read().unwrap(); let index = source_box_imp.reset_model_index.read().unwrap();
let model_list = input_box_imp.reset_model_list.read().unwrap(); let model_list = source_box_imp.reset_model_list.read().unwrap();
for entry in 0..*index { for entry in 0..*index {
if model_list.string(entry) == Some(name.alias.clone().into()) { if model_list.string(entry) == Some(name.alias.clone().into()) {
input_box_imp.reset_source_dropdown.set_selected(entry); source_box_imp.reset_source_dropdown.set_selected(entry);
break; break;
} }
} }
input_box_imp source_box_imp
.reset_source_dropdown .reset_source_dropdown
.connect_selected_notify(move |dropdown| { .connect_selected_notify(move |dropdown| {
dropdown_handler(input_box_ref_toggle.clone(), dropdown); dropdown_handler(source_box_ref_toggle.clone(), dropdown);
}); });
input_box_imp source_box_imp
.reset_volume_slider .reset_volume_slider
.connect_change_value(move |_, _, value| { .connect_change_value(move |_, _, value| {
volume_slider_handler(input_box_ref_slider.clone(), value) volume_slider_handler(source_box_ref_slider.clone(), value)
}); });
input_box_imp.reset_source_mute.connect_clicked(move |_| { source_box_imp.reset_source_mute.connect_clicked(move |_| {
mute_clicked_handler(input_box_ref_mute.clone()); mute_clicked_handler(source_box_ref_mute.clone());
}); });
}); });
}); });
} }
pub fn refresh_default_source(new_source: Source, input_box: Arc<SourceBox>, entry: bool) { pub fn refresh_default_source(new_source: Source, source_box: Arc<SourceBox>, entry: bool) {
let volume = *new_source.volume.first().unwrap_or(&0_u32); let volume = *new_source.volume.first().unwrap_or(&0_u32);
let fraction = (volume as f64 / 655.36).round(); let fraction = (volume as f64 / 655.36).round();
let percentage = (fraction).to_string() + "%"; let percentage = (fraction).to_string() + "%";
glib::spawn_future(async move { glib::spawn_future(async move {
glib::idle_add_once(move || { glib::idle_add_once(move || {
let imp = input_box.imp(); let imp = source_box.imp();
if !entry { if !entry {
let list = imp.reset_source_list.read().unwrap(); let list = imp.reset_source_list.read().unwrap();
let entry = list.get(&new_source.index); let entry = list.get(&new_source.index);
@ -134,36 +134,36 @@ pub fn refresh_default_source(new_source: Source, input_box: Arc<SourceBox>, ent
}); });
} }
pub fn populate_outputstreams(input_box: Arc<SourceBox>) { pub fn populate_outputstreams(source_box: Arc<SourceBox>) {
let input_box_ref = input_box.clone(); let source_box_ref = source_box.clone();
gio::spawn_blocking(move || { 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::spawn_future(async move {
glib::idle_add_once(move || { glib::idle_add_once(move || {
let input_box_imp = input_box_ref.imp(); let source_box_imp = source_box_ref.imp();
let mut list = input_box_imp.reset_output_stream_list.write().unwrap(); let mut list = source_box_imp.reset_output_stream_list.write().unwrap();
for stream in streams { for stream in streams {
let index = stream.index; 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 input_stream_clone = input_stream.clone();
let entry = Arc::new(ListEntry::new(&*input_stream)); let entry = Arc::new(ListEntry::new(&*input_stream));
entry.set_activatable(false); entry.set_activatable(false);
list.insert(index, (entry.clone(), input_stream_clone)); 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<SourceBox>) { pub fn populate_cards(source_box: Arc<SourceBox>) {
gio::spawn_blocking(move || { gio::spawn_blocking(move || {
let input_box_ref = input_box.clone(); let source_box_ref = source_box.clone();
let cards = get_cards(input_box.clone()); let cards = get_cards(source_box.clone());
glib::spawn_future(async move { glib::spawn_future(async move {
glib::idle_add_once(move || { glib::idle_add_once(move || {
let imp = input_box_ref.imp(); let imp = source_box_ref.imp();
for card in cards { for card in cards {
imp.reset_cards.add(&CardEntry::new(card)); imp.reset_cards.add(&CardEntry::new(card));
} }
@ -172,57 +172,57 @@ pub fn populate_cards(input_box: Arc<SourceBox>) {
}); });
} }
pub fn get_output_streams(input_box: Arc<SourceBox>) -> Vec<OutputStream> { pub fn get_output_streams(source_box: Arc<SourceBox>) -> Vec<OutputStream> {
let conn = Connection::new_session().unwrap(); let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000)); let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000));
let res: Result<(Vec<OutputStream>,), Error> = let res: Result<(Vec<OutputStream>,), Error> =
proxy.method_call(AUDIO, "ListOutputStreams", ()); proxy.method_call(AUDIO, "ListOutputStreams", ());
if res.is_err() { if res.is_err() {
show_error::<SourceBox>(input_box.clone(), "Failed to get output streams"); show_error::<SourceBox>(source_box.clone(), "Failed to get output streams");
return Vec::new(); return Vec::new();
} }
res.unwrap().0 res.unwrap().0
} }
pub fn get_sources(input_box: Arc<SourceBox>) -> Vec<Source> { pub fn get_sources(source_box: Arc<SourceBox>) -> Vec<Source> {
let conn = Connection::new_session().unwrap(); let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000)); let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000));
let res: Result<(Vec<Source>,), Error> = proxy.method_call(AUDIO, "ListSources", ()); let res: Result<(Vec<Source>,), Error> = proxy.method_call(AUDIO, "ListSources", ());
if res.is_err() { if res.is_err() {
show_error::<SourceBox>(input_box.clone(), "Failed to get sources"); show_error::<SourceBox>(source_box.clone(), "Failed to get sources");
return Vec::new(); return Vec::new();
} }
res.unwrap().0 res.unwrap().0
} }
pub fn get_cards(input_box: Arc<SourceBox>) -> Vec<Card> { pub fn get_cards(source_box: Arc<SourceBox>) -> Vec<Card> {
let conn = Connection::new_session().unwrap(); let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000)); let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000));
let res: Result<(Vec<Card>,), Error> = proxy.method_call(AUDIO, "ListCards", ()); let res: Result<(Vec<Card>,), Error> = proxy.method_call(AUDIO, "ListCards", ());
if res.is_err() { if res.is_err() {
show_error::<SourceBox>(input_box.clone(), "Failed to get profiles"); show_error::<SourceBox>(source_box.clone(), "Failed to get profiles");
return Vec::new(); return Vec::new();
} }
res.unwrap().0 res.unwrap().0
} }
pub fn get_default_source_name(input_box: Arc<SourceBox>) -> String { pub fn get_default_source_name(source_box: Arc<SourceBox>) -> String {
let conn = Connection::new_session().unwrap(); let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000)); let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000));
let res: Result<(String,), Error> = proxy.method_call(AUDIO, "GetDefaultSourceName", ()); let res: Result<(String,), Error> = proxy.method_call(AUDIO, "GetDefaultSourceName", ());
if res.is_err() { if res.is_err() {
show_error::<SourceBox>(input_box.clone(), "Failed to get default source name"); show_error::<SourceBox>(source_box.clone(), "Failed to get default source name");
return String::from(""); return String::from("");
} }
res.unwrap().0 res.unwrap().0
} }
pub fn get_default_source(input_box: Arc<SourceBox>) -> Source { pub fn get_default_source(source_box: Arc<SourceBox>) -> Source {
let conn = Connection::new_session().unwrap(); let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000)); let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000));
let res: Result<(Source,), Error> = proxy.method_call(AUDIO, "GetDefaultSource", ()); let res: Result<(Source,), Error> = proxy.method_call(AUDIO, "GetDefaultSource", ());
if res.is_err() { if res.is_err() {
show_error::<SourceBox>(input_box.clone(), "Failed to get default source"); show_error::<SourceBox>(source_box.clone(), "Failed to get default source");
return Source::default(); return Source::default();
} }
res.unwrap().0 res.unwrap().0

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

@ -103,30 +103,30 @@ impl Default for SinkBox {
} }
} }
pub fn populate_sinks(output_box: Arc<SinkBox>) { pub fn populate_sinks(sink_box: Arc<SinkBox>) {
gio::spawn_blocking(move || { 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 sink_box_imp = sink_box.imp();
let list = output_box_imp.reset_model_list.write().unwrap(); let list = sink_box_imp.reset_model_list.write().unwrap();
let mut map = output_box_imp.reset_sink_map.write().unwrap(); let mut map = sink_box_imp.reset_sink_map.write().unwrap();
let mut model_index = output_box_imp.reset_model_index.write().unwrap(); let mut model_index = sink_box_imp.reset_model_index.write().unwrap();
output_box_imp sink_box_imp
.reset_default_sink .reset_default_sink
.replace(get_default_sink(output_box.clone())); .replace(get_default_sink(sink_box.clone()));
for sink in sinks.iter() { for sink in sinks.iter() {
list.append(&sink.alias); list.append(&sink.alias);
map.insert(sink.alias.clone(), (sink.index, sink.name.clone())); map.insert(sink.alias.clone(), (sink.index, sink.name.clone()));
*model_index += 1; *model_index += 1;
} }
} }
populate_inputstreams(output_box.clone()); populate_inputstreams(sink_box.clone());
populate_cards(output_box.clone()); populate_cards(sink_box.clone());
populate_sink_information(output_box, sinks); populate_sink_information(sink_box, sinks);
}); });
} }
pub fn start_output_box_listener(conn: Connection, sink_box: Arc<SinkBox>) -> Connection { pub fn start_sink_box_listener(conn: Connection, sink_box: Arc<SinkBox>) -> Connection {
let sink_added = let sink_added =
SinkAdded::match_rule(Some(&BASE.into()), Some(&Path::from(DBUS_PATH))).static_clone(); SinkAdded::match_rule(Some(&BASE.into()), Some(&Path::from(DBUS_PATH))).static_clone();
let sink_removed = let sink_removed =

114
src/components/output/sink_box_handlers.rs
View file

@ -26,9 +26,9 @@ use super::{
sink_entry::{set_default_sink, set_sink_volume, toggle_sink_mute, SinkEntry}, sink_entry::{set_default_sink, set_sink_volume, toggle_sink_mute, SinkEntry},
}; };
pub fn drop_down_handler(output_box: Arc<SinkBox>, dropdown: &ComboRow) { pub fn drop_down_handler(sink_box: Arc<SinkBox>, dropdown: &ComboRow) {
let output_box_ref = output_box.clone(); let sink_box_ref = sink_box.clone();
let output_box_imp = output_box.imp(); let sink_box_imp = sink_box.imp();
let selected = dropdown.selected_item(); let selected = dropdown.selected_item();
if selected.is_none() { if selected.is_none() {
return; return;
@ -37,24 +37,24 @@ pub fn drop_down_handler(output_box: Arc<SinkBox>, dropdown: &ComboRow) {
let selected = selected.downcast_ref::<StringObject>().unwrap(); let selected = selected.downcast_ref::<StringObject>().unwrap();
let selected = selected.string().to_string(); 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); let sink = sink.get(&selected);
if sink.is_none() { if sink.is_none() {
return; return;
} }
let new_sink_name = Arc::new(sink.unwrap().1.clone()); let new_sink_name = Arc::new(sink.unwrap().1.clone());
gio::spawn_blocking(move || { 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() { if result.is_none() {
return; return;
} }
let new_sink = result.unwrap(); 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<SinkBox>, value: f64) -> glib::Propagation { pub fn volume_slider_handler(sink_box: Arc<SinkBox>, value: f64) -> glib::Propagation {
let imp = output_box.imp(); let imp = sink_box.imp();
let fraction = (value / 655.36).round(); let fraction = (value / 655.36).round();
let percentage = (fraction).to_string() + "%"; let percentage = (fraction).to_string() + "%";
imp.reset_volume_percentage.set_text(&percentage); imp.reset_volume_percentage.set_text(&percentage);
@ -68,12 +68,12 @@ pub fn volume_slider_handler(output_box: Arc<SinkBox>, value: f64) -> glib::Prop
} }
*time = Some(SystemTime::now()); *time = Some(SystemTime::now());
} }
set_sink_volume(value, index, channels, output_box.clone()); set_sink_volume(value, index, channels, sink_box.clone());
Propagation::Proceed Propagation::Proceed
} }
pub fn mute_handler(output_box: Arc<SinkBox>) { pub fn mute_handler(sink_box: Arc<SinkBox>) {
let imp = output_box.imp(); let imp = sink_box.imp();
let mut stream = imp.reset_default_sink.borrow_mut(); let mut stream = imp.reset_default_sink.borrow_mut();
stream.muted = !stream.muted; stream.muted = !stream.muted;
if stream.muted { if stream.muted {
@ -83,46 +83,46 @@ pub fn mute_handler(output_box: Arc<SinkBox>) {
imp.reset_sink_mute imp.reset_sink_mute
.set_icon_name("audio-volume-high-symbolic"); .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<SinkBox>, ir: SinkAdded) -> bool { pub fn sink_added_handler(sink_box: Arc<SinkBox>, ir: SinkAdded) -> bool {
glib::spawn_future(async move { glib::spawn_future(async move {
glib::idle_add_once(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 sink_index = ir.sink.index;
let alias = ir.sink.alias.clone(); let alias = ir.sink.alias.clone();
let name = ir.sink.name.clone(); let name = ir.sink.name.clone();
let mut is_default = false; 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; is_default = true;
} }
let sink_entry = Arc::new(SinkEntry::new( let sink_entry = Arc::new(SinkEntry::new(
is_default, is_default,
output_box_imp.reset_default_check_button.clone(), sink_box_imp.reset_default_check_button.clone(),
ir.sink, ir.sink,
output_box.clone(), sink_box.clone(),
)); ));
let sink_clone = sink_entry.clone(); let sink_clone = sink_entry.clone();
let entry = Arc::new(ListEntry::new(&*sink_entry)); let entry = Arc::new(ListEntry::new(&*sink_entry));
entry.set_activatable(false); 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())); list.insert(sink_index, (entry.clone(), sink_clone, alias.clone()));
output_box_imp.reset_sinks.append(&*entry); sink_box_imp.reset_sinks.append(&*entry);
let mut map = output_box_imp.reset_sink_map.write().unwrap(); let mut map = sink_box_imp.reset_sink_map.write().unwrap();
let mut index = output_box_imp.reset_model_index.write().unwrap(); let mut index = sink_box_imp.reset_model_index.write().unwrap();
let model_list = output_box_imp.reset_model_list.write().unwrap(); let model_list = sink_box_imp.reset_model_list.write().unwrap();
if model_list.string(*index - 1) == Some("Dummy Output".into()) { if model_list.string(*index - 1) == Some("Dummy Output".into()) {
model_list.append(&alias); model_list.append(&alias);
model_list.remove(*index - 1); model_list.remove(*index - 1);
map.insert(alias, (sink_index, name)); 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 { } else {
model_list.append(&alias); model_list.append(&alias);
map.insert(alias.clone(), (sink_index, name)); map.insert(alias.clone(), (sink_index, name));
if alias == "Dummy Output" { if alias == "Dummy Output" {
output_box_imp.reset_sink_dropdown.set_selected(0); sink_box_imp.reset_sink_dropdown.set_selected(0);
} }
*index += 1; *index += 1;
} }
@ -131,32 +131,32 @@ pub fn sink_added_handler(output_box: Arc<SinkBox>, ir: SinkAdded) -> bool {
true true
} }
pub fn sink_removed_handler(output_box: Arc<SinkBox>, ir: SinkRemoved) -> bool { pub fn sink_removed_handler(sink_box: Arc<SinkBox>, ir: SinkRemoved) -> bool {
glib::spawn_future(async move { glib::spawn_future(async move {
glib::idle_add_once(move || { glib::idle_add_once(move || {
let output_box_imp = output_box.imp(); let sink_box_imp = sink_box.imp();
let entry: Option<(Arc<ListEntry>, Arc<SinkEntry>, String)>; let entry: Option<(Arc<ListEntry>, Arc<SinkEntry>, 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); entry = list.remove(&ir.index);
if entry.is_none() { if entry.is_none() {
return; return;
} }
} }
output_box_imp sink_box_imp
.reset_sinks .reset_sinks
.remove(&*entry.clone().unwrap().0); .remove(&*entry.clone().unwrap().0);
let alias = entry.unwrap().2; let alias = entry.unwrap().2;
let mut index = output_box_imp.reset_model_index.write().unwrap(); let mut index = sink_box_imp.reset_model_index.write().unwrap();
let model_list = output_box_imp.reset_model_list.write().unwrap(); let model_list = sink_box_imp.reset_model_list.write().unwrap();
// add dummy entry when no other devices are available // add dummy entry when no other devices are available
if *index == 1 { if *index == 1 {
model_list.append("Dummy Output"); 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); map.remove(&alias);
for entry in 0..*index { for entry in 0..*index {
@ -175,32 +175,32 @@ pub fn sink_removed_handler(output_box: Arc<SinkBox>, ir: SinkRemoved) -> bool {
true true
} }
pub fn sink_changed_handler(output_box: Arc<SinkBox>, ir: SinkChanged) -> bool { pub fn sink_changed_handler(sink_box: Arc<SinkBox>, ir: SinkChanged) -> bool {
glib::spawn_future(async move { glib::spawn_future(async move {
glib::idle_add_once(move || { glib::idle_add_once(move || {
let default_sink = get_default_sink_name(output_box.clone()); let default_sink = get_default_sink_name(sink_box.clone());
let output_box_imp = output_box.imp(); let sink_box_imp = sink_box.imp();
let is_default = ir.sink.name == default_sink; let is_default = ir.sink.name == default_sink;
let volume = ir.sink.volume.first().unwrap_or(&0_u32); let volume = ir.sink.volume.first().unwrap_or(&0_u32);
let fraction = (*volume as f64 / 655.36).round(); let fraction = (*volume as f64 / 655.36).round();
let percentage = (fraction).to_string() + "%"; 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); let entry = list.get(&ir.sink.index);
if entry.is_none() { if entry.is_none() {
return; return;
} }
let imp = entry.unwrap().1.imp(); let imp = entry.unwrap().1.imp();
if is_default { if is_default {
output_box_imp.reset_volume_percentage.set_text(&percentage); sink_box_imp.reset_volume_percentage.set_text(&percentage);
output_box_imp.reset_volume_slider.set_value(*volume as f64); sink_box_imp.reset_volume_slider.set_value(*volume as f64);
output_box_imp.reset_default_sink.replace(ir.sink.clone()); sink_box_imp.reset_default_sink.replace(ir.sink.clone());
if ir.sink.muted { if ir.sink.muted {
output_box_imp sink_box_imp
.reset_sink_mute .reset_sink_mute
.set_icon_name("audio-volume-muted-symbolic"); .set_icon_name("audio-volume-muted-symbolic");
} else { } else {
output_box_imp sink_box_imp
.reset_sink_mute .reset_sink_mute
.set_icon_name("audio-volume-high-symbolic"); .set_icon_name("audio-volume-high-symbolic");
} }
@ -224,32 +224,32 @@ pub fn sink_changed_handler(output_box: Arc<SinkBox>, ir: SinkChanged) -> bool {
true true
} }
pub fn input_stream_added_handler(output_box: Arc<SinkBox>, ir: InputStreamAdded) -> bool { pub fn input_stream_added_handler(sink_box: Arc<SinkBox>, ir: InputStreamAdded) -> bool {
glib::spawn_future(async move { glib::spawn_future(async move {
glib::idle_add_once(move || { glib::idle_add_once(move || {
let output_box_imp = output_box.imp(); let sink_box_imp = sink_box.imp();
let mut list = output_box_imp.reset_input_stream_list.write().unwrap(); let mut list = sink_box_imp.reset_input_stream_list.write().unwrap();
let index = ir.stream.index; 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)); let entry = Arc::new(ListEntry::new(&*input_stream));
entry.set_activatable(false); entry.set_activatable(false);
list.insert(index, (entry.clone(), input_stream.clone())); 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 true
} }
pub fn input_stream_removed_handler(output_box: Arc<SinkBox>, ir: InputStreamRemoved) -> bool { pub fn input_stream_removed_handler(sink_box: Arc<SinkBox>, ir: InputStreamRemoved) -> bool {
glib::spawn_future(async move { glib::spawn_future(async move {
glib::idle_add_once(move || { glib::idle_add_once(move || {
let output_box_imp = output_box.imp(); let sink_box_imp = sink_box.imp();
let mut list = output_box_imp.reset_input_stream_list.write().unwrap(); let mut list = sink_box_imp.reset_input_stream_list.write().unwrap();
let entry = list.remove(&ir.index); let entry = list.remove(&ir.index);
if entry.is_none() { if entry.is_none() {
return; return;
} }
output_box_imp sink_box_imp
.reset_input_streams .reset_input_streams
.remove(&*entry.unwrap().0); .remove(&*entry.unwrap().0);
}); });
@ -257,8 +257,8 @@ pub fn input_stream_removed_handler(output_box: Arc<SinkBox>, ir: InputStreamRem
true true
} }
pub fn input_stream_changed_handler(output_box: Arc<SinkBox>, ir: InputStreamChanged) -> bool { pub fn input_stream_changed_handler(sink_box: Arc<SinkBox>, ir: InputStreamChanged) -> bool {
let imp = output_box.imp(); let imp = sink_box.imp();
let alias: String; let alias: String;
{ {
let sink_list = imp.reset_sink_list.read().unwrap(); let sink_list = imp.reset_sink_list.read().unwrap();
@ -268,14 +268,14 @@ pub fn input_stream_changed_handler(output_box: Arc<SinkBox>, ir: InputStreamCha
alias = String::from(""); alias = String::from("");
} }
} }
let sink_box = output_box.clone(); let sink_box = sink_box.clone();
glib::spawn_future(async move { glib::spawn_future(async move {
glib::idle_add_once(move || { glib::idle_add_once(move || {
let output_box = sink_box.clone(); let sink_box = sink_box.clone();
let output_box_imp = output_box.imp(); let sink_box_imp = sink_box.imp();
let entry: Arc<InputStreamEntry>; let entry: Arc<InputStreamEntry>;
{ {
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); let entry_opt = list.get(&ir.stream.index);
if entry_opt.is_none() { if entry_opt.is_none() {
return; return;
@ -297,8 +297,8 @@ pub fn input_stream_changed_handler(output_box: Arc<SinkBox>, ir: InputStreamCha
let percentage = (fraction).to_string() + "%"; let percentage = (fraction).to_string() + "%";
imp.reset_volume_percentage.set_text(&percentage); imp.reset_volume_percentage.set_text(&percentage);
imp.reset_volume_slider.set_value(*volume as f64); imp.reset_volume_slider.set_value(*volume as f64);
let index = output_box_imp.reset_model_index.read().unwrap(); let index = sink_box_imp.reset_model_index.read().unwrap();
let model_list = output_box_imp.reset_model_list.read().unwrap(); let model_list = sink_box_imp.reset_model_list.read().unwrap();
for entry in 0..*index { for entry in 0..*index {
if model_list.string(entry) == Some(alias.clone().into()) { if model_list.string(entry) == Some(alias.clone().into()) {
imp.reset_sink_selection.set_selected(entry); imp.reset_sink_selection.set_selected(entry);

102
src/components/output/sink_box_utils.rs
View file

@ -21,24 +21,24 @@ use super::{
sink_entry::SinkEntry, sink_entry::SinkEntry,
}; };
pub fn populate_sink_information(output_box: Arc<SinkBox>, sinks: Vec<Sink>) { pub fn populate_sink_information(sink_box: Arc<SinkBox>, sinks: Vec<Sink>) {
glib::spawn_future(async move { glib::spawn_future(async move {
glib::idle_add_once(move || { glib::idle_add_once(move || {
let output_box_ref_select = output_box.clone(); let sink_box_ref_select = sink_box.clone();
let output_box_ref_slider = output_box.clone(); let sink_box_ref_slider = sink_box.clone();
let output_box_ref_mute = output_box.clone(); let sink_box_ref_mute = sink_box.clone();
let output_box_ref = output_box.clone(); let sink_box_ref = sink_box.clone();
{ {
let output_box_imp = output_box_ref.imp(); let sink_box_imp = sink_box_ref.imp();
let default_sink = output_box_imp.reset_default_sink.clone(); let default_sink = sink_box_imp.reset_default_sink.clone();
let sink = default_sink.borrow(); let sink = default_sink.borrow();
if sink.muted { if sink.muted {
output_box_imp sink_box_imp
.reset_sink_mute .reset_sink_mute
.set_icon_name("audio-volume-muted-symbolic"); .set_icon_name("audio-volume-muted-symbolic");
} else { } else {
output_box_imp sink_box_imp
.reset_sink_mute .reset_sink_mute
.set_icon_name("audio-volume-high-symbolic"); .set_icon_name("audio-volume-high-symbolic");
} }
@ -46,69 +46,69 @@ pub fn populate_sink_information(output_box: Arc<SinkBox>, sinks: Vec<Sink>) {
let volume = sink.volume.first().unwrap_or(&0); let volume = sink.volume.first().unwrap_or(&0);
let fraction = (*volume as f64 / 655.36).round(); let fraction = (*volume as f64 / 655.36).round();
let percentage = (fraction).to_string() + "%"; let percentage = (fraction).to_string() + "%";
output_box_imp.reset_volume_percentage.set_text(&percentage); sink_box_imp.reset_volume_percentage.set_text(&percentage);
output_box_imp.reset_volume_slider.set_value(*volume as f64); sink_box_imp.reset_volume_slider.set_value(*volume as f64);
let mut list = output_box_imp.reset_sink_list.write().unwrap(); let mut list = sink_box_imp.reset_sink_list.write().unwrap();
for sink in sinks { for sink in sinks {
let index = sink.index; let index = sink.index;
let alias = sink.alias.clone(); let alias = sink.alias.clone();
let mut is_default = false; 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; is_default = true;
} }
let sink_entry = Arc::new(SinkEntry::new( let sink_entry = Arc::new(SinkEntry::new(
is_default, is_default,
output_box_imp.reset_default_check_button.clone(), sink_box_imp.reset_default_check_button.clone(),
sink, sink,
output_box.clone(), sink_box.clone(),
)); ));
let sink_clone = sink_entry.clone(); let sink_clone = sink_entry.clone();
let entry = Arc::new(ListEntry::new(&*sink_entry)); let entry = Arc::new(ListEntry::new(&*sink_entry));
entry.set_activatable(false); entry.set_activatable(false);
list.insert(index, (entry.clone(), sink_clone, alias)); 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(); let list = sink_box_imp.reset_model_list.read().unwrap();
output_box_imp.reset_sink_dropdown.set_model(Some(&*list)); sink_box_imp.reset_sink_dropdown.set_model(Some(&*list));
let name = output_box_imp.reset_default_sink.borrow(); let name = sink_box_imp.reset_default_sink.borrow();
let index = output_box_imp.reset_model_index.read().unwrap(); let index = sink_box_imp.reset_model_index.read().unwrap();
let model_list = output_box_imp.reset_model_list.read().unwrap(); let model_list = sink_box_imp.reset_model_list.read().unwrap();
for entry in 0..*index { for entry in 0..*index {
if model_list.string(entry) == Some(name.alias.clone().into()) { 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; break;
} }
} }
output_box_imp sink_box_imp
.reset_sink_dropdown .reset_sink_dropdown
.connect_selected_notify(move |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() .imp()
.reset_volume_slider .reset_volume_slider
.connect_change_value(move |_, _, value| { .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() .imp()
.reset_sink_mute .reset_sink_mute
.connect_clicked(move |_| { .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<SinkBox>, entry: bool) { pub fn refresh_default_sink(new_sink: Sink, sink_box: Arc<SinkBox>, entry: bool) {
let volume = *new_sink.volume.first().unwrap_or(&0_u32); let volume = *new_sink.volume.first().unwrap_or(&0_u32);
let fraction = (volume as f64 / 655.36).round(); let fraction = (volume as f64 / 655.36).round();
let percentage = (fraction).to_string() + "%"; let percentage = (fraction).to_string() + "%";
glib::spawn_future(async move { glib::spawn_future(async move {
glib::idle_add_once(move || { glib::idle_add_once(move || {
let imp = output_box.imp(); let imp = sink_box.imp();
if !entry { if !entry {
let list = imp.reset_sink_list.read().unwrap(); let list = imp.reset_sink_list.read().unwrap();
let entry = list.get(&new_sink.index); let entry = list.get(&new_sink.index);
@ -141,35 +141,33 @@ pub fn refresh_default_sink(new_sink: Sink, output_box: Arc<SinkBox>, entry: boo
}); });
} }
pub fn populate_inputstreams(output_box: Arc<SinkBox>) { pub fn populate_inputstreams(sink_box: Arc<SinkBox>) {
let output_box_ref = output_box.clone();
gio::spawn_blocking(move || { 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::spawn_future(async move {
glib::idle_add_once(move || { glib::idle_add_once(move || {
let output_box_imp = output_box_ref.imp(); let sink_box_imp = sink_box.imp();
let mut list = output_box_imp.reset_input_stream_list.write().unwrap(); let mut list = sink_box_imp.reset_input_stream_list.write().unwrap();
for stream in streams { for stream in streams {
let index = stream.index; 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)); let entry = Arc::new(ListEntry::new(&*input_stream));
entry.set_activatable(false); entry.set_activatable(false);
list.insert(index, (entry.clone(), input_stream.clone())); 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<SinkBox>) { pub fn populate_cards(sink_box: Arc<SinkBox>) {
gio::spawn_blocking(move || { gio::spawn_blocking(move || {
let output_box_ref = output_box.clone(); let sink_box_ref = sink_box.clone();
let cards = get_cards(output_box.clone()); let cards = get_cards(sink_box.clone());
glib::spawn_future(async move { glib::spawn_future(async move {
glib::idle_add_once(move || { glib::idle_add_once(move || {
let imp = output_box_ref.imp(); let imp = sink_box_ref.imp();
for card in cards { for card in cards {
imp.reset_cards.add(&CardEntry::new(card)); imp.reset_cards.add(&CardEntry::new(card));
} }
@ -178,56 +176,56 @@ pub fn populate_cards(output_box: Arc<SinkBox>) {
}); });
} }
pub fn get_input_streams(output_box: Arc<SinkBox>) -> Vec<InputStream> { pub fn get_input_streams(sink_box: Arc<SinkBox>) -> Vec<InputStream> {
let conn = Connection::new_session().unwrap(); let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000)); let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000));
let res: Result<(Vec<InputStream>,), Error> = proxy.method_call(AUDIO, "ListInputStreams", ()); let res: Result<(Vec<InputStream>,), Error> = proxy.method_call(AUDIO, "ListInputStreams", ());
if res.is_err() { if res.is_err() {
show_error::<SinkBox>(output_box.clone(), "Failed to list input streams"); show_error::<SinkBox>(sink_box.clone(), "Failed to list input streams");
return Vec::new(); return Vec::new();
} }
res.unwrap().0 res.unwrap().0
} }
pub fn get_sinks(output_box: Arc<SinkBox>) -> Vec<Sink> { pub fn get_sinks(sink_box: Arc<SinkBox>) -> Vec<Sink> {
let conn = Connection::new_session().unwrap(); let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000)); let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000));
let res: Result<(Vec<Sink>,), Error> = proxy.method_call(AUDIO, "ListSinks", ()); let res: Result<(Vec<Sink>,), Error> = proxy.method_call(AUDIO, "ListSinks", ());
if res.is_err() { if res.is_err() {
show_error::<SinkBox>(output_box.clone(), "Failed to list sinks"); show_error::<SinkBox>(sink_box.clone(), "Failed to list sinks");
return Vec::new(); return Vec::new();
} }
res.unwrap().0 res.unwrap().0
} }
pub fn get_cards(output_box: Arc<SinkBox>) -> Vec<Card> { pub fn get_cards(sink_box: Arc<SinkBox>) -> Vec<Card> {
let conn = Connection::new_session().unwrap(); let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000)); let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000));
let res: Result<(Vec<Card>,), Error> = proxy.method_call(AUDIO, "ListCards", ()); let res: Result<(Vec<Card>,), Error> = proxy.method_call(AUDIO, "ListCards", ());
if res.is_err() { if res.is_err() {
show_error::<SinkBox>(output_box.clone(), "Failed to list profiles"); show_error::<SinkBox>(sink_box.clone(), "Failed to list profiles");
return Vec::new(); return Vec::new();
} }
res.unwrap().0 res.unwrap().0
} }
pub fn get_default_sink_name(output_box: Arc<SinkBox>) -> String { pub fn get_default_sink_name(sink_box: Arc<SinkBox>) -> String {
let conn = Connection::new_session().unwrap(); let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000)); let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000));
let res: Result<(String,), Error> = proxy.method_call(AUDIO, "GetDefaultSinkName", ()); let res: Result<(String,), Error> = proxy.method_call(AUDIO, "GetDefaultSinkName", ());
if res.is_err() { if res.is_err() {
show_error::<SinkBox>(output_box.clone(), "Failed to get default sink name"); show_error::<SinkBox>(sink_box.clone(), "Failed to get default sink name");
return String::from(""); return String::from("");
} }
res.unwrap().0 res.unwrap().0
} }
pub fn get_default_sink(output_box: Arc<SinkBox>) -> Sink { pub fn get_default_sink(sink_box: Arc<SinkBox>) -> Sink {
let conn = Connection::new_session().unwrap(); let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000)); let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000));
let res: Result<(Sink,), Error> = proxy.method_call(AUDIO, "GetDefaultSink", ()); let res: Result<(Sink,), Error> = proxy.method_call(AUDIO, "GetDefaultSink", ());
if res.is_err() { if res.is_err() {
show_error::<SinkBox>(output_box.clone(), "Failed to get default sink"); show_error::<SinkBox>(sink_box.clone(), "Failed to get default sink");
return Sink::default(); return Sink::default();
} }
res.unwrap().0 res.unwrap().0