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);
}
static void
propdict_dump (const gchar *key, xmmsv_t *src_dict, void *udata)
{
const gchar *keyfilter[] = {key, udata};
xmmsv_dict_foreach (src_dict, dict_dump, (void *) keyfilter);
}
static void
propdict_foreach( const char* key, xmmsv_t *pair, void* userdata )
{
Xmms::PropDict::ForEachFunc* func =
static_cast< Xmms::PropDict::ForEachFunc* >( userdata );
Xmms::PropDict::ForEachData fedata( key, func );
xmmsv_dict_foreach( pair, &propdict_foreach_inner,
static_cast< void* >( &fedata ) );
}
static VALUE
c_dict_each_value (VALUE self)
{
RbDict *dict = NULL;
Data_Get_Struct (self, RbDict, dict);
xmmsv_dict_foreach (dict->real, dict_each_value, &self);
return self;
}
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);
}
static void
id_print_info (xmmsc_result_t *res, guint id, gchar *source)
{
xmmsv_t *val;
const gchar *err;
val = xmmsc_result_get_value (res);
if (!xmmsv_get_error (val, &err)) {
xmmsv_dict_foreach (val, propdict_dump, source);
} else {
g_printf (_("Server error: %s\n"), err);
}
xmmsc_result_unref (res);
}
static VALUE
c_attrs_each_value (VALUE self)
{
RbCollection *coll = NULL;
xmmsv_t *attributes;
VALUE tmp;
tmp = rb_iv_get (self, "collection");
Data_Get_Struct (tmp, RbCollection, coll);
attributes = xmmsv_coll_attributes_get (coll->real);
xmmsv_dict_foreach (attributes, attr_each,
XINT_TO_POINTER (EACH_VALUE));
return self;
}
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);
}
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);
}
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 PropDict::each( PropDict::ForEachFunc func ) const
{
xmmsv_dict_foreach( propdict_, &propdict_foreach,
static_cast< void* >( &func ) );
}
void Dict::each( ForEachFunc func ) const
{
xmmsv_dict_foreach( value_, &dict_foreach,
static_cast< void* >( &func ) );
}
/** 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;
}
/**
* Encodes an url with arguments stored in dict args.
*
* The encoded url is allocated using malloc and has to be freed by the user.
*
* @param url The url to encode.
* @param args The dict with arguments, or NULL.
* @return The encoded url
*/
char *
xmmsc_medialib_encode_url_full (const char *url, xmmsv_t *args)
{
static const char hex[16] = "0123456789abcdef";
int i = 0, j = 0, extra = 0, l;
char *res;
xmmsv_dict_iter_t *it;
x_api_error_if (!url, "with a NULL url", NULL);
if (args) {
if (!xmmsv_dict_foreach (args, _sum_len_string_dict, (void *) &extra)) {
return NULL;
}
}
/* Provide enough room for the worst-case scenario (all characters of the
URL must be encoded), the args, and a \0. */
res = malloc (strlen (url) * 3 + 1 + extra);
if (!res) {
return NULL;
}
for (i = 0; url[i]; i++) {
unsigned char chr = url[i];
if (GOODCHAR (chr)) {
res[j++] = chr;
} else if (chr == ' ') {
res[j++] = '+';
} else {
res[j++] = '%';
res[j++] = hex[((chr & 0xf0) >> 4)];
res[j++] = hex[(chr & 0x0f)];
}
}
if (args) {
for (xmmsv_get_dict_iter (args, &it), i = 0;
xmmsv_dict_iter_valid (it);
xmmsv_dict_iter_next (it), i++) {
const char *arg, *key;
xmmsv_t *val;
xmmsv_dict_iter_pair (it, &key, &val);
l = strlen (key);
res[j] = (i == 0) ? '?' : '&';
j++;
memcpy (&res[j], key, l);
j += l;
if (xmmsv_get_string (val, &arg)) {
l = strlen (arg);
res[j] = '=';
j++;
memcpy (&res[j], arg, l);
j += l;
}
}
}
res[j] = '\0';
return res;
}
