Xetibo/ReSet
1
0
Fork 0
mirror of https://github.com/Xetibo/ReSet.git synced 2025-07-01 15:57:46 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

chore: snake_case all but UI templates

Browse source
This commit is contained in:
Fabio Lenherr / DashieTM 2023-12-05 15:30:04 +01:00
parent 9f0ca6e8bf
commit 391182607d
55 changed files with 1471 additions and 1427 deletions
Download patch file Download diff file Expand all files Collapse all files

30
src/components/output/inputStreamEntry.rs → src/components/output/input_stream_entry.rs
View file

@ -1,7 +1,7 @@
use std::sync::Arc;
use std::time::{Duration, SystemTime};
use crate::components::utils::{createDropdownLabelFactory, setComboRowEllipsis};
use crate::components::utils::{create_dropdown_label_factory, set_combo_row_ellipsis};
use adw::glib;
use adw::glib::Object;
use adw::prelude::{ButtonExt, ComboRowExt, PreferencesRowExt, RangeExt};
@ -12,11 +12,11 @@ use glib::{clone, Cast, Propagation};
use gtk::{gio, StringObject};
use ReSet_Lib::audio::audio::InputStream;
use super::inputStreamEntryImpl;
use super::sinkBox::SinkBox;
use super::input_stream_entry_impl;
use super::sink_box::SinkBox;
glib::wrapper! {
pub struct InputStreamEntry(ObjectSubclass<inputStreamEntryImpl::InputStreamEntry>)
pub struct InputStreamEntry(ObjectSubclass<input_stream_entry_impl::InputStreamEntry>)
@extends adw::PreferencesGroup, gtk::Widget,
@implements gtk::Accessible, gtk::Buildable, gtk::ConstraintTarget, gtk::Orientable;
}
@ -42,8 +42,8 @@ impl InputStreamEntry {
let name = stream.application_name.clone() + ": " + stream.name.as_str();
imp.resetSinkSelection.set_title(name.as_str());
imp.resetSinkSelection
.set_factory(Some(&createDropdownLabelFactory()));
setComboRowEllipsis(imp.resetSinkSelection.get());
.set_factory(Some(&create_dropdown_label_factory()));
set_combo_row_ellipsis(imp.resetSinkSelection.get());
let volume = stream.volume.first().unwrap_or(&0_u32);
let fraction = (*volume as f64 / 655.36).round();
let percentage = (fraction).to_string() + "%";
@ -51,8 +51,8 @@ impl InputStreamEntry {
imp.resetVolumeSlider.set_value(*volume as f64);
imp.stream.replace(stream);
{
let sink = box_imp.resetDefaultSink.borrow();
imp.associatedSink.replace((sink.index, sink.name.clone()));
let sink = box_imp.reset_default_sink.borrow();
imp.associated_sink.replace((sink.index, sink.name.clone()));
}
imp.resetVolumeSlider.connect_change_value(
clone!(@weak imp => @default-return Propagation::Stop, move |_, _, value| {
@ -67,7 +67,7 @@ impl InputStreamEntry {
let index = stream.index;
let channels = stream.channels;
{
let mut time = imp.volumeTimeStamp.borrow_mut();
let mut time = imp.volume_time_stamp.borrow_mut();
if time.is_some() && time.unwrap().elapsed().unwrap() < Duration::from_millis(50) {
return Propagation::Proceed;
}
@ -78,14 +78,14 @@ impl InputStreamEntry {
}),
);
{
let list = box_imp.resetModelList.read().unwrap();
let list = box_imp.reset_model_list.read().unwrap();
// while list.is_err() {
// list = box_imp.resetModelList.try_borrow();
// }
// let list = list.unwrap();
imp.resetSinkSelection.set_model(Some(&*list));
let map = box_imp.resetSinkMap.read().unwrap();
let sink_list = box_imp.resetSinkList.read().unwrap();
let map = box_imp.reset_sink_map.read().unwrap();
let sink_list = box_imp.reset_sink_list.read().unwrap();
let name = sink_list.get(&index);
if let Some(name) = name {
let name = &name.2;
@ -94,9 +94,9 @@ impl InputStreamEntry {
imp.resetSinkSelection.set_selected(index.1);
}
} else {
let mut name = box_imp.resetDefaultSink.try_borrow();
let mut name = box_imp.reset_default_sink.try_borrow();
while name.is_err() {
name = box_imp.resetDefaultSink.try_borrow();
name = box_imp.reset_default_sink.try_borrow();
}
let name = &name.unwrap().alias;
let index = map.get(name);
@ -114,7 +114,7 @@ impl InputStreamEntry {
let selected = selected.unwrap();
let selected = selected.downcast_ref::<StringObject>().unwrap();
let selected = selected.string().to_string();
let sink = box_imp.resetSinkMap.read().unwrap();
let sink = box_imp.reset_sink_map.read().unwrap();
// if sink.is_err() {
// return;
// }

8
src/components/output/inputStreamEntryImpl.rs → src/components/output/input_stream_entry_impl.rs
View file

@ -8,7 +8,7 @@ use gtk::subclass::prelude::*;
use gtk::{glib, Button, CompositeTemplate, Label, ProgressBar, Scale};
use ReSet_Lib::audio::audio::InputStream;
use super::inputStreamEntry;
use super::input_stream_entry;
#[allow(non_snake_case)]
#[derive(Default, CompositeTemplate)]
@ -25,15 +25,15 @@ pub struct InputStreamEntry {
#[template_child]
pub resetVolumeMeter: TemplateChild<ProgressBar>,
pub stream: Arc<RefCell<InputStream>>,
pub associatedSink: Arc<RefCell<(u32, String)>>,
pub volumeTimeStamp: RefCell<Option<SystemTime>>,
pub associated_sink: Arc<RefCell<(u32, String)>>,
pub volume_time_stamp: RefCell<Option<SystemTime>>,
}
#[glib::object_subclass]
impl ObjectSubclass for InputStreamEntry {
const ABSTRACT: bool = false;
const NAME: &'static str = "resetInputStreamEntry";
type Type = inputStreamEntry::InputStreamEntry;
type Type = input_stream_entry::InputStreamEntry;
type ParentType = PreferencesGroup;
fn class_init(klass: &mut Self::Class) {

13
src/components/output/mod.rs
View file

@ -1,7 +1,6 @@
#![allow(non_snake_case)]
pub mod inputStreamEntry;
pub mod inputStreamEntryImpl;
pub mod sinkBox;
pub mod sinkBoxImpl;
pub mod sinkEntry;
pub mod sinkEntryImpl;
pub mod input_stream_entry;
pub mod input_stream_entry_impl;
pub mod sink_box;
pub mod sink_box_impl;
pub mod sink_entry;
pub mod sink_entry_impl;

116
src/components/output/sinkBox.rs → src/components/output/sink_box.rs
View file

@ -15,20 +15,20 @@ use gtk::prelude::ActionableExt;
use gtk::{gio, StringObject};
use ReSet_Lib::audio::audio::{Card, InputStream, Sink};
use crate::components::base::cardEntry::CardEntry;
use crate::components::base::listEntry::ListEntry;
use crate::components::base::card_entry::CardEntry;
use crate::components::base::list_entry::ListEntry;
use crate::components::base::utils::{
InputStreamAdded, InputStreamChanged, InputStreamRemoved, SinkAdded, SinkChanged, SinkRemoved,
};
use crate::components::output::sinkEntry::set_sink_volume;
use crate::components::utils::{createDropdownLabelFactory, setComboRowEllipsis};
use crate::components::output::sink_entry::set_sink_volume;
use crate::components::utils::{create_dropdown_label_factory, set_combo_row_ellipsis};
use super::inputStreamEntry::InputStreamEntry;
use super::sinkBoxImpl;
use super::sinkEntry::{set_default_sink, toggle_sink_mute, SinkEntry};
use super::input_stream_entry::InputStreamEntry;
use super::sink_box_impl;
use super::sink_entry::{set_default_sink, toggle_sink_mute, SinkEntry};
glib::wrapper! {
pub struct SinkBox(ObjectSubclass<sinkBoxImpl::SinkBox>)
pub struct SinkBox(ObjectSubclass<sink_box_impl::SinkBox>)
@extends gtk::Box, gtk::Widget,
@implements gtk::Accessible, gtk::Buildable, gtk::ConstraintTarget, gtk::Orientable;
}
@ -41,44 +41,44 @@ impl SinkBox {
let obj: Self = Object::builder().build();
{
let imp = obj.imp();
let mut model_index = imp.resetModelIndex.write().unwrap();
let mut model_index = imp.reset_model_index.write().unwrap();
*model_index = 0;
}
obj
}
pub fn setupCallbacks(&self) {
let selfImp = self.imp();
selfImp.resetSinksRow.set_activatable(true);
selfImp
pub fn setup_callbacks(&self) {
let self_imp = self.imp();
self_imp.resetSinksRow.set_activatable(true);
self_imp
.resetSinksRow
.set_action_name(Some("navigation.push"));
selfImp
self_imp
.resetSinksRow
.set_action_target_value(Some(&Variant::from("outputDevices")));
selfImp.resetCardsRow.set_activatable(true);
selfImp
self_imp.resetCardsRow.set_activatable(true);
self_imp
.resetCardsRow
.set_action_name(Some("navigation.push"));
selfImp
self_imp
.resetCardsRow
.set_action_target_value(Some(&Variant::from("profileConfiguration")));
selfImp.resetCardsRow.connect_action_name_notify(|_| {});
self_imp.resetCardsRow.connect_action_name_notify(|_| {});
selfImp.resetInputStreamButton.set_activatable(true);
selfImp
self_imp.resetInputStreamButton.set_activatable(true);
self_imp
.resetInputStreamButton
.set_action_name(Some("navigation.pop"));
selfImp.resetInputCardsBackButton.set_activatable(true);
selfImp
self_imp.resetInputCardsBackButton.set_activatable(true);
self_imp
.resetInputCardsBackButton
.set_action_name(Some("navigation.pop"));
selfImp
self_imp
.resetSinkDropdown
.set_factory(Some(&createDropdownLabelFactory()));
setComboRowEllipsis(selfImp.resetSinkDropdown.get());
.set_factory(Some(&create_dropdown_label_factory()));
set_combo_row_ellipsis(self_imp.resetSinkDropdown.get());
}
}
@ -94,10 +94,12 @@ pub fn populate_sinks(output_box: Arc<SinkBox>) {
let sinks = get_sinks();
{
let output_box_imp = output_box.imp();
let mut map = output_box_imp.resetSinkMap.write().unwrap();
let list = output_box_imp.resetModelList.write().unwrap();
let mut model_index = output_box_imp.resetModelIndex.write().unwrap();
output_box_imp.resetDefaultSink.replace(get_default_sink());
let mut map = output_box_imp.reset_sink_map.write().unwrap();
let list = output_box_imp.reset_model_list.write().unwrap();
let mut model_index = output_box_imp.reset_model_index.write().unwrap();
output_box_imp
.reset_default_sink
.replace(get_default_sink());
for (i, sink) in (0_u32..).zip(sinks.iter()) {
list.append(&sink.alias);
map.insert(sink.alias.clone(), (sink.index, i, sink.name.clone()));
@ -112,7 +114,7 @@ pub fn populate_sinks(output_box: Arc<SinkBox>) {
let output_box_ref_mute = output_box.clone();
{
let output_box_imp = output_box_ref.imp();
let default_sink = output_box_imp.resetDefaultSink.clone();
let default_sink = output_box_imp.reset_default_sink.clone();
let sink = default_sink.borrow();
let volume = sink.volume.first().unwrap_or(&0);
@ -120,17 +122,17 @@ pub fn populate_sinks(output_box: Arc<SinkBox>) {
let percentage = (fraction).to_string() + "%";
output_box_imp.resetVolumePercentage.set_text(&percentage);
output_box_imp.resetVolumeSlider.set_value(*volume as f64);
let mut list = output_box_imp.resetSinkList.write().unwrap();
let mut list = output_box_imp.reset_sink_list.write().unwrap();
for sink in sinks {
let index = sink.index;
let alias = sink.alias.clone();
let mut is_default = false;
if output_box_imp.resetDefaultSink.borrow().name == sink.name {
if output_box_imp.reset_default_sink.borrow().name == sink.name {
is_default = true;
}
let sink_entry = Arc::new(SinkEntry::new(
is_default,
output_box_imp.resetDefaultCheckButton.clone(),
output_box_imp.reset_default_check_button.clone(),
sink,
));
let sink_clone = sink_entry.clone();
@ -139,10 +141,10 @@ pub fn populate_sinks(output_box: Arc<SinkBox>) {
list.insert(index, (entry.clone(), sink_clone, alias));
output_box_imp.resetSinks.append(&*entry);
}
let list = output_box_imp.resetModelList.read().unwrap();
let list = output_box_imp.reset_model_list.read().unwrap();
output_box_imp.resetSinkDropdown.set_model(Some(&*list));
let map = output_box_imp.resetSinkMap.read().unwrap();
let name = output_box_imp.resetDefaultSink.borrow();
let map = output_box_imp.reset_sink_map.read().unwrap();
let name = output_box_imp.reset_default_sink.borrow();
let name = &name.alias;
let index = map.get(name);
if let Some(index) = index {
@ -158,7 +160,7 @@ pub fn populate_sinks(output_box: Arc<SinkBox>) {
let selected = selected.downcast_ref::<StringObject>().unwrap();
let selected = selected.string().to_string();
let sink = output_box_imp.resetSinkMap.read().unwrap();
let sink = output_box_imp.reset_sink_map.read().unwrap();
let sink = sink.get(&selected);
if sink.is_none() {
return;
@ -176,11 +178,11 @@ pub fn populate_sinks(output_box: Arc<SinkBox>) {
let fraction = (value / 655.36).round();
let percentage = (fraction).to_string() + "%";
imp.resetVolumePercentage.set_text(&percentage);
let sink = imp.resetDefaultSink.borrow();
let sink = imp.reset_default_sink.borrow();
let index = sink.index;
let channels = sink.channels;
{
let mut time = imp.volumeTimeStamp.borrow_mut();
let mut time = imp.volume_time_stamp.borrow_mut();
if time.is_some()
&& time.unwrap().elapsed().unwrap() < Duration::from_millis(50)
{
@ -196,7 +198,7 @@ pub fn populate_sinks(output_box: Arc<SinkBox>) {
.resetSinkMute
.connect_clicked(move |_| {
let imp = output_box_ref_mute.imp();
let stream = imp.resetDefaultSink.clone();
let stream = imp.reset_default_sink.clone();
let mut stream = stream.borrow_mut();
stream.muted = !stream.muted;
let muted = stream.muted;
@ -223,7 +225,7 @@ pub fn populate_inputstreams(output_box: Arc<SinkBox>) {
glib::spawn_future(async move {
glib::idle_add_once(move || {
let output_box_imp = output_box_ref.imp();
let mut list = output_box_imp.resetInputStreamList.write().unwrap();
let mut list = output_box_imp.reset_input_stream_list.write().unwrap();
for stream in streams {
let index = stream.index;
let input_stream = Arc::new(InputStreamEntry::new(output_box.clone(), stream));
@ -357,17 +359,17 @@ pub fn start_output_box_listener(conn: Connection, sink_box: Arc<SinkBox>) -> Co
glib::idle_add_once(move || {
let output_box = sink_box.clone();
let output_box_imp = output_box.imp();
let mut list = output_box_imp.resetSinkList.write().unwrap();
let mut list = output_box_imp.reset_sink_list.write().unwrap();
let sink_index = ir.sink.index;
let alias = ir.sink.alias.clone();
let name = ir.sink.name.clone();
let mut is_default = false;
if output_box_imp.resetDefaultSink.borrow().name == ir.sink.name {
if output_box_imp.reset_default_sink.borrow().name == ir.sink.name {
is_default = true;
}
let sink_entry = Arc::new(SinkEntry::new(
is_default,
output_box_imp.resetDefaultCheckButton.clone(),
output_box_imp.reset_default_check_button.clone(),
ir.sink,
));
let sink_clone = sink_entry.clone();
@ -375,10 +377,10 @@ pub fn start_output_box_listener(conn: Connection, sink_box: Arc<SinkBox>) -> Co
entry.set_activatable(false);
list.insert(sink_index, (entry.clone(), sink_clone, alias.clone()));
output_box_imp.resetSinks.append(&*entry);
let mut map = output_box_imp.resetSinkMap.write().unwrap();
let mut index = output_box_imp.resetModelIndex.write().unwrap();
let mut map = output_box_imp.reset_sink_map.write().unwrap();
let mut index = output_box_imp.reset_model_index.write().unwrap();
output_box_imp
.resetModelList
.reset_model_list
.write()
.unwrap()
.append(&alias);
@ -399,7 +401,7 @@ pub fn start_output_box_listener(conn: Connection, sink_box: Arc<SinkBox>) -> Co
glib::idle_add_once(move || {
let output_box = sink_box.clone();
let output_box_imp = output_box.imp();
let mut list = output_box_imp.resetSinkList.write().unwrap();
let mut list = output_box_imp.reset_sink_list.write().unwrap();
let entry = list.get(&ir.index);
if entry.is_none() {
return;
@ -409,16 +411,16 @@ pub fn start_output_box_listener(conn: Connection, sink_box: Arc<SinkBox>) -> Co
if alias.is_none() {
return;
}
let mut map = output_box_imp.resetSinkMap.write().unwrap();
let mut map = output_box_imp.reset_sink_map.write().unwrap();
let entry_index = map.remove(&alias.unwrap().2);
if let Some(entry_index) = entry_index {
output_box_imp
.resetModelList
.reset_model_list
.write()
.unwrap()
.remove(entry_index.1);
}
let mut index = output_box_imp.resetModelIndex.write().unwrap();
let mut index = output_box_imp.reset_model_index.write().unwrap();
if *index != 0 {
*index -= 1;
}
@ -443,7 +445,7 @@ pub fn start_output_box_listener(conn: Connection, sink_box: Arc<SinkBox>) -> Co
let fraction = (*volume as f64 / 655.36).round();
let percentage = (fraction).to_string() + "%";
let list = output_box_imp.resetSinkList.read().unwrap();
let list = output_box_imp.reset_sink_list.read().unwrap();
let entry = list.get(&ir.sink.index);
if entry.is_none() {
return;
@ -474,7 +476,7 @@ pub fn start_output_box_listener(conn: Connection, sink_box: Arc<SinkBox>) -> Co
glib::idle_add_once(move || {
let output_box = sink_box.clone();
let output_box_imp = output_box.imp();
let mut list = output_box_imp.resetInputStreamList.write().unwrap();
let mut list = output_box_imp.reset_input_stream_list.write().unwrap();
let index = ir.stream.index;
let input_stream = Arc::new(InputStreamEntry::new(output_box.clone(), ir.stream));
let entry = Arc::new(ListEntry::new(&*input_stream));
@ -494,7 +496,7 @@ pub fn start_output_box_listener(conn: Connection, sink_box: Arc<SinkBox>) -> Co
let imp = input_stream_changed_box.imp();
let alias: String;
{
let sink_list = imp.resetSinkList.read().unwrap();
let sink_list = imp.reset_sink_list.read().unwrap();
let alias_opt = sink_list.get(&ir.stream.sink_index);
if let Some(alias_opt) = alias_opt {
alias = alias_opt.2.clone();
@ -509,7 +511,7 @@ pub fn start_output_box_listener(conn: Connection, sink_box: Arc<SinkBox>) -> Co
let output_box_imp = output_box.imp();
let entry: Arc<InputStreamEntry>;
{
let list = output_box_imp.resetInputStreamList.read().unwrap();
let list = output_box_imp.reset_input_stream_list.read().unwrap();
let entry_opt = list.get(&ir.stream.index);
if entry_opt.is_none() {
return;
@ -531,7 +533,7 @@ pub fn start_output_box_listener(conn: Connection, sink_box: Arc<SinkBox>) -> Co
let percentage = (fraction).to_string() + "%";
imp.resetVolumePercentage.set_text(&percentage);
imp.resetVolumeSlider.set_value(*volume as f64);
let map = output_box_imp.resetSinkMap.read().unwrap();
let map = output_box_imp.reset_sink_map.read().unwrap();
let index = map.get(&alias);
if let Some(index) = index {
imp.resetSinkSelection.set_selected(index.1);
@ -551,7 +553,7 @@ pub fn start_output_box_listener(conn: Connection, sink_box: Arc<SinkBox>) -> Co
glib::idle_add_once(move || {
let output_box = sink_box.clone();
let output_box_imp = output_box.imp();
let mut list = output_box_imp.resetInputStreamList.write().unwrap();
let mut list = output_box_imp.reset_input_stream_list.write().unwrap();
let entry = list.get(&ir.index);
if entry.is_none() {
return;

28
src/components/output/sinkBoxImpl.rs → src/components/output/sink_box_impl.rs
View file

@ -4,15 +4,15 @@ use std::collections::HashMap;
use std::sync::{Arc, RwLock};
use std::time::SystemTime;
use crate::components::base::listEntry::ListEntry;
use crate::components::output::inputStreamEntry::InputStreamEntry;
use crate::components::base::list_entry::ListEntry;
use crate::components::output::input_stream_entry::InputStreamEntry;
use gtk::subclass::prelude::*;
use gtk::{glib, Box, Button, CheckButton, CompositeTemplate, Label, StringList, TemplateChild};
use gtk::{prelude::*, ProgressBar, Scale};
use ReSet_Lib::audio::audio::Sink;
use super::sinkBox;
use super::sinkEntry::SinkEntry;
use super::sink_box;
use super::sink_entry::SinkEntry;
type SinkEntryMap = Arc<RwLock<HashMap<u32, (Arc<ListEntry>, Arc<SinkEntry>, String)>>>;
type InputStreamEntryMap = Arc<RwLock<HashMap<u32, (Arc<ListEntry>, Arc<InputStreamEntry>)>>>;
@ -46,23 +46,23 @@ pub struct SinkBox {
pub resetInputCardsBackButton: TemplateChild<ActionRow>,
#[template_child]
pub resetCards: TemplateChild<PreferencesGroup>,
pub resetDefaultCheckButton: Arc<CheckButton>,
pub resetDefaultSink: Arc<RefCell<Sink>>,
pub resetSinkList: SinkEntryMap,
pub resetInputStreamList: InputStreamEntryMap,
pub resetModelList: Arc<RwLock<StringList>>,
pub resetModelIndex: Arc<RwLock<u32>>,
pub reset_default_check_button: Arc<CheckButton>,
pub reset_default_sink: Arc<RefCell<Sink>>,
pub reset_sink_list: SinkEntryMap,
pub reset_input_stream_list: InputStreamEntryMap,
pub reset_model_list: Arc<RwLock<StringList>>,
pub reset_model_index: Arc<RwLock<u32>>,
// first u32 is the index of the sink, the second the index in the model list and the third is
// the full name
pub resetSinkMap: SinkMap,
pub volumeTimeStamp: RefCell<Option<SystemTime>>,
pub reset_sink_map: SinkMap,
pub volume_time_stamp: RefCell<Option<SystemTime>>,
}
#[glib::object_subclass]
impl ObjectSubclass for SinkBox {
const ABSTRACT: bool = false;
const NAME: &'static str = "resetAudioOutput";
type Type = sinkBox::SinkBox;
type Type = sink_box::SinkBox;
type ParentType = gtk::Box;
fn class_init(klass: &mut Self::Class) {
@ -82,7 +82,7 @@ impl BoxImpl for SinkBox {}
impl ObjectImpl for SinkBox {
fn constructed(&self) {
let obj = self.obj();
obj.setupCallbacks();
obj.setup_callbacks();
}
}

6
src/components/output/sinkEntry.rs → src/components/output/sink_entry.rs
View file

@ -11,10 +11,10 @@ use glib::{clone, Propagation};
use gtk::{gio, CheckButton};
use ReSet_Lib::audio::audio::Sink;
use super::sinkEntryImpl;
use super::sink_entry_impl;
glib::wrapper! {
pub struct SinkEntry(ObjectSubclass<sinkEntryImpl::SinkEntry>)
pub struct SinkEntry(ObjectSubclass<sink_entry_impl::SinkEntry>)
@extends adw::PreferencesGroup, gtk::Widget,
@implements gtk::Accessible, gtk::Buildable, gtk::ConstraintTarget, gtk::Orientable;
}
@ -45,7 +45,7 @@ impl SinkEntry {
let index = sink.index;
let channels = sink.channels;
{
let mut time = imp.volumeTimeStamp.borrow_mut();
let mut time = imp.volume_time_stamp.borrow_mut();
if time.is_some() && time.unwrap().elapsed().unwrap() < Duration::from_millis(50) {
return Propagation::Proceed;
}

6
src/components/output/sinkEntryImpl.rs → src/components/output/sink_entry_impl.rs
View file

@ -4,7 +4,7 @@ use std::cell::RefCell;
use std::sync::Arc;
use std::time::SystemTime;
use crate::components::output::sinkEntry;
use crate::components::output::sink_entry;
use gtk::subclass::prelude::*;
use gtk::{glib, Button, CheckButton, CompositeTemplate, Label, ProgressBar, Scale};
use ReSet_Lib::audio::audio::Sink;
@ -26,14 +26,14 @@ pub struct SinkEntry {
#[template_child]
pub resetVolumeMeter: TemplateChild<ProgressBar>,
pub stream: Arc<RefCell<Sink>>,
pub volumeTimeStamp: RefCell<Option<SystemTime>>,
pub volume_time_stamp: RefCell<Option<SystemTime>>,
}
#[glib::object_subclass]
impl ObjectSubclass for SinkEntry {
const ABSTRACT: bool = false;
const NAME: &'static str = "resetSinkEntry";
type Type = sinkEntry::SinkEntry;
type Type = sink_entry::SinkEntry;
type ParentType = PreferencesGroup;
fn class_init(klass: &mut Self::Class) {