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