From d56dfa505c619378b5cdffa6d681b5b4cb95b331 Mon Sep 17 00:00:00 2001 From: Fabio Lenherr / DashieTM Date: Wed, 3 Apr 2024 18:37:22 +0200 Subject: [PATCH] wip: Work on generic audio listener --- .../audio/generic_audio_box_handlers.rs | 590 ++++++++++++++++++ .../audio/generic_audio_box_utils.rs | 437 +++++++++++++ .../audio/generic_audio_object_entry_utils.rs | 0 .../audio/generic_audio_stream_utils.rs | 0 src/components/audio/input/mod.rs | 1 - src/components/audio/input/source_box.rs | 113 ++-- .../audio/input/source_box_handlers.rs | 81 +-- src/components/audio/input/source_box_impl.rs | 7 +- .../audio/input/source_box_utils.rs | 185 ------ src/components/audio/mod.rs | 4 + src/components/audio/output/sink_box.rs | 50 +- src/components/audio/output/sink_box_impl.rs | 7 +- src/resources/resetAudioInput.ui | 6 +- src/resources/resetAudioOutput.ui | 6 +- src/resources/resetBluetooth.ui | 2 +- src/resources/resetBluetoothEntry.ui | 2 +- src/resources/resetCardEntry.ui | 2 +- src/resources/resetError.ui | 2 +- src/resources/resetInputStreamEntry.ui | 2 +- src/resources/resetListBoxRow.ui | 2 +- src/resources/resetMainWindow.ui | 6 +- src/resources/resetOutputStreamEntry.ui | 2 +- src/resources/resetPopup.ui | 2 +- src/resources/resetSavedWifiEntry.ui | 2 +- src/resources/resetSettingBox.ui | 2 +- src/resources/resetShortcuts.ui | 2 +- src/resources/resetSidebarEntry.ui | 2 +- src/resources/resetSinkEntry.ui | 2 +- src/resources/resetSourceEntry.ui | 2 +- src/resources/resetUI.cmb | 576 ++++++++--------- src/resources/resetWiFi.ui | 2 +- src/resources/resetWifiAddressEntry.ui | 2 +- src/resources/resetWifiEntry.ui | 2 +- src/resources/resetWifiOptions.ui | 2 +- src/resources/resetWifiRouteEntry.ui | 2 +- 35 files changed, 1410 insertions(+), 697 deletions(-) create mode 100644 src/components/audio/generic_audio_box_handlers.rs create mode 100644 src/components/audio/generic_audio_box_utils.rs create mode 100644 src/components/audio/generic_audio_object_entry_utils.rs create mode 100644 src/components/audio/generic_audio_stream_utils.rs delete mode 100644 src/components/audio/input/source_box_utils.rs diff --git a/src/components/audio/generic_audio_box_handlers.rs b/src/components/audio/generic_audio_box_handlers.rs new file mode 100644 index 0000000..b5aad71 --- /dev/null +++ b/src/components/audio/generic_audio_box_handlers.rs @@ -0,0 +1,590 @@ +use std::{ + sync::Arc, + time::{Duration, SystemTime}, +}; + +use adw::traits::{ComboRowExt, PreferencesRowExt}; +use dbus::arg::{Arg, Get}; +use glib::{ + object::{Cast, IsA}, + ControlFlow, Propagation, +}; +use gtk::{ + gio, + prelude::{BoxExt, ButtonExt, CheckButtonExt, ListBoxRowExt, RangeExt}, + StringObject, +}; +use re_set_lib::{ + audio::audio_structures::{TAudioObject, TAudioStreamObject}, + signals::{TAudioEventRemoved, TAudioObjectEvent, TAudioStreamEvent}, +}; + +use crate::components::base::{error_impl::ReSetErrorImpl, list_entry::ListEntry}; + +use super::{ + generic_audio_box_utils::{ + populate_audio_object_information, populate_cards, populate_streams, + refresh_default_audio_object, + }, + generic_audio_functions::new_stream_entry, + generic_entry::{ + new_entry, DBusFunction, TAudioBox, TAudioBoxImpl, TAudioEntry, TAudioEntryImpl, + TAudioStream, TAudioStreamImpl, + }, + generic_utils::audio_dbus_call, +}; + +pub fn mute_clicked_handler< + AudioObject: TAudioObject, + StreamObject: TAudioStreamObject, + AudioEntry: TAudioEntry, + AudioEntryImpl: TAudioEntryImpl, + AudioStream: TAudioStream, + AudioStreamImpl: TAudioStreamImpl, + AudioBox: TAudioBox + ReSetErrorImpl + 'static, + AudioBoxImpl: TAudioBoxImpl, +>( + audio_box: Arc, + function: &'static DBusFunction, +) { + let imp = audio_box.box_imp(); + let source = imp.default_audio_object(); + let mut source = source.borrow_mut(); + source.toggle_muted(); + let icons = imp.icons(); + let mute_button = imp.audio_object_mute(); + if source.muted() { + mute_button.set_icon_name(icons.muted); + } else { + mute_button.set_icon_name(icons.active); + } + audio_dbus_call::( + audio_box.clone(), + (source.index(), source.muted()), + function, + ); +} + +pub fn volume_slider_handler< + AudioObject: TAudioObject, + StreamObject: TAudioStreamObject, + AudioEntry: TAudioEntry, + AudioEntryImpl: TAudioEntryImpl, + AudioStream: TAudioStream, + AudioStreamImpl: TAudioStreamImpl, + AudioBox: TAudioBox + ReSetErrorImpl + 'static, + AudioBoxImpl: TAudioBoxImpl, +>( + audio_box: Arc, + value: f64, + function: &'static DBusFunction, +) -> Propagation { + let imp = audio_box.box_imp(); + let fraction = (value / 655.36).round(); + let percentage = (fraction).to_string() + "%"; + imp.volume_percentage().set_text(&percentage); + let source = imp.default_audio_object(); + let source = 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()); + } + audio_dbus_call::( + audio_box.clone(), + (index, channels, value as u32), + function, + ); + Propagation::Proceed +} + +pub fn dropdown_handler< + AudioObject: TAudioObject + Send + Sync, + StreamObject: TAudioStreamObject + Send + Sync, + AudioEntry: TAudioEntry, + AudioEntryImpl: TAudioEntryImpl, + AudioStream: TAudioStream + IsA, + AudioStreamImpl: TAudioStreamImpl, + AudioBox: TAudioBox + ReSetErrorImpl + 'static, + AudioBoxImpl: TAudioBoxImpl, +>( + audio_box: Arc, + dropdown: &adw::ComboRow, + function: &'static DBusFunction, +) -> ControlFlow { + let source_box_imp = audio_box.box_imp(); + let source_box_ref = audio_box.clone(); + let selected = dropdown.selected_item(); + if selected.is_none() { + return ControlFlow::Break; + } + let selected = selected.unwrap(); + let selected = selected.downcast_ref::().unwrap(); + let selected = selected.string().to_string(); + let source_map = source_box_imp.source_map(); + let source_map = source_map.read().unwrap(); + let source = source_map.get(&selected); + if source.is_none() { + return ControlFlow::Break; + } + let source = Arc::new(source.unwrap().1.clone()); + gio::spawn_blocking(move || { + let result = audio_dbus_call::( + source_box_ref.clone(), + (&source,), + function, + ); + if result.is_none() { + return ControlFlow::Break; + } + refresh_default_audio_object::< + AudioObject, + StreamObject, + AudioEntry, + AudioEntryImpl, + AudioStream, + AudioStreamImpl, + AudioBox, + AudioBoxImpl, + >(result.unwrap().0, source_box_ref.clone(), false); + ControlFlow::Continue + }); + ControlFlow::Continue +} + +pub fn populate_audio_objects< + AudioObject: TAudioObject + Arg + for<'z> Get<'z> + Send + Sync + 'static, + StreamObject: TAudioStreamObject + Send + Sync + for<'z> Get<'z> + Arg + 'static, + AudioEntry: TAudioEntry + IsA, + AudioEntryImpl: TAudioEntryImpl, + AudioStream: TAudioStream + IsA, + AudioStreamImpl: TAudioStreamImpl, + AudioBox: TAudioBox + ReSetErrorImpl + 'static, + AudioBoxImpl: TAudioBoxImpl, +>( + audio_box: Arc, + audio_objects_function: &'static DBusFunction, + default_audio_object_function: &'static DBusFunction, + set_default_audio_object_function: &'static DBusFunction, + get_audio_streams_function: &'static DBusFunction, + set_audio_object_mute_function: &'static DBusFunction, + set_audio_object_volume_function: &'static DBusFunction, +) { + gio::spawn_blocking(move || { + let sources = audio_dbus_call::,), ()>( + audio_box.clone(), + (), + audio_objects_function, + ); + if sources.is_none() { + return; + } + let audio_objects = sources.unwrap().0; + { + let imp = audio_box.box_imp(); + let list = imp.model_list(); + let list = list.write().unwrap(); + let map = imp.source_map(); + let mut map = map.write().unwrap(); + let model_index = imp.model_index(); + let mut model_index = model_index.write().unwrap(); + + let audio_object = audio_dbus_call::( + audio_box.clone(), + (), + default_audio_object_function, + ); + if let Some(audio_object) = audio_object { + imp.default_audio_object().replace(audio_object.0); + } + + for audio_object in audio_objects.iter() { + let alias = audio_object.alias(); + list.append(&alias); + map.insert( + alias.clone(), + (audio_object.index(), audio_object.name().clone()), + ); + *model_index += 1; + } + } + populate_streams::< + AudioObject, + StreamObject, + AudioEntry, + AudioEntryImpl, + AudioStream, + AudioStreamImpl, + AudioBox, + AudioBoxImpl, + >(audio_box.clone(), get_audio_streams_function); + populate_cards::< + AudioObject, + StreamObject, + AudioEntry, + AudioEntryImpl, + AudioStream, + AudioStreamImpl, + AudioBox, + AudioBoxImpl, + >(audio_box.clone()); + populate_audio_object_information::< + AudioObject, + StreamObject, + AudioEntry, + AudioEntryImpl, + AudioStream, + AudioStreamImpl, + AudioBox, + AudioBoxImpl, + >( + audio_box, + audio_objects, + set_default_audio_object_function, + set_audio_object_volume_function, + set_audio_object_mute_function, + ); + }); +} + +pub fn object_added_handler< + AudioObject: TAudioObject, + StreamObject: TAudioStreamObject, + AudioEntry: TAudioEntry + IsA, + AudioEntryImpl: TAudioEntryImpl, + AudioStream: TAudioStream + IsA, + AudioStreamImpl: TAudioStreamImpl, + AudioBox: TAudioBox + ReSetErrorImpl + 'static, + AudioBoxImpl: TAudioBoxImpl, + Event: TAudioObjectEvent, +>( + audio_box: Arc, + ir: Event, +) -> bool { + glib::spawn_future(async move { + glib::idle_add_once(move || { + let audio_box = audio_box.clone(); + let source_box_imp = audio_box.box_imp(); + let object = ir.object_ref(); + let object_index = object.index(); + let alias = object.alias().clone(); + let name = object.name().clone(); + let mut is_default = false; + if source_box_imp.default_audio_object().borrow().name() == object.name() { + is_default = true; + } + let source_entry = new_entry::< + AudioObject, + StreamObject, + AudioEntry, + AudioEntryImpl, + AudioStream, + AudioStreamImpl, + AudioBox, + AudioBoxImpl, + >( + is_default, + source_box_imp.default_check_button().clone(), + ir.object(), + audio_box.clone(), + ); + let source_clone = source_entry.clone(); + let entry = Arc::new(ListEntry::new(&*source_entry)); + entry.set_activatable(false); + let list = source_box_imp.audio_object_list(); + let mut list = list.write().unwrap(); + list.insert(object_index, (entry.clone(), source_clone, alias.clone())); + source_box_imp.audio_objects().append(&*entry); + let map = source_box_imp.source_map(); + let mut map = map.write().unwrap(); + let index = source_box_imp.model_index(); + let mut index = index.write().unwrap(); + let model_list = source_box_imp.model_list(); + let model_list = model_list.write().unwrap(); + // TODO: make this work generic! + if model_list.string(*index - 1) == Some("Monitor of Dummy Output".into()) { + model_list.append(&alias); + model_list.remove(*index - 1); + map.insert(alias, (object_index, name)); + source_box_imp.audio_object_dropdown().set_selected(0); + } else { + model_list.append(&alias); + map.insert(alias.clone(), (object_index, name)); + // TODO: make this work generic! + if alias == "Monitor of Dummy Output" { + source_box_imp.audio_object_dropdown().set_selected(0); + } + *index += 1; + } + }); + }); + true +} + +pub fn object_changed_handler< + AudioObject: TAudioObject, + StreamObject: TAudioStreamObject, + AudioEntry: TAudioEntry + IsA, + AudioEntryImpl: TAudioEntryImpl, + AudioStream: TAudioStream + IsA, + AudioStreamImpl: TAudioStreamImpl, + AudioBox: TAudioBox + ReSetErrorImpl + 'static, + AudioBoxImpl: TAudioBoxImpl, + Event: TAudioObjectEvent, +>( + audio_box: Arc, + ir: Event, + function: &'static DBusFunction, +) -> bool { + let source = audio_dbus_call::(audio_box.clone(), (), function); + if source.is_none() { + return false; + } + let default_source = source.unwrap().0; + glib::spawn_future(async move { + glib::idle_add_once(move || { + let audio_box = audio_box.clone(); + let box_imp = audio_box.box_imp(); + let object = ir.object_ref(); + let is_default = object.name() == default_source; + let volume = object.volume(); + let volume = volume.first().unwrap_or(&0_u32); + let fraction = (*volume as f64 / 655.36).round(); + let percentage = (fraction).to_string() + "%"; + + let list = box_imp.audio_object_list(); + let list = list.read().unwrap(); + let entry = list.get(&object.index()); + if entry.is_none() { + return; + } + let imp = entry.unwrap().1.entry_imp(); + if is_default { + box_imp.volume_percentage().set_text(&percentage); + box_imp.volume_slider().set_value(*volume as f64); + box_imp.default_audio_object().replace(ir.object()); + let icons = imp.icons(); + let mute_button = imp.mute(); + if object.muted() { + mute_button.set_icon_name(icons.muted); + } else { + mute_button.set_icon_name(icons.active); + } + imp.selected_audio_object().set_active(true); + } else { + imp.selected_audio_object().set_active(false); + } + imp.name().set_title(object.alias().as_str()); + imp.volume_percentage().set_text(&percentage); + imp.volume_slider().set_value(*volume as f64); + let mute_button = imp.mute(); + let icons = imp.icons(); + if object.muted() { + mute_button.set_icon_name(icons.muted); + } else { + mute_button.set_icon_name(icons.active); + } + }); + }); + true +} + +pub fn object_removed_handler< + AudioObject: TAudioObject, + StreamObject: TAudioStreamObject, + AudioEntry: TAudioEntry + IsA, + AudioEntryImpl: TAudioEntryImpl, + AudioStream: TAudioStream + IsA, + AudioStreamImpl: TAudioStreamImpl, + AudioBox: TAudioBox + ReSetErrorImpl + 'static, + AudioBoxImpl: TAudioBoxImpl, + Event: TAudioEventRemoved, +>( + audio_box: Arc, + ir: Event, +) -> bool { + glib::spawn_future(async move { + glib::idle_add_once(move || { + let audio_box = audio_box.clone(); + let box_imp = audio_box.box_imp(); + let entry: Option<(Arc, Arc, String)>; + { + let list = box_imp.audio_object_list(); + let mut list = list.write().unwrap(); + entry = list.remove(&ir.index()); + if entry.is_none() { + return; + } + } + box_imp.audio_objects().remove(&*entry.clone().unwrap().0); + let map = box_imp.source_map(); + let mut map = map.write().unwrap(); + let alias = entry.unwrap().2; + map.remove(&alias); + let index = box_imp.model_index(); + let mut index = index.write().unwrap(); + let model_list = box_imp.model_list(); + let model_list = model_list.write().unwrap(); + + if *index == 1 { + // TODO: ensure dummy output and input are mentioned + model_list.append("Dummy"); + } + 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 output_stream_added_handler< + AudioObject: TAudioObject, + StreamObject: TAudioStreamObject, + AudioEntry: TAudioEntry + IsA, + AudioEntryImpl: TAudioEntryImpl, + AudioStream: TAudioStream + IsA, + AudioStreamImpl: TAudioStreamImpl, + AudioBox: TAudioBox + ReSetErrorImpl + 'static, + AudioBoxImpl: TAudioBoxImpl, + Event: TAudioStreamEvent, +>( + audio_box: Arc, + ir: Event, +) -> bool { + glib::spawn_future(async move { + glib::idle_add_once(move || { + let audio_box = audio_box.clone(); + let imp = audio_box.box_imp(); + let mut list = imp.audio_object_stream_list(); + let mut list = list.write().unwrap(); + let index = ir.stream_ref().index(); + let stream = new_stream_entry::< + AudioObject, + StreamObject, + AudioEntry, + AudioEntryImpl, + AudioStream, + AudioStreamImpl, + AudioBox, + AudioBoxImpl, + >(audio_box.clone(), ir.stream()); + let entry = Arc::new(ListEntry::new(&*stream)); + entry.set_activatable(false); + list.insert(index, (entry.clone(), stream.clone())); + imp.audio_object_streams().append(&*entry); + }); + }); + true +} + +pub fn audio_stream_changed_handler< + AudioObject: TAudioObject, + StreamObject: TAudioStreamObject, + AudioEntry: TAudioEntry + IsA, + AudioEntryImpl: TAudioEntryImpl, + AudioStream: TAudioStream + IsA, + AudioStreamImpl: TAudioStreamImpl, + AudioBox: TAudioBox + ReSetErrorImpl + 'static, + AudioBoxImpl: TAudioBoxImpl, + Event: TAudioStreamEvent, +>( + audio_box: Arc, + ir: Event, +) -> bool { + let imp = audio_box.box_imp(); + let alias: String; + { + let stream = ir.stream_ref(); + let object_list = imp.audio_object_list(); + let object_list = object_list.read().unwrap(); + if let Some(alias_opt) = object_list.get(&stream.audio_object_index()) { + alias = alias_opt.2.clone(); + } else { + alias = String::from(""); + } + } + glib::spawn_future(async move { + glib::idle_add_once(move || { + let audio_box = audio_box.clone(); + let box_imp = audio_box.box_imp(); + let entry: Arc; + let stream = ir.stream_ref(); + { + let list = box_imp.audio_object_stream_list(); + let list = list.read().unwrap(); + let entry_opt = list.get(&stream.index()); + if entry_opt.is_none() { + return; + } + entry = entry_opt.unwrap().1.clone(); + } + let imp = entry.entry_imp(); + let mute_button = imp.audio_object_mute(); + let icons = imp.icons(); + if stream.muted() { + mute_button.set_icon_name(icons.muted); + } else { + mute_button.set_icon_name(icons.active); + } + let name = stream.application_name().clone() + ": " + stream.name().as_str(); + imp.audio_object_selection().set_title(name.as_str()); + let volume = stream.volume(); + let volume = volume.first().unwrap_or(&0_u32); + let fraction = (*volume as f64 / 655.36).round(); + let percentage = (fraction).to_string() + "%"; + imp.volume_percentage().set_text(&percentage); + imp.volume_slider().set_value(*volume as f64); + let index = box_imp.model_index(); + let index = index.read().unwrap(); + let model_list = box_imp.model_list(); + let model_list = model_list.read().unwrap(); + for entry in 0..*index { + if model_list.string(entry) == Some(alias.clone().into()) { + imp.audio_object_selection().set_selected(entry); + break; + } + } + }); + }); + true +} + +pub fn audio_stream_removed_handler< + AudioObject: TAudioObject, + StreamObject: TAudioStreamObject, + AudioEntry: TAudioEntry + IsA, + AudioEntryImpl: TAudioEntryImpl, + AudioStream: TAudioStream + IsA, + AudioStreamImpl: TAudioStreamImpl, + AudioBox: TAudioBox + ReSetErrorImpl + 'static, + AudioBoxImpl: TAudioBoxImpl, + Event: TAudioEventRemoved, +>( + audio_box: Arc, + ir: Event, +) -> bool { + glib::spawn_future(async move { + glib::idle_add_once(move || { + let imp = audio_box.box_imp(); + let list = imp.audio_object_stream_list(); + let mut list = list.write().unwrap(); + let entry = list.remove(&ir.index()); + if entry.is_none() { + return; + } + imp.audio_object_streams().remove(&*entry.unwrap().0); + }); + }); + true +} diff --git a/src/components/audio/generic_audio_box_utils.rs b/src/components/audio/generic_audio_box_utils.rs new file mode 100644 index 0000000..e131eac --- /dev/null +++ b/src/components/audio/generic_audio_box_utils.rs @@ -0,0 +1,437 @@ +use std::sync::Arc; + +use adw::{prelude::ComboRowExt, prelude::PreferencesGroupExt}; +use dbus::{ + arg::{Arg, Get, ReadAll}, + blocking::Connection, + message::SignalArgs, + Path, +}; +use glib::{object::IsA, Variant}; +use gtk::{ + gio, + prelude::{ActionableExt, BoxExt, ButtonExt, CheckButtonExt, ListBoxRowExt, RangeExt}, +}; +use re_set_lib::{ + audio::audio_structures::{Card, TAudioObject, TAudioStreamObject}, + signals::{TAudioEventRemoved, TAudioObjectEvent, TAudioStreamEvent}, +}; + +use crate::components::{ + base::{card_entry::CardEntry, error_impl::ReSetErrorImpl, list_entry::ListEntry}, + utils::{create_dropdown_label_factory, set_combo_row_ellipsis, BASE, DBUS_PATH}, +}; + +use super::{ + generic_audio_box_handlers::{ + dropdown_handler, mute_clicked_handler, object_added_handler, object_changed_handler, + object_removed_handler, volume_slider_handler, + }, + generic_audio_functions::new_stream_entry, + generic_const::GETCARDS, + generic_entry::{ + new_entry, DBusFunction, TAudioBox, TAudioBoxImpl, TAudioEntry, TAudioEntryImpl, + TAudioStream, TAudioStreamImpl, + }, + generic_utils::audio_dbus_call, +}; + +pub fn setup_audio_box_callbacks< + AudioObject: TAudioObject, + StreamObject: TAudioStreamObject, + AudioEntry: TAudioEntry, + AudioEntryImpl: TAudioEntryImpl, + AudioStream: TAudioStream, + AudioStreamImpl: TAudioStreamImpl, + AudioBox: TAudioBox, + AudioBoxImpl: TAudioBoxImpl, +>( + audio_box: &mut AudioBox, +) { + let imp = audio_box.box_imp(); + let object_row = imp.audio_object_row(); + object_row.set_activatable(true); + object_row.set_action_name(Some("navigation.push")); + object_row.set_action_target_value(Some(&Variant::from("devices"))); + + let cards_row = imp.cards_row(); + cards_row.set_activatable(true); + cards_row.set_action_name(Some("navigation.push")); + cards_row.set_action_target_value(Some(&Variant::from("profileConfiguration"))); + + let stream_button = imp.audio_object_stream_button(); + stream_button.set_activatable(true); + stream_button.set_action_name(Some("navigation.pop")); + + let cards_back_button = imp.cards_button(); + cards_back_button.set_activatable(true); + cards_back_button.set_action_name(Some("navigation.pop")); + + let audio_object_dropdown = imp.audio_object_dropdown(); + audio_object_dropdown.set_factory(Some(&create_dropdown_label_factory())); + set_combo_row_ellipsis(audio_object_dropdown.get()); +} + +pub fn populate_cards< + AudioObject: TAudioObject, + StreamObject: TAudioStreamObject, + AudioEntry: TAudioEntry, + AudioEntryImpl: TAudioEntryImpl, + AudioStream: TAudioStream, + AudioStreamImpl: TAudioStreamImpl, + AudioBox: TAudioBox + ReSetErrorImpl + 'static, + AudioBoxImpl: TAudioBoxImpl, +>( + source_box: Arc, +) { + gio::spawn_blocking(move || { + let source_box_ref = source_box.clone(); + let cards = + audio_dbus_call::,), ()>(source_box.clone(), (), &GETCARDS); + if cards.is_none() { + return; + } + let cards = cards.unwrap().0; + glib::spawn_future(async move { + glib::idle_add_once(move || { + let imp = source_box_ref.box_imp(); + for card in cards { + imp.cards().add(&CardEntry::new(card)); + } + }); + }); + }); +} + +pub fn populate_streams< + AudioObject: TAudioObject + Sync + Send + 'static, + StreamObject: TAudioStreamObject + Arg + for<'z> Get<'z> + Sync + Send + 'static, + AudioEntry: TAudioEntry, + AudioEntryImpl: TAudioEntryImpl, + AudioStream: TAudioStream + IsA, + AudioStreamImpl: TAudioStreamImpl, + AudioBox: TAudioBox + ReSetErrorImpl + 'static, + AudioBoxImpl: TAudioBoxImpl, +>( + audio_box: Arc, + function: &'static DBusFunction, +) { + let audio_box_ref = audio_box.clone(); + gio::spawn_blocking(move || { + let streams = + audio_dbus_call::,), ()>(audio_box.clone(), (), function); + if streams.is_none() { + return; + } + let streams = streams.unwrap().0; + glib::spawn_future(async move { + glib::idle_add_once(move || { + let imp = audio_box_ref.box_imp(); + let mut list = imp.audio_object_stream_list().write().unwrap(); + for stream in streams { + let index = stream.index(); + let stream = new_stream_entry::< + AudioObject, + StreamObject, + AudioEntry, + AudioEntryImpl, + AudioStream, + AudioStreamImpl, + AudioBox, + AudioBoxImpl, + >(audio_box.clone(), stream); + let stream_clone = stream.clone(); + let entry = Arc::new(ListEntry::new(&*stream)); + entry.set_activatable(false); + list.insert(index, (entry.clone(), stream_clone)); + imp.audio_object_streams().append(&*entry); + } + }); + }); + }); +} + +pub fn refresh_default_audio_object< + AudioObject: TAudioObject + Sync + Send + 'static, + StreamObject: TAudioStreamObject + Arg + for<'z> Get<'z> + Sync + Send + 'static, + AudioEntry: TAudioEntry, + AudioEntryImpl: TAudioEntryImpl, + AudioStream: TAudioStream + IsA, + AudioStreamImpl: TAudioStreamImpl, + AudioBox: TAudioBox + ReSetErrorImpl + 'static, + AudioBoxImpl: TAudioBoxImpl, +>( + new_audio_object: AudioObject, + audio_box: Arc, + entry: bool, +) { + let volume = *new_audio_object.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 = audio_box.box_imp(); + if !entry { + let list = imp.audio_object_list().read().unwrap(); + let entry = list.get(&new_audio_object.index()); + if entry.is_none() { + return; + } + let entry_imp = entry.unwrap().1.entry_imp(); + entry_imp.selected_audio_object().set_active(true); + } else { + let model_list = imp.model_list(); + let model_list = model_list.read().unwrap(); + for entry in 0..*imp.model_index().read().unwrap() { + if model_list.string(entry) == Some(new_audio_object.alias().clone().into()) { + imp.audio_object_dropdown().set_selected(entry); + break; + } + } + } + imp.volume_percentage().set_text(&percentage); + imp.volume_slider().set_value(volume as f64); + let icons = imp.icons(); + let mute_button = imp.audio_object_mute(); + if new_audio_object.muted() { + mute_button.set_icon_name(icons.muted); + } else { + mute_button.set_icon_name(icons.active); + } + imp.default_audio_object().replace(new_audio_object); + }); + }); +} + +pub fn populate_audio_object_information< + AudioObject: TAudioObject + Sync + Send + 'static + Arg + for<'z> Get<'z>, + StreamObject: TAudioStreamObject + Arg + for<'z> Get<'z> + Sync + Send + 'static, + AudioEntry: TAudioEntry + IsA, + AudioEntryImpl: TAudioEntryImpl, + AudioStream: TAudioStream + IsA, + AudioStreamImpl: TAudioStreamImpl, + AudioBox: TAudioBox + ReSetErrorImpl + 'static, + AudioBoxImpl: TAudioBoxImpl, +>( + audio_box: Arc, + audio_objects: Vec, + dropdown_function: &'static DBusFunction, + change_volume_function: &'static DBusFunction, + mute_function: &'static DBusFunction, +) { + glib::spawn_future(async move { + glib::idle_add_once(move || { + let source_box_ref_slider = audio_box.clone(); + let source_box_ref_toggle = audio_box.clone(); + let source_box_ref_mute = audio_box.clone(); + let imp = audio_box.box_imp(); + let default_sink = imp.default_audio_object().clone(); + let source = default_sink.borrow(); + + let icons = imp.icons(); + let mute_button = imp.audio_object_mute(); + if source.muted() { + mute_button.set_icon_name(icons.muted); + } else { + mute_button.set_icon_name(icons.active); + } + + let volume = source.volume(); + let volume = volume.first().unwrap_or(&0_u32); + let fraction = (*volume as f64 / 655.36).round(); + let percentage = (fraction).to_string() + "%"; + imp.volume_percentage().set_text(&percentage); + imp.volume_slider().set_value(*volume as f64); + let list = imp.audio_object_list(); + let mut list = list.write().unwrap(); + for source in audio_objects { + let index = source.index(); + let alias = source.alias().clone(); + let mut is_default = false; + if imp.default_audio_object().borrow().name() == source.name() { + is_default = true; + } + let source_entry = new_entry::< + AudioObject, + StreamObject, + AudioEntry, + AudioEntryImpl, + AudioStream, + AudioStreamImpl, + AudioBox, + AudioBoxImpl, + >( + is_default, + imp.default_check_button().clone(), + source, + audio_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)); + imp.audio_objects().append(&*entry); + } + let list = imp.model_list(); + let list = list.read().unwrap(); + imp.audio_object_dropdown().set_model(Some(&*list)); + let name = imp.default_audio_object(); + let name = name.borrow(); + + let index = imp.model_index(); + let index = index.read().unwrap(); + let model_list = imp.model_list(); + let model_list = model_list.read().unwrap(); + for entry in 0..*index { + if model_list.string(entry) == Some(name.alias().clone().into()) { + imp.audio_object_dropdown().set_selected(entry); + break; + } + } + imp.audio_object_dropdown() + .connect_selected_notify(move |dropdown| { + dropdown_handler(source_box_ref_toggle.clone(), dropdown, dropdown_function); + }); + imp.volume_slider() + .connect_change_value(move |_, _, value| { + volume_slider_handler( + source_box_ref_slider.clone(), + value, + change_volume_function, + ) + }); + + imp.audio_object_mute().connect_clicked(move |_| { + mute_clicked_handler(source_box_ref_mute.clone(), mute_function); + }); + }); + }); +} + +pub fn start_source_box_listener< + AudioObject: TAudioObject, + StreamObject: TAudioStreamObject, + AudioEntry: TAudioEntry + IsA, + AudioEntryImpl: TAudioEntryImpl, + AudioStream: TAudioStream + IsA, + AudioStreamImpl: TAudioStreamImpl, + AudioBox: TAudioBox + ReSetErrorImpl + 'static, + AudioBoxImpl: TAudioBoxImpl, + ObjectAdded: TAudioObjectEvent + ReadAll + SignalArgs, + ObjectChanged: TAudioObjectEvent + ReadAll + SignalArgs, + ObjectRemoved: TAudioEventRemoved + ReadAll + SignalArgs, + StreamAdded: TAudioStreamEvent + ReadAll + SignalArgs, + StreamChanged: TAudioStreamEvent + ReadAll + SignalArgs, + StreamRemoved: TAudioEventRemoved + ReadAll + SignalArgs, +>( + conn: Connection, + source_box: Arc, + get_default_name_function: &'static DBusFunction, +) -> Connection { + // TODO: make the failed logs generically sound -> deynamic output for both + let object_added = + ObjectAdded::match_rule(Some(&BASE.into()), Some(&Path::from(DBUS_PATH))).static_clone(); + let object_changed = + ObjectChanged::match_rule(Some(&BASE.into()), Some(&Path::from(DBUS_PATH))).static_clone(); + let object_removed = + ObjectRemoved::match_rule(Some(&BASE.into()), Some(&Path::from(DBUS_PATH))).static_clone(); + let stream_added = + StreamAdded::match_rule(Some(&BASE.into()), Some(&Path::from(DBUS_PATH))).static_clone(); + let stream_changed = + StreamChanged::match_rule(Some(&BASE.into()), Some(&Path::from(DBUS_PATH))).static_clone(); + let stream_removed = + StreamRemoved::match_rule(Some(&BASE.into()), Some(&Path::from(DBUS_PATH))).static_clone(); + + let object_added_box = source_box.clone(); + let object_removed_box = source_box.clone(); + let object_changed_box = source_box.clone(); + let stream_added_box = source_box.clone(); + let stream_removed_box = source_box.clone(); + let stream_changed_box = source_box.clone(); + + let res = conn.add_match(object_added, move |ir: ObjectAdded, _, _| { + object_added_handler::< + AudioObject, + StreamObject, + AudioEntry, + AudioEntryImpl, + AudioStream, + AudioStreamImpl, + AudioBox, + AudioBoxImpl, + ObjectAdded, + >(object_added_box.clone(), 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(object_changed, move |ir: ObjectChanged, _, _| { + // source_changed_handler(source_changed_box.clone(), ir) + object_changed_handler::< + AudioObject, + StreamObject, + AudioEntry, + AudioEntryImpl, + AudioStream, + AudioStreamImpl, + AudioBox, + AudioBoxImpl, + ObjectChanged, + >(object_changed_box.clone(), ir, get_default_name_function) + }); + if res.is_err() { + println!("fail on source change event"); + return conn; + } + + let res = conn.add_match(object_removed, move |ir: ObjectRemoved, _, _| { + // source_removed_handler(source_removed_box.clone(), ir) + object_removed_handler::< + AudioObject, + StreamObject, + AudioEntry, + AudioEntryImpl, + AudioStream, + AudioStreamImpl, + AudioBox, + AudioBoxImpl, + ObjectRemoved, + >(object_removed_box.clone(), ir) + }); + if res.is_err() { + println!("fail on source remove event"); + return conn; + } + + let res = conn.add_match(stream_added, move |ir: StreamAdded, _, _| { + // output_stream_added_handler(output_stream_added_box.clone(), ir) + true + }); + if res.is_err() { + println!("fail on output stream add event"); + return conn; + } + + let res = conn.add_match(stream_changed, move |ir: StreamChanged, _, _| { + // output_stream_changed_handler(output_stream_changed_box.clone(), ir) + true + }); + if res.is_err() { + println!("fail on output stream change event"); + return conn; + } + + let res = conn.add_match(stream_removed, move |ir: StreamRemoved, _, _| { + // output_stream_removed_handler(output_stream_removed_box.clone(), ir) + true + }); + if res.is_err() { + println!("fail on output stream remove event"); + return conn; + } + + conn +} diff --git a/src/components/audio/generic_audio_object_entry_utils.rs b/src/components/audio/generic_audio_object_entry_utils.rs new file mode 100644 index 0000000..e69de29 diff --git a/src/components/audio/generic_audio_stream_utils.rs b/src/components/audio/generic_audio_stream_utils.rs new file mode 100644 index 0000000..e69de29 diff --git a/src/components/audio/input/mod.rs b/src/components/audio/input/mod.rs index 6c76eca..f3e5775 100644 --- a/src/components/audio/input/mod.rs +++ b/src/components/audio/input/mod.rs @@ -3,7 +3,6 @@ pub mod output_stream_entry_impl; pub mod source_box; mod source_box_handlers; pub mod source_box_impl; -mod source_box_utils; mod source_const; pub mod source_entry; pub mod source_entry_impl; diff --git a/src/components/audio/input/source_box.rs b/src/components/audio/input/source_box.rs index 76cb007..2fa4673 100644 --- a/src/components/audio/input/source_box.rs +++ b/src/components/audio/input/source_box.rs @@ -1,4 +1,4 @@ -use re_set_lib::audio::audio_structures::Source; +use re_set_lib::audio::audio_structures::{OutputStream, Source}; use re_set_lib::signals::{ OutputStreamAdded, OutputStreamChanged, OutputStreamRemoved, SourceAdded, SourceChanged, SourceRemoved, @@ -6,32 +6,30 @@ use re_set_lib::signals::{ use std::sync::Arc; use adw::glib::Object; -use adw::prelude::{ComboRowExt, ListBoxRowExt}; use dbus::blocking::Connection; use dbus::message::SignalArgs; use dbus::Path; use glib::subclass::prelude::ObjectSubclassIsExt; -use glib::Variant; use gtk::gio; -use gtk::prelude::ActionableExt; +use crate::components::audio::generic_audio_box_handlers::populate_audio_objects; +use crate::components::audio::generic_audio_box_utils::{ + populate_audio_object_information, populate_cards, populate_streams, setup_audio_box_callbacks, +}; use crate::components::audio::generic_entry::TAudioBox; use crate::components::audio::generic_utils::audio_dbus_call; use crate::components::audio::input::source_box_impl; use crate::components::base::error::{self}; use crate::components::base::error_impl::ReSetErrorImpl; -use crate::components::utils::{ - create_dropdown_label_factory, set_combo_row_ellipsis, BASE, DBUS_PATH, -}; +use crate::components::utils::{BASE, DBUS_PATH}; +use super::output_stream_entry::OutputStreamEntry; use super::source_box_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_box_utils::{ - populate_cards, populate_outputstreams, populate_source_information, -}; -use super::source_const::{GETDEFAULT, GETOBJECTS}; +use super::source_const::{GETDEFAULT, GETOBJECTS, GETSTREAMS, SETDEFAULT, SETMUTE, SETVOLUME}; +use super::source_entry::SourceEntry; glib::wrapper! { pub struct SourceBox(ObjectSubclass) @@ -56,7 +54,17 @@ impl TAudioBox for SourceBox { impl SourceBox { pub fn new() -> Self { - let obj: Self = Object::builder().build(); + let mut obj: Self = Object::builder().build(); + setup_audio_box_callbacks::< + Source, + OutputStream, + SourceEntry, + super::source_entry_impl::SourceEntry, + OutputStreamEntry, + super::output_stream_entry_impl::OutputStreamEntry, + SourceBox, + super::source_box_impl::SourceBox, + >(&mut obj); { let imp = obj.imp(); let mut model_index = imp.reset_model_index.write().unwrap(); @@ -64,39 +72,6 @@ impl SourceBox { } obj } - - pub fn setup_callbacks(&self) { - let self_imp = self.imp(); - self_imp.reset_source_row.set_activatable(true); - self_imp - .reset_source_row - .set_action_name(Some("navigation.push")); - self_imp - .reset_source_row - .set_action_target_value(Some(&Variant::from("sources"))); - self_imp.reset_cards_row.set_activatable(true); - self_imp - .reset_cards_row - .set_action_name(Some("navigation.push")); - self_imp - .reset_cards_row - .set_action_target_value(Some(&Variant::from("profileConfiguration"))); - - self_imp.reset_output_stream_button.set_activatable(true); - self_imp - .reset_output_stream_button - .set_action_name(Some("navigation.pop")); - - self_imp.reset_input_cards_back_button.set_activatable(true); - self_imp - .reset_input_cards_back_button - .set_action_name(Some("navigation.pop")); - - self_imp - .reset_source_dropdown - .set_factory(Some(&create_dropdown_label_factory())); - set_combo_row_ellipsis(self_imp.reset_source_dropdown.get()); - } } impl Default for SourceBox { @@ -106,36 +81,24 @@ impl Default for SourceBox { } pub fn populate_sources(source_box: Arc) { - gio::spawn_blocking(move || { - let sources = - audio_dbus_call::,), ()>(source_box.clone(), (), &GETOBJECTS); - if sources.is_none() { - return; - } - let sources = sources.unwrap().0; - { - 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(); - - let source = - audio_dbus_call::(source_box.clone(), (), &GETDEFAULT); - if let Some(source) = source { - source_box_imp.reset_default_source.replace(source.0); - } - - for source in sources.iter() { - list.append(&source.alias); - map.insert(source.alias.clone(), (source.index, source.name.clone())); - *model_index += 1; - } - } - - populate_outputstreams(source_box.clone()); - populate_cards(source_box.clone()); - populate_source_information(source_box, sources); - }); + populate_audio_objects::< + Source, + OutputStream, + SourceEntry, + super::source_entry_impl::SourceEntry, + OutputStreamEntry, + super::output_stream_entry_impl::OutputStreamEntry, + SourceBox, + super::source_box_impl::SourceBox, + >( + source_box, + &GETOBJECTS, + &GETDEFAULT, + &SETDEFAULT, + &GETSTREAMS, + &SETVOLUME, + &SETMUTE, + ); } pub fn start_source_box_listener(conn: Connection, source_box: Arc) -> Connection { diff --git a/src/components/audio/input/source_box_handlers.rs b/src/components/audio/input/source_box_handlers.rs index 46244bf..82ff80b 100644 --- a/src/components/audio/input/source_box_handlers.rs +++ b/src/components/audio/input/source_box_handlers.rs @@ -12,19 +12,23 @@ use gtk::{ StringObject, }; use re_set_lib::{ - audio::audio_structures::Source, + audio::audio_structures::{OutputStream, Source}, signals::{ OutputStreamAdded, OutputStreamChanged, OutputStreamRemoved, SourceAdded, SourceChanged, SourceRemoved, }, }; -use crate::components::{audio::generic_utils::audio_dbus_call, base::list_entry::ListEntry}; +use crate::components::{ + audio::{ + generic_audio_box_utils::refresh_default_audio_object, generic_utils::audio_dbus_call, + }, + base::list_entry::ListEntry, +}; use super::{ output_stream_entry::OutputStreamEntry, source_box::SourceBox, - source_box_utils::refresh_default_source, source_const::{GETDEFAULTNAME, SETDEFAULT, SETMUTE, SETVOLUME}, source_entry::SourceEntry, }; @@ -257,74 +261,3 @@ pub fn output_stream_removed_handler(source_box: Arc, ir: OutputStrea true } -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; - } - let selected = selected.unwrap(); - let selected = selected.downcast_ref::().unwrap(); - let selected = selected.string().to_string(); - 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 = audio_dbus_call::( - source_box_ref.clone(), - (&source,), - &SETDEFAULT, - ); - if result.is_none() { - return ControlFlow::Break; - } - refresh_default_source(result.unwrap().0, source_box_ref.clone(), false); - ControlFlow::Continue - }); - ControlFlow::Continue -} - -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); - 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()); - } - audio_dbus_call::( - source_box.clone(), - (index, channels, value as u32), - &SETVOLUME, - ); - Propagation::Proceed -} - -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 { - imp.reset_source_mute - .set_icon_name("microphone-disabled-symbolic"); - } else { - imp.reset_source_mute - .set_icon_name("audio-input-microphone-symbolic"); - } - audio_dbus_call::( - source_box_ref_mute.clone(), - (source.index, source.muted), - &SETMUTE, - ); -} diff --git a/src/components/audio/input/source_box_impl.rs b/src/components/audio/input/source_box_impl.rs index 219b9a3..58bec6e 100644 --- a/src/components/audio/input/source_box_impl.rs +++ b/src/components/audio/input/source_box_impl.rs @@ -80,12 +80,7 @@ impl ObjectSubclass for SourceBox { impl BoxImpl for SourceBox {} -impl ObjectImpl for SourceBox { - fn constructed(&self) { - let obj = self.obj(); - obj.setup_callbacks(); - } -} +impl ObjectImpl for SourceBox {} impl ListBoxRowImpl for SourceBox {} diff --git a/src/components/audio/input/source_box_utils.rs b/src/components/audio/input/source_box_utils.rs deleted file mode 100644 index 7143b94..0000000 --- a/src/components/audio/input/source_box_utils.rs +++ /dev/null @@ -1,185 +0,0 @@ -use std::sync::Arc; - -use adw::prelude::{ComboRowExt, PreferencesGroupExt}; -use glib::subclass::types::ObjectSubclassIsExt; -use gtk::{ - gio, - prelude::{BoxExt, ButtonExt, CheckButtonExt, ListBoxRowExt, RangeExt}, -}; -use re_set_lib::audio::audio_structures::{Card, OutputStream, Source}; - -use crate::components::{ - audio::{generic_const::GETCARDS, generic_utils::audio_dbus_call}, - base::{card_entry::CardEntry, list_entry::ListEntry}, -}; - -use super::{ - output_stream_entry::OutputStreamEntry, - source_box::SourceBox, - source_box_handlers::{dropdown_handler, mute_clicked_handler, volume_slider_handler}, - source_const::GETSTREAMS, - source_entry::SourceEntry, -}; - -pub fn populate_source_information(source_box: Arc, sources: Vec) { - glib::spawn_future(async move { - glib::idle_add_once(move || { - 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 { - source_box_imp - .reset_source_mute - .set_icon_name("microphone-disabled-symbolic"); - } else { - source_box_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() + "%"; - source_box_imp.reset_volume_percentage.set_text(&percentage); - source_box_imp.reset_volume_slider.set_value(*volume as f64); - let mut list = source_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 source_box_imp.reset_default_source.borrow().name == source.name { - is_default = true; - } - let source_entry = SourceEntry::new( - is_default, - source_box_imp.reset_default_check_button.clone(), - source, - source_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)); - source_box_imp.reset_sources.append(&*entry); - } - let list = source_box_imp.reset_model_list.read().unwrap(); - source_box_imp.reset_source_dropdown.set_model(Some(&*list)); - let name = source_box_imp.reset_default_source.borrow(); - - 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(name.alias.clone().into()) { - source_box_imp.reset_source_dropdown.set_selected(entry); - break; - } - } - source_box_imp - .reset_source_dropdown - .connect_selected_notify(move |dropdown| { - dropdown_handler(source_box_ref_toggle.clone(), dropdown); - }); - source_box_imp - .reset_volume_slider - .connect_change_value(move |_, _, value| { - volume_slider_handler(source_box_ref_slider.clone(), value) - }); - - source_box_imp.reset_source_mute.connect_clicked(move |_| { - mute_clicked_handler(source_box_ref_mute.clone()); - }); - }); - }); -} - -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 = source_box.imp(); - if !entry { - let list = imp.reset_source_list.read().unwrap(); - let entry = list.get(&new_source.index); - if entry.is_none() { - return; - } - let entry_imp = entry.unwrap().1.imp(); - entry_imp.reset_selected_source.set_active(true); - } else { - let model_list = imp.reset_model_list.read().unwrap(); - for entry in 0..*imp.reset_model_index.read().unwrap() { - if model_list.string(entry) == Some(new_source.alias.clone().into()) { - imp.reset_source_dropdown.set_selected(entry); - break; - } - } - } - imp.reset_volume_percentage.set_text(&percentage); - imp.reset_volume_slider.set_value(volume as f64); - if new_source.muted { - imp.reset_source_mute - .set_icon_name("microphone-disabled-symbolic"); - } else { - imp.reset_source_mute - .set_icon_name("audio-input-microphone-symbolic"); - } - imp.reset_default_source.replace(new_source); - }); - }); -} - -pub fn populate_outputstreams(source_box: Arc) { - let source_box_ref = source_box.clone(); - gio::spawn_blocking(move || { - let streams = audio_dbus_call::,), ()>( - source_box.clone(), - (), - &GETSTREAMS, - ); - if streams.is_none() { - return; - } - let streams = streams.unwrap().0; - glib::spawn_future(async move { - glib::idle_add_once(move || { - 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 = 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)); - source_box_imp.reset_output_streams.append(&*entry); - } - }); - }); - }); -} - -pub fn populate_cards(source_box: Arc) { - gio::spawn_blocking(move || { - let source_box_ref = source_box.clone(); - let cards = - audio_dbus_call::,), ()>(source_box.clone(), (), &GETCARDS); - if cards.is_none() { - return; - } - let cards = cards.unwrap().0; - glib::spawn_future(async move { - glib::idle_add_once(move || { - let imp = source_box_ref.imp(); - for card in cards { - imp.reset_cards.add(&CardEntry::new(card)); - } - }); - }); - }); -} diff --git a/src/components/audio/mod.rs b/src/components/audio/mod.rs index 2adbd3f..7b206db 100644 --- a/src/components/audio/mod.rs +++ b/src/components/audio/mod.rs @@ -4,3 +4,7 @@ pub mod generic_entry; mod generic_utils; pub mod input; pub mod output; +mod generic_audio_box_utils; +mod generic_audio_stream_utils; +mod generic_audio_object_entry_utils; +mod generic_audio_box_handlers; diff --git a/src/components/audio/output/sink_box.rs b/src/components/audio/output/sink_box.rs index 8f29fea..45047f4 100644 --- a/src/components/audio/output/sink_box.rs +++ b/src/components/audio/output/sink_box.rs @@ -1,3 +1,5 @@ +use re_set_lib::audio::audio_structures::InputStream; +use re_set_lib::audio::audio_structures::Sink; use re_set_lib::signals::InputStreamAdded; use re_set_lib::signals::InputStreamChanged; use re_set_lib::signals::InputStreamRemoved; @@ -17,12 +19,14 @@ use glib::Variant; use gtk::gio; use gtk::prelude::ActionableExt; +use crate::components::audio::generic_audio_box_utils::setup_audio_box_callbacks; use crate::components::audio::generic_entry::TAudioBox; use crate::components::base::error_impl::ReSetErrorImpl; use crate::components::utils::BASE; use crate::components::utils::DBUS_PATH; use crate::components::utils::{create_dropdown_label_factory, set_combo_row_ellipsis}; +use super::input_stream_entry::InputStreamEntry; use super::sink_box_handlers::input_stream_added_handler; use super::sink_box_handlers::input_stream_changed_handler; use super::sink_box_handlers::input_stream_removed_handler; @@ -35,6 +39,7 @@ use super::sink_box_utils::get_sinks; use super::sink_box_utils::populate_cards; use super::sink_box_utils::populate_inputstreams; use super::sink_box_utils::populate_sink_information; +use super::sink_entry::SinkEntry; glib::wrapper! { pub struct SinkBox(ObjectSubclass) @@ -61,7 +66,17 @@ impl TAudioBox for SinkBox { impl SinkBox { pub fn new() -> Self { - let obj: Self = Object::builder().build(); + let mut obj: Self = Object::builder().build(); + setup_audio_box_callbacks::< + Sink, + InputStream, + SinkEntry, + super::sink_entry_impl::SinkEntry, + InputStreamEntry, + super::input_stream_entry_impl::InputStreamEntry, + SinkBox, + super::sink_box_impl::SinkBox, + >(&mut obj); { let imp = obj.imp(); let mut model_index = imp.reset_model_index.write().unwrap(); @@ -69,39 +84,6 @@ impl SinkBox { } obj } - - pub fn setup_callbacks(&self) { - let self_imp = self.imp(); - self_imp.reset_sinks_row.set_activatable(true); - self_imp - .reset_sinks_row - .set_action_name(Some("navigation.push")); - self_imp - .reset_sinks_row - .set_action_target_value(Some(&Variant::from("outputDevices"))); - self_imp.reset_cards_row.set_activatable(true); - self_imp - .reset_cards_row - .set_action_name(Some("navigation.push")); - self_imp - .reset_cards_row - .set_action_target_value(Some(&Variant::from("profileConfiguration"))); - - self_imp.reset_input_stream_button.set_activatable(true); - self_imp - .reset_input_stream_button - .set_action_name(Some("navigation.pop")); - - self_imp.reset_input_cards_back_button.set_activatable(true); - self_imp - .reset_input_cards_back_button - .set_action_name(Some("navigation.pop")); - - self_imp - .reset_sink_dropdown - .set_factory(Some(&create_dropdown_label_factory())); - set_combo_row_ellipsis(self_imp.reset_sink_dropdown.get()); - } } impl Default for SinkBox { diff --git a/src/components/audio/output/sink_box_impl.rs b/src/components/audio/output/sink_box_impl.rs index f1d4a59..8a511f3 100644 --- a/src/components/audio/output/sink_box_impl.rs +++ b/src/components/audio/output/sink_box_impl.rs @@ -81,12 +81,7 @@ impl ObjectSubclass for SinkBox { impl BoxImpl for SinkBox {} -impl ObjectImpl for SinkBox { - fn constructed(&self) { - let obj = self.obj(); - obj.setup_callbacks(); - } -} +impl ObjectImpl for SinkBox {} impl ListBoxRowImpl for SinkBox {} diff --git a/src/resources/resetAudioInput.ui b/src/resources/resetAudioInput.ui index f2486c9..2685da6 100644 --- a/src/resources/resetAudioInput.ui +++ b/src/resources/resetAudioInput.ui @@ -1,5 +1,5 @@ - + @@ -22,7 +22,7 @@ - output + audiostreams output @@ -128,7 +128,7 @@ - sources + devices sources diff --git a/src/resources/resetAudioOutput.ui b/src/resources/resetAudioOutput.ui index 99237a9..0a204a4 100644 --- a/src/resources/resetAudioOutput.ui +++ b/src/resources/resetAudioOutput.ui @@ -1,5 +1,5 @@ - + @@ -19,7 +19,7 @@ - output + audiostreams output @@ -126,7 +126,7 @@ - outputDevices + devices outputDevices diff --git a/src/resources/resetBluetooth.ui b/src/resources/resetBluetooth.ui index c3f9eb7..48f6b47 100644 --- a/src/resources/resetBluetooth.ui +++ b/src/resources/resetBluetooth.ui @@ -1,5 +1,5 @@ - + diff --git a/src/resources/resetBluetoothEntry.ui b/src/resources/resetBluetoothEntry.ui index c96eb03..c5c5157 100644 --- a/src/resources/resetBluetoothEntry.ui +++ b/src/resources/resetBluetoothEntry.ui @@ -1,5 +1,5 @@ - + diff --git a/src/resources/resetCardEntry.ui b/src/resources/resetCardEntry.ui index 501ecdd..a69608f 100644 --- a/src/resources/resetCardEntry.ui +++ b/src/resources/resetCardEntry.ui @@ -1,5 +1,5 @@ - + diff --git a/src/resources/resetError.ui b/src/resources/resetError.ui index f812af6..7616695 100644 --- a/src/resources/resetError.ui +++ b/src/resources/resetError.ui @@ -1,5 +1,5 @@ - +