refactor: Move audio to separate component as one

src/components/audio/input/mod.rs

@@ -0,0 +1,8 @@
+pub mod output_stream_entry;
+pub mod output_stream_entry_impl;
+pub mod source_box;
+mod source_box_handlers;
+pub mod source_box_impl;
+mod source_box_utils;
+pub mod source_entry;
+pub mod source_entry_impl;

src/components/audio/input/output_stream_entry.rs

@@ -0,0 +1,199 @@
+use std::sync::Arc;
+use std::time::{Duration, SystemTime};
+
+use crate::components::base::error_impl::show_error;
+use crate::components::utils::{
+    create_dropdown_label_factory, set_combo_row_ellipsis, AUDIO, BASE, DBUS_PATH,
+};
+use adw::glib::Object;
+use adw::prelude::{ButtonExt, ComboRowExt, PreferencesRowExt, RangeExt};
+use dbus::blocking::Connection;
+use dbus::Error;
+use glib::subclass::types::ObjectSubclassIsExt;
+use glib::{clone, Cast, Propagation};
+use gtk::{gio, StringObject};
+use re_set_lib::audio::audio_structures::OutputStream;
+
+use super::output_stream_entry_impl;
+use super::source_box::SourceBox;
+
+glib::wrapper! {
+    pub struct OutputStreamEntry(ObjectSubclass<output_stream_entry_impl::OutputStreamEntry>)
+    @extends adw::PreferencesGroup, gtk::Widget,
+    @implements gtk::Accessible, gtk::Buildable, gtk::ConstraintTarget, gtk::Orientable;
+}
+
+unsafe impl Send for OutputStreamEntry {}
+unsafe impl Sync for OutputStreamEntry {}
+
+impl OutputStreamEntry {
+    pub fn new(source_box: Arc<SourceBox>, stream: OutputStream) -> Self {
+        let obj: Self = Object::builder().build();
+        // TODO use event callback for progress bar -> this is the "im speaking" indicator
+        let output_box_volume_ref = source_box.clone();
+        let output_box_mute_ref = source_box.clone();
+        let output_box_source_ref = source_box.clone();
+        {
+            let index = stream.index;
+            let box_imp = source_box.imp();
+            let imp = obj.imp();
+            let name = stream.application_name.clone() + ": " + stream.name.as_str();
+            imp.reset_source_selection.set_title(name.as_str());
+            imp.reset_source_selection
+                .set_factory(Some(&create_dropdown_label_factory()));
+            set_combo_row_ellipsis(imp.reset_source_selection.get());
+            let volume = stream.volume.first().unwrap_or(&0_u32);
+            let fraction = (*volume as f64 / 655.36).round();
+            let percentage = (fraction).to_string() + "%";
+            imp.reset_volume_percentage.set_text(&percentage);
+            imp.reset_volume_slider.set_value(*volume as f64);
+            imp.stream.replace(stream);
+            imp.reset_volume_slider.connect_change_value(
+                clone!(@weak imp => @default-return Propagation::Stop, move |_, _, value| {
+                    let fraction = (value / 655.36).round();
+                    let percentage = (fraction).to_string() + "%";
+                    imp.reset_volume_percentage.set_text(&percentage);
+                    let mut stream = imp.stream.try_borrow();
+                    while stream.is_err() {
+                        stream = imp.stream.try_borrow();
+                    }
+                    let stream = stream.unwrap();
+                    let index = stream.index;
+                    let channels = stream.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_outputstream_volume(value, index, channels, output_box_volume_ref.clone());
+                    Propagation::Proceed
+                }),
+            );
+            {
+                let list = box_imp.reset_model_list.read().unwrap();
+                imp.reset_source_selection.set_model(Some(&*list));
+                let source_list = box_imp.reset_source_list.read().unwrap();
+                let name = source_list.get(&index);
+                let index = box_imp.reset_model_index.read().unwrap();
+                let model_list = box_imp.reset_model_list.read().unwrap();
+                if let Some(name) = name {
+                    for entry in 0..*index {
+                        if model_list.string(entry) == Some(name.2.clone().into()) {
+                            imp.reset_source_selection.set_selected(entry);
+                            break;
+                        }
+                    }
+                } else {
+                    let mut name = box_imp.reset_default_source.try_borrow();
+                    while name.is_err() {
+                        name = box_imp.reset_default_source.try_borrow();
+                    }
+                    let name = name.unwrap();
+                    for entry in 0..*index {
+                        if model_list.string(entry) == Some(name.alias.clone().into()) {
+                            imp.reset_source_selection.set_selected(entry);
+                            break;
+                        }
+                    }
+                }
+            }
+            imp.reset_source_selection.connect_selected_notify(
+                clone!(@weak imp, @weak box_imp => move |dropdown| {
+                    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 = box_imp.reset_source_map.write().unwrap();
+                    let source = source.get(&selected);
+                    if source.is_none() {
+                        return;
+                    }
+                    let mut stream = imp.stream.try_borrow();
+                    while stream.is_err() {
+                        stream = imp.stream.try_borrow();
+                    }
+                    let stream = stream.unwrap();
+                    let source = source.unwrap().0;
+                    set_source_of_output_stream(stream.index, source, output_box_source_ref.clone());
+                }),
+            );
+            imp.reset_source_mute
+                .connect_clicked(clone!(@weak imp => move |_| {
+                    let stream = imp.stream.clone();
+                    let mut stream = stream.try_borrow_mut();
+                    while stream.is_err() {
+                        stream = imp.stream.try_borrow_mut();
+                    }
+                    let mut stream = stream.unwrap();
+                    stream.muted = !stream.muted;
+                    let muted = stream.muted;
+                    let index = stream.index;
+                    if muted {
+                        imp.reset_source_mute
+                           .set_icon_name("microphone-disabled-symbolic");
+                    } else {
+                        imp.reset_source_mute
+                           .set_icon_name("audio-input-microphone-symbolic");
+                    }
+                    toggle_output_stream_mute(index, muted, output_box_mute_ref.clone());
+                }));
+        }
+        obj
+    }
+}
+
+fn set_outputstream_volume(
+    value: f64,
+    index: u32,
+    channels: u16,
+    input_box: Arc<SourceBox>,
+) -> bool {
+    gio::spawn_blocking(move || {
+        let conn = Connection::new_session().unwrap();
+        let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000));
+        let res: Result<(), Error> = proxy.method_call(
+            AUDIO,
+            "SetOutputStreamVolume",
+            (index, channels, value as u32),
+        );
+        if res.is_err() {
+            show_error::<SourceBox>(input_box.clone(), "Failed to set output stream volume");
+        }
+    });
+    true
+}
+
+fn toggle_output_stream_mute(index: u32, muted: bool, input_box: Arc<SourceBox>) -> bool {
+    gio::spawn_blocking(move || {
+        let conn = Connection::new_session().unwrap();
+        let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000));
+        let res: Result<(), Error> =
+            proxy.method_call(AUDIO, "SetOutputStreamMute", (index, muted));
+        if res.is_err() {
+            show_error::<SourceBox>(input_box.clone(), "Failed to mute output stream");
+        }
+    });
+    true
+}
+
+fn set_source_of_output_stream(stream: u32, source: u32, input_box: Arc<SourceBox>) -> bool {
+    gio::spawn_blocking(move || {
+        let conn = Connection::new_session().unwrap();
+        let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000));
+        let res: Result<(bool,), Error> =
+            proxy.method_call(AUDIO, "SetSourceOfOutputStream", (stream, source));
+        if res.is_err() {
+            show_error::<SourceBox>(input_box.clone(), "Failed to set source of output stream");
+        }
+    });
+    true
+}
+
+// TODO propagate error from dbus

