static gint
xmms_browse_list_sortfunc (xmmsv_t **a, xmmsv_t **b)
{
xmmsv_t *val1, *val2;
const gchar *s1, *s2;
int r1, r2;
g_return_val_if_fail (xmmsv_is_type (*a, XMMSV_TYPE_DICT), 0);
g_return_val_if_fail (xmmsv_is_type (*b, XMMSV_TYPE_DICT), 0);
r1 = xmmsv_dict_get (*a, "intsort", &val1);
r2 = xmmsv_dict_get (*b, "intsort", &val2);
if (r1 && r2) {
gint i1, i2;
if (!xmmsv_get_int (val1, &i1))
return 0;
if (!xmmsv_get_int (val2, &i2))
return 0;
return i1 > i2;
}
if (!xmmsv_dict_get (*a, "path", &val1))
return 0;
if (!xmmsv_dict_get (*b, "path", &val2))
return 0;
if (!xmmsv_get_string (val1, &s1))
return 0;
if (!xmmsv_get_string (val2, &s2))
return 0;
return xmms_natcmp (s1, s2);
}
static void
__int_xmms_cmd_set_property_int (xmms_object_t *object, xmms_object_cmd_arg_t *arg)
{
xmmsv_t *t;
if (xmmsv_list_get_size (arg->args) != 4) {
XMMS_DBG ("Wrong number of arguments to set_property_int (%d)", xmmsv_list_get_size (arg->args));
xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Wrong number of arguments to set_property_int");
return;
}
gint32 argval0;
const char * argval1;
const char * argval2;
gint32 argval3;
if (!xmmsv_list_get (arg->args, 0, &t)) {
XMMS_DBG ("Missing arg 0 in set_property_int");
xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Missing arg 0 in set_property_int");
return;
}
if (!xmmsv_get_int (t, &argval0)) {
XMMS_DBG ("Error parsing arg 0 in set_property_int");
xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Error parsing arg 0 in set_property_int");
return;
}
if (!xmmsv_list_get (arg->args, 1, &t)) {
XMMS_DBG ("Missing arg 1 in set_property_int");
xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Missing arg 1 in set_property_int");
return;
}
if (!xmmsv_get_string (t, &argval1)) {
XMMS_DBG ("Error parsing arg 1 in set_property_int");
xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Error parsing arg 1 in set_property_int");
return;
}
if (!xmmsv_list_get (arg->args, 2, &t)) {
XMMS_DBG ("Missing arg 2 in set_property_int");
xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Missing arg 2 in set_property_int");
return;
}
if (!xmmsv_get_string (t, &argval2)) {
XMMS_DBG ("Error parsing arg 2 in set_property_int");
xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Error parsing arg 2 in set_property_int");
return;
}
if (!xmmsv_list_get (arg->args, 3, &t)) {
XMMS_DBG ("Missing arg 3 in set_property_int");
xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Missing arg 3 in set_property_int");
return;
}
if (!xmmsv_get_int (t, &argval3)) {
XMMS_DBG ("Error parsing arg 3 in set_property_int");
xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Error parsing arg 3 in set_property_int");
return;
}
xmms_medialib_client_set_property_int ((xmms_medialib_t *) object, argval0, argval1, argval2, argval3, &arg->error);
arg->retval = xmmsv_new_none ();
}
static void
__int_xmms_cmd_rehash (xmms_object_t *object, xmms_object_cmd_arg_t *arg)
{
xmmsv_t *t;
if (xmmsv_list_get_size (arg->args) != 1) {
XMMS_DBG ("Wrong number of arguments to rehash (%d)", xmmsv_list_get_size (arg->args));
xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Wrong number of arguments to rehash");
return;
}
gint32 argval0;
if (!xmmsv_list_get (arg->args, 0, &t)) {
XMMS_DBG ("Missing arg 0 in rehash");
xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Missing arg 0 in rehash");
return;
}
if (!xmmsv_get_int (t, &argval0)) {
XMMS_DBG ("Error parsing arg 0 in rehash");
xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Error parsing arg 0 in rehash");
return;
}
xmms_medialib_client_rehash ((xmms_medialib_t *) object, argval0, &arg->error);
arg->retval = xmmsv_new_none ();
}
static gint
refresh_active_playlist (xmmsv_t *val, void *udata)
{
cli_cache_t *cache = (cli_cache_t *) udata;
xmmsv_list_iter_t *it;
gint32 id;
if (!xmmsv_is_error (val)) {
/* Reset array */
if (cache->active_playlist->len > 0) {
gint len = cache->active_playlist->len;
cache->active_playlist = g_array_remove_range (cache->active_playlist,
0, len);
}
xmmsv_get_list_iter (val, &it);
/* .. and refill it */
while (xmmsv_list_iter_valid (it)) {
xmmsv_t *entry;
xmmsv_list_iter_entry (it, &entry);
xmmsv_get_int (entry, &id);
g_array_append_val (cache->active_playlist, id);
xmmsv_list_iter_next (it);
}
}
freshness_received (&cache->freshness_active_playlist);
return TRUE;
}
static void
xmms_ipc_register_broadcast (xmms_ipc_client_t *client,
xmms_ipc_msg_t *msg, xmmsv_t *arguments)
{
xmmsv_t *arg;
gint32 broadcastid;
int r;
if (!arguments || !xmmsv_list_get (arguments, 0, &arg)) {
xmms_log_error ("No broadcastid in this msg?!");
return;
}
r = xmmsv_get_int (arg, &broadcastid);
if (!r) {
xmms_log_error ("Cannot extract broadcast id from value");
return;
}
if (broadcastid < 0 || broadcastid >= XMMS_IPC_SIGNAL_END) {
xmms_log_error ("Bad broadcast id (%d)", broadcastid);
return;
}
g_mutex_lock (client->lock);
client->broadcasts[broadcastid] =
g_list_append (client->broadcasts[broadcastid],
GUINT_TO_POINTER (xmms_ipc_msg_get_cookie (msg)));
g_mutex_unlock (client->lock);
}
void
print_hash (const gchar *key, xmmsv_t *value, void *udata)
{
xmmsv_type_t value_type;
const char *string_val;
unsigned int uint_val;
int int_val;
value_type = xmmsv_get_type (value);
switch (value_type) {
case XMMSV_TYPE_STRING:
xmmsv_get_string (value, &string_val);
print_info ("%s = %s", key, string_val);
break;
case XMMSV_TYPE_INT32:
xmmsv_get_int (value, &int_val);
print_info ("%s = %d", key, int_val);
break;
default:
print_error ("unhandled hash value %i", value_type);
}
}
static void
xmms_ipc_register_signal (xmms_ipc_client_t *client,
xmms_ipc_msg_t *msg, xmmsv_t *arguments)
{
xmmsv_t *arg;
gint32 signalid;
int r;
if (!arguments || !xmmsv_list_get (arguments, 0, &arg)) {
xmms_log_error ("No signalid in this msg?!");
return;
}
r = xmmsv_get_int (arg, &signalid);
if (!r) {
xmms_log_error ("Cannot extract signal id from value");
return;
}
if (signalid < 0 || signalid >= XMMS_IPC_SIGNAL_END) {
xmms_log_error ("Bad signal id (%d)", signalid);
return;
}
g_mutex_lock (client->lock);
client->pendingsignals[signalid] = xmms_ipc_msg_get_cookie (msg);
g_mutex_unlock (client->lock);
}
static void
currently_playing_update_status (currently_playing_t *entry, xmmsv_t *value)
{
const gchar *status_name;
gint status = -1;
xmmsv_get_int (value, &status);
switch (status) {
case XMMS_PLAYBACK_STATUS_STOP:
status_name = _("Stopped");
break;
case XMMS_PLAYBACK_STATUS_PLAY:
status_name = _("Playing");
break;
case XMMS_PLAYBACK_STATUS_PAUSE:
status_name = _("Paused");
break;
default:
status_name = _("Unknown");
break;
}
xmmsv_dict_set_string (entry->data, "playback_status", status_name);
}
static int
updater_rehash_file_by_id (xmmsv_t *value, void *udata)
{
xmmsc_result_t *res;
updater_t *updater;
int mid;
updater = (updater_t *) udata;
g_return_val_if_fail (updater, FALSE);
if (!xmmsv_get_int (value, &mid)) {
return FALSE;
}
if (!mid) {
g_warning ("Couldn't find requested medialib entry.");
return FALSE;
}
res = xmmsc_medialib_rehash (updater->conn, mid);
xmmsc_result_unref (res);
return FALSE;
}
/**
* Convenient function for adding a directory to the playlist,
* It will dive down the URL you feed it and recursivly add
* all files there.
*
* @param playlist the playlist to add it URL to.
* @param plname the name of the playlist to modify.
* @param nurl the URL of an directory you want to add
* @param err an #xmms_error_t that should be defined upon error.
*/
static void
xmms_playlist_client_radd (xmms_playlist_t *playlist, const gchar *plname,
const gchar *path, xmms_error_t *err)
{
xmmsv_coll_t *idlist;
xmmsv_list_iter_t *it;
xmmsv_t *list;
idlist = xmms_medialib_add_recursive (playlist->medialib, path, err);
list = xmmsv_coll_idlist_get (idlist);
xmmsv_get_list_iter (list, &it);
while (xmmsv_list_iter_valid (it)) {
xmms_medialib_entry_t entry;
xmmsv_t *value;
xmmsv_list_iter_entry (it, &value);
xmmsv_get_int (value, &entry);
xmms_playlist_add_entry (playlist, plname, entry, err);
xmmsv_list_iter_next (it);
}
xmmsv_coll_unref (idlist);
}
/* dumps a recursive key-source-val dict */
void
print_entry (const gchar *key, xmmsv_t *dict, void *udata)
{
xmmsv_t *v;
const gchar *source;
if (xmmsv_get_type (dict) == XMMSV_TYPE_DICT) {
xmmsv_dict_iter_t *it;
xmmsv_get_dict_iter (dict, &it);
while (xmmsv_dict_iter_valid (it)) {
xmmsv_dict_iter_pair (it, &source, &v);
switch (xmmsv_get_type (v)) {
case XMMSV_TYPE_STRING:
print_entry_string (v, key, source);
break;
case XMMSV_TYPE_INT32:
{
gint i;
xmmsv_get_int (v, &i);
print_info ("[%s] %s = %d", source, key, i);
break;
}
default:
print_info ("[%s] %s = (unknown data)", source, key);
break;
}
xmmsv_dict_iter_next (it);
}
}
}
static int
updater_remove_file_by_id (xmmsv_t *value, void *udata)
{
xmmsc_result_t *res;
updater_t *updater;
int mid;
updater = (updater_t *) udata;
g_return_val_if_fail (updater, FALSE);
if (!xmmsv_get_int (value, &mid)) {
g_error ("couldn't find this one!");
return FALSE;
}
if (!mid) {
g_debug ("entry not in medialib");
return FALSE;
}
res = xmmsc_medialib_remove_entry (updater->conn, mid);
xmmsc_result_unref (res);
return FALSE;
}
static void
print_config_entry (const gchar *confname, xmmsv_t *val, void *udata)
{
xmmsv_type_t type;
type = xmmsv_get_type (val);
switch (type) {
case XMMSV_TYPE_STRING:
{
const gchar *confval;
xmmsv_get_string (val, &confval);
g_printf ("%s = %s\n", confname, confval);
break;
}
case XMMSV_TYPE_INT32:
{
int confval;
xmmsv_get_int (val, &confval);
g_printf ("%s = %d\n", confname, confval);
break;
}
default:
break;
}
}
static void
xmms_playlist_client_insert_collection (xmms_playlist_t *playlist, const gchar *plname,
gint32 pos, xmmsv_coll_t *coll,
xmmsv_t *order, xmms_error_t *err)
{
xmmsv_list_iter_t *it;
xmmsv_t *list;
list = xmms_collection_query_ids (playlist->colldag, coll, 0, 0, order, err);
if (xmms_error_iserror (err)) {
return;
}
xmmsv_get_list_iter (list, &it);
xmmsv_list_iter_last (it);
while (xmmsv_list_iter_valid (it)) {
xmms_medialib_entry_t mid;
xmmsv_t *entry;
xmmsv_list_iter_entry (it, &entry);
xmmsv_get_int (entry, &mid);
xmms_playlist_insert_entry (playlist, plname, pos, mid, err);
xmmsv_list_iter_prev (it);
}
xmmsv_unref (list);
}
static void
add_metadatum (gpointer _key, gpointer _value, gpointer user_data)
{
xmmsv_t *value = (xmmsv_t *) _value;
gchar *key = (gchar *) _key;
metadata_festate_t *st = (metadata_festate_t *) user_data;
if (xmmsv_get_type (value) == XMMSV_TYPE_STRING) {
const gchar *s;
xmmsv_get_string (value, &s);
xmms_medialib_entry_property_set_str_source (st->session,
st->entry,
key,
s,
st->source);
} else if (xmmsv_get_type (value) == XMMSV_TYPE_INT32) {
gint i;
xmmsv_get_int (value, &i);
xmms_medialib_entry_property_set_int_source (st->session,
st->entry,
key,
i,
st->source);
} else {
XMMS_DBG ("Unknown type?!?");
}
}
bool
setup_udp_handle (xmmsc_result_t *res)
{
bool ret;
xmmsc_vis_udp_t *t;
xmmsc_visualization_t *visc;
visc = xmmsc_result_visc_get (res);
if (!visc) {
x_api_error_if (1, "non vis result?", -1);
}
t = &visc->transport.udp;
if (!xmmsc_result_iserror (res)) {
xmmsv_t *val;
int port;
val = xmmsc_result_get_value (res);
xmmsv_get_int (val, &port);
ret = setup_socket (xmmsc_result_get_connection (res), t, visc->id, port);
} else {
ret = false;
}
return ret;
}
bool
setup_shm_handle (xmmsc_result_t *res)
{
bool ret;
xmmsc_visualization_t *visc;
xmmsc_vis_unixshm_t *t;
visc = xmmsc_result_visc_get (res);
if (!visc) {
x_api_error_if (1, "non vis result?", -1);
}
t = &visc->transport.shm;
if (!xmmsc_result_iserror (res)) {
xmmsv_t *val;
t->size = XMMS_VISPACKET_SHMCOUNT;
t->pos = 0;
val = xmmsc_result_get_value (res);
xmmsv_get_int (val, &t->semid);
ret = true;
} else {
/* didn't work, detach from shm to get it removed later on */
shmdt (t->buffer);
ret = false;
}
/* In either case, mark the shared memory segment to be destroyed.
The segment will only actually be destroyed after the last process detaches it. */
shmctl (t->shmid, IPC_RMID, NULL);
return ret;
}
static void
getValue( Dict::Variant& val, xmmsv_t *value )
{
switch( xmmsv_get_type( value ) ) {
case XMMSV_TYPE_INT32: {
int32_t temp = 0;
if( !xmmsv_get_int( value, &temp ) ) {
// FIXME: handle error
}
val = temp;
break;
}
case XMMSV_TYPE_STRING: {
const char* temp = 0;
if( !xmmsv_get_string( value, &temp ) ) {
// FIXME: handle error
}
val = std::string( temp );
break;
}
case XMMSV_TYPE_NONE: {
break;
}
default: {
}
}
}
static int32_t
ol_player_xmms2_get_currend_id ()
{
/* ol_log_func (); */
if (!ol_player_xmms2_ensure_connection ())
return 0;
int32_t ret = 0;
xmmsc_result_t *result = xmmsc_playback_current_id (connection);
xmmsc_result_wait (result);
xmmsv_t *return_value = xmmsc_result_get_value (result);
if (xmmsv_is_error (return_value))
{
ol_error ("Error on getting current id");
ret = 0;
}
else
{
if (!xmmsv_get_int (return_value, &ret))
{
ol_error ("Get id from result failed");
ret = 0;
}
}
xmmsc_result_unref (result);
return ret;
}
static int
xmmsv_dict_get_int (xmmsv_t *dict,
const char *key,
int32_t *val)
{
xmmsv_t *dict_entry;
return (xmmsv_dict_get (dict, key, &dict_entry) &&
xmmsv_get_int (dict_entry, val));
}
static VALUE
int_get (xmmsv_t *val)
{
int32_t id = 0;
if (!xmmsv_get_int (val, &id))
rb_raise (eValueError, "cannot retrieve value");
return INT2NUM (id);
}
/* Dumps a propdict on stdout */
static void
dict_dump (const gchar *source, xmmsv_t *val, void *udata)
{
xmmsv_type_t type;
const gchar **keyfilter = (const gchar **) udata;
const gchar *key = (const gchar *) keyfilter[0];
const gchar *filter = (const gchar *) keyfilter[1];
if (filter && strcmp (filter, source) != 0) {
return;
}
type = xmmsv_get_type (val);
switch (type) {
case XMMSV_TYPE_INT32:
{
gint value;
xmmsv_get_int (val, &value);
g_printf (_("[%s] %s = %u\n"), source, key, value);
break;
}
case XMMSV_TYPE_STRING:
{
const gchar *value;
xmmsv_get_string (val, &value);
/* FIXME: special handling for url, guess charset, see common.c:print_entry */
g_printf (_("[%s] %s = %s\n"), source, key, value);
break;
}
case XMMSV_TYPE_LIST:
g_printf (_("[%s] %s = <list>\n"), source, key);
break;
case XMMSV_TYPE_DICT:
g_printf (_("[%s] %s = <dict>\n"), source, key);
break;
case XMMSV_TYPE_COLL:
g_printf (_("[%s] %s = <coll>\n"), source, key);
break;
case XMMSV_TYPE_BIN:
g_printf (_("[%s] %s = <bin>\n"), source, key);
break;
case XMMSV_TYPE_END:
g_printf (_("[%s] %s = <end>\n"), source, key);
break;
case XMMSV_TYPE_NONE:
g_printf (_("[%s] %s = <none>\n"), source, key);
break;
case XMMSV_TYPE_ERROR:
g_printf (_("[%s] %s = <error>\n"), source, key);
break;
}
}
/*
* We set this up as a callback for our current_id
* method. Read the main program first before
* returning here.
*/
int
my_current_id (xmmsv_t *value, void *userdata)
{
/*
* At this point the value struct contains the
* answer. And we can now extract it as normal.
*/
int id;
int keep_alive = TRUE;
/*
* we passed the udata struct as an argument
* to set_notifier, which means it will be
* passed as userdata to this function
*/
udata_t *udata = (udata_t *) userdata;
/*
* Increase the counter that keeps track of how many
* times we've visited the broadcast callback.
*/
udata->counter++;
if (!xmmsv_get_int (value, &id)) {
fprintf (stderr, "Value didn't contain the expected type!\n");
exit (EXIT_FAILURE);
}
printf ("Current id is %d\n", id);
/*
* Check how many times the broadcast has been called.
* If five times, then stop the broadcast and
* tell the mainloop to exit.
*/
if (udata->counter == 5) {
printf ("Broadcast called %d times, exiting...\n", udata->counter);
g_main_loop_quit (udata->ml);
keep_alive = FALSE;
}
/*
* As promised, let's explain this magic. The return value of
* callbacks has no purpose for normal commands, but in the case
* of signals and broadcasts, it determines whether we want to keep
* running that callback or not.
* If returning TRUE, a signal would be restarted and a broadcast
* would keep going.
* If returning FALSE, a signal would not be restarted and a
* broadcast would be disconnected, i.e. they would stop.
* Here, we return FALSE after the callback is called 5 times.
*/
return keep_alive;
}
static void
currently_playing_update_playtime (currently_playing_t *entry, xmmsv_t *value)
{
gchar *formatted;
gint playtime;
xmmsv_get_int (value, &playtime);
formatted = format_time (playtime, FALSE);
xmmsv_dict_set_string (entry->data, "playtime", formatted);
g_free (formatted);
}
/*
* We set this up as a callback for our current_id
* method. Read the main program first before
* returning here.
*/
int
my_playtime (xmmsv_t *value, void *userdata)
{
/*
* At this point the result struct is filled with the
* answer. And we can now extract it as normal.
*/
int time;
int keep_alive;
/*
* we passed the mainloop as an argument
* to set_notifier, which means it will be
* passed as userdata to this function
*/
GMainLoop *ml = (GMainLoop *) userdata;
if (!xmmsv_get_int (value, &time)) {
fprintf (stderr, "Value didn't contain the expected type!\n");
exit (EXIT_FAILURE);
}
/*
* Print the time on the same line and flush stdout
* so that the text becomes visible.
*/
printf ("\r%4dms has been played", time);
fflush (stdout);
/*
* We will exit the application after 5000ms have passed.
* Otherwise we will restart the signal to enable this
* callback to be called yet another time.
*/
if (time > 5000) {
printf ("\nMore than 5000 ms has been played, exiting...\n");
g_main_loop_quit (ml);
keep_alive = FALSE;
} else {
/* Tell the server to send updates to the
* same callback (AKA restart the signal) */
keep_alive = TRUE;
}
/*
* We use the return value of the callback once
* again to determine whether to restart the signal
* or just let it die.
*/
return keep_alive;
}
/**
* Return a new value object which is a deep copy of the input value
*
* @param val #xmmsv_t to copy.
* @return 1 the address to the new copy of the value.
*/
xmmsv_t *
xmmsv_copy (xmmsv_t *val)
{
xmmsv_t *cur_val = NULL;
xmmsv_type_t type;
int64_t i;
const char *s;
float f;
x_return_val_if_fail (val, 0);
type = xmmsv_get_type (val);
switch (type) {
case XMMSV_TYPE_DICT:
cur_val = duplicate_dict_value (val);
break;
case XMMSV_TYPE_LIST:
cur_val = duplicate_list_value (val);
break;
case XMMSV_TYPE_INT64:
xmmsv_get_int (val, &i);
cur_val = xmmsv_new_int (i);
break;
case XMMSV_TYPE_FLOAT:
xmmsv_get_float (val, &f);
cur_val = xmmsv_new_float (f);
break;
case XMMSV_TYPE_STRING:
xmmsv_get_string (val, &s);
cur_val = xmmsv_new_string (s);
break;
case XMMSV_TYPE_ERROR:
xmmsv_get_error (val, &s);
cur_val = xmmsv_new_error (s);
break;
case XMMSV_TYPE_COLL:
cur_val = duplicate_coll_value (val);
break;
case XMMSV_TYPE_BIN:
cur_val = xmmsv_new_bin (val->value.bin.data, val->value.bin.len);
break;
case XMMSV_TYPE_BITBUFFER:
cur_val = xmmsv_new_bitbuffer ();
xmmsv_bitbuffer_put_data (cur_val, val->value.bit.buf, val->value.bit.len / 8);
xmmsv_bitbuffer_goto (cur_val, xmmsv_bitbuffer_pos (val));
break;
default:
cur_val = xmmsv_new_none ();
break;
}
assert (cur_val);
return cur_val;
}
static gint
refresh_playback_status (xmmsv_t *val, void *udata)
{
cli_cache_t *cache = (cli_cache_t *) udata;
if (!xmmsv_is_error (val)) {
xmmsv_get_int (val, &cache->playback_status);
}
freshness_received (&cache->freshness_playback_status);
return TRUE;
}
static gint
refresh_currid (xmmsv_t *val, void *udata)
{
cli_cache_t *cache = (cli_cache_t *) udata;
if (!xmmsv_is_error (val)) {
xmmsv_get_int (val, &cache->currid);
}
freshness_received (&cache->freshness_currid);
return TRUE;
}
gboolean
xmms_xform_auxdata_get_int (xmms_xform_t *xform, const gchar *key, gint32 *val)
{
const xmmsv_t *obj;
obj = xmms_xform_auxdata_get_val (xform, key);
if (obj && xmmsv_get_type (obj) == XMMSV_TYPE_INT32) {
xmmsv_get_int (obj, val);
return TRUE;
}
return FALSE;
}
static gint
xmms_browse_list_sortfunc (gconstpointer a, gconstpointer b)
{
int r1, r2;
xmmsv_t *val1, *val2, *tmp1, *tmp2;
const gchar *s1, *s2;
val1 = (xmmsv_t *) a;
val2 = (xmmsv_t *) b;
g_return_val_if_fail (xmmsv_get_type (val1) == XMMSV_TYPE_DICT, 0);
g_return_val_if_fail (xmmsv_get_type (val2) == XMMSV_TYPE_DICT, 0);
r1 = xmmsv_dict_get (val1, "intsort", &tmp1);
r2 = xmmsv_dict_get (val2, "intsort", &tmp2);
if (r1 && r2) {
gint i1, i2;
if (!xmmsv_get_int (tmp1, &i1))
return 0;
if (!xmmsv_get_int (tmp2, &i2))
return 0;
return i1 > i2;
}
if (!xmmsv_dict_get (val1, "path", &tmp1))
return 0;
if (!xmmsv_dict_get (val2, "path", &tmp2))
return 0;
if (!xmmsv_get_string (tmp1, &s1))
return 0;
if (!xmmsv_get_string (tmp2, &s2))
return 0;
return xmms_natcmp (s1, s2);
}
