static void ui_infoarea_set_title (void)
{
g_return_if_fail (area);
if (! aud_drct_get_playing ())
return;
int playlist = aud_playlist_get_playing ();
int entry = aud_playlist_get_position (playlist);
char * title, * artist, * album;
aud_playlist_entry_describe (playlist, entry, & title, & artist, & album, TRUE);
if (! g_strcmp0 (title, area->title) && ! g_strcmp0 (artist, area->artist)
&& ! g_strcmp0 (album, area->album))
{
str_unref (title);
str_unref (artist);
str_unref (album);
return;
}
str_unref (area->title);
str_unref (area->artist);
str_unref (area->album);
area->title = title;
area->artist = artist;
area->album = album;
gtk_widget_queue_draw (area->main);
}
static gboolean search_cb (GtkTreeModel * model, gint column, const gchar * key,
GtkTreeIter * iter, void * user)
{
GtkTreePath * path = gtk_tree_model_get_path (model, iter);
g_return_val_if_fail (path, TRUE);
gint row = gtk_tree_path_get_indices (path)[0];
g_return_val_if_fail (row >= 0, TRUE);
gchar * s[3] = {NULL, NULL, NULL};
aud_playlist_entry_describe (((PlaylistWidgetData *) user)->list, row,
& s[0], & s[1], & s[2], FALSE);
gtk_tree_path_free (path);
gchar * temp = g_utf8_strdown (key, -1);
gchar * * keys = g_strsplit (temp, " ", 0);
g_free (temp);
gint remain = 0; /* number of keys remaining to be matched */
for (gint j = 0; keys[j]; j ++)
{
if (keys[j][0])
remain ++;
}
if (! remain)
remain ++; /* force non-match if there are no non-blank keys */
for (gint i = 0; i < G_N_ELEMENTS (s); i ++)
{
if (! s[i])
continue;
if (remain)
{
temp = g_utf8_strdown (s[i], -1);
for (gint j = 0; keys[j] && remain; j ++)
{
if (keys[j][0] && strstr (temp, keys[j]))
{
keys[j][0] = 0; /* don't look for this one again */
remain --;
}
}
g_free (temp);
}
str_unref (s[i]);
}
g_strfreev (keys);
return remain ? TRUE : FALSE; /* TRUE == not matched, FALSE == matched */
}
static bool_t search_cb (GtkTreeModel * model, int column, const char * search,
GtkTreeIter * iter, void * user)
{
GtkTreePath * path = gtk_tree_model_get_path (model, iter);
g_return_val_if_fail (path, TRUE);
int row = gtk_tree_path_get_indices (path)[0];
g_return_val_if_fail (row >= 0, TRUE);
gtk_tree_path_free (path);
Index * keys = str_list_to_index (search, " ");
int n_keys = index_count (keys);
bool_t matched = FALSE;
if (n_keys)
{
char * s[3] = {NULL, NULL, NULL};
aud_playlist_entry_describe (((PlaylistWidgetData *) user)->list, row,
& s[0], & s[1], & s[2], FALSE);
for (int i = 0; i < ARRAY_LEN (s); i ++)
{
if (! s[i])
continue;
for (int j = 0; j < n_keys;)
{
if (strstr_nocase_utf8 (s[i], index_get (keys, j)))
{
index_delete_full (keys, j, 1, (IndexFreeFunc) str_unref);
n_keys --;
}
else
j ++;
}
str_unref (s[i]);
}
matched = ! n_keys;
}
index_free_full (keys, (IndexFreeFunc) str_unref);
return ! matched;
}
static void lyricwiki_playback_began(void)
{
if (!aud_drct_get_playing())
return;
/* FIXME: cancel previous VFS requests (not possible with current API) */
str_unref(state.filename);
str_unref(state.title);
str_unref(state.artist);
str_unref(state.uri);
int playlist = aud_playlist_get_playing();
int pos = aud_playlist_get_position(playlist);
state.filename = aud_playlist_entry_get_filename(playlist, pos);
aud_playlist_entry_describe(playlist, pos, &state.title, &state.artist, NULL, FALSE);
state.uri = NULL;
get_lyrics_step_1();
}
static void get_value (void * user, gint row, gint column, GValue * value)
{
PlaylistWidgetData * data = user;
g_return_if_fail (column >= 0 && column < pw_num_cols);
g_return_if_fail (row >= 0 && row < aud_playlist_entry_count (data->list));
column = pw_cols[column];
gchar * title = NULL, * artist = NULL, * album = NULL;
Tuple * tuple = NULL;
if (column == PW_COL_TITLE || column == PW_COL_ARTIST || column ==
PW_COL_ALBUM)
aud_playlist_entry_describe (data->list, row, & title, & artist,
& album, TRUE);
else if (column == PW_COL_YEAR || column == PW_COL_TRACK || column ==
PW_COL_GENRE || column == PW_COL_FILENAME || column == PW_COL_PATH ||
column == PW_COL_BITRATE)
tuple = aud_playlist_entry_get_tuple (data->list, row, TRUE);
switch (column)
{
case PW_COL_NUMBER:
g_value_set_int (value, 1 + row);
break;
case PW_COL_TITLE:
g_value_set_string (value, title);
break;
case PW_COL_ARTIST:
g_value_set_string (value, artist);
break;
case PW_COL_YEAR:
set_int_from_tuple (value, tuple, FIELD_YEAR);
break;
case PW_COL_ALBUM:
g_value_set_string (value, album);
break;
case PW_COL_TRACK:
set_int_from_tuple (value, tuple, FIELD_TRACK_NUMBER);
break;
case PW_COL_GENRE:
set_string_from_tuple (value, tuple, FIELD_GENRE);
break;
case PW_COL_QUEUED:
set_queued (value, data->list, row);
break;
case PW_COL_LENGTH:
set_length (value, data->list, row);
break;
case PW_COL_FILENAME:
set_string_from_tuple (value, tuple, FIELD_FILE_NAME);
break;
case PW_COL_PATH:
set_string_from_tuple (value, tuple, FIELD_FILE_PATH);
break;
case PW_COL_CUSTOM:;
gchar * custom = aud_playlist_entry_get_title (data->list, row, TRUE);
g_value_set_string (value, custom);
str_unref (custom);
break;
case PW_COL_BITRATE:
set_int_from_tuple (value, tuple, FIELD_BITRATE);
break;
}
str_unref (title);
str_unref (artist);
str_unref (album);
if (tuple)
tuple_unref (tuple);
}
static void update_metadata (void * data, GObject * object)
{
char * title = NULL, * artist = NULL, * album = NULL, * file = NULL;
int length = 0;
int playlist = aud_playlist_get_playing ();
int entry = (playlist >= 0) ? aud_playlist_get_position (playlist) : -1;
if (entry >= 0)
{
aud_playlist_entry_describe (playlist, entry, & title, & artist, & album, TRUE);
file = aud_playlist_entry_get_filename (playlist, entry);
length = aud_playlist_entry_get_length (playlist, entry, TRUE);
}
/* pointer comparison works for pooled strings */
if (title == last_title && artist == last_artist && album == last_album &&
file == last_file && length == last_length)
{
str_unref (title);
str_unref (artist);
str_unref (album);
str_unref (file);
return;
}
if (file != last_file)
{
if (image_file)
aud_art_unref (last_file);
image_file = file ? aud_art_get_file (file) : NULL;
}
str_unref (last_title);
str_unref (last_artist);
str_unref (last_album);
str_unref (last_file);
last_title = title;
last_artist = artist;
last_album = album;
last_file = file;
last_length = length;
GVariant * elems[7];
int nelems = 0;
if (title)
{
GVariant * key = g_variant_new_string ("xesam:title");
GVariant * str = g_variant_new_string (title);
GVariant * var = g_variant_new_variant (str);
elems[nelems ++] = g_variant_new_dict_entry (key, var);
}
if (artist)
{
GVariant * key = g_variant_new_string ("xesam:artist");
GVariant * str = g_variant_new_string (artist);
GVariant * array = g_variant_new_array (G_VARIANT_TYPE_STRING, & str, 1);
GVariant * var = g_variant_new_variant (array);
elems[nelems ++] = g_variant_new_dict_entry (key, var);
}
if (album)
{
GVariant * key = g_variant_new_string ("xesam:album");
GVariant * str = g_variant_new_string (album);
GVariant * var = g_variant_new_variant (str);
elems[nelems ++] = g_variant_new_dict_entry (key, var);
}
if (file)
{
GVariant * key = g_variant_new_string ("xesam:url");
GVariant * str = g_variant_new_string (file);
GVariant * var = g_variant_new_variant (str);
elems[nelems ++] = g_variant_new_dict_entry (key, var);
}
if (length > 0)
{
GVariant * key = g_variant_new_string ("mpris:length");
GVariant * val = g_variant_new_int64 ((int64_t) length * 1000);
GVariant * var = g_variant_new_variant (val);
elems[nelems ++] = g_variant_new_dict_entry (key, var);
}
if (image_file)
{
GVariant * key = g_variant_new_string ("mpris:artUrl");
GVariant * str = g_variant_new_string (image_file);
GVariant * var = g_variant_new_variant (str);
elems[nelems ++] = g_variant_new_dict_entry (key, var);
}
GVariant * key = g_variant_new_string ("mpris:trackid");
GVariant * str = g_variant_new_string ("/org/mpris/MediaPlayer2/CurrentTrack");
GVariant * var = g_variant_new_variant (str);
elems[nelems ++] = g_variant_new_dict_entry (key, var);
if (! metadata_type)
metadata_type = g_variant_type_new ("{sv}");
GVariant * array = g_variant_new_array (metadata_type, elems, nelems);
g_object_set (object, "metadata", array, NULL);
}
static void create_database (int list)
{
destroy_database ();
database = g_hash_table_new_full ((GHashFunc) str_hash, (GEqualFunc)
str_equal, NULL, (GDestroyNotify) item_free);
int entries = aud_playlist_entry_count (list);
for (int e = 0; e < entries; e ++)
{
char * title, * artist, * album;
Item * artist_item, * album_item, * title_item;
aud_playlist_entry_describe (list, e, & title, & artist, & album, TRUE);
if (! title)
{
str_unref (artist);
str_unref (album);
continue;
}
if (! artist)
artist = str_get (_("Unknown Artist"));
if (! album)
album = str_get (_("Unknown Album"));
artist_item = g_hash_table_lookup (database, artist);
if (! artist_item)
{
/* item_new() takes ownership of reference to artist */
artist_item = item_new (ARTIST, artist, NULL);
g_hash_table_insert (database, artist, artist_item);
}
else
str_unref (artist);
g_array_append_val (artist_item->matches, e);
album_item = g_hash_table_lookup (artist_item->children, album);
if (! album_item)
{
/* item_new() takes ownership of reference to album */
album_item = item_new (ALBUM, album, artist_item);
g_hash_table_insert (artist_item->children, album, album_item);
}
else
str_unref (album);
g_array_append_val (album_item->matches, e);
title_item = g_hash_table_lookup (album_item->children, title);
if (! title_item)
{
/* item_new() takes ownership of reference to title */
title_item = item_new (TITLE, title, album_item);
g_hash_table_insert (album_item->children, title, title_item);
}
else
str_unref (title);
g_array_append_val (title_item->matches, e);
}
}
