760 lines
27 KiB
Rust
760 lines
27 KiB
Rust
mod imp {
|
|
use crate::model::{Album, Song};
|
|
use crate::{mpris, mpv};
|
|
use adw::prelude::*;
|
|
use adw::subclass::prelude::*;
|
|
use glib::subclass::InitializingObject;
|
|
use glib::JoinHandle;
|
|
use gtk::{gdk, gio, glib};
|
|
use std::cell::{Cell, RefCell};
|
|
use std::rc::Rc;
|
|
use tracing::{event, span, Level};
|
|
use zbus::object_server::InterfaceRef;
|
|
|
|
#[derive(gtk::CompositeTemplate, glib::Properties)]
|
|
#[template(resource = "/eu/callcc/audrey/window.ui")]
|
|
#[properties(wrapper_type = super::Window)]
|
|
pub struct Window {
|
|
#[template_child]
|
|
pub(super) playbar: TemplateChild<crate::ui::Playbar>,
|
|
|
|
#[template_child]
|
|
pub(super) play_queue: TemplateChild<crate::ui::PlayQueue>,
|
|
|
|
#[property(get, set)]
|
|
can_click_shuffle_all: Cell<bool>,
|
|
|
|
#[property(get, set, nullable)]
|
|
playing_cover_art: RefCell<Option<gdk::Paintable>>,
|
|
|
|
#[property(type = Option<Song>, get = Self::song, nullable)]
|
|
_song: (),
|
|
|
|
pub(super) setup: crate::ui::Setup,
|
|
|
|
pub(super) api: RefCell<Option<Rc<crate::subsonic::Client>>>,
|
|
|
|
pub(super) mpv: mpv::Handle,
|
|
#[property(get)]
|
|
playlist_model: gio::ListStore,
|
|
|
|
#[property(get)]
|
|
albums_model: gio::ListStore,
|
|
|
|
#[property(type = i64, get = Self::volume, set = Self::set_volume, minimum = 0, maximum = 100)]
|
|
_volume: (),
|
|
#[property(type = bool, get = Self::mute, set = Self::set_mute)]
|
|
_mute: (),
|
|
#[property(type = bool, get = Self::pause, set = Self::set_pause)]
|
|
_pause: (),
|
|
#[property(type = i64, get = Self::playlist_pos)]
|
|
_playlist_pos: (),
|
|
#[property(type = f64, get = Self::time_pos)]
|
|
_time_pos: (),
|
|
#[property(type = f64, get = Self::duration)]
|
|
_duration: (), // as reported by mpv, compare with song.duration
|
|
#[property(type = bool, get = Self::idle_active)]
|
|
_idle_active: (),
|
|
#[property(type = i64, get = Self::playlist_count)]
|
|
_playlist_count: (),
|
|
|
|
pub(super) queued_seek: Cell<Option<f64>>,
|
|
|
|
pub(crate) initial_setup_handle: RefCell<Option<JoinHandle<()>>>,
|
|
mpv_event_loop_handle: RefCell<Option<JoinHandle<()>>>, // really !, not ()
|
|
zbus_executor_loop_handle: RefCell<Option<JoinHandle<()>>>, // same
|
|
|
|
loading_cover_handle: RefCell<Option<JoinHandle<()>>>,
|
|
|
|
buffering_timeout: Cell<Option<glib::SourceId>>,
|
|
time_pos_notify_timeout: Cell<Option<glib::SourceId>>,
|
|
|
|
mpris_player: RefCell<Option<InterfaceRef<mpris::Player>>>,
|
|
|
|
#[property(get, set)]
|
|
refreshing_albums: Cell<bool>,
|
|
}
|
|
|
|
impl Default for Window {
|
|
fn default() -> Self {
|
|
let mpv = mpv::Handle::new();
|
|
mpv.set_property("audio-client-name", "audrey").unwrap();
|
|
mpv.set_property("user-agent", crate::USER_AGENT).unwrap();
|
|
mpv.set_property("vid", false).unwrap();
|
|
mpv.set_property("prefetch-playlist", true).unwrap();
|
|
|
|
mpv.observe_property(3, "playlist-pos").unwrap();
|
|
mpv.observe_property(4, "idle-active").unwrap();
|
|
mpv.observe_property(6, "playlist-count").unwrap();
|
|
mpv.observe_property(7, "duration").unwrap();
|
|
|
|
// "Useful to drain property changes before a new file is loaded."
|
|
mpv.add_hook(0, "on_before_start_file", 0).unwrap();
|
|
|
|
Self {
|
|
playbar: Default::default(),
|
|
play_queue: Default::default(),
|
|
can_click_shuffle_all: Cell::new(false),
|
|
playing_cover_art: Default::default(),
|
|
_song: (),
|
|
setup: Default::default(),
|
|
api: Default::default(),
|
|
mpv,
|
|
|
|
playlist_model: gio::ListStore::new::<Song>(),
|
|
albums_model: gio::ListStore::new::<Album>(),
|
|
|
|
_volume: (),
|
|
_mute: (),
|
|
_pause: (),
|
|
_playlist_pos: (),
|
|
_time_pos: (),
|
|
_duration: (),
|
|
_idle_active: (),
|
|
_playlist_count: (),
|
|
|
|
queued_seek: Default::default(),
|
|
|
|
initial_setup_handle: Default::default(),
|
|
mpv_event_loop_handle: Default::default(),
|
|
zbus_executor_loop_handle: Default::default(),
|
|
|
|
loading_cover_handle: Default::default(),
|
|
|
|
buffering_timeout: Default::default(),
|
|
time_pos_notify_timeout: Default::default(),
|
|
|
|
mpris_player: Default::default(),
|
|
refreshing_albums: Cell::new(true),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[glib::object_subclass]
|
|
impl ObjectSubclass for Window {
|
|
const NAME: &'static str = "AudreyUiWindow";
|
|
type Type = super::Window;
|
|
type ParentType = adw::ApplicationWindow;
|
|
|
|
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 Window {
|
|
fn constructed(&self) {
|
|
self.parent_constructed();
|
|
|
|
// update time-pos every 100 ms
|
|
let window = self.obj().downgrade();
|
|
self.time_pos_notify_timeout
|
|
.replace(Some(glib::timeout_add_local(
|
|
std::time::Duration::from_millis(100),
|
|
move || match window.upgrade() {
|
|
None => glib::ControlFlow::Break,
|
|
Some(window) => {
|
|
if !window.idle_active() && !window.pause() {
|
|
window.notify("time-pos");
|
|
}
|
|
glib::ControlFlow::Continue
|
|
}
|
|
},
|
|
)));
|
|
|
|
let window = self.obj().downgrade();
|
|
let mpv_event_loop_handle = glib::spawn_future_local(async move {
|
|
loop {
|
|
let window = window.upgrade().unwrap();
|
|
let listener = window.imp().mpv.wakeup_listener();
|
|
|
|
// only send property change notifications after the event queue is drained
|
|
let freeze_notify = window.freeze_notify();
|
|
|
|
while let Some(event) = window.imp().mpv.wait_event(0.0) {
|
|
use crate::mpv::Event;
|
|
|
|
match event {
|
|
Event::PropertyChange(event) => window.imp().on_property_change(event),
|
|
Event::Hook(event) => window.imp().on_hook(event),
|
|
Event::LogMessage(event) => window.imp().on_log_message(event),
|
|
|
|
Event::StartFile(_) => window.imp().on_start_file(),
|
|
Event::FileLoaded => window.imp().on_file_loaded(),
|
|
Event::PlaybackRestart => window.imp().on_playback_restart(),
|
|
Event::Seek => window.imp().on_seek(),
|
|
Event::EndFile(event) => window.imp().on_end_file(event),
|
|
|
|
Event::Unknown(_) => {
|
|
// either deprecated or future, ignore
|
|
}
|
|
|
|
Event::AudioReconfig => {
|
|
// "This is relatively uninteresting, because there is no such thing as audio output embedding."
|
|
// ^ ignore
|
|
}
|
|
|
|
_ => event!(Level::DEBUG, "unhandled {event:?}"),
|
|
}
|
|
}
|
|
|
|
// send property change notifications now
|
|
drop(freeze_notify);
|
|
drop(window);
|
|
listener.await;
|
|
}
|
|
});
|
|
self.mpv_event_loop_handle
|
|
.replace(Some(mpv_event_loop_handle));
|
|
|
|
// set up mpris
|
|
let window = self.obj().clone();
|
|
let zbus_executor_loop_handle = glib::spawn_future_local(async move {
|
|
let conn = zbus::connection::Builder::session()
|
|
.expect("could not connect to the session bus")
|
|
.internal_executor(false)
|
|
.build()
|
|
.await
|
|
.expect("could not build connection to the session bus");
|
|
|
|
futures::join!(
|
|
glib::clone!(
|
|
#[strong]
|
|
conn,
|
|
async move {
|
|
crate::Mpris::setup(conn.object_server(), &window)
|
|
.await
|
|
.expect("could not serve mpris");
|
|
|
|
window.imp().mpris_player.replace(Some(
|
|
mpris::Player::new(conn.object_server(), &window)
|
|
.await
|
|
.expect("could not serve mpris player"),
|
|
));
|
|
|
|
// always set up handlers before requesting service name
|
|
conn.request_name("org.mpris.MediaPlayer2.audrey")
|
|
.await
|
|
.expect("could not register name in session bus");
|
|
}
|
|
),
|
|
async {
|
|
loop {
|
|
conn.executor().tick().await;
|
|
}
|
|
}
|
|
);
|
|
});
|
|
self.zbus_executor_loop_handle
|
|
.replace(Some(zbus_executor_loop_handle));
|
|
}
|
|
}
|
|
|
|
impl WidgetImpl for Window {}
|
|
|
|
impl WindowImpl for Window {}
|
|
|
|
impl ApplicationWindowImpl for Window {}
|
|
|
|
impl AdwApplicationWindowImpl for Window {}
|
|
|
|
#[gtk::template_callbacks]
|
|
impl Window {
|
|
#[template_callback]
|
|
fn show_playbar_cover_art(&self, stack_child: Option<&str>) -> bool {
|
|
stack_child != Some("play-queue")
|
|
}
|
|
|
|
#[template_callback]
|
|
async fn shuffle_all(&self) {
|
|
self.obj().set_can_click_shuffle_all(false);
|
|
|
|
self.mpv.command(["stop"]).unwrap();
|
|
self.playlist_model.remove_all();
|
|
self.set_pause(false);
|
|
|
|
let api = {
|
|
let api = self.api.borrow();
|
|
Rc::clone(api.as_ref().unwrap())
|
|
};
|
|
for song in api.random_songs(10).await.unwrap().into_iter() {
|
|
let song = Song::from_child(&api, &song, true);
|
|
self.mpv
|
|
.command(["loadfile", &song.stream_url(), "append-play"])
|
|
.unwrap();
|
|
self.playlist_model.append(&song);
|
|
}
|
|
self.obj().set_can_click_shuffle_all(true);
|
|
}
|
|
|
|
#[template_callback]
|
|
fn show_setup_dialog(&self) {
|
|
self.setup.present(Some(self.obj().as_ref()));
|
|
}
|
|
|
|
fn volume(&self) -> i64 {
|
|
self.mpv.get_property("volume").unwrap()
|
|
}
|
|
|
|
fn set_volume(&self, volume: i64) {
|
|
self.mpv.set_property("volume", volume).unwrap();
|
|
}
|
|
|
|
fn mute(&self) -> bool {
|
|
self.mpv.get_property("mute").unwrap()
|
|
}
|
|
|
|
fn set_mute(&self, mute: bool) {
|
|
self.mpv.set_property("mute", mute).unwrap();
|
|
}
|
|
|
|
fn pause(&self) -> bool {
|
|
self.mpv.get_property("pause").unwrap()
|
|
}
|
|
|
|
fn set_pause(&self, pause: bool) {
|
|
self.mpv.set_property("pause", pause).unwrap();
|
|
}
|
|
|
|
fn playlist_pos(&self) -> i64 {
|
|
self.mpv.get_property("playlist-pos").unwrap()
|
|
}
|
|
|
|
fn time_pos(&self) -> f64 {
|
|
if let Some(queued_seek) = self.queued_seek.get() {
|
|
// counterfeit time-pos while the seek is ongoing
|
|
queued_seek
|
|
} else {
|
|
match self.mpv.get_property("time-pos") {
|
|
Ok(time_pos) => Ok(time_pos),
|
|
Err(err) if err.is_property_unavailable() => Ok(0.0), //placeholder
|
|
Err(err) => Err(err),
|
|
}
|
|
.unwrap()
|
|
}
|
|
}
|
|
|
|
fn duration(&self) -> f64 {
|
|
let duration = match self.mpv.get_property::<f64>("duration") {
|
|
Ok(duration) => Ok(Some(duration)),
|
|
Err(err) if err.is_property_unavailable() => {
|
|
Ok(self.song().as_ref().map(|song| song.duration() as f64))
|
|
}
|
|
Err(err) => Err(err),
|
|
}
|
|
.unwrap();
|
|
|
|
{
|
|
let left = duration.map(|f| f as i64);
|
|
let right = self.song().as_ref().map(crate::model::Song::duration);
|
|
if left != right {
|
|
event!(
|
|
Level::WARN,
|
|
"mpv duration {left:?} doesn not match subsonic duration {right:?}"
|
|
);
|
|
}
|
|
}
|
|
|
|
duration.unwrap_or(0.0) // placeholder
|
|
}
|
|
|
|
fn idle_active(&self) -> bool {
|
|
self.mpv.get_property("idle-active").unwrap()
|
|
}
|
|
|
|
fn playlist_count(&self) -> i64 {
|
|
self.mpv.get_property::<i64>("playlist-count").unwrap()
|
|
}
|
|
|
|
fn song(&self) -> Option<Song> {
|
|
match self.obj().playlist_pos().try_into() {
|
|
Ok(playlist_pos) => Some(
|
|
self.obj()
|
|
.playlist_model()
|
|
.item(playlist_pos)
|
|
.unwrap()
|
|
.dynamic_cast()
|
|
.unwrap(),
|
|
),
|
|
Err(_) => None,
|
|
}
|
|
}
|
|
|
|
fn buffering_start(&self) {
|
|
let started_buffering = std::time::Instant::now();
|
|
let window = self.obj().downgrade();
|
|
if let Some(source) = self.buffering_timeout.replace(Some(glib::timeout_add_local(
|
|
std::time::Duration::from_millis(100),
|
|
move || {
|
|
match window.upgrade() {
|
|
None => glib::ControlFlow::Break,
|
|
Some(window) => {
|
|
// 3 second period from gnome hig
|
|
if started_buffering.elapsed() > std::time::Duration::from_secs(3) {
|
|
window.imp().playbar.set_show_pulse_bar(true);
|
|
window.imp().playbar.pulse_bar().pulse();
|
|
}
|
|
glib::ControlFlow::Continue
|
|
}
|
|
}
|
|
},
|
|
))) {
|
|
source.remove()
|
|
}
|
|
}
|
|
|
|
fn buffering_end(&self) {
|
|
if let Some(source) = self.buffering_timeout.take() {
|
|
source.remove();
|
|
}
|
|
self.playbar.set_show_pulse_bar(false);
|
|
}
|
|
|
|
fn on_property_change(&self, event: crate::mpv::event::PropertyEvent) {
|
|
match event.reply_userdata {
|
|
3 => {
|
|
assert_eq!(event.name, "playlist-pos");
|
|
self.obj().notify("playlist-pos");
|
|
}
|
|
|
|
4 => {
|
|
assert_eq!(event.name, "idle-active");
|
|
self.obj().notify("idle-active");
|
|
}
|
|
|
|
6 => {
|
|
assert_eq!(event.name, "playlist-count");
|
|
self.obj().notify("playlist-count");
|
|
}
|
|
|
|
7 => {
|
|
assert_eq!(event.name, "duration");
|
|
self.obj().notify("duration");
|
|
}
|
|
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
|
|
fn on_hook(&self, event: crate::mpv::event::HookEvent) {
|
|
match event.reply_userdata {
|
|
0 => {
|
|
assert_eq!(&event.name, "on_before_start_file");
|
|
event!(Level::DEBUG, "on_before_start_file triggered");
|
|
// just use this as a barrier
|
|
self.mpv.continue_hook(event.id).unwrap();
|
|
}
|
|
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
|
|
fn on_log_message(&self, event: crate::mpv::event::LogMessageEvent) {
|
|
let span = span!(Level::DEBUG, "mpv_log", prefix = event.prefix);
|
|
let _guard = span.enter();
|
|
match event.log_level {
|
|
// level has to be 'static so this sux
|
|
l if l <= 20 => {
|
|
event!(target: "mpv_event", Level::ERROR, "{}", event.text.trim())
|
|
}
|
|
l if l <= 30 => {
|
|
event!(target: "mpv_event", Level::WARN, "{}", event.text.trim())
|
|
}
|
|
l if l <= 40 => {
|
|
event!(target: "mpv_event", Level::INFO, "{}", event.text.trim())
|
|
}
|
|
l if l <= 60 => {
|
|
event!(target: "mpv_event", Level::DEBUG, "{}", event.text.trim())
|
|
}
|
|
l if l <= 70 => {
|
|
event!(target: "mpv_event", Level::TRACE, "{}", event.text.trim())
|
|
}
|
|
// should be unused
|
|
_ => event!(
|
|
target: "mpv_erroneus_event",
|
|
Level::DEBUG,
|
|
log_level = event.log_level,
|
|
"{}",
|
|
event.text.trim(),
|
|
),
|
|
};
|
|
}
|
|
|
|
fn on_start_file(&self) {
|
|
event!(Level::INFO, "StartFile");
|
|
self.obj().notify("song");
|
|
self.buffering_start();
|
|
|
|
let window = self.obj().clone();
|
|
let song_id = window.song().unwrap().id();
|
|
if let Some(handle) = self
|
|
.loading_cover_handle
|
|
.replace(Some(glib::spawn_future_local(async move {
|
|
let api = window.imp().api.borrow().as_ref().unwrap().clone();
|
|
let bytes = api
|
|
.cover_art(&song_id, None) // full size
|
|
.await
|
|
.expect("could not load cover art for song {song_id}");
|
|
|
|
match window.song() {
|
|
Some(song) if song.id() == song_id => {
|
|
let texture = gdk::Texture::from_bytes(&glib::Bytes::from_owned(bytes))
|
|
.expect("could not create texture from cover art for {song_id}");
|
|
window.set_playing_cover_art(Some(texture));
|
|
}
|
|
_ => {
|
|
event!(
|
|
Level::WARN,
|
|
"was too late to fetch cover for song {song_id}"
|
|
)
|
|
}
|
|
}
|
|
})))
|
|
{
|
|
handle.abort();
|
|
}
|
|
|
|
// make sure this is reported as 0
|
|
self.obj().notify("time-pos");
|
|
}
|
|
|
|
fn on_file_loaded(&self) {
|
|
event!(Level::INFO, "FileLoaded");
|
|
// sanity check
|
|
// i think "path" is only available after this event is dispatched
|
|
assert_eq!(
|
|
self.mpv.get_property::<String>("path").unwrap(),
|
|
self.obj().song().unwrap().stream_url()
|
|
);
|
|
}
|
|
|
|
fn on_seek(&self) {
|
|
event!(Level::INFO, "Seek");
|
|
self.buffering_start();
|
|
}
|
|
|
|
fn on_playback_restart(&self) {
|
|
event!(Level::INFO, "PlaybackRestart");
|
|
self.buffering_end();
|
|
self.obj().notify("time-pos");
|
|
|
|
if let Some(queued_seek) = self.queued_seek.take() {
|
|
// a seek was tried before and failed, try again now
|
|
event!(Level::INFO, "performing queued seek to {queued_seek}");
|
|
self.obj().seek(queued_seek);
|
|
}
|
|
}
|
|
|
|
fn on_end_file(&self, event: crate::mpv::event::EndFileEvent) {
|
|
event!(Level::INFO, "EndFile: {event:?}");
|
|
self.obj().notify("song");
|
|
self.buffering_end();
|
|
|
|
if let Err(err) = event.reason {
|
|
event!(Level::ERROR, "end file error: {err}");
|
|
}
|
|
|
|
// cancel queued seek always
|
|
self.queued_seek.set(None);
|
|
|
|
self.obj().set_playing_cover_art(None::<gdk::Texture>);
|
|
|
|
// make sure the seekbar looks full
|
|
self.obj().notify("time-pos");
|
|
}
|
|
|
|
#[template_callback]
|
|
pub(super) async fn on_refresh_albums_clicked(&self) {
|
|
self.obj().set_refreshing_albums(true);
|
|
self.albums_model.remove_all();
|
|
|
|
let api = Rc::clone(self.api.borrow().as_ref().unwrap());
|
|
let albums_model = self.obj().albums_model().clone();
|
|
let perform = async move {
|
|
use futures::TryStreamExt;
|
|
|
|
let mut albums =
|
|
std::pin::pin!(api.album_list_full(crate::subsonic::AlbumListType::Newest));
|
|
while let Some(album) = albums.try_next().await? {
|
|
albums_model.append(
|
|
&glib::Object::builder::<crate::model::Album>()
|
|
.property("id", &album.id)
|
|
.property("name", &album.name)
|
|
.property("artist", &album.artist)
|
|
.build(),
|
|
);
|
|
}
|
|
|
|
Ok::<(), crate::subsonic::Error>(())
|
|
};
|
|
|
|
match perform.await {
|
|
Ok(()) => {}
|
|
Err(err) => event!(Level::ERROR, "could not refresh album list: {err}"),
|
|
}
|
|
|
|
self.obj().set_refreshing_albums(false);
|
|
}
|
|
}
|
|
|
|
impl Drop for Window {
|
|
fn drop(&mut self) {
|
|
event!(Level::DEBUG, "dropping AudreyUiWindow");
|
|
|
|
self.mpv_event_loop_handle.take().unwrap().abort();
|
|
self.zbus_executor_loop_handle.take().unwrap().abort();
|
|
|
|
if let Some(source) = self.time_pos_notify_timeout.take() {
|
|
source.remove();
|
|
}
|
|
if let Some(source) = self.buffering_timeout.take() {
|
|
source.remove();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
use adw::prelude::*;
|
|
use adw::subclass::prelude::*;
|
|
use gtk::{gio, glib};
|
|
use std::rc::Rc;
|
|
use tracing::{event, Level};
|
|
|
|
glib::wrapper! {
|
|
pub struct Window(ObjectSubclass<imp::Window>)
|
|
@extends adw::ApplicationWindow, gtk::ApplicationWindow, gtk::Window, gtk::Widget,
|
|
@implements gio::ActionGroup, gio::ActionMap, gtk::Accessible, gtk::Buildable, gtk::ConstraintTarget, gtk::Native, gtk::Root, gtk::ShortcutManager;
|
|
}
|
|
|
|
impl Window {
|
|
pub fn new(app: &impl IsA<gtk::Application>) -> Self {
|
|
let window: Self = glib::Object::builder().property("application", app).build();
|
|
|
|
window.imp().setup.set_window(&window);
|
|
let initial_setup_handle = {
|
|
let setup = window.imp().setup.clone();
|
|
glib::spawn_future_local(async move { setup.load().await })
|
|
};
|
|
window
|
|
.imp()
|
|
.initial_setup_handle
|
|
.replace(Some(initial_setup_handle));
|
|
|
|
window
|
|
}
|
|
|
|
pub fn playbin(&self) -> ! {
|
|
todo!()
|
|
}
|
|
|
|
pub fn playlist_play_index(&self, index: Option<i64>) {
|
|
match index.as_ref() {
|
|
Some(index) => self
|
|
.imp()
|
|
.mpv
|
|
.command(["playlist-play-index", &index.to_string()])
|
|
.unwrap(),
|
|
None => self
|
|
.imp()
|
|
.mpv
|
|
.command(["playlist-play-index", "none"])
|
|
.unwrap(),
|
|
};
|
|
}
|
|
|
|
pub fn playlist_remove(&self, index: i64) {
|
|
self.imp()
|
|
.mpv
|
|
.command(["playlist-remove", &index.to_string()])
|
|
.unwrap();
|
|
self.playlist_model().remove(index as u32);
|
|
}
|
|
|
|
pub fn setup_connected(&self, api: crate::subsonic::Client) {
|
|
if self.imp().api.replace(Some(Rc::new(api))).is_some() {
|
|
unimplemented!("changing the api object");
|
|
}
|
|
|
|
self.set_can_click_shuffle_all(true);
|
|
|
|
let window = self.clone();
|
|
glib::spawn_future_local(async move { window.imp().on_refresh_albums_clicked().await });
|
|
}
|
|
|
|
pub fn playlist_next(&self) {
|
|
self.imp().mpv.command(["playlist-next"]).unwrap();
|
|
}
|
|
|
|
pub fn playlist_prev(&self) {
|
|
self.imp().mpv.command(["playlist-prev"]).unwrap();
|
|
}
|
|
|
|
pub fn seek(&self, new_position: f64) {
|
|
match self
|
|
.imp()
|
|
.mpv
|
|
.command(["seek", &new_position.to_string(), "absolute", "exact"])
|
|
{
|
|
Ok(()) => {}
|
|
Err(err) => {
|
|
event!(Level::INFO, "queuing seek to {new_position}: {err}");
|
|
self.imp().queued_seek.set(Some(new_position));
|
|
self.notify("time-pos");
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn playlist_move(&self, from: u32, to: u32) {
|
|
// NOTE: for mpv, to refers to the "gap" right before i
|
|
// so playlist-move i 0 makes a track the first
|
|
// playlist-move i 1 makes a track the second
|
|
// and playlist-move i playlist-count makes a track the last
|
|
// (so if to is the position of another track, from is left behind to)
|
|
self.imp()
|
|
.mpv
|
|
.command(["playlist-move", &from.to_string(), &to.to_string()])
|
|
.unwrap();
|
|
|
|
use std::cmp::Ordering;
|
|
match from.cmp(&to) {
|
|
Ordering::Less => {
|
|
// F1234T -> 1234FT
|
|
let mut spliced = Vec::with_capacity((to - from) as usize);
|
|
for i in from + 1..to {
|
|
spliced.push(self.playlist_model().item(i).unwrap());
|
|
}
|
|
spliced.push(self.playlist_model().item(from).unwrap());
|
|
|
|
self.playlist_model()
|
|
.splice(from, spliced.len() as u32, &spliced);
|
|
}
|
|
Ordering::Greater => {
|
|
// T1234F -> FT1234
|
|
let mut spliced = Vec::with_capacity((from - to + 1) as usize);
|
|
spliced.push(self.playlist_model().item(from).unwrap());
|
|
spliced.push(self.playlist_model().item(to).unwrap());
|
|
for i in to + 1..from {
|
|
spliced.push(self.playlist_model().item(i).unwrap());
|
|
}
|
|
|
|
self.playlist_model()
|
|
.splice(to, spliced.len() as u32, &spliced);
|
|
}
|
|
Ordering::Equal => {}
|
|
}
|
|
}
|
|
|
|
pub fn stop(&self) {
|
|
self.imp().mpv.command(["stop"]).unwrap();
|
|
self.playlist_model().remove_all();
|
|
}
|
|
|
|
pub fn api(&self) -> Rc<crate::subsonic::Client> {
|
|
Rc::clone(self.imp().api.borrow().as_ref().unwrap())
|
|
}
|
|
}
|