void
list_plugins (cli_infos_t *infos, xmmsc_result_t *res)
{
const gchar *name, *desc, *err;
xmmsv_t *val;
val = xmmsc_result_get_value (res);
if (!xmmsv_get_error (val, &err)) {
xmmsv_list_iter_t *it;
xmmsv_get_list_iter (val, &it);
for (xmmsv_list_iter_first (it);
xmmsv_list_iter_valid (it);
xmmsv_list_iter_next (it)) {
xmmsv_t *elem;
xmmsv_list_iter_entry (it, &elem);
xmmsv_dict_entry_get_string (elem, "shortname", &name);
xmmsv_dict_entry_get_string (elem, "description", &desc);
g_printf ("%s - %s\n", name, desc);
}
} else {
g_printf (_("Server error: %s\n"), err);
}
xmmsc_result_unref (res);
cli_infos_loop_resume (infos);
}
/** List a playlist */
static GList *
xmms_playlist_client_list_entries (xmms_playlist_t *playlist, const gchar *plname,
xmms_error_t *err)
{
GList *entries = NULL;
xmmsv_coll_t *plcoll;
xmms_medialib_entry_t entry;
xmmsv_list_iter_t *it;
g_return_val_if_fail (playlist, NULL);
g_mutex_lock (playlist->mutex);
plcoll = xmms_playlist_get_coll (playlist, plname, err);
if (plcoll == NULL) {
g_mutex_unlock (playlist->mutex);
return NULL;
}
xmmsv_get_list_iter (xmmsv_coll_idlist_get (plcoll), &it);
for (xmmsv_list_iter_first (it);
xmmsv_list_iter_valid (it);
xmmsv_list_iter_next (it)) {
xmmsv_list_iter_entry_int (it, &entry);
entries = g_list_prepend (entries, xmmsv_new_int (entry));
}
xmmsv_list_iter_explicit_destroy (it);
g_mutex_unlock (playlist->mutex);
entries = g_list_reverse (entries);
return entries;
}
void plugin_config_setup (xmmsc_connection_t *con)
{
xmmsc_result_t* res;
xmmsv_t *val;
const gchar *err, *name;
/* call only once */
g_assert(plugins == NULL );
/* get translation of plugins/configs */
plugin_config_init_translation();
/* get list of available plugins */
res = xmmsc_main_list_plugins (con, XMMS_PLUGIN_TYPE_OUTPUT);
/* we havn't entered async xmmsc_mainloop, so it's ok todo sync ops */
xmmsc_result_wait (res);
val = xmmsc_result_get_value (res);
if (!xmmsv_get_error (val, &err)) {
xmmsv_list_iter_t *it;
xmmsv_get_list_iter (val, &it);
for (xmmsv_list_iter_first (it);
xmmsv_list_iter_valid (it);
xmmsv_list_iter_next (it))
{
xmmsv_t *elem;
Plugin *plugin;
xmmsv_list_iter_entry (it, &elem);
xmmsv_dict_entry_get_string (elem, "shortname", &name);
/* not blacklisted */
if ( g_strrstr( PLUGIN_BLACKLIST, name ) != NULL )
continue;
plugin = g_slice_new( Plugin );
plugin->name = g_strdup(name);
plugin->config = NULL;
plugins = g_list_append(plugins, plugin);
}
} else {
g_error ( "Server error: %s", err);
}
xmmsc_result_unref (res);
/* get configuration options */
res = xmmsc_config_list_values (con );
xmmsc_result_wait (res);
val = xmmsc_result_get_value (res);
xmmsv_dict_foreach( val, plugin_config_setup_parameter, NULL);
}
void
remove_cached_list (xmmsc_result_t *matching, cli_infos_t *infos)
{
/* FIXME: w00t at code copy-paste, please modularize */
xmmsc_result_t *rmres;
guint plid, id;
gint plsize;
GArray *playlist;
gint i;
const gchar *err;
xmmsv_t *val;
val = xmmsc_result_get_value (matching);
plsize = infos->cache->active_playlist->len;
playlist = infos->cache->active_playlist;
if (xmmsv_get_error (val, &err) || !xmmsv_is_list (val)) {
g_printf (_("Error retrieving the media matching the pattern!\n"));
} else {
xmmsv_list_iter_t *it;
xmmsv_get_list_iter (val, &it);
/* Loop on the playlist (backward, easier to remove) */
for (i = plsize - 1; i >= 0; i--) {
plid = g_array_index (playlist, guint, i);
/* Loop on the matched media */
for (xmmsv_list_iter_first (it);
xmmsv_list_iter_valid (it);
xmmsv_list_iter_next (it)) {
xmmsv_t *entry;
xmmsv_list_iter_entry (it, &entry);
/* If both match, remove! */
if (xmmsv_get_uint (entry, &id) && plid == id) {
rmres = xmmsc_playlist_remove_entry (infos->sync, NULL, i);
xmmsc_result_wait (rmres);
xmmsc_result_unref (rmres);
break;
}
}
}
}
cli_infos_loop_resume (infos);
xmmsc_result_unref (matching);
}
void
xmms_playlist_client_add_idlist (xmms_playlist_t *playlist,
const gchar *plname,
xmmsv_coll_t *coll, xmms_error_t *err)
{
xmms_medialib_entry_t entry;
xmmsv_list_iter_t *it;
gboolean valid;
xmmsv_get_list_iter (xmmsv_coll_idlist_get (coll), &it);
for (xmmsv_list_iter_first (it);
xmmsv_list_iter_valid (it);
xmmsv_list_iter_next (it)) {
xmmsv_list_iter_entry_int (it, &entry);
MEDIALIB_SESSION (playlist->medialib,
valid = xmms_medialib_check_id (session, entry));
if (!valid) {
xmms_error_set (err, XMMS_ERROR_NOENT,
"Idlist contains invalid medialib id!");
xmmsv_list_iter_explicit_destroy (it);
return;
}
}
for (xmmsv_list_iter_first (it);
xmmsv_list_iter_valid (it);
xmmsv_list_iter_next (it)) {
xmmsv_list_iter_entry_int (it, &entry);
xmms_playlist_add_entry (playlist, plname, entry, err);
}
xmmsv_list_iter_explicit_destroy (it);
}
/* Apply operation to an idlist */
void
apply_ids (cli_infos_t *infos, xmmsc_result_t *res, idlist_command_t cmd)
{
const gchar *err;
xmmsc_result_t *cmdres;
xmmsv_t *val;
val = xmmsc_result_get_value (res);
if (!xmmsv_get_error (val, &err)) {
xmmsv_list_iter_t *it;
xmmsv_get_list_iter (val, &it);
for (xmmsv_list_iter_first (it);
xmmsv_list_iter_valid (it);
xmmsv_list_iter_next (it)) {
xmmsv_t *entry;
guint id;
xmmsv_list_iter_entry (it, &entry);
if (xmmsv_get_uint (entry, &id)) {
switch (cmd) {
case IDLIST_CMD_REHASH:
cmdres = xmmsc_medialib_rehash (infos->sync, id);
break;
case IDLIST_CMD_REMOVE:
cmdres = xmmsc_medialib_remove_entry (infos->sync, id);
break;
default:
break;
}
xmmsc_result_wait (cmdres);
xmmsc_result_unref (cmdres);
}
}
} else {
g_printf (_("Server error: %s\n"), err);
}
cli_infos_loop_resume (infos);
xmmsc_result_unref (res);
}
void
add_list (xmmsc_result_t *matching, cli_infos_t *infos,
gchar *playlist, gint pos)
{
/* FIXME: w00t at code copy-paste, please modularize */
xmmsc_result_t *insres;
guint id;
gint offset;
const gchar *err;
xmmsv_t *val;
val = xmmsc_result_get_value (matching);
offset = 0;
if (xmmsv_get_error (val, &err) || !xmmsv_is_list (val)) {
g_printf (_("Error retrieving the media matching the pattern!\n"));
} else {
xmmsv_list_iter_t *it;
xmmsv_get_list_iter (val, &it);
/* Loop on the matched media */
for (xmmsv_list_iter_first (it);
xmmsv_list_iter_valid (it);
xmmsv_list_iter_next (it)) {
xmmsv_t *entry;
xmmsv_list_iter_entry (it, &entry);
if (xmmsv_get_uint (entry, &id)) {
insres = xmmsc_playlist_insert_id (infos->sync, playlist,
pos + offset, id);
xmmsc_result_wait (insres);
xmmsc_result_unref (insres);
offset++;
}
}
}
cli_infos_loop_resume (infos);
xmmsc_result_unref (matching);
}
static void
cli_jump_relative (cli_context_t *ctx, gint inc, xmmsv_t *value)
{
xmmsc_connection_t *conn = cli_context_xmms_sync (ctx);
xmmsv_list_iter_t *it;
gint i, plid, id, currpos, plsize;
xmmsv_t *playlist;
currpos = cli_context_current_position (ctx);
playlist = cli_context_active_playlist (ctx);
plsize = xmmsv_list_get_size (playlist);
/* If no currpos, start jump from beginning */
if (currpos < 0) {
currpos = 0;
}
/* magic trick so we can loop in either direction */
inc += plsize;
xmmsv_get_list_iter (value, &it);
/* Loop on the playlist */
for (i = (currpos + inc) % plsize; i != currpos; i = (i + inc) % plsize) {
xmmsv_list_iter_first (it);
xmmsv_list_get_int (playlist, i, &plid);
/* Loop on the matched media */
while (xmmsv_list_iter_entry_int (it, &id)) {
/* If both match, jump! */
if (plid == id) {
XMMS_CALL_CHAIN (XMMS_CALL_P (xmmsc_playlist_set_next, conn, i),
XMMS_CALL_P (xmmsc_playback_tickle, conn));
return;
}
xmmsv_list_iter_next (it);
}
}
/* No matching media found, don't jump */
g_printf (_("No media matching the pattern in the playlist!\n"));
}
/* call-seq:
* c.idlist
*
* Gets the list of media ids that make up the collection.
*/
static VALUE
c_coll_idlist_get (VALUE self)
{
VALUE ary = rb_ary_new ();
xmmsv_t *ret = NULL;
xmmsv_list_iter_t *it = NULL;
int32_t entry;
COLL_METHOD_ADD_HANDLER_RET (idlist_get)
xmmsv_get_list_iter (ret, &it);
for (xmmsv_list_iter_first (it);
xmmsv_list_iter_valid (it);
xmmsv_list_iter_next (it)) {
xmmsv_list_iter_entry_int (it, &entry);
rb_ary_push (ary, INT2NUM (entry));
}
xmmsv_list_iter_explicit_destroy (it);
return ary;
}
/* Returned tree must be freed by the caller */
static GTree *
matching_ids_tree (xmmsc_result_t *matching)
{
xmmsv_t *val;
guint id;
GTree *list = NULL;
const gchar *err;
val = xmmsc_result_get_value (matching);
if (xmmsv_get_error (val, &err) || !xmmsv_is_list (val)) {
g_printf (_("Error retrieving the media matching the pattern!\n"));
} else {
xmmsv_list_iter_t *it;
xmmsv_t *entry;
list = g_tree_new_full (compare_uint, NULL, g_free, NULL);
xmmsv_get_list_iter (val, &it);
for (xmmsv_list_iter_first (it);
xmmsv_list_iter_valid (it);
xmmsv_list_iter_next (it)) {
xmmsv_list_iter_entry (it, &entry);
if (xmmsv_get_uint (entry, &id)) {
guint *tid;
tid = g_new (guint, 1);
*tid = id;
g_tree_insert (list, tid, tid);
}
}
}
return list;
}
/* Recursively append conditions corresponding to the given collection to the query. */
static void
xmms_collection_append_to_query (xmms_coll_dag_t *dag, xmmsv_coll_t *coll,
coll_query_t *query)
{
xmmsv_coll_t *op;
xmms_medialib_entry_t entry;
gchar *attr1, *attr2, *attr3;
gboolean case_sens;
xmmsv_list_iter_t *iter;
xmmsv_t *tmp;
gboolean first;
xmmsv_coll_type_t type = xmmsv_coll_get_type (coll);
switch (type) {
case XMMS_COLLECTION_TYPE_REFERENCE:
if (!operator_is_allmedia (coll)) {
query_append_operand (query, dag, coll);
} else {
/* FIXME: Hackish solution to append a ref to All Media */
query_append_string (query, "1");
}
break;
case XMMS_COLLECTION_TYPE_UNION:
case XMMS_COLLECTION_TYPE_INTERSECTION:
first = TRUE;
query_append_string (query, "(");
xmmsv_get_list_iter (xmmsv_coll_operands_get (coll), &iter);
for (xmmsv_list_iter_first (iter);
xmmsv_list_iter_valid (iter);
xmmsv_list_iter_next (iter)) {
if (first) {
first = FALSE;
} else {
if (type == XMMS_COLLECTION_TYPE_UNION)
query_append_string (query, " OR ");
else
query_append_string (query, " AND ");
}
xmmsv_list_iter_entry (iter, &tmp);
xmmsv_get_coll (tmp, &op);
xmms_collection_append_to_query (dag, op, query);
}
xmmsv_list_iter_explicit_destroy (iter);
query_append_string (query, ")");
break;
case XMMS_COLLECTION_TYPE_COMPLEMENT:
query_append_string (query, "NOT ");
query_append_operand (query, dag, coll);
break;
case XMMS_COLLECTION_TYPE_HAS:
case XMMS_COLLECTION_TYPE_EQUALS:
case XMMS_COLLECTION_TYPE_MATCH:
case XMMS_COLLECTION_TYPE_SMALLER:
case XMMS_COLLECTION_TYPE_GREATER:
xmmsv_coll_attribute_get (coll, "field", &attr1);
xmmsv_coll_attribute_get (coll, "value", &attr2);
xmmsv_coll_attribute_get (coll, "case-sensitive", &attr3);
case_sens = (attr3 != NULL && strcmp (attr3, "true") == 0);
query_append_string (query, "(");
query_append_filter (query, type, attr1, attr2, case_sens);
query_append_intersect_operand (query, dag, coll);
query_append_string (query, ")");
break;
case XMMS_COLLECTION_TYPE_IDLIST:
case XMMS_COLLECTION_TYPE_QUEUE:
case XMMS_COLLECTION_TYPE_PARTYSHUFFLE:
first = TRUE;
query_append_string (query, "m0.id IN (");
xmmsv_get_list_iter (xmmsv_coll_idlist_get (coll), &iter);
for (xmmsv_list_iter_first (iter);
xmmsv_list_iter_valid (iter);
xmmsv_list_iter_next (iter)) {
if (first) {
first = FALSE;
} else {
query_append_string (query, ",");
}
xmmsv_list_iter_entry_int (iter, &entry);
query_append_int (query, entry);
}
xmmsv_list_iter_explicit_destroy (iter);
query_append_string (query, ")");
break;
/* invalid type */
default:
XMMS_DBG ("Cannot append invalid collection operator!");
g_assert_not_reached ();
break;
}
}
/** Write the given operator to the database under the given id.
*
* @param session The medialib session connected to the DB.
* @param collid The id under which to save the collection.
* @param coll The structure of the collection to save.
* @return The next free collection id.
*/
static guint
xmms_collection_dbwrite_operator (xmms_medialib_session_t *session,
guint collid, xmmsv_coll_t *coll)
{
gchar query[128];
guint *idlist;
gint i;
xmmsv_coll_t *op;
xmmsv_t *attrs;
gint newid, nextid;
coll_dbwrite_t dbwrite_infos = { session, collid, 0 };
/* Write operator */
g_snprintf (query, sizeof (query),
"INSERT INTO CollectionOperators VALUES(%d, %d)",
collid, xmmsv_coll_get_type (coll));
xmms_medialib_select (session, query, NULL);
/* Write attributes */
attrs = xmmsv_coll_attributes_get (coll);
xmmsv_dict_foreach (attrs, dbwrite_coll_attributes, &dbwrite_infos);
attrs = NULL; /* no unref needed. */
/* Write idlist */
idlist = xmmsv_coll_get_idlist (coll);
for (i = 0; idlist[i] != 0; i++) {
g_snprintf (query, sizeof (query),
"INSERT INTO CollectionIdlists VALUES(%d, %d, %d)",
collid, i, idlist[i]);
xmms_medialib_select (session, query, NULL);
}
/* Save operands and connections (don't recurse in ref operand) */
newid = collid + 1;
if (xmmsv_coll_get_type (coll) != XMMS_COLLECTION_TYPE_REFERENCE) {
xmmsv_t *tmp;
xmmsv_list_iter_t *iter;
xmmsv_get_list_iter (xmmsv_coll_operands_get (coll), &iter);
for (xmmsv_list_iter_first (iter);
xmmsv_list_iter_valid (iter);
xmmsv_list_iter_next (iter)) {
xmmsv_list_iter_entry (iter, &tmp);
xmmsv_get_coll (tmp, &op);
nextid = xmms_collection_dbwrite_operator (session, newid, op);
g_snprintf (query, sizeof (query),
"INSERT INTO CollectionConnections VALUES(%d, %d)",
newid, collid);
xmms_medialib_select (session, query, NULL);
newid = nextid;
}
xmmsv_list_iter_explicit_destroy (iter);
}
/* return next available id */
return newid;
}
static bool
_internal_put_on_bb_collection (xmmsv_t *bb, xmmsv_coll_t *coll)
{
xmmsv_list_iter_t *it;
xmmsv_t *v, *attrs;
int n;
uint32_t ret;
int32_t entry;
xmmsv_coll_t *op;
if (!bb || !coll) {
return false;
}
/* push type */
if (!xmmsv_bitbuffer_put_bits (bb, 32, xmmsv_coll_get_type (coll)))
return false;
/* attribute counter and values */
attrs = xmmsv_coll_attributes_get (coll);
n = 0;
xmmsv_dict_foreach (attrs, _internal_put_on_bb_count_coll_attr, &n);
if (!xmmsv_bitbuffer_put_bits (bb, 32, n))
return false;
/* needs error checking! */
xmmsv_dict_foreach (attrs, _internal_put_on_bb_append_coll_attr, bb);
attrs = NULL; /* no unref needed. */
/* idlist counter and content */
xmmsv_bitbuffer_put_bits (bb, 32, xmmsv_coll_idlist_get_size (coll));
xmmsv_get_list_iter (xmmsv_coll_idlist_get (coll), &it);
for (xmmsv_list_iter_first (it);
xmmsv_list_iter_valid (it);
xmmsv_list_iter_next (it)) {
if (!xmmsv_list_iter_entry_int (it, &entry)) {
x_api_error ("Non integer in idlist", 0);
}
xmmsv_bitbuffer_put_bits (bb, 32, entry);
}
xmmsv_list_iter_explicit_destroy (it);
/* operands counter and objects */
n = 0;
if (xmmsv_coll_get_type (coll) != XMMS_COLLECTION_TYPE_REFERENCE) {
n = xmmsv_list_get_size (xmmsv_coll_operands_get (coll));
}
ret = xmmsv_bitbuffer_pos (bb);
xmmsv_bitbuffer_put_bits (bb, 32, n);
if (n > 0) {
xmmsv_get_list_iter (xmmsv_coll_operands_get (coll), &it);
while (xmmsv_list_iter_entry (it, &v)) {
if (!xmmsv_get_coll (v, &op)) {
x_api_error ("Non collection operand", 0);
}
_internal_put_on_bb_int32 (bb, XMMSV_TYPE_COLL);
ret = _internal_put_on_bb_collection (bb, op);
xmmsv_list_iter_next (it);
}
}
return ret;
}
void
remove_list (xmmsc_result_t *matchres, xmmsc_result_t *plistres,
cli_infos_t *infos, gchar *playlist)
{
/* FIXME: w00t at code copy-paste, please modularize */
xmmsc_result_t *rmres;
guint plid, id, i;
gint offset;
const gchar *err;
xmmsv_t *matchval, *plistval;
matchval = xmmsc_result_get_value (matchres);
plistval = xmmsc_result_get_value (plistres);
if (xmmsv_get_error (matchval, &err) || !xmmsv_is_list (matchval)) {
g_printf (_("Error retrieving the media matching the pattern!\n"));
} else if (xmmsv_get_error (plistval, &err) || !xmmsv_is_list (plistval)) {
g_printf (_("Error retrieving the playlist!\n"));
} else {
xmmsv_list_iter_t *matchit, *plistit;
/* FIXME: Can we use a GList to remove more safely in the rev order? */
offset = 0;
i = 0;
xmmsv_get_list_iter (matchval, &matchit);
xmmsv_get_list_iter (plistval, &plistit);
/* Loop on the playlist */
for (xmmsv_list_iter_first (plistit);
xmmsv_list_iter_valid (plistit);
xmmsv_list_iter_next (plistit)) {
xmmsv_t *plist_entry;
xmmsv_list_iter_entry (plistit, &plist_entry);
if (!xmmsv_get_uint (plist_entry, &plid)) {
plid = 0; /* failed to get id, should not happen */
}
/* Loop on the matched media */
for (xmmsv_list_iter_first (matchit);
xmmsv_list_iter_valid (matchit);
xmmsv_list_iter_next (matchit)) {
xmmsv_t *match_entry;
xmmsv_list_iter_entry (matchit, &match_entry);
/* If both match, jump! */
if (xmmsv_get_uint (match_entry, &id) && plid == id) {
rmres = xmmsc_playlist_remove_entry (infos->sync, playlist,
i - offset);
xmmsc_result_wait (rmres);
xmmsc_result_unref (rmres);
offset++;
break;
}
}
i++;
}
}
cli_infos_loop_resume (infos);
xmmsc_result_unref (matchres);
xmmsc_result_unref (plistres);
}
void
move_entries (xmmsc_result_t *matching, cli_infos_t *infos,
gchar *playlist, gint pos)
{
xmmsc_result_t *movres, *lisres;
guint id, curr;
gint inc;
gboolean up;
GTree *list;
xmmsv_t *lisval;
const gchar *err;
lisres = xmmsc_playlist_list_entries (infos->sync, playlist);
xmmsc_result_wait (lisres);
lisval = xmmsc_result_get_value (lisres);
if (xmmsv_get_error (lisval, &err) || !xmmsv_is_list (lisval)) {
g_printf (_("Error retrieving playlist entries\n"));
} else {
xmmsv_list_iter_t *it;
xmmsv_t *entry;
/* store matching mediaids in a tree (faster lookup) */
list = matching_ids_tree (matching);
/* move matched playlist items */
curr = 0;
inc = 0;
up = TRUE;
xmmsv_get_list_iter (lisval, &it);
for (xmmsv_list_iter_first (it);
xmmsv_list_iter_valid (it);
xmmsv_list_iter_next (it)) {
xmmsv_list_iter_entry (it, &entry);
if (curr == pos) {
up = FALSE;
}
if (xmmsv_get_uint (entry, &id) &&
g_tree_lookup (list, &id) != NULL) {
if (up) {
/* moving forward */
movres = xmmsc_playlist_move_entry (infos->sync, playlist,
curr - inc, pos - 1);
} else {
/* moving backward */
movres = xmmsc_playlist_move_entry (infos->sync, playlist,
curr, pos + inc);
}
xmmsc_result_wait (movres);
xmmsc_result_unref (movres);
inc++;
}
curr++;
}
g_tree_destroy (list);
}
finish:
cli_infos_loop_resume (infos);
xmmsc_result_unref (matching);
xmmsc_result_unref (lisres);
}
/* Abstract jump, use inc to choose the direction. */
static void
list_jump_rel (xmmsc_result_t *res, cli_infos_t *infos, gint inc)
{
guint i;
guint id;
xmmsc_result_t *jumpres = NULL;
xmmsv_t *val;
const gchar *err;
gint currpos;
gint plsize;
GArray *playlist;
currpos = infos->cache->currpos;
plsize = infos->cache->active_playlist->len;
playlist = infos->cache->active_playlist;
/* If no currpos, start jump from beginning */
if (currpos < 0) {
currpos = 0;
}
val = xmmsc_result_get_value (res);
if (!xmmsv_get_error (val, &err) && xmmsv_is_list (val)) {
xmmsv_list_iter_t *it;
xmmsv_get_list_iter (val, &it);
inc += plsize; /* magic trick so we can loop in either direction */
/* Loop on the playlist */
for (i = (currpos + inc) % plsize; i != currpos; i = (i + inc) % plsize) {
/* Loop on the matched media */
for (xmmsv_list_iter_first (it);
xmmsv_list_iter_valid (it);
xmmsv_list_iter_next (it)) {
xmmsv_t *entry;
xmmsv_list_iter_entry (it, &entry);
/* If both match, jump! */
if (xmmsv_get_uint (entry, &id)
&& g_array_index (playlist, guint, i) == id) {
jumpres = xmmsc_playlist_set_next (infos->sync, i);
xmmsc_result_wait (jumpres);
tickle (jumpres, infos);
goto finish;
}
}
}
}
finish:
/* No matching media found, don't jump */
if (!jumpres) {
g_printf (_("No media matching the pattern in the playlist!\n"));
cli_infos_loop_resume (infos);
}
xmmsc_result_unref (res);
}
void OperandIterator::first()
{
xmmsv_list_iter_first( oper_it_ );
}