src/components/audio/input/output_stream_entry_impl.rs

@@ -0,0 +1,48 @@
+use adw::subclass::prelude::PreferencesGroupImpl;
+use adw::{ComboRow, PreferencesGroup};
+use re_set_lib::audio::audio_structures::OutputStream;
+use std::cell::RefCell;
+use std::sync::Arc;
+use std::time::SystemTime;
+
+use crate::components::audio::input::output_stream_entry;
+use gtk::subclass::prelude::*;
+use gtk::{Button, CompositeTemplate, Label, Scale};
+
+#[derive(Default, CompositeTemplate)]
+#[template(resource = "/org/Xetibo/ReSet/resetOutputStreamEntry.ui")]
+pub struct OutputStreamEntry {
+    #[template_child]
+    pub reset_source_selection: TemplateChild<ComboRow>,
+    #[template_child]
+    pub reset_source_mute: TemplateChild<Button>,
+    #[template_child]
+    pub reset_volume_slider: TemplateChild<Scale>,
+    #[template_child]
+    pub reset_volume_percentage: TemplateChild<Label>,
+    pub stream: Arc<RefCell<OutputStream>>,
+    pub associated_source: Arc<RefCell<(u32, String)>>,
+    pub volume_time_stamp: RefCell<Option<SystemTime>>,
+}
+
+#[glib::object_subclass]
+impl ObjectSubclass for OutputStreamEntry {
+    const ABSTRACT: bool = false;
+    const NAME: &'static str = "resetOutputStreamEntry";
+    type Type = output_stream_entry::OutputStreamEntry;
+    type ParentType = PreferencesGroup;
+
+    fn class_init(klass: &mut Self::Class) {
+        klass.bind_template();
+    }
+
+    fn instance_init(obj: &glib::subclass::InitializingObject<Self>) {
+        obj.init_template();
+    }
+}
+
+impl PreferencesGroupImpl for OutputStreamEntry {}
+
+impl ObjectImpl for OutputStreamEntry {}
+
+impl WidgetImpl for OutputStreamEntry {}

