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

refactor: audio sources

Browse source
This commit is contained in:
Fabio Lenherr / DashieTM 2024-03-11 13:39:30 +01:00
parent 260077006e
commit cc73c425f7
3 changed files with 398 additions and 335 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -16,7 +16,7 @@ use dbus::blocking::Connection;
use dbus::message::SignalArgs;
use dbus::{Error, Path};
use glib::subclass::prelude::ObjectSubclassIsExt;
use glib::{clone, Cast, Propagation, Variant};
use glib::{clone, Cast, ControlFlow, Propagation, Variant};
use gtk::prelude::ActionableExt;
use gtk::{gio, StringObject};
@ -29,6 +29,10 @@ use crate::components::utils::{
};
use super::output_stream_entry::OutputStreamEntry;
use super::source_box_event_handlers::{
output_stream_added_handler, output_stream_changed_handler, output_stream_removed_handler,
source_added_handler, source_changed_handler, source_removed_handler,
};
use super::source_entry::{set_default_source, toggle_source_mute, SourceEntry};
glib::wrapper! {
@ -111,136 +115,159 @@ pub fn populate_sources(input_box: Arc<SourceBox>) {
populate_outputstreams(input_box.clone());
populate_cards(input_box.clone());
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_ref = input_box.clone();
{
let input_box_imp = input_box_ref.imp();
let default_sink = input_box_imp.reset_default_source.clone();
let source = default_sink.borrow();
populate_source_information(input_box, sources);
});
}
if source.muted {
input_box_imp
.reset_source_mute
.set_icon_name("microphone-disabled-symbolic");
} else {
input_box_imp
.reset_source_mute
.set_icon_name("audio-input-microphone-symbolic");
}
fn populate_source_information(input_box: Arc<SourceBox>, sources: Vec<Source>) {
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_ref = input_box.clone();
{
let input_box_imp = input_box_ref.imp();
let default_sink = input_box_imp.reset_default_source.clone();
let source = default_sink.borrow();
let volume = source.volume.first().unwrap_or(&0_u32);
let fraction = (*volume as f64 / 655.36).round();
let percentage = (fraction).to_string() + "%";
input_box_imp.reset_volume_percentage.set_text(&percentage);
input_box_imp.reset_volume_slider.set_value(*volume as f64);
let mut list = input_box_imp.reset_source_list.write().unwrap();
for source in sources {
let index = source.index;
let alias = source.alias.clone();
let mut is_default = false;
if input_box_imp.reset_default_source.borrow().name == source.name {
is_default = true;
}
let source_entry = Arc::new(SourceEntry::new(
is_default,
input_box_imp.reset_default_check_button.clone(),
source,
input_box.clone(),
));
let source_clone = source_entry.clone();
let entry = Arc::new(ListEntry::new(&*source_entry));
entry.set_activatable(false);
list.insert(index, (entry.clone(), source_clone, alias));
input_box_imp.reset_sources.append(&*entry);
}
let list = input_box_imp.reset_model_list.read().unwrap();
input_box_imp.reset_source_dropdown.set_model(Some(&*list));
let name = input_box_imp.reset_default_source.borrow();
let index = input_box_imp.reset_model_index.read().unwrap();
let model_list = input_box_imp.reset_model_list.read().unwrap();
for entry in 0..*index {
if model_list.string(entry) == Some(name.alias.clone().into()) {
input_box_imp.reset_source_dropdown.set_selected(entry);
break;
}
}
input_box_imp.reset_source_dropdown.connect_selected_notify(
clone!(@weak input_box_imp => move |dropdown| {
let input_box = input_box_ref_toggle.clone();
let selected = dropdown.selected_item();
if selected.is_none() {
return;
}
let selected = selected.unwrap();
let selected = selected.downcast_ref::<StringObject>().unwrap();
let selected = selected.string().to_string();
let source = input_box_imp.reset_source_map.read().unwrap();
let source = source.get(&selected);
if source.is_none() {
return;
}
let source = Arc::new(source.unwrap().1.clone());
gio::spawn_blocking(move || {
let result = set_default_source(source);
if result.is_none(){
return;
}
refresh_default_source(result.unwrap(), input_box.clone(), false);
});
}),
);
if source.muted {
input_box_imp
.reset_source_mute
.set_icon_name("microphone-disabled-symbolic");
} else {
input_box_imp
.reset_source_mute
.set_icon_name("audio-input-microphone-symbolic");
}
input_box_ref
.imp()
.reset_volume_slider
.connect_change_value(move |_, _, value| {
let imp = input_box_ref_slider.imp();
let fraction = (value / 655.36).round();
let percentage = (fraction).to_string() + "%";
imp.reset_volume_percentage.set_text(&percentage);
let source = imp.reset_default_source.borrow();
let index = source.index;
let channels = source.channels;
{
let mut time = imp.volume_time_stamp.borrow_mut();
if time.is_some()
&& time.unwrap().elapsed().unwrap() < Duration::from_millis(50)
{
return Propagation::Proceed;
}
*time = Some(SystemTime::now());
}
set_source_volume(value, index, channels);
Propagation::Proceed
});
input_box_ref
.imp()
.reset_source_mute
.connect_clicked(move |_| {
let imp = input_box_ref_mute.imp();
let mut source = imp.reset_default_source.borrow_mut();
source.muted = !source.muted;
if source.muted {
imp.reset_source_mute
.set_icon_name("microphone-disabled-symbolic");
} else {
imp.reset_source_mute
.set_icon_name("audio-input-microphone-symbolic");
let volume = source.volume.first().unwrap_or(&0_u32);
let fraction = (*volume as f64 / 655.36).round();
let percentage = (fraction).to_string() + "%";
input_box_imp.reset_volume_percentage.set_text(&percentage);
input_box_imp.reset_volume_slider.set_value(*volume as f64);
let mut list = input_box_imp.reset_source_list.write().unwrap();
for source in sources {
let index = source.index;
let alias = source.alias.clone();
let mut is_default = false;
if input_box_imp.reset_default_source.borrow().name == source.name {
is_default = true;
}
let source_entry = Arc::new(SourceEntry::new(
is_default,
input_box_imp.reset_default_check_button.clone(),
source,
input_box.clone(),
));
let source_clone = source_entry.clone();
let entry = Arc::new(ListEntry::new(&*source_entry));
entry.set_activatable(false);
list.insert(index, (entry.clone(), source_clone, alias));
input_box_imp.reset_sources.append(&*entry);
}
let list = input_box_imp.reset_model_list.read().unwrap();
input_box_imp.reset_source_dropdown.set_model(Some(&*list));
let name = input_box_imp.reset_default_source.borrow();
let index = input_box_imp.reset_model_index.read().unwrap();
let model_list = input_box_imp.reset_model_list.read().unwrap();
for entry in 0..*index {
if model_list.string(entry) == Some(name.alias.clone().into()) {
input_box_imp.reset_source_dropdown.set_selected(entry);
break;
}
}
input_box_imp
.reset_source_dropdown
.connect_selected_notify(move |dropdown| {
if let ControlFlow::Break() =
dropdown_handler(input_box_ref_toggle, dropdown, input_box_imp)
{
return;
}
toggle_source_mute(source.index, source.muted);
});
});
}
input_box_ref
.imp()
.reset_volume_slider
.connect_change_value(move |_, _, value| {
volume_slider_handler(input_box_ref_slider, value)
});
input_box_ref
.imp()
.reset_source_mute
.connect_clicked(move |_| {
mute_clicked_handler(input_box_ref_mute);
});
});
});
}
fn dropdown_handler(
input_box_ref_toggle: Arc<SourceBox>,
dropdown: &adw::ComboRow,
input_box_imp: &source_box_impl::SourceBox,
) -> ControlFlow<()> {
let input_box = input_box_ref_toggle.clone();
let selected = dropdown.selected_item();
if selected.is_none() {
return ControlFlow::Break(());
}
let selected = selected.unwrap();
let selected = selected.downcast_ref::<StringObject>().unwrap();
let selected = selected.string().to_string();
let source = input_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);
if result.is_none() {
return ControlFlow::Break(());
}
refresh_default_source(result.unwrap(), input_box.clone(), false);
});
ControlFlow::Continue(())
}
fn volume_slider_handler(input_box_ref_slider: Arc<SourceBox>, value: f64) -> Propagation {
let imp = input_box_ref_slider.imp();
let fraction = (value / 655.36).round();
let percentage = (fraction).to_string() + "%";
imp.reset_volume_percentage.set_text(&percentage);
let source = imp.reset_default_source.borrow();
let index = source.index;
let channels = source.channels;
{
let mut time = imp.volume_time_stamp.borrow_mut();
if time.is_some() && time.unwrap().elapsed().unwrap() < Duration::from_millis(50) {
return Propagation::Proceed;
}
*time = Some(SystemTime::now());
}
set_source_volume(value, index, channels);
Propagation::Proceed
}
fn mute_clicked_handler(input_box_ref_mute: Arc<SourceBox>) {
let imp = input_box_ref_mute.imp();
let mut source = imp.reset_default_source.borrow_mut();
source.muted = !source.muted;
if source.muted {
imp.reset_source_mute
.set_icon_name("microphone-disabled-symbolic");
} else {
imp.reset_source_mute
.set_icon_name("audio-input-microphone-symbolic");
}
toggle_source_mute(source.index, source.muted);
}
pub fn refresh_default_source(new_source: Source, input_box: Arc<SourceBox>, entry: bool) {
let volume = *new_source.volume.first().unwrap_or(&0_u32);
let fraction = (volume as f64 / 655.36).round();
@ -348,7 +375,7 @@ fn get_cards() -> Vec<Card> {
res.unwrap().0
}
fn get_default_source_name() -> String {
pub fn get_default_source_name() -> 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", ());
@ -393,93 +420,16 @@ pub fn start_input_box_listener(conn: Connection, source_box: Arc<SourceBox>) ->
let output_stream_changed_box = source_box.clone();
let res = conn.add_match(source_added, move |ir: SourceAdded, _, _| {
let source_box = source_added_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_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 {
is_default = true;
}
let source_entry = Arc::new(SourceEntry::new(
is_default,
input_box_imp.reset_default_check_button.clone(),
ir.source,
input_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();
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();
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);
} 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);
}
*index += 1;
}
});
});
true
source_added_handler(source_box, ir)
});
if res.is_err() {
// TODO: handle this with the log/error macro
println!("fail on source add event");
return conn;
}
let res = conn.add_match(source_removed, move |ir: SourceRemoved, _, _| {
let source_box = source_removed_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 entry: Option<(Arc<ListEntry>, Arc<SourceEntry>, String)>;
{
let mut list = input_box_imp.reset_source_list.write().unwrap();
entry = list.remove(&ir.index);
if entry.is_none() {
return;
}
}
input_box_imp
.reset_sources
.remove(&*entry.clone().unwrap().0);
let mut map = input_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();
if *index == 1 {
model_list.append("Monitor of Dummy Output");
}
for entry in 0..*index {
if model_list.string(entry) == Some(alias.clone().into()) {
model_list.splice(entry, 1, &[]);
break;
}
}
if *index > 1 {
*index -= 1;
}
});
});
true
source_removed_handler(source_box, ir)
});
if res.is_err() {
println!("fail on source remove event");
@ -487,56 +437,7 @@ pub fn start_input_box_listener(conn: Connection, source_box: Arc<SourceBox>) ->
}
let res = conn.add_match(source_changed, move |ir: SourceChanged, _, _| {
let source_box = source_changed_box.clone();
let default_source = get_default_source_name();
glib::spawn_future(async move {
glib::idle_add_once(move || {
let input_box = source_box.clone();
let input_box_imp = input_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 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
.reset_default_source
.replace(ir.source.clone());
if ir.source.muted {
input_box_imp
.reset_source_mute
.set_icon_name("microphone-disabled-symbolic");
} else {
input_box_imp
.reset_source_mute
.set_icon_name("audio-input-microphone-symbolic");
}
imp.reset_selected_source.set_active(true);
} else {
imp.reset_selected_source.set_active(false);
}
imp.reset_source_name
.set_title(ir.source.alias.clone().as_str());
imp.reset_volume_percentage.set_text(&percentage);
imp.reset_volume_slider.set_value(*volume as f64);
if ir.source.muted {
imp.reset_source_mute
.set_icon_name("microphone-disabled-symbolic");
} else {
imp.reset_source_mute
.set_icon_name("audio-input-microphone-symbolic");
}
});
});
true
source_changed_handler(source_box, ir)
});
if res.is_err() {
println!("fail on source change event");
@ -544,21 +445,7 @@ pub fn start_input_box_listener(conn: Connection, source_box: Arc<SourceBox>) ->
}
let res = conn.add_match(output_stream_added, move |ir: OutputStreamAdded, _, _| {
let source_box = output_stream_added_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 mut list = input_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 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);
});
});
true
output_stream_added_handler(output_stream_added_box, ir)
});
if res.is_err() {
println!("fail on output stream add event");
@ -568,56 +455,7 @@ pub fn start_input_box_listener(conn: Connection, source_box: Arc<SourceBox>) ->
let res = conn.add_match(
output_stream_changed,
move |ir: OutputStreamChanged, _, _| {
let imp = output_stream_changed_box.imp();
let alias: String;
{
let source_list = imp.reset_source_list.read().unwrap();
if let Some(alias_opt) = source_list.get(&ir.stream.source_index) {
alias = alias_opt.2.clone();
} else {
alias = String::from("");
}
}
let source_box = output_stream_changed_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 entry: Arc<OutputStreamEntry>;
{
let list = input_box_imp.reset_output_stream_list.read().unwrap();
let entry_opt = list.get(&ir.stream.index);
if entry_opt.is_none() {
return;
}
entry = entry_opt.unwrap().1.clone();
}
let imp = entry.imp();
if ir.stream.muted {
imp.reset_source_mute
.set_icon_name("microphone-disabled-symbolic");
} else {
imp.reset_source_mute
.set_icon_name("audio-input-microphone-symbolic");
}
let name = ir.stream.application_name.clone() + ": " + ir.stream.name.as_str();
imp.reset_source_selection.set_title(name.as_str());
let volume = ir.stream.volume.first().unwrap_or(&0_u32);
let fraction = (*volume as f64 / 655.36).round();
let percentage = (fraction).to_string() + "%";
imp.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();
for entry in 0..*index {
if model_list.string(entry) == Some(alias.clone().into()) {
imp.reset_source_selection.set_selected(entry);
break;
}
}
});
});
true
output_stream_changed_handler(output_stream_changed_box, ir)
},
);
if res.is_err() {
@ -628,22 +466,7 @@ pub fn start_input_box_listener(conn: Connection, source_box: Arc<SourceBox>) ->
let res = conn.add_match(
output_stream_removed,
move |ir: OutputStreamRemoved, _, _| {
let source_box = output_stream_removed_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 mut list = input_box_imp.reset_output_stream_list.write().unwrap();
let entry = list.remove(&ir.index);
if entry.is_none() {
return;
}
input_box_imp
.reset_output_streams
.remove(&*entry.unwrap().0);
});
});
true
output_stream_removed_handler(output_stream_removed_box, ir)
},
);
if res.is_err() {

240
src/components/input/source_box_event_handlers.rs Normal file
View file

@ -0,0 +1,240 @@
use std::sync::Arc;
use adw::prelude::{ComboRowExt, PreferencesRowExt};
use glib::subclass::types::ObjectSubclassIsExt;
use gtk::prelude::{BoxExt, ButtonExt, CheckButtonExt, ListBoxRowExt, RangeExt};
use re_set_lib::signals::{
OutputStreamAdded, OutputStreamChanged, OutputStreamRemoved, SourceAdded, SourceChanged,
SourceRemoved,
};
use crate::components::base::list_entry::ListEntry;
use super::{
output_stream_entry::OutputStreamEntry,
source_box::{get_default_source_name, SourceBox},
source_entry::SourceEntry,
};
pub fn source_added_handler(source_box: Arc<SourceBox>, 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_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 {
is_default = true;
}
let source_entry = Arc::new(SourceEntry::new(
is_default,
input_box_imp.reset_default_check_button.clone(),
ir.source,
input_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();
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();
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);
} 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);
}
*index += 1;
}
});
});
true
}
pub fn source_removed_handler(source_box: Arc<SourceBox>, 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 entry: Option<(Arc<ListEntry>, Arc<SourceEntry>, String)>;
{
let mut list = input_box_imp.reset_source_list.write().unwrap();
entry = list.remove(&ir.index);
if entry.is_none() {
return;
}
}
input_box_imp
.reset_sources
.remove(&*entry.clone().unwrap().0);
let mut map = input_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();
if *index == 1 {
model_list.append("Monitor of Dummy Output");
}
for entry in 0..*index {
if model_list.string(entry) == Some(alias.clone().into()) {
model_list.splice(entry, 1, &[]);
break;
}
}
if *index > 1 {
*index -= 1;
}
});
});
true
}
pub fn source_changed_handler(source_box: Arc<SourceBox>, ir: SourceChanged) -> bool {
let default_source = get_default_source_name();
glib::spawn_future(async move {
glib::idle_add_once(move || {
let input_box = source_box.clone();
let input_box_imp = input_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 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
.reset_default_source
.replace(ir.source.clone());
if ir.source.muted {
input_box_imp
.reset_source_mute
.set_icon_name("microphone-disabled-symbolic");
} else {
input_box_imp
.reset_source_mute
.set_icon_name("audio-input-microphone-symbolic");
}
imp.reset_selected_source.set_active(true);
} else {
imp.reset_selected_source.set_active(false);
}
imp.reset_source_name
.set_title(ir.source.alias.clone().as_str());
imp.reset_volume_percentage.set_text(&percentage);
imp.reset_volume_slider.set_value(*volume as f64);
if ir.source.muted {
imp.reset_source_mute
.set_icon_name("microphone-disabled-symbolic");
} else {
imp.reset_source_mute
.set_icon_name("audio-input-microphone-symbolic");
}
});
});
true
}
pub fn output_stream_added_handler(source_box: Arc<SourceBox>, 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 index = ir.stream.index;
let output_stream = Arc::new(OutputStreamEntry::new(input_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);
});
});
true
}
pub fn output_stream_changed_handler(source_box: Arc<SourceBox>, ir: OutputStreamChanged) -> bool {
let imp = source_box.imp();
let alias: String;
{
let source_list = imp.reset_source_list.read().unwrap();
if let Some(alias_opt) = source_list.get(&ir.stream.source_index) {
alias = alias_opt.2.clone();
} else {
alias = String::from("");
}
}
glib::spawn_future(async move {
glib::idle_add_once(move || {
let input_box = source_box.clone();
let input_box_imp = input_box.imp();
let entry: Arc<OutputStreamEntry>;
{
let list = input_box_imp.reset_output_stream_list.read().unwrap();
let entry_opt = list.get(&ir.stream.index);
if entry_opt.is_none() {
return;
}
entry = entry_opt.unwrap().1.clone();
}
let imp = entry.imp();
if ir.stream.muted {
imp.reset_source_mute
.set_icon_name("microphone-disabled-symbolic");
} else {
imp.reset_source_mute
.set_icon_name("audio-input-microphone-symbolic");
}
let name = ir.stream.application_name.clone() + ": " + ir.stream.name.as_str();
imp.reset_source_selection.set_title(name.as_str());
let volume = ir.stream.volume.first().unwrap_or(&0_u32);
let fraction = (*volume as f64 / 655.36).round();
let percentage = (fraction).to_string() + "%";
imp.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();
for entry in 0..*index {
if model_list.string(entry) == Some(alias.clone().into()) {
imp.reset_source_selection.set_selected(entry);
break;
}
}
});
});
true
}
pub fn output_stream_removed_handler(source_box: Arc<SourceBox>, 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 entry = list.remove(&ir.index);
if entry.is_none() {
return;
}
input_box_imp
.reset_output_streams
.remove(&*entry.unwrap().0);
});
});
true
}

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

@ -120,7 +120,7 @@ pub fn populate_sinks(output_box: Arc<SinkBox>) {
}
populate_inputstreams(output_box.clone());
populate_cards(output_box.clone());
initialize(output_box, sinks);
populate_sink_information(output_box, sinks);
});
}
@ -184,7 +184,7 @@ fn mute_handler(output_box_ref_mute: Arc<SinkBox>) {
toggle_sink_mute(stream.index, stream.muted);
}
fn initialize(output_box: Arc<SinkBox>, sinks: Vec<Sink>) {
fn populate_sink_information(output_box: Arc<SinkBox>, sinks: Vec<Sink>) {
glib::spawn_future(async move {
glib::idle_add_once(move || {
let output_box_ref_select = output_box.clone();