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; }