src/components/audio/input/source_box.rs

@@ -0,0 +1,203 @@
+use re_set_lib::signals::{
+    OutputStreamAdded, OutputStreamChanged, OutputStreamRemoved, SourceAdded, SourceChanged,
+    SourceRemoved,
+};
+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::base::error::{self};
+use crate::components::base::error_impl::ReSetErrorImpl;
+use crate::components::audio::input::source_box_impl;
+use crate::components::utils::{
+    create_dropdown_label_factory, set_combo_row_ellipsis, BASE, DBUS_PATH,
+};
+
+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::{
+    get_default_source, get_sources, populate_cards, populate_outputstreams,
+    populate_source_information,
+};
+
+glib::wrapper! {
+    pub struct SourceBox(ObjectSubclass<source_box_impl::SourceBox>)
+    @extends gtk::Box, gtk::Widget,
+    @implements gtk::Accessible, gtk::Buildable, gtk::ConstraintTarget, gtk::Orientable;
+}
+
+unsafe impl Send for SourceBox {}
+unsafe impl Sync for SourceBox {}
+
+impl ReSetErrorImpl for SourceBox {
+    fn error(&self) -> &gtk::subclass::prelude::TemplateChild<error::ReSetError> {
+        &self.imp().error
+    }
+}
+
+impl SourceBox {
+    pub fn new() -> Self {
+        let obj: Self = Object::builder().build();
+        {
+            let imp = obj.imp();
+            let mut model_index = imp.reset_model_index.write().unwrap();
+            *model_index = 0;
+        }
+        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 {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+pub fn populate_sources(source_box: Arc<SourceBox>) {
+    gio::spawn_blocking(move || {
+        let sources = get_sources(source_box.clone());
+        {
+            let source_box_imp = source_box.imp();
+            let list = source_box_imp.reset_model_list.write().unwrap();
+            let mut map = source_box_imp.reset_source_map.write().unwrap();
+            let mut model_index = source_box_imp.reset_model_index.write().unwrap();
+            source_box_imp
+                .reset_default_source
+                .replace(get_default_source(source_box.clone()));
+            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);
+    });
+}
+
+pub fn start_source_box_listener(conn: Connection, source_box: Arc<SourceBox>) -> Connection {
+    let source_added =
+        SourceAdded::match_rule(Some(&BASE.into()), Some(&Path::from(DBUS_PATH))).static_clone();
+    let source_removed =
+        SourceRemoved::match_rule(Some(&BASE.into()), Some(&Path::from(DBUS_PATH))).static_clone();
+    let source_changed =
+        SourceChanged::match_rule(Some(&BASE.into()), Some(&Path::from(DBUS_PATH))).static_clone();
+    let output_stream_added =
+        OutputStreamAdded::match_rule(Some(&BASE.into()), Some(&Path::from(DBUS_PATH)))
+            .static_clone();
+    let output_stream_removed =
+        OutputStreamRemoved::match_rule(Some(&BASE.into()), Some(&Path::from(DBUS_PATH)))
+            .static_clone();
+    let output_stream_changed =
+        OutputStreamChanged::match_rule(Some(&BASE.into()), Some(&Path::from(DBUS_PATH)))
+            .static_clone();
+
+    let source_added_box = source_box.clone();
+    let source_removed_box = source_box.clone();
+    let source_changed_box = source_box.clone();
+    let output_stream_added_box = source_box.clone();
+    let output_stream_removed_box = source_box.clone();
+    let output_stream_changed_box = source_box.clone();
+
+    let res = conn.add_match(source_added, move |ir: SourceAdded, _, _| {
+        source_added_handler(source_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(source_removed, move |ir: SourceRemoved, _, _| {
+        source_removed_handler(source_removed_box.clone(), ir)
+    });
+    if res.is_err() {
+        println!("fail on source remove event");
+        return conn;
+    }
+
+    let res = conn.add_match(source_changed, move |ir: SourceChanged, _, _| {
+        source_changed_handler(source_changed_box.clone(), ir)
+    });
+    if res.is_err() {
+        println!("fail on source change event");
+        return conn;
+    }
+
+    let res = conn.add_match(output_stream_added, move |ir: OutputStreamAdded, _, _| {
+        output_stream_added_handler(output_stream_added_box.clone(), ir)
+    });
+    if res.is_err() {
+        println!("fail on output stream add event");
+        return conn;
+    }
+
+    let res = conn.add_match(
+        output_stream_changed,
+        move |ir: OutputStreamChanged, _, _| {
+            output_stream_changed_handler(output_stream_changed_box.clone(), ir)
+        },
+    );
+    if res.is_err() {
+        println!("fail on output stream change event");
+        return conn;
+    }
+
+    let res = conn.add_match(
+        output_stream_removed,
+        move |ir: OutputStreamRemoved, _, _| {
+            output_stream_removed_handler(output_stream_removed_box.clone(), ir)
+        },
+    );
+    if res.is_err() {
+        println!("fail on output stream remove event");
+        return conn;
+    }
+
+    conn
+}

src/components/audio/input/source_box_handlers.rs

@@ -0,0 +1,308 @@
+use std::{
+    sync::Arc,
+    time::{Duration, SystemTime},
+};
+
+use adw::prelude::{ComboRowExt, PreferencesRowExt};
+use glib::{subclass::types::ObjectSubclassIsExt, Cast, ControlFlow, Propagation};
+use gtk::{
+    gio,
+    prelude::{BoxExt, ButtonExt, CheckButtonExt, ListBoxRowExt, RangeExt},
+    StringObject,
+};
+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::SourceBox,
+    source_box_utils::{get_default_source_name, refresh_default_source},
+    source_entry::{set_default_source, set_source_volume, toggle_source_mute, SourceEntry},
+};
+
+pub fn source_added_handler(source_box: Arc<SourceBox>, ir: SourceAdded) -> bool {
+    glib::spawn_future(async move {
+        glib::idle_add_once(move || {
+            let source_box = source_box.clone();
+            let source_box_imp = source_box.imp();
+            let source_index = ir.source.index;
+            let alias = ir.source.alias.clone();
+            let name = ir.source.name.clone();
+            let mut is_default = false;
+            if source_box_imp.reset_default_source.borrow().name == ir.source.name {
+                is_default = true;
+            }
+            let source_entry = Arc::new(SourceEntry::new(
+                is_default,
+                source_box_imp.reset_default_check_button.clone(),
+                ir.source,
+                source_box.clone(),
+            ));
+            let source_clone = source_entry.clone();
+            let entry = Arc::new(ListEntry::new(&*source_entry));
+            entry.set_activatable(false);
+            let mut list = source_box_imp.reset_source_list.write().unwrap();
+            list.insert(source_index, (entry.clone(), source_clone, alias.clone()));
+            source_box_imp.reset_sources.append(&*entry);
+            let mut map = source_box_imp.reset_source_map.write().unwrap();
+            let mut index = source_box_imp.reset_model_index.write().unwrap();
+            let model_list = source_box_imp.reset_model_list.write().unwrap();
+            if model_list.string(*index - 1) == Some("Monitor of Dummy Output".into()) {
+                model_list.append(&alias);
+                model_list.remove(*index - 1);
+                map.insert(alias, (source_index, name));
+                source_box_imp.reset_source_dropdown.set_selected(0);
+            } else {
+                model_list.append(&alias);
+                map.insert(alias.clone(), (source_index, name));
+                if alias == "Monitor of Dummy Output" {
+                    source_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 source_box = source_box.clone();
+            let source_box_imp = source_box.imp();
+            let entry: Option<(Arc<ListEntry>, Arc<SourceEntry>, String)>;
+            {
+                let mut list = source_box_imp.reset_source_list.write().unwrap();
+                entry = list.remove(&ir.index);
+                if entry.is_none() {
+                    return;
+                }
+            }
+            source_box_imp
+                .reset_sources
+                .remove(&*entry.clone().unwrap().0);
+            let mut map = source_box_imp.reset_source_map.write().unwrap();
+            let alias = entry.unwrap().2;
+            map.remove(&alias);
+            let mut index = source_box_imp.reset_model_index.write().unwrap();
+            let model_list = source_box_imp.reset_model_list.write().unwrap();
+
+            if *index == 1 {
+                model_list.append("Monitor of Dummy Output");
+            }
+            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(source_box.clone());
+    glib::spawn_future(async move {
+        glib::idle_add_once(move || {
+            let source_box = source_box.clone();
+            let source_box_imp = source_box.imp();
+            let is_default = ir.source.name == default_source;
+            let volume = ir.source.volume.first().unwrap_or(&0_u32);
+            let fraction = (*volume as f64 / 655.36).round();
+            let percentage = (fraction).to_string() + "%";
+
+            let list = source_box_imp.reset_source_list.read().unwrap();
+            let entry = list.get(&ir.source.index);
+            if entry.is_none() {
+                return;
+            }
+            let imp = entry.unwrap().1.imp();
+            if is_default {
+                source_box_imp.reset_volume_percentage.set_text(&percentage);
+                source_box_imp.reset_volume_slider.set_value(*volume as f64);
+                source_box_imp
+                    .reset_default_source
+                    .replace(ir.source.clone());
+                if ir.source.muted {
+                    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");
+                }
+                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 source_box = source_box.clone();
+            let source_box_imp = source_box.imp();
+            let mut list = source_box_imp.reset_output_stream_list.write().unwrap();
+            let index = ir.stream.index;
+            let output_stream = Arc::new(OutputStreamEntry::new(source_box.clone(), ir.stream));
+            let entry = Arc::new(ListEntry::new(&*output_stream));
+            entry.set_activatable(false);
+            list.insert(index, (entry.clone(), output_stream.clone()));
+            source_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 source_box = source_box.clone();
+            let source_box_imp = source_box.imp();
+            let entry: Arc<OutputStreamEntry>;
+            {
+                let list = source_box_imp.reset_output_stream_list.read().unwrap();
+                let entry_opt = list.get(&ir.stream.index);
+                if entry_opt.is_none() {
+                    return;
+                }
+                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 = source_box_imp.reset_model_index.read().unwrap();
+            let model_list = source_box_imp.reset_model_list.read().unwrap();
+            for entry in 0..*index {
+                if model_list.string(entry) == Some(alias.clone().into()) {
+                    imp.reset_source_selection.set_selected(entry);
+                    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 source_box = source_box.clone();
+            let source_box_imp = source_box.imp();
+            let mut list = source_box_imp.reset_output_stream_list.write().unwrap();
+            let entry = list.remove(&ir.index);
+            if entry.is_none() {
+                return;
+            }
+            source_box_imp
+                .reset_output_streams
+                .remove(&*entry.unwrap().0);
+        });
+    });
+    true
+}
+
+pub fn dropdown_handler(source_box: Arc<SourceBox>, 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::<StringObject>().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 = set_default_source(source, source_box_ref.clone());
+        if result.is_none() {
+            return ControlFlow::Break;
+        }
+        refresh_default_source(result.unwrap(), source_box_ref.clone(), false);
+        ControlFlow::Continue
+    });
+    ControlFlow::Continue
+}
+
+pub fn volume_slider_handler(source_box: Arc<SourceBox>, 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());
+    }
+    set_source_volume(value, index, channels, source_box.clone());
+    Propagation::Proceed
+}
+
+pub fn mute_clicked_handler(source_box_ref_mute: Arc<SourceBox>) {
+    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");
+    }
+    toggle_source_mute(source.index, source.muted, source_box_ref_mute.clone());
+}

src/components/audio/input/source_box_impl.rs

@@ -0,0 +1,95 @@
+use adw::{ActionRow, ComboRow, PreferencesGroup};
+use re_set_lib::audio::audio_structures::Source;
+use std::cell::RefCell;
+use std::collections::HashMap;
+use std::sync::{Arc, RwLock};
+use std::time::SystemTime;
+
+use crate::components::base::error::ReSetError;
+use crate::components::base::list_entry::ListEntry;
+use crate::components::audio::input::source_box;
+use gtk::subclass::prelude::*;
+use gtk::{prelude::*, Button, Label, Scale};
+use gtk::{CheckButton, CompositeTemplate, StringList};
+
+use super::output_stream_entry::OutputStreamEntry;
+use super::source_entry::SourceEntry;
+
+type SourceEntryMap = Arc<RwLock<HashMap<u32, (Arc<ListEntry>, Arc<SourceEntry>, String)>>>;
+type OutputStreamEntryMap = Arc<RwLock<HashMap<u32, (Arc<ListEntry>, Arc<OutputStreamEntry>)>>>;
+// the key is the alias, the first value u32 is the index of the source, the second is the technical name
+type SourceMap = Arc<RwLock<HashMap<String, (u32, String)>>>;
+
+#[derive(Default, CompositeTemplate)]
+#[template(resource = "/org/Xetibo/ReSet/resetAudioInput.ui")]
+pub struct SourceBox {
+    #[template_child]
+    pub reset_source_row: TemplateChild<ActionRow>,
+    #[template_child]
+    pub reset_cards_row: TemplateChild<ActionRow>,
+    #[template_child]
+    pub reset_source_dropdown: TemplateChild<ComboRow>,
+    #[template_child]
+    pub reset_source_mute: TemplateChild<Button>,
+    #[template_child]
+    pub reset_volume_slider: TemplateChild<Scale>,
+    #[template_child]
+    pub reset_volume_percentage: TemplateChild<Label>,
+
+    #[template_child]
+    pub reset_sources: TemplateChild<gtk::Box>,
+    #[template_child]
+    pub reset_output_stream_button: TemplateChild<ActionRow>,
+    #[template_child]
+    pub reset_output_streams: TemplateChild<gtk::Box>,
+    #[template_child]
+    pub reset_input_cards_back_button: TemplateChild<ActionRow>,
+    #[template_child]
+    pub reset_cards: TemplateChild<PreferencesGroup>,
+    #[template_child]
+    pub error: TemplateChild<ReSetError>,
+    pub reset_default_check_button: Arc<CheckButton>,
+    pub reset_default_source: Arc<RefCell<Source>>,
+    pub reset_source_list: SourceEntryMap,
+    pub reset_output_stream_list: OutputStreamEntryMap,
+    pub reset_model_list: Arc<RwLock<StringList>>,
+    pub reset_model_index: Arc<RwLock<u32>>,
+    pub reset_source_map: SourceMap,
+    pub volume_time_stamp: RefCell<Option<SystemTime>>,
+}
+
+#[glib::object_subclass]
+impl ObjectSubclass for SourceBox {
+    const ABSTRACT: bool = false;
+    const NAME: &'static str = "resetAudioInput";
+    type Type = source_box::SourceBox;
+    type ParentType = gtk::Box;
+
+    fn class_init(klass: &mut Self::Class) {
+        OutputStreamEntry::ensure_type();
+        SourceEntry::ensure_type();
+        ListEntry::ensure_type();
+        klass.bind_template();
+    }
+
+    fn instance_init(obj: &glib::subclass::InitializingObject<Self>) {
+        obj.init_template();
+    }
+}
+
+impl BoxImpl for SourceBox {}
+
+impl ObjectImpl for SourceBox {
+    fn constructed(&self) {
+        let obj = self.obj();
+        obj.setup_callbacks();
+    }
+}
+
+impl ListBoxRowImpl for SourceBox {}
+
+impl WidgetImpl for SourceBox {}
+
+impl WindowImpl for SourceBox {}
+
+impl ApplicationWindowImpl for SourceBox {}

src/components/audio/input/source_box_utils.rs

@@ -0,0 +1,229 @@
+use std::{sync::Arc, time::Duration};
+
+use adw::prelude::{ComboRowExt, PreferencesGroupExt};
+use dbus::{blocking::Connection, Error};
+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::{
+    base::{card_entry::CardEntry, error_impl::show_error, list_entry::ListEntry},
+    utils::{AUDIO, BASE, DBUS_PATH},
+};
+
+use super::{
+    output_stream_entry::OutputStreamEntry,
+    source_box::SourceBox,
+    source_box_handlers::{dropdown_handler, mute_clicked_handler, volume_slider_handler},
+    source_entry::SourceEntry,
+};
+
+pub fn populate_source_information(source_box: Arc<SourceBox>, sources: Vec<Source>) {
+    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 = Arc::new(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<SourceBox>, 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<SourceBox>) {
+    let source_box_ref = source_box.clone();
+
+    gio::spawn_blocking(move || {
+        let streams = get_output_streams(source_box.clone());
+        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 = Arc::new(OutputStreamEntry::new(source_box.clone(), stream));
+                    let input_stream_clone = input_stream.clone();
+                    let entry = Arc::new(ListEntry::new(&*input_stream));
+                    entry.set_activatable(false);
+                    list.insert(index, (entry.clone(), input_stream_clone));
+                    source_box_imp.reset_output_streams.append(&*entry);
+                }
+            });
+        });
+    });
+}
+
+pub fn populate_cards(source_box: Arc<SourceBox>) {
+    gio::spawn_blocking(move || {
+        let source_box_ref = source_box.clone();
+        let cards = get_cards(source_box.clone());
+        glib::spawn_future(async move {
+            glib::idle_add_once(move || {
+                let imp = source_box_ref.imp();
+                for card in cards {
+                    imp.reset_cards.add(&CardEntry::new(card));
+                }
+            });
+        });
+    });
+}
+
+pub fn get_output_streams(source_box: Arc<SourceBox>) -> Vec<OutputStream> {
+    let conn = Connection::new_session().unwrap();
+    let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000));
+    let res: Result<(Vec<OutputStream>,), Error> =
+        proxy.method_call(AUDIO, "ListOutputStreams", ());
+    if res.is_err() {
+        show_error::<SourceBox>(source_box.clone(), "Failed to get output streams");
+        return Vec::new();
+    }
+    res.unwrap().0
+}
+
+pub fn get_sources(source_box: Arc<SourceBox>) -> Vec<Source> {
+    let conn = Connection::new_session().unwrap();
+    let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000));
+    let res: Result<(Vec<Source>,), Error> = proxy.method_call(AUDIO, "ListSources", ());
+    if res.is_err() {
+        show_error::<SourceBox>(source_box.clone(), "Failed to get sources");
+        return Vec::new();
+    }
+    res.unwrap().0
+}
+
+pub fn get_cards(source_box: Arc<SourceBox>) -> Vec<Card> {
+    let conn = Connection::new_session().unwrap();
+    let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000));
+    let res: Result<(Vec<Card>,), Error> = proxy.method_call(AUDIO, "ListCards", ());
+    if res.is_err() {
+        show_error::<SourceBox>(source_box.clone(), "Failed to get profiles");
+        return Vec::new();
+    }
+    res.unwrap().0
+}
+
+pub fn get_default_source_name(source_box: Arc<SourceBox>) -> String {
+    let conn = Connection::new_session().unwrap();
+    let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000));
+    let res: Result<(String,), Error> = proxy.method_call(AUDIO, "GetDefaultSourceName", ());
+    if res.is_err() {
+        show_error::<SourceBox>(source_box.clone(), "Failed to get default source name");
+        return String::from("");
+    }
+    res.unwrap().0
+}
+
+pub fn get_default_source(source_box: Arc<SourceBox>) -> Source {
+    let conn = Connection::new_session().unwrap();
+    let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000));
+    let res: Result<(Source,), Error> = proxy.method_call(AUDIO, "GetDefaultSource", ());
+    if res.is_err() {
+        show_error::<SourceBox>(source_box.clone(), "Failed to get default source");
+        return Source::default();
+    }
+    res.unwrap().0
+}

