audrey/src/ui/playbar.rs

mod imp {
    use crate::PlaybinSong;
    use adw::prelude::*;
    use adw::subclass::prelude::*;
    use glib::subclass::InitializingObject;
    use gtk::{gdk, glib};
    use std::cell::{Cell, RefCell};
    use tracing::{event, Level};

    #[derive(glib::Properties, gtk::CompositeTemplate, Default)]
    #[properties(wrapper_type = super::Playbar)]
    #[template(resource = "/eu/callcc/audrey/playbar.ui")]
    pub struct Playbar {
        #[property(get, set)]
        song: RefCell<Option<PlaybinSong>>,
        #[property(get, set)]
        playing_cover_art: RefCell<Option<gdk::Paintable>>,
        #[property(get, set, default = true)]
        show_cover_art: Cell<bool>,

        // synced with root window
        #[property(get, set)]
        _volume: Cell<u32>,
        #[property(get, set)]
        _mute: Cell<bool>,
        #[property(get, set)]
        _pause: Cell<bool>,
        #[property(get, set)]
        _idle_active: Cell<bool>,
        #[property(get, set)]
        _playlist_count: Cell<u32>,

        #[property(get, set)]
        position: Cell<f64>,
        #[property(get, set)]
        duration: Cell<f64>,
    }

    #[glib::object_subclass]
    impl ObjectSubclass for Playbar {
        const NAME: &'static str = "AudreyUiPlaybar";
        type Type = super::Playbar;
        type ParentType = adw::Bin;

        fn class_init(klass: &mut Self::Class) {
            klass.bind_template();
            klass.bind_template_callbacks();
        }

        fn instance_init(obj: &InitializingObject<Self>) {
            obj.init_template();
        }
    }

    #[glib::derived_properties]
    impl ObjectImpl for Playbar {}

    impl WidgetImpl for Playbar {}

    impl BinImpl for Playbar {}

    #[gtk::template_callbacks]
    impl Playbar {
        #[template_callback]
        fn format_timestamp(&self, s: f64) -> String {
            format!("{:02}:{:02}", (s as i64) / 64, (s as i64) % 60)
        }

        #[template_callback]
        fn mute_button_icon_name(&self, mute: bool) -> &'static str {
            if mute {
                "audio-volume-muted"
            } else {
                "audio-volume-high"
            }
        }

        #[template_callback]
        fn on_play_position_seek(
            &self,
            _scroll_type: gtk::ScrollType,
            value: f64,
            _range: &gtk::Range,
        ) -> bool {
            self.window().seek(value);
            false
        }

        #[template_callback]
        fn on_skip_forward_clicked(&self) {
            self.window().playlist_next();
        }

        #[template_callback]
        fn on_skip_backward_clicked(&self) {
            self.window().playlist_prev();
        }

        #[template_callback]
        fn seek_backward(&self) {
            // 10 seconds
            let mut new_position = self.window().time_pos() - 10.0;
            if new_position < 0.0 {
                new_position = 0.0;
            }
            self.window().seek(new_position);
        }

        #[template_callback]
        fn seek_forward(&self) {
            // 10 seconds
            let new_position = self.window().time_pos() + 10.0;
            if new_position > self.window().duration() {
                // just seek to the next track
                self.on_skip_forward_clicked();
            }
            self.window().seek(new_position);
        }

        #[template_callback]
        fn on_play_pause_clicked(&self, _button: &gtk::Button) {
            self.window().set_pause(!self.window().pause());
        }

        #[template_callback]
        fn on_mute_toggle(&self) {
            self.obj().set_mute(!self.obj().mute());
        }

        #[template_callback]
        fn play_pause_icon_name(&self, idle_active: bool, pause: bool) -> &'static str {
            match (idle_active, pause) {
                (true, _) => "media-playback-start",
                (false, true) => "media-playback-start",
                (false, false) => "media-playback-pause",
            }
        }

        #[template_callback]
        fn play_pause_sensitive(&self, playlist_count: u32) -> bool {
            playlist_count > 0
        }

        fn window(&self) -> crate::ui::Window {
            self.obj().root().unwrap().dynamic_cast().unwrap()
        }
    }

    impl Drop for Playbar {
        fn drop(&mut self) {
            event!(Level::DEBUG, "dropping AudreyUiPlaybar");
        }
    }
}

use gtk::glib;

glib::wrapper! {
    pub struct Playbar(ObjectSubclass<imp::Playbar>)
        @extends adw::Bin, gtk::Widget,
        @implements gtk::Accessible, gtk::Buildable, gtk::ConstraintTarget;
}