2015-12-10 13:59:21 -05:00
|
|
|
/*
|
2013-12-22 17:24:09 -05:00
|
|
|
* Copyright 2013 (c) Anna Schumaker.
|
|
|
|
*/
|
2014-06-05 10:19:22 -04:00
|
|
|
#include <core/playlist.h>
|
2016-08-01 09:41:10 -04:00
|
|
|
#include <core/settings.h>
|
2016-08-16 10:21:22 -04:00
|
|
|
#include <core/string.h>
|
2016-05-13 13:50:59 -04:00
|
|
|
|
2016-08-16 10:21:22 -04:00
|
|
|
static const gchar *SETTINGS_CUR_TYPE = "core.playlist.cur.type";
|
|
|
|
static const gchar *SETTINGS_CUR_ID = "core.playlist.cur.id";
|
|
|
|
static const gchar *SETTINGS_PREV_TYPE = "core.playlist.prev.type";
|
|
|
|
static const gchar *SETTINGS_PREV_ID = "core.playlist.prev.id";
|
2013-12-22 17:24:09 -05:00
|
|
|
|
2016-05-06 08:05:21 -04:00
|
|
|
struct playlist_type *playlist_types[] = {
|
|
|
|
[PL_SYSTEM] = &pl_system,
|
2016-05-15 10:19:31 -04:00
|
|
|
[PL_ARTIST] = &pl_artist,
|
2016-05-09 07:52:10 -04:00
|
|
|
[PL_LIBRARY] = &pl_library,
|
2016-08-14 10:20:15 -04:00
|
|
|
[PL_USER] = &pl_user,
|
2016-05-06 08:05:21 -04:00
|
|
|
};
|
|
|
|
|
2015-12-10 10:55:53 -05:00
|
|
|
|
2015-12-09 08:11:21 -05:00
|
|
|
void playlist_init(struct queue_ops *ops)
|
2014-05-18 21:09:46 -04:00
|
|
|
{
|
2016-04-24 10:36:15 -04:00
|
|
|
pl_system_init(ops);
|
2016-05-15 10:19:31 -04:00
|
|
|
pl_artist_init(ops);
|
2016-08-14 10:20:15 -04:00
|
|
|
pl_user_init(ops);
|
2016-05-09 07:52:10 -04:00
|
|
|
pl_library_init(ops);
|
2016-08-01 09:41:10 -04:00
|
|
|
|
|
|
|
if (!settings_has(SETTINGS_CUR_TYPE) ||
|
2016-08-16 10:21:22 -04:00
|
|
|
!settings_has(SETTINGS_CUR_ID)) {
|
2016-08-01 09:41:10 -04:00
|
|
|
playlist_select(PL_SYSTEM, "Collection");
|
2016-09-10 14:31:43 -04:00
|
|
|
if (playlist_size(playlist_get(PL_SYSTEM, "Queued Tracks")) > 0)
|
2016-08-16 10:21:22 -04:00
|
|
|
playlist_select(PL_SYSTEM, "Queued Tracks");
|
|
|
|
}
|
2014-05-18 21:09:46 -04:00
|
|
|
}
|
2014-02-02 14:11:38 -05:00
|
|
|
|
2015-12-09 09:20:18 -05:00
|
|
|
void playlist_deinit()
|
|
|
|
{
|
2016-04-24 10:36:15 -04:00
|
|
|
pl_system_deinit();
|
2016-05-15 10:19:31 -04:00
|
|
|
pl_artist_deinit();
|
2016-08-14 10:20:15 -04:00
|
|
|
pl_user_deinit();
|
2016-05-09 07:52:10 -04:00
|
|
|
pl_library_deinit();
|
2015-12-09 09:20:18 -05:00
|
|
|
}
|
|
|
|
|
2016-08-12 16:12:17 -04:00
|
|
|
void playlist_save()
|
|
|
|
{
|
|
|
|
unsigned int i;
|
|
|
|
for (i = 0; i < PL_MAX_TYPE; i++)
|
|
|
|
playlist_types[i]->pl_save();
|
|
|
|
}
|
|
|
|
|
2016-08-01 09:41:10 -04:00
|
|
|
bool playlist_select(enum playlist_type_t type, const gchar *name)
|
|
|
|
{
|
|
|
|
if (!playlist_types[type]->pl_can_select(name))
|
|
|
|
return false;
|
2016-10-19 07:54:31 -04:00
|
|
|
if ((settings_get(SETTINGS_CUR_TYPE) == type) &&
|
|
|
|
settings_get(SETTINGS_CUR_ID) == playlist_get_id(type, name))
|
|
|
|
return true;
|
2016-08-01 09:41:10 -04:00
|
|
|
|
2016-08-16 10:21:22 -04:00
|
|
|
settings_set(SETTINGS_PREV_TYPE, settings_get(SETTINGS_CUR_TYPE));
|
|
|
|
settings_set(SETTINGS_PREV_ID, settings_get(SETTINGS_CUR_ID));
|
|
|
|
settings_set(SETTINGS_CUR_TYPE, type);
|
|
|
|
settings_set(SETTINGS_CUR_ID, playlist_get_id(type, name));
|
2016-08-01 09:41:10 -04:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-09-09 08:35:52 -04:00
|
|
|
struct playlist *playlist_new(enum playlist_type_t type, const gchar *name)
|
2016-05-09 10:38:47 -04:00
|
|
|
{
|
2016-09-09 08:35:52 -04:00
|
|
|
if (type < PL_MAX_TYPE && playlist_types[type]->pl_new)
|
|
|
|
return playlist_types[type]->pl_new(name);
|
|
|
|
return NULL;
|
2016-05-09 10:38:47 -04:00
|
|
|
}
|
|
|
|
|
2016-09-09 10:17:37 -04:00
|
|
|
bool playlist_delete(struct playlist *playlist)
|
2016-05-09 10:38:47 -04:00
|
|
|
{
|
2016-09-09 10:17:37 -04:00
|
|
|
enum playlist_type_t type;
|
|
|
|
bool ret;
|
|
|
|
|
|
|
|
if (!playlist || !playlist->pl_ops->pl_delete)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
type = playlist->pl_type;
|
|
|
|
ret = playlist->pl_ops->pl_delete(playlist);
|
|
|
|
if (ret)
|
|
|
|
playlist_types[type]->pl_save();
|
|
|
|
return ret;
|
2016-05-09 10:38:47 -04:00
|
|
|
}
|
|
|
|
|
2016-09-10 12:08:11 -04:00
|
|
|
bool playlist_add(struct playlist *playlist, struct track *track)
|
2013-12-22 17:53:58 -05:00
|
|
|
{
|
2016-08-16 10:21:22 -04:00
|
|
|
bool ret;
|
|
|
|
|
2016-09-10 12:08:11 -04:00
|
|
|
if (!track || !playlist || !playlist->pl_ops->pl_add)
|
2016-04-22 13:56:42 -04:00
|
|
|
return false;
|
2016-08-16 10:21:22 -04:00
|
|
|
|
2016-09-10 12:08:11 -04:00
|
|
|
ret = playlist->pl_ops->pl_add(playlist, track);
|
|
|
|
if (ret)
|
|
|
|
playlist_types[playlist->pl_type]->pl_save();
|
|
|
|
if (playlist == playlist_get(PL_SYSTEM, "Queued Tracks"))
|
2016-08-16 10:21:22 -04:00
|
|
|
playlist_select(PL_SYSTEM, "Queued Tracks");
|
|
|
|
return ret;
|
2013-12-22 17:53:58 -05:00
|
|
|
}
|
|
|
|
|
2016-09-10 13:11:18 -04:00
|
|
|
bool playlist_remove(struct playlist *playlist, struct track *track)
|
2013-12-22 17:53:58 -05:00
|
|
|
{
|
2016-09-10 13:11:18 -04:00
|
|
|
bool ret;
|
|
|
|
|
|
|
|
if (!track || !playlist || !playlist->pl_ops->pl_remove)
|
2016-04-22 13:56:42 -04:00
|
|
|
return false;
|
2016-09-10 13:11:18 -04:00
|
|
|
|
|
|
|
ret = playlist->pl_ops->pl_remove(playlist, track);
|
|
|
|
if (ret)
|
|
|
|
playlist_types[playlist->pl_type]->pl_save();
|
|
|
|
return ret;
|
2013-12-22 17:53:58 -05:00
|
|
|
}
|
2013-12-22 20:53:06 -05:00
|
|
|
|
2016-05-06 08:05:21 -04:00
|
|
|
void playlist_update(enum playlist_type_t type, const gchar *name)
|
2016-05-01 09:17:21 -04:00
|
|
|
{
|
2016-05-06 08:05:21 -04:00
|
|
|
playlist_types[type]->pl_update(name);
|
2016-05-01 09:17:21 -04:00
|
|
|
}
|
|
|
|
|
2016-09-10 13:46:30 -04:00
|
|
|
bool playlist_has(struct playlist *playlist, struct track *track)
|
2015-12-09 09:31:12 -05:00
|
|
|
{
|
2016-09-10 13:46:30 -04:00
|
|
|
if (!playlist || !track)
|
2015-12-09 09:31:12 -05:00
|
|
|
return false;
|
2016-09-10 13:46:30 -04:00
|
|
|
return queue_has(&playlist->pl_queue, track);
|
2015-12-09 09:31:12 -05:00
|
|
|
}
|
|
|
|
|
2016-09-10 14:31:43 -04:00
|
|
|
unsigned int playlist_size(struct playlist *playlist)
|
2016-04-28 10:10:11 -04:00
|
|
|
{
|
2016-09-10 14:31:43 -04:00
|
|
|
return playlist ? queue_size(&playlist->pl_queue) : 0;
|
2016-04-28 10:10:11 -04:00
|
|
|
}
|
|
|
|
|
2016-05-06 08:05:21 -04:00
|
|
|
void playlist_set_random(enum playlist_type_t type, const gchar *name,
|
|
|
|
bool enabled)
|
2016-05-01 19:55:47 -04:00
|
|
|
{
|
2016-05-06 08:05:21 -04:00
|
|
|
playlist_types[type]->pl_set_flag(name, Q_RANDOM, enabled);
|
2016-05-01 19:55:47 -04:00
|
|
|
}
|
|
|
|
|
2016-05-06 08:05:21 -04:00
|
|
|
bool playlist_get_random(enum playlist_type_t type, const gchar *name)
|
2016-05-01 19:55:47 -04:00
|
|
|
{
|
2016-05-13 11:25:43 -04:00
|
|
|
struct queue *queue = playlist_get_queue(type, name);
|
|
|
|
return queue ? queue_has_flag(queue, Q_RANDOM) : false;
|
2016-05-01 19:55:47 -04:00
|
|
|
}
|
|
|
|
|
2016-05-06 08:05:21 -04:00
|
|
|
void playlist_sort(enum playlist_type_t type, const gchar *name,
|
|
|
|
enum compare_t sort, bool reset)
|
2016-05-04 09:55:37 -04:00
|
|
|
{
|
2016-05-06 08:05:21 -04:00
|
|
|
playlist_types[type]->pl_sort(name, sort, reset);
|
2016-05-04 09:55:37 -04:00
|
|
|
}
|
|
|
|
|
2016-05-04 09:24:10 -04:00
|
|
|
struct track *playlist_next(void)
|
|
|
|
{
|
2016-08-01 09:44:24 -04:00
|
|
|
enum playlist_type_t type = settings_get(SETTINGS_CUR_TYPE);
|
2016-08-16 10:21:22 -04:00
|
|
|
unsigned int id = settings_get(SETTINGS_CUR_ID);
|
|
|
|
gchar *name = playlist_get_name(type, id);
|
|
|
|
struct track *track = playlist_types[type]->pl_next(name);
|
2016-08-01 09:44:24 -04:00
|
|
|
|
2016-09-10 14:31:43 -04:00
|
|
|
if (playlist_size(playlist_get(type, name)) == 0) {
|
2016-08-16 10:21:22 -04:00
|
|
|
settings_set(SETTINGS_CUR_ID, settings_get(SETTINGS_PREV_ID));
|
|
|
|
settings_set(SETTINGS_CUR_TYPE, settings_get(SETTINGS_PREV_TYPE));
|
2016-08-01 09:44:24 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
g_free(name);
|
|
|
|
return track;
|
2016-05-04 09:24:10 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
struct track *playlist_prev(void)
|
|
|
|
{
|
2016-08-05 08:00:13 -04:00
|
|
|
return playlist_types[PL_SYSTEM]->pl_next("History");
|
2016-05-04 09:24:10 -04:00
|
|
|
}
|
|
|
|
|
2016-08-20 19:13:18 -04:00
|
|
|
struct playlist *playlist_get(enum playlist_type_t type, const gchar *name)
|
|
|
|
{
|
|
|
|
return playlist_types[type]->pl_get_playlist(name);
|
|
|
|
}
|
|
|
|
|
2016-08-30 13:40:55 -04:00
|
|
|
struct playlist *playlist_cur(void)
|
|
|
|
{
|
|
|
|
enum playlist_type_t type = settings_get(SETTINGS_CUR_TYPE);
|
|
|
|
unsigned int id = settings_get(SETTINGS_CUR_ID);
|
|
|
|
gchar *name = playlist_get_name(type, id);
|
|
|
|
struct playlist *ret = playlist_get(type, name);
|
|
|
|
|
|
|
|
g_free(name);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-05-06 08:05:21 -04:00
|
|
|
struct queue *playlist_get_queue(enum playlist_type_t type, const gchar *name)
|
2013-12-31 16:58:40 -05:00
|
|
|
{
|
2016-08-20 19:13:18 -04:00
|
|
|
struct playlist *playlist = playlist_get(type, name);
|
|
|
|
return playlist ? &playlist->pl_queue : NULL;
|
2013-12-22 20:53:06 -05:00
|
|
|
}
|
2016-07-28 16:03:47 -04:00
|
|
|
|
|
|
|
unsigned int playlist_get_id(enum playlist_type_t type, const gchar *name)
|
|
|
|
{
|
|
|
|
return playlist_types[type]->pl_get_id(name);
|
|
|
|
}
|
|
|
|
|
|
|
|
gchar *playlist_get_name(enum playlist_type_t type, unsigned int id)
|
|
|
|
{
|
|
|
|
return playlist_types[type]->pl_get_name(id);
|
|
|
|
}
|