src/components/audio/input/source_entry.rs

@@ -0,0 +1,147 @@
+use std::sync::Arc;
+use std::time::{Duration, SystemTime};
+
+use crate::components::base::error_impl::show_error;
+use crate::components::utils::set_action_row_ellipsis;
+use adw::glib::Object;
+use adw::prelude::{ButtonExt, CheckButtonExt, PreferencesRowExt, RangeExt};
+use dbus::blocking::Connection;
+use dbus::Error;
+use glib::subclass::types::ObjectSubclassIsExt;
+use glib::{clone, Propagation};
+use gtk::{gio, CheckButton};
+use re_set_lib::audio::audio_structures::Source;
+
+use crate::components::utils::{AUDIO, BASE, DBUS_PATH};
+
+use super::source_box::SourceBox;
+use super::source_box_utils::refresh_default_source;
+use super::source_entry_impl;
+
+glib::wrapper! {
+    pub struct SourceEntry(ObjectSubclass<source_entry_impl::SourceEntry>)
+    @extends adw::PreferencesGroup, gtk::Widget,
+    @implements gtk::Accessible, gtk::Buildable, gtk::ConstraintTarget, gtk::Orientable;
+}
+
+unsafe impl Send for SourceEntry {}
+unsafe impl Sync for SourceEntry {}
+
+impl SourceEntry {
+    pub fn new(
+        is_default: bool,
+        check_group: Arc<CheckButton>,
+        source: Source,
+        input_box: Arc<SourceBox>,
+    ) -> Self {
+        let obj: Self = Object::builder().build();
+        // TODO use event callback for progress bar -> this is the "im speaking" indicator
+        {
+            let imp = obj.imp();
+            imp.reset_source_name
+                .set_title(source.alias.clone().as_str());
+            let name = Arc::new(source.name.clone());
+            let volume = source.volume.first().unwrap_or(&0_u32);
+            let fraction = (*volume as f64 / 655.36).round();
+            let percentage = (fraction).to_string() + "%";
+            let input_box_slider = input_box.clone();
+            let input_box_ref = input_box.clone();
+            imp.reset_volume_percentage.set_text(&percentage);
+            imp.reset_volume_slider.set_value(*volume as f64);
+            imp.source.replace(source);
+            imp.reset_volume_slider.connect_change_value(
+                clone!(@weak imp => @default-return Propagation::Stop, move |_, _, value| {
+                    let fraction = (value / 655.36).round();
+                    let percentage = (fraction).to_string() + "%";
+                    imp.reset_volume_percentage.set_text(&percentage);
+                    let source = imp.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, input_box_slider.clone());
+                    Propagation::Proceed
+                }),
+            );
+            imp.reset_selected_source.set_group(Some(&*check_group));
+            if is_default {
+                imp.reset_selected_source.set_active(true);
+            } else {
+                imp.reset_selected_source.set_active(false);
+            }
+            imp.reset_selected_source.connect_toggled(move |button| {
+                let input_box = input_box.clone();
+                if button.is_active() {
+                    let name = name.clone();
+                    gio::spawn_blocking(move || {
+                        let result = set_default_source(name, input_box.clone());
+                        if result.is_none() {
+                            return;
+                        }
+                        refresh_default_source(result.unwrap(), input_box, true);
+                    });
+                }
+            });
+            imp.reset_source_mute
+                .connect_clicked(clone!(@weak imp => move |_| {
+                    let mut source = imp.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, input_box_ref.clone());
+                }));
+            set_action_row_ellipsis(imp.reset_source_name.get());
+        }
+        obj
+    }
+}
+
+pub fn set_source_volume(value: f64, index: u32, channels: u16, input_box: Arc<SourceBox>) -> bool {
+    gio::spawn_blocking(move || {
+        let conn = Connection::new_session().unwrap();
+        let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000));
+        let res: Result<(), Error> =
+            proxy.method_call(AUDIO, "SetSourceVolume", (index, channels, value as u32));
+        if res.is_err() {
+            // TODO: also log this with LOG/ERROR
+            show_error::<SourceBox>(input_box.clone(), "Failed to set source volume");
+        }
+    });
+    true
+}
+
+pub fn toggle_source_mute(index: u32, muted: bool, input_box: Arc<SourceBox>) -> bool {
+    gio::spawn_blocking(move || {
+        let conn = Connection::new_session().unwrap();
+        let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000));
+        let res: Result<(), Error> = proxy.method_call(AUDIO, "SetSourceMute", (index, muted));
+        if res.is_err() {
+            show_error::<SourceBox>(input_box.clone(), "Failed to mute source");
+        }
+    });
+    true
+}
+
+pub fn set_default_source(name: Arc<String>, input_box: Arc<SourceBox>) -> Option<Source> {
+    let conn = Connection::new_session().unwrap();
+    let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000));
+    let res: Result<(Source,), Error> =
+        proxy.method_call(AUDIO, "SetDefaultSource", (name.as_str(),));
+    if res.is_err() {
+        show_error::<SourceBox>(input_box.clone(), "Failed to set default source");
+        return None;
+    }
+    Some(res.unwrap().0)
+}

