volume slider works again

resources/playbar.blp

@@ -121,7 +121,7 @@ template $AudreyUiPlaybar: Adw.Bin {
           valign: center;
           sensitive: bind $can_press_play (template.playbin as <$AudreyPlaybin>.state as <$AudreyPlaybinState>, template.playbin as <$AudreyPlaybin>.play-queue-length) as <bool>;
 
-          clicked => $on_play_pause_clicked ();
+          clicked => $on_play_pause_clicked (template);
         }
 
         Button {

src/playbin.rs

@@ -19,6 +19,11 @@ mod ffi {
 
     extern "C" {
         pub fn audrey_playbin_get_type() -> glib::ffi::GType;
+        pub fn audrey_playbin_get_state(self_: *mut AudreyPlaybin) -> super::state::ffi::State;
+        pub fn audrey_playbin_pause(self_: *mut AudreyPlaybin);
+        pub fn audrey_playbin_play(self_: *mut AudreyPlaybin);
+        pub fn audrey_playbin_get_volume(self_: *mut AudreyPlaybin) -> std::ffi::c_int;
+        pub fn audrey_playbin_set_volume(self_: *mut AudreyPlaybin, volume: std::ffi::c_int);
     }
 }
 
@@ -31,3 +36,35 @@ glib::wrapper! {
         type_ => || ffi::audrey_playbin_get_type(),
     }
 }
+
+impl Playbin {
+    pub fn get_state(&self) -> State {
+        use glib::translate::ToGlibPtr;
+
+        unsafe { glib::translate::from_glib(ffi::audrey_playbin_get_state(self.to_glib_none().0)) }
+    }
+
+    pub fn pause(&self) {
+        use glib::translate::ToGlibPtr;
+
+        unsafe { ffi::audrey_playbin_pause(self.to_glib_none().0) }
+    }
+
+    pub fn play(&self) {
+        use glib::translate::ToGlibPtr;
+
+        unsafe { ffi::audrey_playbin_play(self.to_glib_none().0) }
+    }
+
+    pub fn get_volume(&self) -> i32 {
+        use glib::translate::ToGlibPtr;
+
+        unsafe { ffi::audrey_playbin_get_volume(self.to_glib_none().0) }
+    }
+
+    pub fn set_volume(&self, value: i32) {
+        use glib::translate::ToGlibPtr;
+
+        unsafe { ffi::audrey_playbin_set_volume(self.to_glib_none().0, value) }
+    }
+}

src/playbin/state.rs

@@ -1,13 +1,15 @@
-mod ffi {
+pub mod ffi {
     use gtk::glib;
 
+    pub type State = std::ffi::c_int;
+
     extern "C" {
         pub fn audrey_playbin_state_get_type() -> glib::ffi::GType;
     }
 }
 
-use gtk::glib;
 use glib::prelude::*;
+use gtk::glib;
 
 #[derive(Copy, Clone, PartialEq, Eq)]
 pub enum State {
@@ -16,13 +18,9 @@ pub enum State {
     Playing,
 }
 
-unsafe impl<'a> glib::value::FromValue<'a> for State {
-    type Checker = glib::value::GenericValueTypeChecker<Self>;
-
-    unsafe fn from_value(value: &'a glib::Value) -> Self {
-        use glib::translate::ToGlibPtr;
-
-        match glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0) {
+impl glib::translate::FromGlib<ffi::State> for State {
+    unsafe fn from_glib(value: ffi::State) -> Self {
+        match value {
             0 => Self::Stopped,
             1 => Self::Paused,
             2 => Self::Playing,
@@ -31,6 +29,16 @@ unsafe impl<'a> glib::value::FromValue<'a> for State {
     }
 }
 
+unsafe impl<'a> glib::value::FromValue<'a> for State {
+    type Checker = glib::value::GenericValueTypeChecker<Self>;
+
+    unsafe fn from_value(value: &'a glib::Value) -> Self {
+        use glib::translate::ToGlibPtr;
+
+        glib::translate::from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
+    }
+}
+
 impl StaticType for State {
     fn static_type() -> glib::Type {
         unsafe { glib::translate::from_glib(ffi::audrey_playbin_state_get_type()) }

src/ui/playbar.rs

@@ -18,8 +18,8 @@ mod imp {
         #[property(get, set, default = true)]
         show_cover_art: Cell<bool>,
 
-        #[property(get, set)]
-        volume: Cell<i32>,
+        #[property(get = Self::get_volume, set = Self::set_volume)]
+        volume: i32,
     }
 
     #[glib::object_subclass]
@@ -96,11 +96,20 @@ mod imp {
 
         #[template_callback]
         fn mute_button_icon_name(&self, mute: bool) -> &'static str {
-            if mute { "audio-volume-muted" } else { "audio-volume-high" }
+            if mute {
+                "audio-volume-muted"
+            } else {
+                "audio-volume-high"
+            }
         }
 
         #[template_callback]
-        fn on_play_position_seek(&self, _range: &gtk::Range, _scroll_type: gtk::ScrollType, _value: f64) -> bool {
+        fn on_play_position_seek(
+            &self,
+            _range: &gtk::Range,
+            _scroll_type: gtk::ScrollType,
+            _value: f64,
+        ) -> bool {
             /*
             if (range.adjustment.lower < range.adjustment.upper) {
                 this.playbin.seek ((int64) value);
@@ -141,13 +150,15 @@ mod imp {
         }
 
         #[template_callback]
-        fn on_play_pause_clicked(&self) {
-            // if (this.playbin.state == PlaybinState.PLAYING) {
-            //     this.playbin.pause();
-            // } else {
-            //     this.playbin.play();
-            // }
-            todo!()
+        fn on_play_pause_clicked(&self, _button: &gtk::Button) {
+            let playbin = self.playbin.borrow();
+            let playbin = playbin.as_ref().unwrap();
+
+            if playbin.get_state() == crate::playbin::State::Playing {
+                playbin.pause();
+            } else {
+                playbin.play();
+            }
         }
 
         #[template_callback]
@@ -155,6 +166,21 @@ mod imp {
             //this.playbin.mute = !this.playbin.mute;
             todo!()
         }
+
+        fn get_volume(&self) -> i32 {
+            let playbin = self.playbin.borrow();
+
+            match playbin.as_ref() {
+                None => 100,
+                Some(playbin) => playbin.get_volume(),
+            }
+        }
+
+        fn set_volume(&self, value: i32) {
+            let playbin = self.playbin.borrow();
+            let playbin = playbin.as_ref().unwrap();
+            playbin.set_volume(value);
+        }
     }
 }