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);
}
void
set_volume (cli_infos_t *infos, gchar *channel, gint volume)
{
xmmsc_result_t *res;
xmmsv_t *val;
GList *it, *channels = NULL;
if (!channel) {
/* get all channels */
res = xmmsc_playback_volume_get (infos->sync);
xmmsc_result_wait (res);
val = xmmsc_result_get_value (res);
xmmsv_dict_foreach (val, dict_keys, &channels);
xmmsc_result_unref (res);
} else {
channels = g_list_prepend (channels, g_strdup (channel));
}
/* set volumes for channels in list */
for (it = g_list_first (channels); it != NULL; it = g_list_next (it)) {
res = xmmsc_playback_volume_set (infos->sync, it->data, volume);
xmmsc_result_wait (res);
xmmsc_result_unref (res);
/* free channel string */
g_free (it->data);
}
g_list_free (channels);
cli_infos_loop_resume (infos);
}
void
coll_save (cli_infos_t *infos, xmmsv_coll_t *coll,
xmmsc_coll_namespace_t ns, gchar *name, gboolean force)
{
xmmsc_result_t *res;
xmmsv_t *val;
gboolean save = TRUE;
if (!force) {
xmmsv_coll_t *exists;
res = xmmsc_coll_get (infos->sync, name, ns);
xmmsc_result_wait (res);
val = xmmsc_result_get_value (res);
if (xmmsv_get_coll (val, &exists)) {
g_printf (_("Error: A collection already exists "
"with the target name!\n"));
save = FALSE;
}
xmmsc_result_unref (res);
}
if (save) {
res = xmmsc_coll_save (infos->sync, coll, name, ns);
xmmsc_result_wait (res);
done (res, infos);
} else {
cli_infos_loop_resume (infos);
}
}
static void
print_collections_list (xmmsc_result_t *res, cli_infos_t *infos,
gchar *mark, gboolean all)
{
const gchar *s, *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);
while (xmmsv_list_iter_valid (it)) {
xmmsv_t *entry;
xmmsv_list_iter_entry (it, &entry);
/* Skip hidden playlists if all is FALSE*/
if (xmmsv_get_string (entry, &s) && ((*s != '_') || all)) {
/* Highlight active playlist */
if (mark && strcmp (s, mark) == 0) {
g_printf ("* %s\n", s);
} else {
g_printf (" %s\n", s);
}
}
xmmsv_list_iter_next (it);
}
} else {
g_printf (_("Server error: %s\n"), err);
}
cli_infos_loop_resume (infos);
xmmsc_result_unref (res);
}
void
collection_print_config (xmmsc_result_t *res, cli_infos_t *infos,
gchar *attrname)
{
xmmsv_coll_t *coll;
gchar *attrvalue;
xmmsv_t *val;
val = xmmsc_result_get_value (res);
if (xmmsv_get_coll (val, &coll)) {
if (attrname == NULL) {
xmmsc_coll_attribute_foreach (coll,
coll_print_attributes, NULL);
} else {
if (xmmsc_coll_attribute_get (coll, attrname, &attrvalue)) {
coll_print_attributes (attrname, attrvalue, NULL);
} else {
g_printf (_("Invalid attribute!\n"));
}
}
} else {
g_printf (_("Invalid collection!\n"));
}
cli_infos_loop_resume (infos);
xmmsc_result_unref (res);
}
void
cli_infos_status_mode_exit (cli_infos_t *infos)
{
infos->status = CLI_ACTION_STATUS_BUSY;
infos->status_entry = NULL;
cli_infos_loop_resume (infos);
}
void
print_stats (cli_infos_t *infos, xmmsc_result_t *res)
{
print_server_stats (res);
cli_infos_loop_resume (infos);
xmmsc_result_unref (res);
}
void
positions_print_info (cli_infos_t *infos, playlist_positions_t *positions)
{
pl_pos_udata_t udata = { infos, NULL, NULL, NULL, 0, 0 };
playlist_positions_foreach (positions, pos_print_info_cb, TRUE, &udata);
cli_infos_loop_resume (infos);
}
void
cli_infos_alias_end (cli_infos_t *infos)
{
infos->alias_count--;
if (infos->status != CLI_ACTION_STATUS_FINISH && infos->alias_count == 0) {
infos->status = CLI_ACTION_STATUS_BUSY;
}
cli_infos_loop_resume (infos);
}
void
positions_remove (cli_infos_t *infos, const gchar *playlist,
playlist_positions_t *positions)
{
pl_pos_udata_t udata = { infos, NULL, playlist, NULL, 0, 0 };
playlist_positions_foreach (positions, pos_remove_cb, FALSE, &udata);
cli_infos_loop_resume (infos);
}
void
positions_print_list (xmmsc_result_t *res, playlist_positions_t *positions,
column_display_t *coldisp, gboolean is_search)
{
cli_infos_t *infos = column_display_infos_get (coldisp);
pl_pos_udata_t udata = { infos, coldisp, NULL, NULL, 0, 0};
xmmsv_t *val;
GArray *entries;
guint id;
const gchar *err;
/* FIXME: separate function or merge
with list_print_row (lot of if(positions))? */
val = xmmsc_result_get_value (res);
if (!xmmsv_get_error (val, &err)) {
xmmsv_list_iter_t *it;
column_display_prepare (coldisp);
if (is_search) {
column_display_print_header (coldisp);
}
entries = g_array_sized_new (FALSE, FALSE, sizeof (guint),
xmmsv_list_get_size (val));
for (xmmsv_get_list_iter (val, &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)) {
g_array_append_val (entries, id);
}
}
udata.entries = entries;
playlist_positions_foreach (positions, pos_print_row_cb, TRUE, &udata);
} else {
g_printf (_("Server error: %s\n"), err);
}
if (is_search) {
column_display_print_footer (coldisp);
} else {
g_printf ("\n");
column_display_print_footer_totaltime (coldisp);
}
column_display_free (coldisp);
g_array_free (entries, TRUE);
cli_infos_loop_resume (infos);
xmmsc_result_unref (res);
}
void
print_property (cli_infos_t *infos, xmmsc_result_t *res, guint id,
gchar *source, gchar *property)
{
if (property == NULL) {
id_print_info (res, id, source);
} else {
/* FIXME(g): print if given an specific property */
}
cli_infos_loop_resume (infos);
}
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
command_dispatch (cli_infos_t *infos, gint in_argc, gchar **in_argv)
{
command_action_t *action;
command_trie_match_type_t match;
gint argc;
gchar **argv;
gboolean auto_complete;
/* The arguments will be updated by command_trie_find. */
argc = in_argc;
argv = in_argv;
auto_complete = configuration_get_boolean (infos->config,
"AUTO_UNIQUE_COMPLETE");
match = command_trie_find (infos->commands, &argv, &argc,
auto_complete, &action);
if (match == COMMAND_TRIE_MATCH_ACTION) {
gboolean help;
gboolean need_io;
command_context_t *ctx;
/* Include one command token as a workaround for the bug that
* the option parser does not parse commands starting with a
* flag properly (e.g. "-p foo arg1"). Will be skipped by the
* command utils. */
ctx = init_context_from_args (action->argdefs, argc + 1, argv - 1);
ctx->name = g_strdup (action->name);
if (command_flag_boolean_get (ctx, "help", &help) && help) {
/* Help flag passed, bypass action and show help */
/* FIXME(g): select aliasnames list if it's an alias */
help_command (infos, infos->cmdnames, in_argv, in_argc, CMD_TYPE_COMMAND);
} else if (command_runnable (infos, action)) {
/* All fine, run the command */
cli_infos_loop_suspend (infos);
need_io = action->callback (infos, ctx);
if (!need_io) {
cli_infos_loop_resume (infos);
}
}
command_context_free (ctx);
} else {
/* Call help to print the "no such command" error */
help_command (infos, infos->cmdnames, in_argv, in_argc, CMD_TYPE_COMMAND);
}
}
void
configure_playlist (xmmsc_result_t *res, cli_infos_t *infos, gchar *playlist,
gint history, gint upcoming, xmmsv_coll_type_t type,
gchar *input)
{
xmmsc_result_t *saveres;
xmmsv_coll_t *coll;
xmmsv_coll_t *newcoll;
xmmsv_t *val;
gboolean copied = FALSE;
val = xmmsc_result_get_value (res);
if (xmmsv_get_coll (val, &coll)) {
if (type >= 0 && xmmsv_coll_get_type (coll) != type) {
newcoll = coll_copy_retype (coll, type);
coll = newcoll;
copied = TRUE;
}
if (history >= 0) {
coll_int_attribute_set (coll, "history", history);
}
if (upcoming >= 0) {
coll_int_attribute_set (coll, "upcoming", upcoming);
}
if (input) {
/* Replace previous operand. */
newcoll = coll_make_reference (input, XMMS_COLLECTION_NS_COLLECTIONS);
xmmsv_list_clear (xmmsv_coll_operands_get (coll));
xmmsv_coll_add_operand (coll, newcoll);
xmmsv_coll_unref (newcoll);
}
saveres = xmmsc_coll_save (infos->sync, coll, playlist,
XMMS_COLLECTION_NS_PLAYLISTS);
xmmsc_result_wait (saveres);
done (saveres, infos);
} else {
g_printf (_("Cannot find the playlist to configure!\n"));
cli_infos_loop_resume (infos);
}
if (copied) {
xmmsv_coll_unref (coll);
}
xmmsc_result_unref (res);
}
/* Dummy callback that resets the action status as finished. */
void
done (xmmsc_result_t *res, cli_infos_t *infos)
{
const gchar *err;
xmmsv_t *val;
val = xmmsc_result_get_value (res);
if (xmmsv_get_error (val, &err)) {
g_printf (_("Server error: %s\n"), err);
}
cli_infos_loop_resume (infos);
xmmsc_result_unref (res);
}
/* Called on server disconnection. We can keep the loop running. */
static gint
cli_infos_disconnect_callback (xmmsv_t *val, void *userdata)
{
cli_infos_t *infos = (cli_infos_t *) userdata;
xmmsc_unref (infos->conn);
xmmsc_unref (infos->sync);
infos->conn = NULL;
infos->sync = NULL;
readline_status_mode_exit ();
cli_infos_loop_resume (infos);
return TRUE;
}
void
position_jump (cli_infos_t *infos, playlist_positions_t *positions)
{
xmmsc_result_t *jumpres;
int pos;
if (playlist_positions_get_single (positions, &pos)) {
jumpres = xmmsc_playlist_set_next (infos->sync, pos);
xmmsc_result_wait (jumpres);
tickle (jumpres, infos);
} else {
g_printf (_("Cannot jump to several positions!\n"));
}
cli_infos_loop_resume (infos);
}
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);
}
/* 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
print_volume (xmmsc_result_t *res, cli_infos_t *infos, gchar *channel)
{
xmmsv_t *val;
const gchar *err;
val = xmmsc_result_get_value (res);
if (!xmmsv_get_error (val, &err)) {
xmmsv_dict_foreach (val, print_volume_entry, channel);
} else {
g_printf (_("Server error: %s\n"), err);
}
cli_infos_loop_resume (infos);
xmmsc_result_unref (res);
}
/* Called on server disconnection. We can keep the loop running. */
static gint
cli_infos_disconnect_callback (xmmsv_t *val, void *userdata)
{
cli_infos_t *infos = (cli_infos_t *) userdata;
xmmsc_unref (infos->conn);
xmmsc_unref (infos->sync);
infos->conn = NULL;
infos->sync = NULL;
if (infos->status == CLI_ACTION_STATUS_REFRESH) {
status_refresh (infos, infos->status_entry, FALSE, TRUE);
readline_status_mode_exit ();
}
cli_infos_loop_resume (infos);
return TRUE;
}
void
coll_show (cli_infos_t *infos, xmmsc_result_t *res)
{
const gchar *err;
xmmsv_coll_t *coll;
xmmsv_t *val;
val = xmmsc_result_get_value (res);
if (!xmmsv_get_error (val, &err)) {
xmmsv_get_coll (val, &coll);
coll_dump (coll, 0);
} else {
g_printf (_("Server error: %s\n"), err);
}
cli_infos_loop_resume (infos);
xmmsc_result_unref (res);
}
void
playlist_print_config (xmmsc_result_t *res, cli_infos_t *infos,
gchar *playlist)
{
xmmsv_coll_t *coll;
xmmsv_t *val;
val = xmmsc_result_get_value (res);
if (xmmsv_get_coll (val, &coll)) {
pl_print_config (coll, playlist);
} else {
g_printf (_("Invalid playlist!\n"));
}
cli_infos_loop_resume (infos);
xmmsc_result_unref (res);
}
void configure_collection (xmmsc_result_t *res, cli_infos_t *infos,
gchar *ns, gchar *name,
gchar *attrname, gchar *attrvalue)
{
xmmsv_coll_t *coll;
xmmsv_t *val;
val = xmmsc_result_get_value (res);
if (xmmsv_get_coll (val, &coll)) {
xmmsc_coll_attribute_set (coll, attrname, attrvalue);
coll_save (infos, coll, ns, name, TRUE);
} else {
g_printf (_("Invalid collection!\n"));
cli_infos_loop_resume (infos);
}
xmmsc_result_unref (res);
}
void
tickle (xmmsc_result_t *res, cli_infos_t *infos)
{
xmmsc_result_t *res2;
const gchar *err;
xmmsv_t *val;
val = xmmsc_result_get_value (res);
if (!xmmsv_get_error (val, &err)) {
res2 = xmmsc_playback_tickle (infos->sync);
xmmsc_result_wait (res2);
done (res2, infos);
} else {
g_printf (_("Server error: %s\n"), err);
cli_infos_loop_resume (infos);
}
xmmsc_result_unref (res);
}
void
status_mode (cli_infos_t *infos, gchar *format, gint refresh)
{
status_entry_t *status;
status = status_init (format, refresh);
if (refresh > 0) {
g_printf (_("\n"
" (n) next song\n"
" (p) previous song\n"
" (t) toggle playback\n"
" (ENTER) exit status mode\n\n"));
cli_infos_status_mode (infos, status);
} else {
status_update_all (infos, status);
status_print_entry (status);
status_free (status);
cli_infos_loop_resume (infos);
}
}
void
list_print_info (xmmsc_result_t *res, cli_infos_t *infos)
{
xmmsc_result_t *infores = NULL;
xmmsv_t *val;
const gchar *err;
guint id;
gboolean first = true;
val = xmmsc_result_get_value (res);
if (!xmmsv_get_error (val, &err)) {
xmmsv_list_iter_t *it;
xmmsv_get_list_iter (val, &it);
while (xmmsv_list_iter_valid (it)) {
xmmsv_t *entry;
xmmsv_list_iter_entry (it, &entry);
if (xmmsv_get_uint (entry, &id)) {
infores = xmmsc_medialib_get_info (infos->sync, id);
xmmsc_result_wait (infores);
if (!first) {
g_printf ("\n");
} else {
first = false;
}
id_print_info (infores, id, NULL);
}
xmmsv_list_iter_next (it);
}
} else {
g_printf (_("Server error: %s\n"), err);
}
cli_infos_loop_resume (infos);
xmmsc_result_unref (res);
}
void
copy_playlist (xmmsc_result_t *res, cli_infos_t *infos, gchar *playlist)
{
xmmsc_result_t *saveres;
xmmsv_coll_t *coll;
xmmsv_t *val;
val = xmmsc_result_get_value (res);
if (xmmsv_get_coll (val, &coll)) {
saveres = xmmsc_coll_save (infos->sync, coll, playlist,
XMMS_COLLECTION_NS_PLAYLISTS);
xmmsc_result_wait (saveres);
done (saveres, infos);
} else {
g_printf (_("Cannot find the playlist to copy!\n"));
cli_infos_loop_resume (infos);
}
xmmsc_result_unref (res);
}
void
print_config (cli_infos_t *infos, xmmsc_result_t *res, gchar *confname)
{
const gchar *confval;
xmmsv_t *val;
if (confname == NULL) {
res = xmmsc_configval_list (infos->sync);
xmmsc_result_wait (res);
val = xmmsc_result_get_value (res);
xmmsv_dict_foreach (val, print_config_entry, NULL);
} else {
res = xmmsc_configval_get (infos->sync, confname);
xmmsc_result_wait (res);
val = xmmsc_result_get_value (res);
xmmsv_get_string (val, &confval);
print_config_entry (confname, val, NULL);
}
cli_infos_loop_resume (infos);
xmmsc_result_unref (res);
}