src/components/audio/input/source_entry_impl.rs

@@ -0,0 +1,50 @@
+use adw::subclass::prelude::PreferencesGroupImpl;
+use adw::{ActionRow, PreferencesGroup};
+use re_set_lib::audio::audio_structures::Source;
+use std::cell::RefCell;
+use std::sync::Arc;
+use std::time::SystemTime;
+
+use gtk::subclass::prelude::*;
+use gtk::{Button, CheckButton, CompositeTemplate, Label, Scale};
+
+use super::source_entry;
+
+#[derive(Default, CompositeTemplate)]
+#[template(resource = "/org/Xetibo/ReSet/resetSourceEntry.ui")]
+pub struct SourceEntry {
+    #[template_child]
+    pub reset_source_name: TemplateChild<ActionRow>,
+    #[template_child]
+    pub reset_selected_source: TemplateChild<CheckButton>,
+    #[template_child]
+    pub reset_source_mute: TemplateChild<Button>,
+    #[template_child]
+    pub reset_volume_slider: TemplateChild<Scale>,
+    #[template_child]
+    pub reset_volume_percentage: TemplateChild<Label>,
+    pub source: Arc<RefCell<Source>>,
+    pub volume_time_stamp: RefCell<Option<SystemTime>>,
+}
+
+#[glib::object_subclass]
+impl ObjectSubclass for SourceEntry {
+    const ABSTRACT: bool = false;
+    const NAME: &'static str = "resetSourceEntry";
+    type Type = source_entry::SourceEntry;
+    type ParentType = PreferencesGroup;
+
+    fn class_init(klass: &mut Self::Class) {
+        klass.bind_template();
+    }
+
+    fn instance_init(obj: &glib::subclass::InitializingObject<Self>) {
+        obj.init_template();
+    }
+}
+
+impl PreferencesGroupImpl for SourceEntry {}
+
+impl ObjectImpl for SourceEntry {}
+
+impl WidgetImpl for SourceEntry {}