void ui_playlist_notebook_position (void * data, void * user) { gint list = GPOINTER_TO_INT (data); if (aud_get_bool ("gtkui", "autoscroll")) { aud_playlist_select_all (list, FALSE); if (aud_playlist_get_position (list) >= 0) aud_playlist_entry_set_selected (list, aud_playlist_get_position (list), TRUE); } playlist_set_focus (list, CURRENT_POS); }
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 void do_follow (void) { while (! g_queue_is_empty (& follow_queue)) { gint list = aud_playlist_by_unique_id (GPOINTER_TO_INT (g_queue_pop_head (& follow_queue))); gint row = GPOINTER_TO_INT (g_queue_pop_head (& follow_queue)); if (list < 0) continue; GtkWidget * widget = playlist_get_treeview (list); if (row == CURRENT_POS) { row = aud_playlist_get_position (list); audgui_list_set_highlight (widget, row); if (! aud_get_bool ("gtkui", "autoscroll")) continue; } audgui_list_set_focus (widget, row); } }
static void ready (void *hook_data, void *user_data) { cleanup_current_track(); Tuple *current_track = aud_playlist_entry_get_tuple(aud_playlist_get_playing(), aud_playlist_get_position(aud_playlist_get_playing()), FALSE); int duration_seconds = tuple_get_int(current_track, FIELD_LENGTH) / 1000; if (duration_seconds <= 30) { tuple_unref(current_track); return; } pthread_mutex_lock(&communication_mutex); now_playing_track = tuple_ref(current_track); now_playing_requested = TRUE; pthread_cond_signal(&communication_signal); pthread_mutex_unlock(&communication_mutex); time_until_scrobble = (((gint64)duration_seconds)*G_USEC_PER_SEC) / 2; if (time_until_scrobble > 4*60*G_USEC_PER_SEC) { time_until_scrobble = 4*60*G_USEC_PER_SEC; } timestamp = g_get_real_time() / G_USEC_PER_SEC; play_started_at = g_get_monotonic_time(); playing_track = current_track; queue_function_ID = g_timeout_add_seconds(time_until_scrobble / G_USEC_PER_SEC, (GSourceFunc) queue_track_to_scrobble, NULL); }
void ui_playlist_notebook_create_tab(gint playlist) { GtkWidget *scrollwin, *treeview; GtkWidget *label, *entry, *ebox, *hbox; GtkAdjustment *vscroll; gint position = aud_playlist_get_position (playlist); scrollwin = gtk_scrolled_window_new(NULL, NULL); vscroll = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(scrollwin)); treeview = ui_playlist_widget_new(playlist); g_object_set_data(G_OBJECT(scrollwin), "treeview", treeview); gtk_container_add(GTK_CONTAINER(scrollwin), treeview); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_widget_show_all(scrollwin); ebox = gtk_event_box_new(); gtk_event_box_set_visible_window ((GtkEventBox *) ebox, FALSE); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4); label = gtk_label_new (""); set_tab_label (playlist, (GtkLabel *) label); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); entry = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(hbox), entry, FALSE, FALSE, 0); gtk_container_add(GTK_CONTAINER(ebox), hbox); gtk_widget_show_all(ebox); gtk_widget_hide(entry); gtk_box_pack_end ((GtkBox *) hbox, make_close_button (playlist), FALSE, FALSE, 0); g_object_set_data(G_OBJECT(ebox), "label", label); g_object_set_data(G_OBJECT(ebox), "entry", entry); g_object_set_data(G_OBJECT(ebox), "page", scrollwin); gtk_notebook_insert_page (UI_PLAYLIST_NOTEBOOK, scrollwin, ebox, playlist); gtk_notebook_set_tab_reorderable(UI_PLAYLIST_NOTEBOOK, scrollwin, TRUE); g_object_set_data ((GObject *) treeview, "playlist-id", GINT_TO_POINTER (aud_playlist_get_unique_id (playlist))); if (position >= 0) { aud_playlist_select_all (playlist, FALSE); aud_playlist_entry_set_selected (playlist, position, TRUE); audgui_list_set_highlight (treeview, position); audgui_list_set_focus (treeview, position); } g_signal_connect(ebox, "button-press-event", G_CALLBACK(tab_button_press_cb), NULL); g_signal_connect(ebox, "key-press-event", G_CALLBACK(tab_key_press_cb), NULL); g_signal_connect(entry, "activate", G_CALLBACK(tab_title_save), ebox); g_signal_connect_swapped (vscroll, "value-changed", G_CALLBACK(ui_playlist_widget_scroll), treeview); }
static void position_cb (void * data, void * user_data) { gint playlist = GPOINTER_TO_INT (data); gint position = aud_playlist_get_position (playlist); if (! aud_get_bool (NULL, "equalizer_autoload") || playlist != aud_playlist_get_playing () || position == -1) return; gchar * filename = aud_playlist_entry_get_filename (playlist, position); load_auto_preset (filename); str_unref (filename); }
EXPORT GdkPixbuf * audgui_pixbuf_for_current (void) { if (! current_pixbuf) { int list = aud_playlist_get_playing (); current_pixbuf = audgui_pixbuf_for_entry (list, aud_playlist_get_position (list)); } if (current_pixbuf) g_object_ref ((GObject *) current_pixbuf); return current_pixbuf; }
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 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); }
EXPORT GdkPixbuf * audgui_pixbuf_request_current (void) { if (! current_pixbuf) { int list = aud_playlist_get_playing (); int entry = aud_playlist_get_position (list); if (entry < 0) return NULL; char * filename = aud_playlist_entry_get_filename (list, entry); current_pixbuf = audgui_pixbuf_request (filename); str_unref (filename); } if (current_pixbuf) g_object_ref ((GObject *) current_pixbuf); return current_pixbuf; }
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(); }
} if (data->hover != -1) { data->hover = -1; gtk_widget_queue_draw (list); } popup_hide (list, data); } DRAW_FUNC_BEGIN (playlist_draw) PlaylistData * data = g_object_get_data ((GObject *) wid, "playlistdata"); g_return_val_if_fail (data, FALSE); gint active_entry = aud_playlist_get_position (active_playlist); gint left = 3, right = 3; PangoLayout * layout; gint width; /* background */ set_cairo_color (cr, active_skin->colors[SKIN_PLEDIT_NORMALBG]); cairo_paint (cr); /* playlist title */ if (data->offset) { layout = gtk_widget_create_pango_layout (wid, active_title); pango_layout_set_font_description (layout, data->font);
static gint file_open(gint fmt, gint rate, gint nch) { gchar *filename = NULL, *temp = NULL; gchar * directory; gint pos; gint rv; gint playlist; input.format = fmt; input.frequency = rate; input.channels = nch; playlist = aud_playlist_get_playing (); if (playlist < 0) return 0; pos = aud_playlist_get_position(playlist); tuple = aud_playlist_entry_get_tuple (playlist, pos, FALSE); if (tuple == NULL) return 0; if (filenamefromtags) { gchar * utf8 = aud_playlist_entry_get_title (playlist, pos, FALSE); string_replace_char (utf8, '/', ' '); gchar buf[3 * strlen (utf8) + 1]; str_encode_percent (utf8, -1, buf); str_unref (utf8); filename = g_strdup (buf); } else { temp = aud_playlist_entry_get_filename (playlist, pos); gchar * original = strrchr (temp, '/'); g_return_val_if_fail (original != NULL, 0); filename = g_strdup (original + 1); str_unref (temp); if (!use_suffix) if ((temp = strrchr(filename, '.')) != NULL) *temp = '\0'; } if (prependnumber) { gint number = tuple_get_int(tuple, FIELD_TRACK_NUMBER, NULL); if (!tuple || !number) number = pos + 1; temp = g_strdup_printf ("%d%%20%s", number, filename); g_free(filename); filename = temp; } if (save_original) { temp = aud_playlist_entry_get_filename (playlist, pos); directory = g_strdup (temp); str_unref (temp); temp = strrchr (directory, '/'); g_return_val_if_fail (temp != NULL, 0); temp[1] = 0; } else { g_return_val_if_fail (file_path[0], 0); if (file_path[strlen (file_path) - 1] == '/') directory = g_strdup (file_path); else directory = g_strdup_printf ("%s/", file_path); } temp = g_strdup_printf ("%s%s.%s", directory, filename, fileext_str[fileext]); g_free (directory); g_free (filename); filename = temp; output_file = safe_create (filename); g_free (filename); if (output_file == NULL) return 0; convert_init (fmt, plugin->format_required (fmt), nch); rv = (plugin->open)(); samples_written = 0; return rv; }
/* do_command(): do @cmd after replacing the format codes @cmd: command to run */ static void do_command (char * cmd) { int playlist = aud_playlist_get_playing (); int pos = aud_playlist_get_position (playlist); char *shstring = NULL, *temp, numbuf[32]; gboolean playing; Formatter *formatter; if (cmd && strlen(cmd) > 0) { formatter = formatter_new(); char * ctitle = aud_playlist_entry_get_title (playlist, pos, FALSE); if (ctitle) { temp = escape_shell_chars (ctitle); formatter_associate(formatter, 's', temp); formatter_associate(formatter, 'n', temp); g_free(temp); str_unref (ctitle); } else { formatter_associate(formatter, 's', ""); formatter_associate(formatter, 'n', ""); } char * filename = aud_playlist_entry_get_filename (playlist, pos); if (filename) { temp = escape_shell_chars (filename); formatter_associate(formatter, 'f', temp); g_free(temp); str_unref (filename); } else formatter_associate(formatter, 'f', ""); g_snprintf(numbuf, sizeof(numbuf), "%02d", pos + 1); formatter_associate(formatter, 't', numbuf); int length = aud_playlist_entry_get_length (playlist, pos, FALSE); if (length > 0) { g_snprintf(numbuf, sizeof(numbuf), "%d", length); formatter_associate(formatter, 'l', numbuf); } else formatter_associate(formatter, 'l', "0"); playing = aud_drct_get_playing(); g_snprintf(numbuf, sizeof(numbuf), "%d", playing); formatter_associate(formatter, 'p', numbuf); if (playing) { int brate, srate, chans; aud_drct_get_info (& brate, & srate, & chans); snprintf (numbuf, sizeof numbuf, "%d", brate); formatter_associate (formatter, 'r', numbuf); snprintf (numbuf, sizeof numbuf, "%d", srate); formatter_associate (formatter, 'F', numbuf); snprintf (numbuf, sizeof numbuf, "%d", chans); formatter_associate (formatter, 'c', numbuf); } Tuple * tuple = aud_playlist_entry_get_tuple (aud_playlist_get_active (), pos, 0); char * artist = tuple ? tuple_get_str (tuple, FIELD_ARTIST, NULL) : NULL; if (artist) { formatter_associate(formatter, 'a', artist); str_unref(artist); } else formatter_associate(formatter, 'a', ""); char * album = tuple ? tuple_get_str (tuple, FIELD_ALBUM, NULL) : NULL; if (album) { formatter_associate(formatter, 'b', album); str_unref(album); } else formatter_associate(formatter, 'b', ""); char * title = tuple ? tuple_get_str (tuple, FIELD_TITLE, NULL) : NULL; if (title) { formatter_associate(formatter, 'T', title); str_unref(title); } else formatter_associate(formatter, 'T', ""); if (tuple) tuple_unref (tuple); shstring = formatter_format(formatter, cmd); formatter_destroy(formatter); if (shstring) { execute_command(shstring); /* FIXME: This can possibly be freed too early */ g_free(shstring); } } }
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 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); }