/**
* Recursively scan a directory for media files.
*
* @return a reverse sorted list of encoded urls
*/
static gboolean
process_dir (xmms_medialib_t *medialib, xmmsv_t *entries,
const gchar *directory, xmms_error_t *error)
{
xmmsv_list_iter_t *it;
xmmsv_t *list, *val;
list = xmms_xform_browse (directory, error);
if (!list) {
return FALSE;
}
xmmsv_get_list_iter (list, &it);
while (xmmsv_list_iter_entry (it, &val)) {
const gchar *str;
gint isdir;
xmmsv_dict_entry_get_string (val, "path", &str);
xmmsv_dict_entry_get_int (val, "isdir", &isdir);
if (isdir == 1) {
process_dir (medialib, entries, str, error);
} else {
xmms_medialib_session_t *session;
xmms_medialib_entry_t entry;
do {
session = xmms_medialib_session_begin (medialib);
entry = xmms_medialib_entry_new_encoded (session, str, error);
} while (!xmms_medialib_session_commit (session));
if (entry) {
xmmsv_coll_idlist_append (entries, entry);
}
}
xmmsv_list_iter_remove (it);
}
xmmsv_unref (list);
return TRUE;
}
static xmmsv_coll_t *
coll_copy_retype (xmmsv_coll_t *coll, xmmsv_coll_type_t type)
{
xmmsv_coll_t *copy;
gint idlistsize;
gint i;
guint id;
copy = xmmsv_coll_new (type);
idlistsize = xmmsv_coll_idlist_get_size (coll);
for (i = 0; i < idlistsize; i++) {
xmmsv_coll_idlist_get_index (coll, i, &id);
xmmsv_coll_idlist_append (copy, id);
}
xmmsv_coll_attribute_foreach (coll, coll_copy_attributes, copy);
return copy;
}
/** Sorts the playlist by properties.
*
* This will sort the list.
* @param playlist The playlist to sort.
* @param properties Tells xmms_playlist_sort which properties it
* should use when sorting.
* @param err An #xmms_error_t - needed since xmms_playlist_sort is an ipc
* method handler.
*/
static void
xmms_playlist_client_replace (xmms_playlist_t *playlist, const gchar *plname,
xmmsv_coll_t *coll, xmms_playlist_position_action_t action,
xmms_error_t *err)
{
xmms_medialib_entry_t id, current_id;
xmmsv_coll_t *plcoll;
xmmsv_t *result;
gint current_position, i;
g_return_if_fail (playlist);
g_return_if_fail (coll);
g_mutex_lock (playlist->mutex);
plcoll = xmms_playlist_get_coll (playlist, plname, err);
if (plcoll == NULL) {
xmms_error_set (err, XMMS_ERROR_NOENT, "no such playlist!");
g_mutex_unlock (playlist->mutex);
return;
}
current_position = xmms_playlist_coll_get_currpos (plcoll);
xmmsv_coll_idlist_get_index (plcoll, current_position, ¤t_id);
result = xmms_collection_query_ids (playlist->colldag, coll, err);
if (result == NULL) {
g_mutex_unlock (playlist->mutex);
return;
}
xmmsv_coll_idlist_clear (plcoll);
current_position = -1;
for (i = 0; xmmsv_list_get_int (result, i, &id); i++) {
if (id == current_id)
current_position = i;
xmmsv_coll_idlist_append (plcoll, id);
}
switch (action) {
case XMMS_PLAYLIST_CURRENT_ID_FORGET:
current_position = -1;
break;
case XMMS_PLAYLIST_CURRENT_ID_MOVE_TO_FRONT:
if (current_position > 0) {
xmmsv_coll_idlist_move (plcoll, current_position, 0);
current_position = 0;
}
break;
default:
break;
}
xmmsv_unref (result);
xmms_collection_set_int_attr (plcoll, "position", current_position);
XMMS_PLAYLIST_CHANGED_MSG (XMMS_PLAYLIST_CHANGED_REPLACE,
(current_position < 0) ? 0 : current_id, plname);
XMMS_PLAYLIST_CURRPOS_MSG (current_position, plname);
g_mutex_unlock (playlist->mutex);
}
/** Given a collection id, query the DB to build the corresponding
* collection DAG.
*
* @param session The medialib session connected to the DB.
* @param id The id of the collection to create.
* @param type The type of the collection operator.
* @return The created collection DAG.
*/
static xmmsv_coll_t *
xmms_collection_dbread_operator (xmms_medialib_session_t *session,
gint id, xmmsv_coll_type_t type)
{
xmmsv_coll_t *coll;
xmmsv_coll_t *op;
GList *res;
GList *n;
xmmsv_t *cmdval;
gchar query[256];
coll = xmmsv_coll_new (type);
/* Retrieve the attributes */
g_snprintf (query, sizeof (query),
"SELECT attr.key AS key, attr.value AS value "
"FROM CollectionOperators AS op, CollectionAttributes AS attr "
"WHERE op.id=%d AND attr.collid=op.id", id);
res = xmms_medialib_select (session, query, NULL);
for (n = res; n; n = n->next) {
const gchar *key, *value;
cmdval = (xmmsv_t*) n->data;
key = value_get_dict_string (cmdval, "key");
value = value_get_dict_string (cmdval, "value");
xmmsv_coll_attribute_set (coll, key, value);
xmmsv_unref (n->data);
}
g_list_free (res);
/* Retrieve the idlist */
g_snprintf (query, sizeof (query),
"SELECT idl.mid AS mid "
"FROM CollectionOperators AS op, CollectionIdlists AS idl "
"WHERE op.id=%d AND idl.collid=op.id "
"ORDER BY idl.position", id);
res = xmms_medialib_select (session, query, NULL);
for (n = res; n; n = n->next) {
cmdval = (xmmsv_t *) n->data;
xmmsv_coll_idlist_append (coll, value_get_dict_int (cmdval, "mid"));
xmmsv_unref (cmdval);
}
g_list_free (res);
/* Retrieve the operands */
g_snprintf (query, sizeof (query),
"SELECT op.id AS id, op.type AS type "
"FROM CollectionOperators AS op, CollectionConnections AS conn "
"WHERE conn.to_id=%d AND conn.from_id=op.id", id);
res = xmms_medialib_select (session, query, NULL);
for (n = res; n; n = n->next) {
gint _id;
gint type;
cmdval = (xmmsv_t *) n->data;
_id = value_get_dict_int (cmdval, "id");
type = value_get_dict_int (cmdval, "type");
op = xmms_collection_dbread_operator (session, _id, type);
xmmsv_coll_add_operand (coll, op);
xmmsv_coll_unref (op);
xmmsv_unref (cmdval);
}
g_list_free (res);
return coll;
}
void
cmd_playlist_type (xmmsc_connection_t *conn, gint argc, gchar **argv)
{
gchar *name;
xmmsv_coll_type_t prevtype, newtype;
xmmsc_result_t *res;
xmmsv_t *val;
xmmsv_coll_t *coll;
/* Read playlist name */
if (argc < 4) {
print_error ("usage: type_playlist [playlistname] [type] [options]");
}
name = argv[3];
/* Retrieve the playlist operator */
res = xmmsc_coll_get (conn, name, XMMS_COLLECTION_NS_PLAYLISTS);
xmmsc_result_wait (res);
val = xmmsc_result_get_value (res);
if (xmmsv_is_error (val)) {
print_error ("%s", xmmsv_get_error_old (val));
}
xmmsv_get_coll (val, &coll);
prevtype = xmmsv_coll_get_type (coll);
/* No type argument, simply display the current type */
if (argc < 5) {
print_info (get_playlist_type_string (prevtype));
/* Type argument, set the new type */
} else {
gint typelen;
gint idlistsize;
xmmsc_result_t *saveres;
xmmsv_coll_t *newcoll;
gint i;
typelen = strlen (argv[4]);
if (g_ascii_strncasecmp (argv[4], "list", typelen) == 0) {
newtype = XMMS_COLLECTION_TYPE_IDLIST;
} else if (g_ascii_strncasecmp (argv[4], "queue", typelen) == 0) {
newtype = XMMS_COLLECTION_TYPE_QUEUE;
} else if (g_ascii_strncasecmp (argv[4], "pshuffle", typelen) == 0) {
newtype = XMMS_COLLECTION_TYPE_PARTYSHUFFLE;
/* Setup operand for party shuffle (set operand) ! */
if (argc < 6) {
print_error ("Give the source collection for the party shuffle");
}
} else {
print_error ("Invalid playlist type (valid types: list, queue, pshuffle)");
}
/* Copy collection idlist, attributes and operand (if needed) */
newcoll = xmmsv_coll_new (newtype);
idlistsize = xmmsv_coll_idlist_get_size (coll);
for (i = 0; i < idlistsize; i++) {
guint id;
xmmsv_coll_idlist_get_index (coll, i, &id);
xmmsv_coll_idlist_append (newcoll, id);
}
xmmsv_coll_attribute_foreach (coll, coll_copy_attributes, newcoll);
if (newtype == XMMS_COLLECTION_TYPE_PARTYSHUFFLE) {
playlist_setup_pshuffle (conn, newcoll, argv[5]);
}
/* Overwrite with new collection */
saveres = xmmsc_coll_save (conn, newcoll, name, XMMS_COLLECTION_NS_PLAYLISTS);
xmmsc_result_wait (saveres);
if (xmmsc_result_iserror (saveres)) {
print_error ("Couldn't save %s : %s",
name, xmmsc_result_get_error (saveres));
}
xmmsv_coll_unref (newcoll);
xmmsc_result_unref (saveres);
}
xmmsc_result_unref (res);
}