static void confirm_delete (void)
{
int playlist = aud_playlist_get_active ();
int entry_count = aud_playlist_entry_count (playlist);
for (int i = 0; i < entry_count; i ++)
{
if (! aud_playlist_entry_get_selected (playlist, i))
continue;
char * uri = aud_playlist_entry_get_filename (playlist, i);
char * filename = uri_to_filename (uri);
if (filename)
{
if (aud_get_bool ("delete_files", "use_trash"))
move_to_trash (filename);
else
really_delete (filename);
str_unref (filename);
}
else
{
SPRINTF (error, _("Error deleting %s: not a local file."), uri);
aud_interface_show_error (error);
}
str_unref (uri);
}
aud_playlist_delete_selected (playlist);
}
void ui_playlist_widget_update (GtkWidget * widget, gint type, gint at,
gint count)
{
PlaylistWidgetData * data = audgui_list_get_user (widget);
g_return_if_fail (data);
if (type >= PLAYLIST_UPDATE_STRUCTURE)
{
gint diff = aud_playlist_entry_count (data->list) -
audgui_list_row_count (widget);
if (diff > 0)
audgui_list_insert_rows (widget, at, diff);
else if (diff < 0)
audgui_list_delete_rows (widget, at, -diff);
ui_playlist_widget_scroll (widget);
}
if (type >= PLAYLIST_UPDATE_METADATA)
audgui_list_update_rows (widget, at, count);
audgui_list_update_selection (widget, at, count);
audgui_list_set_focus (widget, aud_playlist_get_focus (data->list));
update_queue (widget, data);
}
void ui_playlist_widget_update (GtkWidget * widget, int type, int at,
int count)
{
PlaylistWidgetData * data = audgui_list_get_user (widget);
g_return_if_fail (data);
if (type == PLAYLIST_UPDATE_STRUCTURE)
{
int old_entries = audgui_list_row_count (widget);
int entries = aud_playlist_entry_count (data->list);
audgui_list_delete_rows (widget, at, old_entries - (entries - count));
audgui_list_insert_rows (widget, at, count);
/* scroll to end of playlist if entries were added there
(but not if a newly added entry is playing) */
if (entries > old_entries && at + count == entries &&
aud_playlist_get_focus (data->list) < old_entries)
aud_playlist_set_focus (data->list, entries - 1);
ui_playlist_widget_scroll (widget);
}
else if (type == PLAYLIST_UPDATE_METADATA)
audgui_list_update_rows (widget, at, count);
audgui_list_update_selection (widget, at, count);
audgui_list_set_focus (widget, aud_playlist_get_focus (data->list));
update_queue (widget, data);
}
GtkWidget * ui_playlist_widget_new (gint playlist)
{
PlaylistWidgetData * data = g_malloc0 (sizeof (PlaylistWidgetData));
data->list = playlist;
data->queue = NULL;
data->popup_source = 0;
data->popup_pos = -1;
data->popup_shown = FALSE;
GtkWidget * list = audgui_list_new (& callbacks, data,
aud_playlist_entry_count (playlist));
gtk_tree_view_set_headers_visible ((GtkTreeView *) list,
aud_get_bool ("gtkui", "playlist_headers"));
gtk_tree_view_set_search_equal_func ((GtkTreeView *) list, search_cb, data,
NULL);
g_signal_connect_swapped (list, "destroy", (GCallback) destroy_cb, data);
/* Disable type-to-search because it blocks CTRL-V, causing URI's to be
* pasted into the search box rather than added to the playlist. The search
* box can still be brought up with CTRL-F. */
gtk_tree_view_set_enable_search ((GtkTreeView *) list, FALSE);
for (gint i = 0; i < pw_num_cols; i ++)
{
gint n = pw_cols[i];
audgui_list_add_column (list, pw_col_label[n] ? _(pw_col_names[n]) :
NULL, i, pw_col_types[n], pw_col_widths[n]);
}
return list;
}
static void action_play (void)
{
int list = aud_playlist_get_temporary ();
aud_playlist_set_active (list);
if (aud_get_bool (NULL, "clear_playlist"))
aud_playlist_entry_delete (list, 0, aud_playlist_entry_count (list));
else
aud_playlist_queue_delete (list, 0, aud_playlist_queue_count (list));
do_add (TRUE, NULL);
}
static void begin_add (const char * path)
{
int list = get_playlist (FALSE, FALSE);
if (list < 0)
list = create_playlist ();
aud_set_str ("search-tool", "path", path);
char * uri = filename_to_uri (path);
g_return_if_fail (uri);
if (! g_str_has_suffix (uri, "/"))
{
SCONCAT2 (temp, uri, "/");
str_unref (uri);
uri = str_get (temp);
}
destroy_added_table ();
added_table = g_hash_table_new_full ((GHashFunc) str_hash, (GEqualFunc)
str_equal, (GDestroyNotify) str_unref, NULL);
int entries = aud_playlist_entry_count (list);
for (int entry = 0; entry < entries; entry ++)
{
char * filename = aud_playlist_entry_get_filename (list, entry);
if (g_str_has_prefix (filename, uri) && ! g_hash_table_contains (added_table, filename))
{
aud_playlist_entry_set_selected (list, entry, FALSE);
g_hash_table_insert (added_table, filename, NULL);
}
else
{
aud_playlist_entry_set_selected (list, entry, TRUE);
str_unref (filename);
}
}
aud_playlist_delete_selected (list);
aud_playlist_remove_failed (list);
Index * add = index_new ();
index_insert (add, -1, uri);
aud_playlist_entry_insert_filtered (list, -1, add, NULL, filter_cb, NULL, FALSE);
adding = TRUE;
}
static void get_value (void * user, int row, int column, GValue * value)
{
switch (column)
{
case 0:;
char * title = aud_playlist_get_title (row);
g_value_set_string (value, title);
str_unref (title);
break;
case 1:
g_value_set_int (value, aud_playlist_entry_count (row));
break;
}
}
EXPORT void audgui_import_playlist (void)
{
int list = aud_playlist_get_active ();
int id = aud_playlist_get_unique_id (list);
char * filename = select_file (FALSE, NULL);
if (! filename)
return;
if ((list = aud_playlist_by_unique_id (id)) < 0)
return;
aud_playlist_entry_delete (list, 0, aud_playlist_entry_count (list));
aud_playlist_entry_insert (list, 0, filename, NULL, FALSE);
aud_playlist_set_filename (list, filename);
g_free (filename);
}
void playlist_delete_selected (void)
{
gint list = aud_playlist_get_active ();
gint focus = playlist_get_focus (list);
focus -= playlist_count_selected_in_range (list, 0, focus);
aud_drct_pl_delete_selected (list);
if (aud_playlist_selected_count (list)) /* song changed? */
return;
if (focus == aud_playlist_entry_count (list))
focus --;
if (focus >= 0)
{
aud_playlist_entry_set_selected (list, focus, TRUE);
playlist_set_focus (list, focus);
}
}
static void finish_job (void * data)
{
ImportExportJob * job = data;
int list = aud_playlist_by_unique_id (job->list_id);
if (list >= 0)
{
aud_playlist_set_filename (list, job->filename);
if (job->save)
aud_playlist_save (list, job->filename);
else
{
aud_playlist_entry_delete (list, 0, aud_playlist_entry_count (list));
aud_playlist_entry_insert (list, 0, job->filename, NULL, FALSE);
}
}
gtk_widget_destroy (job->selector);
}
GList *
get_upload_list(void)
{
GList *up_list=NULL;
gint current_play = aud_playlist_get_active();
gint i = (aud_playlist_entry_count(current_play) - 1);
for (; i >= 0; i--)
{
if (aud_playlist_entry_get_selected(current_play, i))
{
Tuple * tuple = aud_playlist_entry_get_tuple (current_play, i, FALSE);
aud_playlist_entry_set_selected(current_play, i, FALSE);
up_list = g_list_prepend (up_list, (void *) tuple);
if (tuple)
tuple_unref (tuple);
}
}
return g_list_reverse(up_list);
}
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 gboolean lirc_input_callback (GIOChannel * source, GIOCondition condition, void * data)
{
char *code;
char *c;
gint playlist_time, playlist_pos, output_time, v;
int ret;
char *ptr;
gint balance;
#if 0
gboolean show_pl;
#endif
int n;
gchar *utf8_title_markup;
while ((ret = lirc_nextcode (&code)) == 0 && code != NULL)
{
while ((ret = lirc_code2char (config, code, &c)) == 0 && c != NULL)
{
if (strcasecmp ("PLAY", c) == 0)
aud_drct_play ();
else if (strcasecmp ("STOP", c) == 0)
aud_drct_stop ();
else if (strcasecmp ("PAUSE", c) == 0)
aud_drct_pause ();
else if (strcasecmp ("PLAYPAUSE", c) == 0)
aud_drct_play_pause ();
else if (strncasecmp ("NEXT", c, 4) == 0)
{
ptr = c + 4;
while (isspace (*ptr))
ptr++;
n = atoi (ptr);
if (n <= 0)
n = 1;
for (; n > 0; n--)
{
aud_drct_pl_next ();
}
}
else if (strncasecmp ("PREV", c, 4) == 0)
{
ptr = c + 4;
while (isspace (*ptr))
ptr++;
n = atoi (ptr);
if (n <= 0)
n = 1;
for (; n > 0; n--)
{
aud_drct_pl_prev ();
}
}
else if (strcasecmp ("SHUFFLE", c) == 0)
aud_set_bool (NULL, "shuffle", ! aud_get_bool (NULL, "shuffle"));
else if (strcasecmp ("REPEAT", c) == 0)
aud_set_bool (NULL, "repeat", ! aud_get_bool (NULL, "repeat"));
else if (strncasecmp ("FWD", c, 3) == 0)
{
ptr = c + 3;
while (isspace (*ptr))
ptr++;
n = atoi (ptr) * 1000;
if (n <= 0)
n = 5000;
output_time = aud_drct_get_time ();
int playlist = aud_playlist_get_active ();
playlist_pos = aud_playlist_get_position (playlist);
playlist_time =
aud_playlist_entry_get_length (playlist, playlist_pos,
FALSE);
if (playlist_time - output_time < n)
output_time = playlist_time - n;
aud_drct_seek (output_time + n);
}
else if (strncasecmp ("BWD", c, 3) == 0)
{
ptr = c + 3;
while (isspace (*ptr))
ptr++;
n = atoi (ptr) * 1000;
if (n <= 0)
n = 5000;
output_time = aud_drct_get_time ();
if (output_time < n)
output_time = n;
aud_drct_seek (output_time - n);
}
else if (strncasecmp ("VOL_UP", c, 6) == 0)
{
ptr = c + 6;
while (isspace (*ptr))
ptr++;
n = atoi (ptr);
if (n <= 0)
n = 5;
aud_drct_get_volume_main (&v);
if (v > (100 - n))
v = 100 - n;
aud_drct_set_volume_main (v + n);
}
else if (strncasecmp ("VOL_DOWN", c, 8) == 0)
{
ptr = c + 8;
while (isspace (*ptr))
ptr++;
n = atoi (ptr);
if (n <= 0)
n = 5;
aud_drct_get_volume_main (&v);
if (v < n)
v = n;
aud_drct_set_volume_main (v - n);
}
else if (strcasecmp ("QUIT", c) == 0)
{
aud_drct_quit ();
}
else if (strcasecmp ("MUTE", c) == 0)
{
if (mute == 0)
{
mute = 1;
/* store the master volume so
we can restore it on unmute. */
aud_drct_get_volume_main (&mute_vol);
aud_drct_set_volume_main (0);
}
else
{
mute = 0;
aud_drct_set_volume_main (mute_vol);
}
}
else if (strncasecmp ("BAL_LEFT", c, 8) == 0)
{
ptr = c + 8;
while (isspace (*ptr))
ptr++;
n = atoi (ptr);
if (n <= 0)
n = 5;
aud_drct_get_volume_balance (&balance);
balance -= n;
if (balance < -100)
balance = -100;
aud_drct_set_volume_balance (balance);
}
else if (strncasecmp ("BAL_RIGHT", c, 9) == 0)
{
ptr = c + 9;
while (isspace (*ptr))
ptr++;
n = atoi (ptr);
if (n <= 0)
n = 5;
aud_drct_get_volume_balance (&balance);
balance += n;
if (balance > 100)
balance = 100;
aud_drct_set_volume_balance (balance);
}
else if (strcasecmp ("BAL_CENTER", c) == 0)
{
balance = 0;
aud_drct_set_volume_balance (balance);
}
else if (strcasecmp ("LIST", c) == 0)
{
#if 0
show_pl = aud_drct_pl_win_is_visible ();
show_pl = (show_pl) ? 0 : 1;
aud_drct_pl_win_toggle (show_pl);
#endif
}
else if (strcasecmp ("PLAYLIST_CLEAR", c) == 0)
{
aud_drct_stop ();
int playlist = aud_playlist_get_active ();
aud_playlist_entry_delete (playlist, 0,
aud_playlist_entry_count
(playlist));
}
else if (strncasecmp ("PLAYLIST_ADD ", c, 13) == 0)
{
aud_drct_pl_add (c + 13, -1);
}
else if ((strlen (c) == 1) && ((*c >= '0') || (*c <= '9')))
{
if (track_no_pos < 63)
{
if (tid)
g_source_remove (tid);
track_no[track_no_pos++] = *c;
track_no[track_no_pos] = 0;
tid = g_timeout_add (1500, jump_to, NULL);
utf8_title_markup = g_markup_printf_escaped ("%s", track_no);
hook_call ("aosd toggle", utf8_title_markup);
}
}
else
{
fprintf (stderr, _("%s: unknown command \"%s\"\n"),
plugin_name, c);
}
}
free (code);
if (ret == -1)
break;
}
if (ret == -1)
{
/* something went badly wrong */
fprintf (stderr, _("%s: disconnected from LIRC\n"), plugin_name);
cleanup ();
if (aud_get_bool ("lirc", "enable_reconnect"))
{
int reconnect_timeout = aud_get_int ("lirc", "reconnect_timeout");
fprintf (stderr,
_("%s: will try reconnect every %d seconds...\n"),
plugin_name, reconnect_timeout);
g_timeout_add (1000 * reconnect_timeout, reconnect_lirc, NULL);
}
}
return TRUE;
}
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);
}
}
