void audgui_queue_manager_show (void)
{
if (qm_win)
{
gtk_window_present ((GtkWindow *) qm_win);
return;
}
qm_win = gtk_dialog_new_with_buttons (_("Queue Manager"), NULL, 0,
GTK_STOCK_REMOVE, RESPONSE_REMOVE, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
NULL);
gtk_window_set_default_size ((GtkWindow *) qm_win, 250, 250);
GtkWidget * vbox = gtk_dialog_get_content_area ((GtkDialog *) qm_win);
GtkWidget * scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_box_pack_start ((GtkBox *) vbox, scrolled, TRUE, TRUE, 0);
gint count = aud_playlist_queue_count (aud_playlist_get_active ());
qm_list = audgui_list_new (& callbacks, NULL, count);
gtk_tree_view_set_headers_visible ((GtkTreeView *) qm_list, FALSE);
audgui_list_add_column (qm_list, NULL, 0, G_TYPE_INT, FALSE);
audgui_list_add_column (qm_list, NULL, 1, G_TYPE_STRING, TRUE);
gtk_container_add ((GtkContainer *) scrolled, qm_list);
hook_associate ("playlist activate", update_hook, NULL);
hook_associate ("playlist update", update_hook, NULL);
g_signal_connect (qm_win, "destroy", (GCallback) destroy_cb, NULL);
g_signal_connect (qm_win, "key-press-event", (GCallback) keypress_cb, NULL);
g_signal_connect (qm_win, "response", (GCallback) response_cb, NULL);
gtk_widget_show_all (qm_win);
}
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);
}
static void action_add_to_playlist (void)
{
if (aud_playlist_by_unique_id (playlist_id) == aud_playlist_get_active ())
return;
do_add (FALSE, NULL);
}
static void shift_rows (void * user, gint row, gint before)
{
GArray * shift = g_array_new (FALSE, FALSE, sizeof (gint));
gint list = aud_playlist_get_active ();
gint count = aud_playlist_queue_count (list);
for (gint i = 0; i < count; i ++)
{
gint entry = aud_playlist_queue_get_entry (list, i);
if (aud_playlist_entry_get_selected (list, entry))
{
g_array_append_val (shift, entry);
if (i < before)
before --;
}
}
aud_playlist_queue_delete_selected (list);
for (gint i = 0; i < shift->len; i ++)
aud_playlist_queue_insert (list, before + i, g_array_index (shift, gint, i));
g_array_free (shift, TRUE);
}
static void update_hook (void * data, void * list)
{
int rows = aud_playlist_count ();
if (GPOINTER_TO_INT (data) == PLAYLIST_UPDATE_STRUCTURE)
{
int old_rows = audgui_list_row_count (list);
if (rows < old_rows)
audgui_list_delete_rows (list, rows, old_rows - rows);
else if (rows > old_rows)
audgui_list_insert_rows (list, old_rows, rows - old_rows);
position_changed = TRUE;
playlist_activated = TRUE;
}
if (GPOINTER_TO_INT (data) >= PLAYLIST_UPDATE_METADATA)
audgui_list_update_rows (list, 0, rows);
if (playlist_activated)
{
audgui_list_set_focus (list, aud_playlist_get_active ());
audgui_list_update_selection (list, 0, rows);
playlist_activated = FALSE;
}
if (position_changed)
{
audgui_list_set_highlight (list, aud_playlist_get_playing ());
position_changed = FALSE;
}
}
static void do_add (bool_t play, char * * title)
{
int list = aud_playlist_by_unique_id (playlist_id);
int n_items = index_count (items);
int n_selected = 0;
Index * filenames = index_new ();
Index * tuples = index_new ();
for (int i = 0; i < n_items; i ++)
{
if (! selection->data[i])
continue;
Item * item = index_get (items, i);
for (int m = 0; m < item->matches->len; m ++)
{
int entry = g_array_index (item->matches, int, m);
index_insert (filenames, -1, aud_playlist_entry_get_filename (list, entry));
index_insert (tuples, -1, aud_playlist_entry_get_tuple (list, entry, TRUE));
}
n_selected ++;
if (title && n_selected == 1)
* title = item->name;
}
if (title && n_selected != 1)
* title = NULL;
aud_playlist_entry_insert_batch (aud_playlist_get_active (), -1, filenames,
tuples, play);
}
void ui_playlist_notebook_update (void * data, void * user)
{
gint global_level = GPOINTER_TO_INT (data);
if (global_level == PLAYLIST_UPDATE_STRUCTURE)
add_remove_pages ();
gint lists = aud_playlist_count ();
for (gint list = 0; list < lists; list ++)
{
if (global_level >= PLAYLIST_UPDATE_METADATA)
set_tab_label (list, get_tab_label (list));
gint at, count;
gint level = aud_playlist_updated_range (list, & at, & count);
if (level)
ui_playlist_widget_update (playlist_get_treeview (list), level, at, count);
}
gtk_notebook_set_current_page ((GtkNotebook *) notebook, aud_playlist_get_active ());
do_follow ();
}
gboolean jump_to (gpointer data)
{
int playlist = aud_playlist_get_active ();
aud_playlist_set_position (playlist, atoi (track_no) - 1);
track_no_pos = 0;
tid = 0;
return FALSE;
}
static void select_all (void * user, gboolean selected)
{
gint list = aud_playlist_get_active ();
gint count = aud_playlist_queue_count (list);
for (gint i = 0; i < count; i ++)
aud_playlist_entry_set_selected (list, aud_playlist_queue_get_entry (list, i), selected);
}
void playlist_copy (void)
{
gchar * text = audgui_urilist_create_from_selected (aud_playlist_get_active ());
if (! text)
return;
gtk_clipboard_set_text (gtk_clipboard_get (GDK_SELECTION_CLIPBOARD), text, -1);
g_free (text);
}
static void activate_hook (void * data, void * list)
{
if (aud_playlist_update_pending ())
playlist_activated = TRUE;
else
{
audgui_list_set_focus (list, aud_playlist_get_active ());
audgui_list_update_selection (list, 0, aud_playlist_count ());
}
}
void playlist_song_info (void)
{
gint list = aud_playlist_get_active ();
gint focus = playlist_get_focus (list);
if (focus < 0)
return;
audgui_infowin_show (list, focus);
}
static void tab_title_save(GtkEntry *entry, gpointer ebox)
{
GtkWidget *label = g_object_get_data(G_OBJECT(ebox), "label");
aud_playlist_set_title(aud_playlist_get_active(), gtk_entry_get_text(entry));
gtk_widget_hide(GTK_WIDGET(entry));
gtk_widget_show(label);
ui_playlist_notebook_tab_title_editing = NULL;
}
void ui_playlist_notebook_populate(void)
{
gint playlists = aud_playlist_count();
gint count;
for (count = 0; count < playlists; count++)
ui_playlist_notebook_create_tab(count);
gtk_notebook_set_current_page (UI_PLAYLIST_NOTEBOOK, aud_playlist_get_active ());
highlighted = aud_playlist_get_unique_id (aud_playlist_get_playing ());
if (! switch_handler)
switch_handler = g_signal_connect (notebook, "switch-page", (GCallback)
tab_changed, NULL);
if (! reorder_handler)
reorder_handler = g_signal_connect (notebook, "page-reordered",
(GCallback) tab_reordered, NULL);
gtk_widget_grab_focus (playlist_get_treeview (aud_playlist_get_active ()));
}
void playlist_paste (void)
{
gchar * text = gtk_clipboard_wait_for_text (gtk_clipboard_get
(GDK_SELECTION_CLIPBOARD));
if (! text)
return;
gint list = aud_playlist_get_active ();
audgui_urilist_insert (list, playlist_get_focus (list), text);
g_free (text);
}
void playlist_shift (gint offset)
{
gint list = aud_playlist_get_active ();
gint focus = playlist_get_focus (list);
if (focus < 0 || ! aud_playlist_entry_get_selected (list, focus))
return;
focus += aud_playlist_shift (list, focus, offset);
playlist_set_focus (list, focus);
}
static gboolean playlist_keypress_cb (GtkWidget * widget, GdkEventKey * event, void * unused)
{
switch (event->state & (GDK_SHIFT_MASK | GDK_CONTROL_MASK | GDK_MOD1_MASK))
{
case 0:
switch (event->keyval)
{
case GDK_KEY_Escape:
ui_playlist_notebook_position (GINT_TO_POINTER (aud_playlist_get_active ()), NULL);
return TRUE;
case GDK_KEY_Delete:
playlist_delete_selected ();
return TRUE;
case GDK_KEY_Menu:
popup_menu_rclick (0, event->time);
return TRUE;
}
break;
case GDK_CONTROL_MASK:
switch (event->keyval)
{
case 'x':
playlist_cut ();
return TRUE;
case 'c':
playlist_copy ();
return TRUE;
case 'v':
playlist_paste ();
return TRUE;
case 'a':
aud_playlist_select_all (aud_playlist_get_active (), TRUE);
return TRUE;
}
break;
}
return FALSE;
}
gboolean checkcover (gint tag) {
gint playlist_position;
//gchar *playlist_uri = NULL;
gchar *playlist_filename = NULL;
gint playlist = aud_playlist_get_active();
gboolean processed = 0;
gboolean fast_call = 0;
gdk_threads_enter ();
playlist_position = aud_playlist_get_position(playlist);
//playlist_uri = aud_playlist_get_filename (playlist);
const Tuple *tuple = aud_playlist_entry_get_tuple(playlist, playlist_position, fast_call);
if (tuple)
{
playlist_filename = g_strdup((gchar *) tuple_get_string(tuple, FIELD_FILE_PATH, NULL));
if (playlist_filename)
{
/*playlist_filename = g_filename_from_uri(playlist_uri, NULL, NULL);
if (playlist_filename)
{*/
if (strcmp (playlist_filename,current_filename) && !mainwindow_data.loading_cover)
{
mainwindow_data.loading_cover = TRUE;
// Filename has changed
current_filename = realloc (current_filename,strlen(playlist_filename)+1);
strcpy (current_filename,playlist_filename);
DPRINT (__DEBUG_GENERAL__,"New playfile detected: %s",current_filename);
// Find new cover if possible
findcover_search (current_filename);
DPRINT (__DEBUG_GENERAL__,"Cover to display: %s",findcover_filename);
loadimage (findcover_filename);
mainwindow_data.loading_cover = FALSE;
}
free (playlist_filename);
//free (playlist_uri);
processed = 1;
/*}*/
}
}
if (!processed)
{
mainwindow_data.loading_cover = TRUE;
loadimage (NULL);
mainwindow_data.loading_cover = FALSE;
}
gdk_threads_leave ();
return TRUE;
}
void playlist_queue_toggle (void)
{
gint list = aud_playlist_get_active ();
gint focus = playlist_get_focus (list);
if (focus < 0)
return;
gint at = aud_playlist_queue_find_entry (list, focus);
if (at < 0)
aud_playlist_queue_insert (list, -1, focus);
else
aud_playlist_queue_delete (list, at, 1);
}
void audgui_infowin_show_current (void)
{
int playlist = aud_playlist_get_playing ();
int position;
if (playlist == -1)
playlist = aud_playlist_get_active ();
position = aud_playlist_get_position (playlist);
if (position == -1)
return;
audgui_infowin_show (playlist, position);
}
void ui_playlist_notebook_edit_tab_title(GtkWidget *ebox)
{
if (!gtk_notebook_get_show_tabs(UI_PLAYLIST_NOTEBOOK))
return;
if (ebox == NULL || !GTK_IS_EVENT_BOX(ebox))
{
GtkWidget *page = gtk_notebook_get_nth_page(UI_PLAYLIST_NOTEBOOK, aud_playlist_get_active());
ebox = gtk_notebook_get_tab_label(UI_PLAYLIST_NOTEBOOK, page);
}
GtkWidget *label = g_object_get_data(G_OBJECT(ebox), "label");
GtkWidget *entry = g_object_get_data(G_OBJECT(ebox), "entry");
gtk_widget_hide(label);
gchar * title = aud_playlist_get_title (aud_playlist_get_active ());
gtk_entry_set_text ((GtkEntry *) entry, title);
str_unref (title);
gtk_widget_grab_focus(entry);
gtk_editable_select_region(GTK_EDITABLE(entry), 0, -1);
gtk_widget_show(entry);
ui_playlist_notebook_tab_title_editing = ebox;
}
static void get_value (void * user, gint row, gint column, GValue * value)
{
gint list = aud_playlist_get_active ();
gint entry = aud_playlist_queue_get_entry (list, row);
switch (column)
{
case COLUMN_ENTRY:
g_value_set_int (value, 1 + entry);
break;
case COLUMN_TITLE:;
gchar * title = aud_playlist_entry_get_title (list, entry, TRUE);
g_value_take_string (value, title);
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 GtkWidget * start_job (bool_t save)
{
int list = aud_playlist_get_active ();
char * filename = aud_playlist_get_filename (list);
char * folder = aud_get_str ("audgui", "playlist_path");
ImportExportJob * job = g_slice_new0 (ImportExportJob);
job->save = save;
job->list_id = aud_playlist_get_unique_id (list);
create_selector (job, filename, folder[0] ? folder : NULL);
str_unref (filename);
str_unref (folder);
return job->selector;
}
EXPORT void audgui_export_playlist (void)
{
int list = aud_playlist_get_active ();
int id = aud_playlist_get_unique_id (list);
char * def = aud_playlist_get_filename (list);
char * filename = select_file (TRUE, def);
str_unref (def);
if (! filename || (vfs_file_test (filename, G_FILE_TEST_EXISTS) &&
! confirm_overwrite (filename)))
return;
if ((list = aud_playlist_by_unique_id (id)) < 0)
return;
aud_playlist_save (list, filename);
g_free (filename);
}
static void remove_selected (void)
{
gint list = aud_playlist_get_active ();
gint count = aud_playlist_queue_count (list);
for (gint i = 0; i < count; )
{
gint entry = aud_playlist_queue_get_entry (list, i);
if (aud_playlist_entry_get_selected (list, entry))
{
aud_playlist_queue_delete (list, i, 1);
aud_playlist_entry_set_selected (list, entry, FALSE);
count --;
}
else
i ++;
}
}
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 gboolean window_keypress_cb (GtkWidget * widget, GdkEventKey * event, void * unused)
{
switch (event->state & (GDK_SHIFT_MASK | GDK_CONTROL_MASK | GDK_MOD1_MASK))
{
case 0:;
GtkWidget * focused = gtk_window_get_focus ((GtkWindow *) window);
/* escape key returns focus to playlist */
if (event->keyval == GDK_KEY_Escape)
{
if (! focused || ! gtk_widget_is_ancestor (focused, (GtkWidget *) UI_PLAYLIST_NOTEBOOK))
gtk_widget_grab_focus (playlist_get_treeview (aud_playlist_get_active ()));
return FALSE;
}
/* single-key shortcuts; must not interfere with text entry */
if (focused && GTK_IS_ENTRY (focused))
return FALSE;
switch (event->keyval)
{
case 'z':
aud_drct_pl_prev ();
return TRUE;
case 'x':
aud_drct_play ();
return TRUE;
case 'c':
case ' ':
aud_drct_pause ();
return TRUE;
case 'v':
aud_drct_stop ();
return TRUE;
case 'b':
aud_drct_pl_next ();
return TRUE;
case GDK_KEY_Left:
if (aud_drct_get_playing ())
do_seek (aud_drct_get_time () - 5000);
return TRUE;
case GDK_KEY_Right:
if (aud_drct_get_playing ())
do_seek (aud_drct_get_time () + 5000);
return TRUE;
}
return FALSE;
case GDK_CONTROL_MASK:
switch (event->keyval)
{
case GDK_KEY_ISO_Left_Tab:
case GDK_KEY_Tab:
aud_playlist_set_active ((aud_playlist_get_active () + 1) %
aud_playlist_count ());
break;
default:
return FALSE;
}
break;
case (GDK_CONTROL_MASK | GDK_SHIFT_MASK):
switch (event->keyval)
{
case GDK_KEY_ISO_Left_Tab:
case GDK_KEY_Tab:
aud_playlist_set_active (aud_playlist_get_active () ?
aud_playlist_get_active () - 1 : aud_playlist_count () - 1);
break;
default:
return FALSE;
}
break;
case GDK_MOD1_MASK:
switch (event->keyval)
{
case GDK_KEY_Left:
if (aud_drct_get_playing ())
do_seek (aud_drct_get_time () - 5000);
break;
case GDK_KEY_Right:
if (aud_drct_get_playing ())
do_seek (aud_drct_get_time () + 5000);
break;
default:
return FALSE;
}
default:
return FALSE;
}
return TRUE;
}
static void window_mapped_cb (GtkWidget * widget, void * unused)
{
gtk_widget_grab_focus (playlist_get_treeview (aud_playlist_get_active ()));
}
