void serverinformation_show_popup(void)
{
GtkWidget *dialog = NULL;
if (serverstats_sw)
{
GtkWidget *win = gtk_widget_get_parent(serverstats_sw);
if (win)
{
gtk_window_present(GTK_WINDOW(win));
return;
}
}
dialog = gtk_dialog_new_with_buttons(_("Server Information"),
GTK_WINDOW(playlist3_get_window()),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CLOSE, GTK_RESPONSE_OK, NULL);
/* Add info window */
serverstats_selected(gtk_dialog_get_content_area(dialog));
/* Restore size */
gtk_window_resize(GTK_WINDOW(dialog),
cfg_get_single_value_as_int_with_default(config, "serverstats", "dialog-width", 400),
cfg_get_single_value_as_int_with_default(config, "serverstats", "dialog-height", 400));
/* handle close */
g_signal_connect(G_OBJECT(dialog), "response", G_CALLBACK(serverinformation_popup_close), NULL);
gtk_widget_show(dialog);
}
/** Called when the user changes the lyrics API. Set a configuration
* value to the new API id.
*/
void lyrics_api_changed (GtkWidget *wid)
{
int id = gtk_combo_box_get_active(GTK_COMBO_BOX(wid));
cfg_set_single_value_as_int(config, "lyrics-plugin", "api-id", id);
debug_printf(DEBUG_INFO, "Saved API ID: %d\n", cfg_get_single_value_as_int_with_default(config, "lyrics-plugin", "api-id", 0));
}
void wp_add(GtkWidget *cat_tree)
{
GtkTreePath *path = NULL;
GtkListStore *pl3_tree = (GtkListStore *)gtk_tree_view_get_model(GTK_TREE_VIEW(cat_tree));
GtkTreeIter iter;
if(!cfg_get_single_value_as_int_with_default(config, "wp-plugin", "enable", 0)) return;
gtk_list_store_append(pl3_tree, &iter);
gtk_list_store_set(pl3_tree, &iter,
PL3_CAT_TYPE, plugin.id,
PL3_CAT_TITLE, _("Wikipedia Lookup"),
PL3_CAT_ICON_ID, "wikipedia",
-1);
if (wiki_ref)
{
gtk_tree_row_reference_free(wiki_ref);
wiki_ref = NULL;
}
path = gtk_tree_model_get_path(GTK_TREE_MODEL(playlist3_get_category_tree_store()), &iter);
if (path)
{
wiki_ref = gtk_tree_row_reference_new(GTK_TREE_MODEL(playlist3_get_category_tree_store()), path);
gtk_tree_path_free(path);
}
}
/**
* Called when the action box is changed
*/
static void on_action_value_changed (GtkWidget *widget)
{
int id = gtk_combo_box_get_active (GTK_COMBO_BOX (widget));
cfg_set_single_value_as_int (config, "alarm-plugin", "action-id", id);
debug_printf (DEBUG_INFO, "* Set alarm action: %d",
cfg_get_single_value_as_int_with_default (config, "alarm-plugin", "action-id", 0));
}
/**
* Handles a continuous tick
*/
static gboolean on_timeout (gpointer user_data)
{
time_t tt = time(NULL);
struct tm *a = localtime (&tt);
Time *current_time_struct, *target_time_struct;
glong countdown_time, target_time_seconds, current_time_seconds, current_diff_seconds;
current_time_struct = g_malloc (sizeof (Time));
target_time_struct = g_malloc (sizeof (Time));
/* Sort out hours, minutes and seconds for the current time */
current_time_struct->hours = a->tm_hour;
current_time_struct->minutes = a->tm_min;
current_time_struct->seconds = a->tm_sec;
/* Get the current elapsed ticks from timer */
countdown_time = (glong) g_timer_elapsed ((GTimer *)user_data, NULL);
/* Sort out target deadlines hours, minutes, seconds */
target_time_struct->hours = cfg_get_single_value_as_int_with_default (config, "alarm-plugin", "time_hours", 0);
target_time_struct->minutes = cfg_get_single_value_as_int_with_default (config, "alarm-plugin", "time_minutes", 0);
target_time_struct->seconds = cfg_get_single_value_as_int_with_default (config, "alarm-plugin", "time_seconds", 0);
/* Debug message */
debug_printf (DEBUG_INFO, "tick(%d) [%d:%d:%d] [%d:%d:%d]",
(guint) countdown_time, (guint) current_time_struct->hours, (guint) current_time_struct->minutes, (guint) current_time_struct->seconds,
(guint) target_time_struct->hours, (guint) target_time_struct->minutes, (guint) target_time_struct->seconds);
/* Convert both times into seconds and work out a difference */
target_time_seconds = (target_time_struct->hours * 60 * 60) + (target_time_struct->minutes * 60) + target_time_struct->seconds;
current_time_seconds = (current_time_struct->hours * 60 * 60) + (current_time_struct->minutes * 60) + current_time_struct->seconds;
current_diff_seconds = target_time_seconds - current_time_seconds;
if (current_diff_seconds < 0)
current_diff_seconds += 86400; // add number of seconds in one day
/* Update the ticker label */
update_ticker_label(current_diff_seconds);
/* Check for deadline */
check_for_deadline(current_time_struct, target_time_struct);
/* Free up unneeded time structures */
g_free(current_time_struct);
g_free(target_time_struct);
return timer_on;
}
void fetch_lyric_uris(mpd_Song *song, MetaDataType type, void (*callback)(GList *list, void *data), void *user_data)
{
printf("lyrics api v2\n");
if(song->title != NULL && type == META_SONG_TXT)
{
Query *q = g_malloc0(sizeof(*q));
q->callback = callback;
q->user_data = user_data;
q->index = 0;
q->song = song;
q->pref =cfg_get_single_value_as_int_with_default(config, "lyrics-plugin", "api-id", 0);
q->exact_match = cfg_get_single_value_as_int_with_default(config, "lyrics-plugin", "exact-match", 1);
q->list = NULL;
fetch_query_iterate(q);
return;
}
callback(NULL, user_data);
}
/**
* Initialize GTK widgets for the preferences window.
*/
void lyrics_construct (GtkWidget *container)
{
GtkWidget *label, *combo, *match;
int i;
label = gtk_label_new(_("Preferred lyric site :"));
combo = gtk_combo_box_new_text();
match = gtk_check_button_new_with_mnemonic(_("Exact _match only"));
lyrics_pref_table = gtk_table_new(2, 2, FALSE);
lyrics_pref_vbox = gtk_vbox_new(FALSE,6);
for (i=0; apis[i].name ; i++)
gtk_combo_box_append_text(GTK_COMBO_BOX(combo), _(apis[i].name));
gtk_combo_box_set_active(GTK_COMBO_BOX(combo),
cfg_get_single_value_as_int_with_default(config, "lyrics-plugin", "api-id", 0));
gtk_table_attach_defaults(GTK_TABLE(lyrics_pref_table), label, 0, 1, 0, 1);
gtk_table_attach_defaults(GTK_TABLE(lyrics_pref_table), combo, 1, 2, 0, 1);
gtk_table_attach_defaults(GTK_TABLE(lyrics_pref_table), match, 0, 2, 1, 2);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(match),
cfg_get_single_value_as_int_with_default(config, "lyrics-plugin", "exact-match", 1));
gtk_widget_set_sensitive(lyrics_pref_table, cfg_get_single_value_as_int_with_default(config, "lyrics-plugin", "enable", 0));
/* TODO: check that this stuff actually works */
//gtk_widget_set_sensitive(match, 0);
/* Connect signals */
g_signal_connect(G_OBJECT(combo), "changed", G_CALLBACK(lyrics_api_changed), NULL);
g_signal_connect(G_OBJECT(match), "toggled", G_CALLBACK(lyrics_match_toggle), NULL);
gtk_box_pack_start(GTK_BOX(lyrics_pref_vbox), lyrics_pref_table, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(container), lyrics_pref_vbox);
gtk_widget_show_all(container);
}
void wp_changed(GtkWidget *tree, GtkTreeIter *iter)
{
mpd_Song *song = mpd_playlist_get_current_song(connection);
gchar *artist = NULL;
if(!song)
return;
/* copied from metadata.h */
if(song->artist) {
if (cfg_get_single_value_as_int_with_default(config, "metadata", "rename", FALSE))
{
gchar **str = g_strsplit(song->artist, ",", 2);
if(str[1])
artist = g_strdup_printf("%s %s", g_strstrip(str[1]), g_strstrip(str[0]));
else
artist = g_strdup(song->artist);
g_strfreev(str);
g_log(wikipedia_logdomain, G_LOG_LEVEL_DEBUG, "string converted to: '%s'", artist);
} else {
artist = g_strdup(song->artist);
}
}
if(artist == NULL)
{
if (strcmp(old_artist, "NONE") != 0)
{
if (current_url)
g_free(current_url);
current_url = g_strdup("http://www.musicpd.org/");
webkit_web_view_open(WEBKIT_WEB_VIEW(moz), current_url);
old_artist = g_strdup("NONE");
}
return;
}
gchar *esc_artist = wp_clean_for_url(artist);
if (strcmp(old_artist, esc_artist) != 0)
{
gchar *url = g_strdup_printf("http://%s.wikipedia.org/w/api.php?action=opensearch&search=%s&format=xml", locale, esc_artist);
g_log(wikipedia_logdomain, G_LOG_LEVEL_DEBUG, "Trying to fetch: %s\n", url);
gmpc_easy_async_downloader(url, wp_query_callback, NULL);
g_free(url);
}
old_artist = g_strdup(esc_artist);
g_free(esc_artist);
g_free(artist);
}
/**
* Compares two times and acts on match (deadline)
*/
static void check_for_deadline(Time* current_time_struct, Time* target_time_struct)
{
if ((current_time_struct->hours == target_time_struct->hours)
&& (current_time_struct->minutes == target_time_struct->minutes)
&& (current_time_struct->seconds == target_time_struct->seconds)) {
debug_printf (DEBUG_INFO, "* Alarm has been activated, decide what action to take!");
/* Decide what action to take from the selected item in the combo */
switch (cfg_get_single_value_as_int_with_default (config, "alarm-plugin", "action-id", 0)) {
case 0:
debug_printf (DEBUG_INFO, "* Attempting to play/pause");
play_song ();
break;
case 1:
debug_printf (DEBUG_INFO, "* Attempting to stop");
stop_song ();
break;
case 2:
debug_printf (DEBUG_INFO, "* Stopping and closing gmpc");
stop_song ();
main_quit ();
break;
case 3:
debug_printf (DEBUG_INFO, "* Closing gmpc only");
/* Friendly way of closing gmpc */
main_quit ();
break;
case 4:
debug_printf (DEBUG_INFO, "* Shutting down system");
/* TODO: Nice way of halting a system */
break;
case 5:
debug_printf (DEBUG_INFO, "* Toggling random");
random_toggle ();
break;
}
/* Disable timer, and thus the ticking timeout */
alarm_stop();
}
}
static void lastfm_fetch_get_uris(mpd_Song *song,
MetaDataType type,
void (*callback)(GList *list, gpointer data),
gpointer user_data)
{
g_debug("Query last.fm api v2");
if(song->artist != NULL && type == META_ARTIST_ART &&
cfg_get_single_value_as_int_with_default(config, "cover-lastfm", "fetch-art-artist", TRUE))
{
char furl[1024];
gchar *artist = gmpc_easy_download_uri_escape(song->artist);
Query *q = g_slice_new0(Query);
q->callback = callback;
q->user_data = user_data;
snprintf(furl,1024,LASTFM_API_ROOT"?method=artist.getImages&artist=%s&api_key=%s", artist,LASTFM_API_KEY);
g_debug("url: '%s'", furl);
gmpc_easy_async_downloader(furl, artist_image_callback, q);
g_free(artist);
return;
}
else if (song->artist != NULL && song->album != NULL && type == META_ALBUM_ART &&
cfg_get_single_value_as_int_with_default(config, "cover-lastfm", "fetch-art-album", TRUE))
{
char furl[1024];
gchar *artist = gmpc_easy_download_uri_escape(song->artist);
gchar *album = gmpc_easy_download_uri_escape(song->album);
Query *q = g_slice_new0(Query);
q->callback = callback;
q->user_data = user_data;
snprintf(furl,1024,LASTFM_API_ROOT"?method=album.getinfo&artist=%s&album=%s&api_key=%s", artist,album,LASTFM_API_KEY);
g_debug("url: '%s'", furl);
gmpc_easy_async_downloader(furl, album_image_callback, q);
g_free(artist);
g_free(album);
return;
}
else if (song->artist != NULL && song->album != NULL && type == META_ALBUM_TXT &&
cfg_get_single_value_as_int_with_default(config, "cover-lastfm", "fetch-album-info", TRUE))
{
char furl[1024];
gchar *artist = gmpc_easy_download_uri_escape(song->artist);
gchar *album = gmpc_easy_download_uri_escape(song->album);
Query *q = g_slice_new0(Query);
q->callback = callback;
q->user_data = user_data;
snprintf(furl,1024,LASTFM_API_ROOT"?method=album.getinfo&artist=%s&album=%s&api_key=%s", artist,album,LASTFM_API_KEY);
g_debug("url: '%s'", furl);
gmpc_easy_async_downloader(furl, album_info_callback, q);
g_free(artist);
g_free(album);
return;
}
/* Fetch artist info */
else if (song->artist != NULL && type == META_ARTIST_TXT &&
cfg_get_single_value_as_int_with_default(config, "cover-lastfm", "fetch-biography-artist", TRUE))
{
char furl[1024];
gchar *artist = gmpc_easy_download_uri_escape(song->artist);
Query *q = g_slice_new0(Query);
q->callback = callback;
q->user_data = user_data;
snprintf(furl,1024, LASTFM_API_ROOT"?method=artist.getinfo&artist=%s&api_key=%s", artist,LASTFM_API_KEY);
g_debug("url: '%s'", furl);
gmpc_easy_async_downloader(furl, biography_callback, q);
g_free(artist);
return;
}
else if (song->artist != NULL && type == META_ARTIST_SIMILAR
&& cfg_get_single_value_as_int_with_default(config, "cover-lastfm", "fetch-similar-artist", TRUE))
{
char furl[1024];
char *artist = gmpc_easy_download_uri_escape(song->artist);
Query *q = g_slice_new0(Query);
q->callback = callback;
q->user_data = user_data;
snprintf(furl,1024,LASTFM_API_ROOT"?method=artist.getsimilar&artist=%s&api_key=%s", artist,LASTFM_API_KEY);
g_debug("url: '%s'", furl);
g_free(artist);
gmpc_easy_async_downloader(furl, similar_artist_callback, q);
return;
}
else if (song->genre != NULL && type == META_GENRE_SIMILAR
&& cfg_get_single_value_as_int_with_default(config, "cover-lastfm", "fetch-similar-genre", TRUE))
{
gchar* genre = gmpc_easy_download_uri_escape(song->genre);
gchar* furl = g_strdup_printf(LASTFM_API_ROOT"?method=tag.getsimilar&tag=%s&api_key=%s", genre, LASTFM_API_KEY);
Query *q = g_slice_new0(Query);
q->callback = callback;
q->user_data = user_data;
g_debug("url: '%s'", furl);
gmpc_easy_async_downloader(furl, similar_genre_callback, q);
g_free(genre);
g_free(furl);
return;
}else if (song->title != NULL && song->artist != NULL &&
type == META_SONG_SIMILAR &&
cfg_get_single_value_as_int_with_default(config, "cover-lastfm", "fetch-similar-song", TRUE))
{
char furl[1024];
char *artist = gmpc_easy_download_uri_escape(song->artist);
char *title = gmpc_easy_download_uri_escape(song->title);
Query *q = g_slice_new0(Query);
q->callback = callback;
q->user_data = user_data;
snprintf(furl,1024,LASTFM_API_ROOT"?method=track.getsimilar&artist=%s&track=%s&api_key=%s", artist,title,LASTFM_API_KEY);
g_debug("url: '%s'", furl);
g_free(artist);
gmpc_easy_async_downloader(furl, similar_song_callback, q);
return;
}
callback(NULL, user_data);
}
static int lastfm_fetch_cover_priority(void){
return cfg_get_single_value_as_int_with_default(config, "cover-lastfm", "priority", 80);
}
static void pref_construct(GtkWidget *con)
{
GtkWidget *frame,*vbox;
GtkWidget *a_a_ck, *a_b_ck, *a_s_ck, *c_a_ck, *a_i_ck, *s_s_ck, *s_g_ck;
/**
* Enable/Disable checkbox
*/
frame = gtk_frame_new("");
gtk_label_set_markup(GTK_LABEL(gtk_frame_get_label_widget(GTK_FRAME(frame))), "<b>Fetch</b>");
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_NONE);
vbox = gtk_vbox_new(FALSE,6);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 12);
gtk_container_add(GTK_CONTAINER(frame), vbox);
/* Fetch artist art */
a_a_ck = gtk_check_button_new_with_label(_("Artist images"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(a_a_ck),
cfg_get_single_value_as_int_with_default(config, "cover-lastfm", "fetch-art-artist", TRUE));
gtk_box_pack_start(GTK_BOX(vbox), a_a_ck, FALSE, TRUE, 0);
g_signal_connect(G_OBJECT(a_a_ck), "toggled", G_CALLBACK(pref_enable_fetch), GINT_TO_POINTER(META_ARTIST_ART));
/* Fetch artist text*/
a_b_ck = gtk_check_button_new_with_label(_("Artist biography"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(a_b_ck),
cfg_get_single_value_as_int_with_default(config, "cover-lastfm", "fetch-biography-artist", TRUE));
gtk_box_pack_start(GTK_BOX(vbox), a_b_ck, FALSE, TRUE, 0);
g_signal_connect(G_OBJECT(a_b_ck), "toggled", G_CALLBACK(pref_enable_fetch), GINT_TO_POINTER(META_ARTIST_TXT));
/* Fetch similar artists */
a_s_ck = gtk_check_button_new_with_label(_("Similar artists"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(a_s_ck),
cfg_get_single_value_as_int_with_default(config, "cover-lastfm", "fetch-similar-artist", TRUE));
gtk_box_pack_start(GTK_BOX(vbox), a_s_ck, FALSE, TRUE, 0);
g_signal_connect(G_OBJECT(a_s_ck), "toggled", G_CALLBACK(pref_enable_fetch), GINT_TO_POINTER(META_ARTIST_SIMILAR));
/* Fetch album art */
c_a_ck = gtk_check_button_new_with_label(_("Album cover"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(c_a_ck),
cfg_get_single_value_as_int_with_default(config, "cover-lastfm", "fetch-art-album", TRUE));
gtk_box_pack_start(GTK_BOX(vbox), c_a_ck, FALSE, TRUE, 0);
g_signal_connect(G_OBJECT(c_a_ck), "toggled", G_CALLBACK(pref_enable_fetch), GINT_TO_POINTER(META_ALBUM_ART));
/* Fetch album info */
a_i_ck = gtk_check_button_new_with_label(_("Album information"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(a_i_ck),
cfg_get_single_value_as_int_with_default(config, "cover-lastfm", "fetch-album-info", TRUE));
gtk_box_pack_start(GTK_BOX(vbox), a_i_ck, FALSE, TRUE, 0);
g_signal_connect(G_OBJECT(c_a_ck), "toggled", G_CALLBACK(pref_enable_fetch), GINT_TO_POINTER(META_ALBUM_TXT));
/* Fetch similar songs */
s_s_ck = gtk_check_button_new_with_label(_("Similar songs"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(s_s_ck),
cfg_get_single_value_as_int_with_default(config, "cover-lastfm", "fetch-similar-song", TRUE));
gtk_box_pack_start(GTK_BOX(vbox), s_s_ck, FALSE, TRUE, 0);
g_signal_connect(G_OBJECT(s_s_ck), "toggled", G_CALLBACK(pref_enable_fetch), GINT_TO_POINTER(META_SONG_SIMILAR));
/* Fetch similar genre */
s_g_ck = gtk_check_button_new_with_label(_("Similar genres"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(s_g_ck),
cfg_get_single_value_as_int_with_default(config, "cover-lastfm", "fetch-similar-genre", TRUE));
gtk_box_pack_start(GTK_BOX(vbox), s_g_ck, FALSE, TRUE, 0);
g_signal_connect(G_OBJECT(s_g_ck), "toggled", G_CALLBACK(pref_enable_fetch), GINT_TO_POINTER(META_GENRE_SIMILAR));
if(!lastfm_get_enabled()) {
gtk_widget_set_sensitive(GTK_WIDGET(vbox), FALSE);
}
gtk_widget_show_all(frame);
gtk_container_add(GTK_CONTAINER(con), frame);
}
static gboolean alarm_get_enabled(void)
{
return cfg_get_single_value_as_int_with_default (config, "alarm-plugin", "enable",TRUE);
}
int lyrics_get_enabled()
{
return cfg_get_single_value_as_int_with_default(config, "lyrics-plugin", "enable", 0);
}
/**
* Get plugin priority, the lower the sooner checked
*/
static int fetch_priority()
{
return cfg_get_single_value_as_int_with_default(config, "lyric-provider", "priority", 90);
}
/**
* Initialize preferences page
*/
void alarm_construct (GtkWidget *container)
{
GtkWidget *action_label, *time_label, *action_combo;
GtkWidget *countdown_label, *separator, *separator2;
/* Preferences page is now visible and thus active */
prefs_active = TRUE;
enable_alarm = gtk_check_button_new_with_mnemonic (_("_Enable alarm"));
/* Set enabled/disable toggle depending on if timer is already running! */
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(enable_alarm), (timer_on) ? TRUE : FALSE);
/* Set up the alarm time spinners */
time_label = gtk_label_new (_("Time:"));
time_hours_spinner = gtk_spin_button_new_with_range (0, 23, 1.0);
time_minutes_spinner = gtk_spin_button_new_with_range (0, 59, 1.0);
time_seconds_spinner = gtk_spin_button_new_with_range (0, 59, 1.0);
guint time_hours_stored = cfg_get_single_value_as_int_with_default
(config, "alarm-plugin", "time_hours", 0);
/* If the hours are stored then assume the minutes and seconds are also. */
gtk_spin_button_set_value (GTK_SPIN_BUTTON (time_hours_spinner), time_hours_stored);
gchar *str = g_strdup_printf ("%02d", (gint) time_hours_stored);
gtk_entry_set_text (GTK_ENTRY (time_hours_spinner), str);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (time_minutes_spinner),
cfg_get_single_value_as_int_with_default (config, "alarm-plugin", "time_minutes", 0));
gtk_spin_button_set_value (GTK_SPIN_BUTTON (time_seconds_spinner),
cfg_get_single_value_as_int_with_default (config, "alarm-plugin", "time_seconds", 0));
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (time_hours_spinner), TRUE);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (time_minutes_spinner), TRUE);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (time_seconds_spinner), TRUE);
separator = gtk_label_new (":");
separator2 = gtk_label_new (":");
action_label = gtk_label_new (_("Action:"));
action_combo = gtk_combo_box_new_text ();
alarm_pref_table = gtk_table_new (2, 2, FALSE);
alarm_pref_vbox = gtk_vbox_new (FALSE,6);
/*
* Hard-coded possible actions for once alarm deadline hit
* TODO: Allow customized actions?
*/
gtk_combo_box_append_text (GTK_COMBO_BOX (action_combo), _("Play/Pause"));
gtk_combo_box_append_text (GTK_COMBO_BOX (action_combo), _("Stop"));
gtk_combo_box_append_text (GTK_COMBO_BOX (action_combo), _("Close (& Stop)"));
gtk_combo_box_append_text (GTK_COMBO_BOX (action_combo), _("Close only"));
gtk_combo_box_append_text (GTK_COMBO_BOX (action_combo), _("Shutdown"));
gtk_combo_box_append_text (GTK_COMBO_BOX (action_combo), _("Toggle random"));
gtk_combo_box_set_active (GTK_COMBO_BOX (action_combo),
cfg_get_single_value_as_int_with_default (config, "alarm-plugin", "action-id", 0));
/* Label to show remaining time */
countdown_label = gtk_label_new (_("Time left:"));
countdown = gtk_label_new ("--");
/* Attach widgets */
gtk_table_attach_defaults (GTK_TABLE (alarm_pref_table), time_label, 0, 1, 0, 1);
gtk_table_attach_defaults (GTK_TABLE (alarm_pref_table), time_hours_spinner, 1, 2, 0, 1);
gtk_table_attach_defaults (GTK_TABLE (alarm_pref_table), separator, 2, 3, 0, 1);
gtk_table_attach_defaults (GTK_TABLE (alarm_pref_table), time_minutes_spinner, 3, 4, 0, 1);
gtk_table_attach_defaults (GTK_TABLE (alarm_pref_table), separator2, 4, 5, 0, 1);
gtk_table_attach_defaults (GTK_TABLE (alarm_pref_table), time_seconds_spinner, 5, 6, 0, 1);
gtk_table_attach_defaults (GTK_TABLE (alarm_pref_table), action_label, 0, 1, 1, 2);
gtk_table_attach_defaults (GTK_TABLE (alarm_pref_table), action_combo, 1, 2, 1, 2);
gtk_table_attach_defaults (GTK_TABLE (alarm_pref_table), countdown_label, 0, 1, 2, 3);
gtk_table_attach_defaults (GTK_TABLE (alarm_pref_table), countdown, 1, 2, 2, 3);
/* Connect signals */
g_signal_connect (G_OBJECT (time_hours_spinner), "value-changed", G_CALLBACK (on_spin_value_changed), NULL);
g_signal_connect (G_OBJECT (time_minutes_spinner), "value-changed", G_CALLBACK (on_spin_value_changed), NULL);
g_signal_connect (G_OBJECT (time_seconds_spinner), "value-changed", G_CALLBACK (on_spin_value_changed), NULL);
/* Check that we're running gtk+ for supported gtk_spin_button 'wrapped' functionality */
#if (GTK_MINOR_VERSION >= 20)
g_signal_connect (G_OBJECT (time_hours_spinner), "wrapped", G_CALLBACK (on_spin_value_wrapped), NULL);
g_signal_connect (G_OBJECT (time_minutes_spinner), "wrapped", G_CALLBACK (on_spin_value_wrapped), NULL);
g_signal_connect (G_OBJECT (time_seconds_spinner), "wrapped", G_CALLBACK (on_spin_value_wrapped), NULL);
#endif
g_signal_connect (G_OBJECT (action_combo), "changed", G_CALLBACK (on_action_value_changed), NULL);
g_signal_connect (G_OBJECT (enable_alarm), "toggled", G_CALLBACK (on_enable_toggle), NULL);
gtk_box_pack_start (GTK_BOX (alarm_pref_vbox), enable_alarm, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (alarm_pref_vbox), alarm_pref_table, FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER (container), alarm_pref_vbox);
gtk_widget_show_all (container);
}
static int lastfm_get_enabled(void)
{
return cfg_get_single_value_as_int_with_default(config, "cover-lastfm", "enable", TRUE);
}
static void gmpc_tools_metadata_appearance_real_preferences_pane_construct (GmpcPluginPreferencesIface* base, GtkContainer* container) {
GmpcToolsMetadataAppearance * self;
GtkBuilder* _tmp0_ = NULL;
GtkBuilder* builder;
gchar* _tmp1_ = NULL;
gchar* preferences_ui_file;
GObject* _tmp2_ = NULL;
GObject* _tmp3_;
GtkWidget* _tmp4_;
GtkWidget* builderWidget;
GObject* _tmp5_ = NULL;
GObject* _tmp6_;
GtkWidget* _tmp7_;
gint _tmp8_;
GObject* _tmp9_ = NULL;
GObject* _tmp10_;
GtkWidget* _tmp11_;
gint _tmp12_;
GObject* _tmp13_ = NULL;
GObject* _tmp14_;
GtkWidget* _tmp15_;
gint _tmp16_;
GObject* _tmp17_ = NULL;
GObject* _tmp18_;
GtkWidget* _tmp19_;
gint _tmp20_;
GObject* _tmp21_ = NULL;
GObject* _tmp22_;
GtkWidget* _tmp23_;
gint _tmp24_;
GObject* _tmp25_ = NULL;
GObject* _tmp26_;
GtkWidget* _tmp27_;
gint _tmp28_;
GError * _inner_error_ = NULL;
self = (GmpcToolsMetadataAppearance*) base;
g_return_if_fail (container != NULL);
_tmp0_ = gtk_builder_new ();
builder = _tmp0_;
_tmp1_ = gmpc_get_full_glade_path ("preferences-metadata-appearance.ui");
preferences_ui_file = _tmp1_;
gtk_builder_add_from_file (builder, preferences_ui_file, &_inner_error_);
if (_inner_error_ != NULL) {
_g_free0 (preferences_ui_file);
_g_object_unref0 (builder);
goto __catch15_g_error;
}
gtk_builder_connect_signals (builder, NULL);
_tmp2_ = gtk_builder_get_object (builder, "frame_metadata_appearance_settings");
_tmp3_ = _tmp2_;
_tmp4_ = _g_object_ref0 ((GtkWidget*) (GTK_IS_FRAME (_tmp3_) ? ((GtkFrame*) _tmp3_) : NULL));
builderWidget = _tmp4_;
gtk_container_add (container, builderWidget);
gtk_widget_show_all (builderWidget);
_tmp5_ = gtk_builder_get_object (builder, "checkbutton_show_lyrics");
_tmp6_ = _tmp5_;
_tmp7_ = _g_object_ref0 ((GtkWidget*) (GTK_IS_CHECK_BUTTON (_tmp6_) ? ((GtkCheckButton*) _tmp6_) : NULL));
_g_object_unref0 (builderWidget);
builderWidget = _tmp7_;
_tmp8_ = cfg_get_single_value_as_int_with_default (config, "MetaData", "show-lyrics", 1);
gtk_toggle_button_set_active ((GtkToggleButton*) GTK_CHECK_BUTTON (builderWidget), (gboolean) _tmp8_);
_tmp9_ = gtk_builder_get_object (builder, "checkbutton_show_artist_information");
_tmp10_ = _tmp9_;
_tmp11_ = _g_object_ref0 ((GtkWidget*) (GTK_IS_CHECK_BUTTON (_tmp10_) ? ((GtkCheckButton*) _tmp10_) : NULL));
_g_object_unref0 (builderWidget);
builderWidget = _tmp11_;
_tmp12_ = cfg_get_single_value_as_int_with_default (config, "MetaData", "show-artist-information", 1);
gtk_toggle_button_set_active ((GtkToggleButton*) GTK_CHECK_BUTTON (builderWidget), (gboolean) _tmp12_);
_tmp13_ = gtk_builder_get_object (builder, "checkbutton_show_web_links");
_tmp14_ = _tmp13_;
_tmp15_ = _g_object_ref0 ((GtkWidget*) (GTK_IS_CHECK_BUTTON (_tmp14_) ? ((GtkCheckButton*) _tmp14_) : NULL));
_g_object_unref0 (builderWidget);
builderWidget = _tmp15_;
_tmp16_ = cfg_get_single_value_as_int_with_default (config, "MetaData", "show-web-links", 1);
gtk_toggle_button_set_active ((GtkToggleButton*) GTK_CHECK_BUTTON (builderWidget), (gboolean) _tmp16_);
_tmp17_ = gtk_builder_get_object (builder, "checkbutton_show_similar_artists");
_tmp18_ = _tmp17_;
_tmp19_ = _g_object_ref0 ((GtkWidget*) (GTK_IS_CHECK_BUTTON (_tmp18_) ? ((GtkCheckButton*) _tmp18_) : NULL));
_g_object_unref0 (builderWidget);
builderWidget = _tmp19_;
_tmp20_ = cfg_get_single_value_as_int_with_default (config, "MetaData", "show-similar-artist", 1);
gtk_toggle_button_set_active ((GtkToggleButton*) GTK_CHECK_BUTTON (builderWidget), (gboolean) _tmp20_);
_tmp21_ = gtk_builder_get_object (builder, "checkbutton_show_similar_songs");
_tmp22_ = _tmp21_;
_tmp23_ = _g_object_ref0 ((GtkWidget*) (GTK_IS_CHECK_BUTTON (_tmp22_) ? ((GtkCheckButton*) _tmp22_) : NULL));
_g_object_unref0 (builderWidget);
builderWidget = _tmp23_;
_tmp24_ = cfg_get_single_value_as_int_with_default (config, "MetaData", "show-similar-songs", 1);
gtk_toggle_button_set_active ((GtkToggleButton*) GTK_CHECK_BUTTON (builderWidget), (gboolean) _tmp24_);
_tmp25_ = gtk_builder_get_object (builder, "checkbutton_show_guitar_tabs");
_tmp26_ = _tmp25_;
_tmp27_ = _g_object_ref0 ((GtkWidget*) (GTK_IS_CHECK_BUTTON (_tmp26_) ? ((GtkCheckButton*) _tmp26_) : NULL));
_g_object_unref0 (builderWidget);
builderWidget = _tmp27_;
_tmp28_ = cfg_get_single_value_as_int_with_default (config, "MetaData", "show-guitar-tabs", 1);
gtk_toggle_button_set_active ((GtkToggleButton*) GTK_CHECK_BUTTON (builderWidget), (gboolean) _tmp28_);
_g_object_unref0 (builderWidget);
_g_free0 (preferences_ui_file);
_g_object_unref0 (builder);
goto __finally15;
__catch15_g_error:
{
GError * e;
e = _inner_error_;
_inner_error_ = NULL;
fprintf (stderr, "Could not load UI: %s\n", e->message);
_g_error_free0 (e);
}
__finally15:
if (_inner_error_ != NULL) {
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
g_clear_error (&_inner_error_);
return;
}
}
static gboolean gmpc_mpd_data_treeview_tooltip_query_tooltip_callback (GmpcMpdDataTreeviewTooltip* self, gint x, gint y, gboolean keyboard_tip, GtkTooltip* tooltip) {
gboolean result = FALSE;
gchar* tag;
gint row_type;
GtkTreePath* path;
GtkTreeIter iter = {0};
GtkTreeModel* _tmp0_ = NULL;
GtkTreeModel* _tmp1_;
GtkTreeModel* model;
gint _tmp2_;
gboolean _tmp3_ = FALSE;
gint _tmp4_;
gint _tmp5_;
GtkTreeModel* _tmp6_ = NULL;
GtkTreePath* _tmp7_ = NULL;
GtkTreeIter _tmp8_ = {0};
gboolean _tmp9_;
GtkTreeModel* _tmp10_;
GtkTreePath* _tmp11_;
mpd_Song* _tmp12_ = NULL;
mpd_Song* song;
gchar* _tmp18_ = NULL;
gchar* new_check;
gboolean _tmp19_ = FALSE;
GtkImageType _tmp23_;
g_return_val_if_fail (self != NULL, FALSE);
g_return_val_if_fail (tooltip != NULL, FALSE);
tag = NULL;
row_type = 0;
path = NULL;
_tmp0_ = gtk_tree_view_get_model (self->priv->par_widget);
_tmp1_ = _g_object_ref0 (_tmp0_);
model = _tmp1_;
_tmp2_ = cfg_get_single_value_as_int_with_default (config, "GmpcTreeView", "show-tooltip", 1);
if (_tmp2_ != 1) {
result = FALSE;
_g_object_unref0 (model);
_gtk_tree_path_free0 (path);
_g_free0 (tag);
return result;
}
if (self->mtype != META_ARTIST_ART) {
_tmp3_ = self->mtype != META_ALBUM_ART;
} else {
_tmp3_ = FALSE;
}
if (_tmp3_) {
_g_free0 (self->priv->checksum);
self->priv->checksum = NULL;
result = FALSE;
_g_object_unref0 (model);
_gtk_tree_path_free0 (path);
_g_free0 (tag);
return result;
}
_tmp9_ = gtk_tree_view_get_tooltip_context (self->priv->par_widget, &_tmp4_, &_tmp5_, keyboard_tip, &_tmp6_, &_tmp7_, &_tmp8_);
x = _tmp4_;
y = _tmp5_;
_g_object_unref0 (model);
_tmp10_ = _g_object_ref0 (_tmp6_);
model = _tmp10_;
_gtk_tree_path_free0 (path);
_tmp11_ = _gtk_tree_path_copy0 (_tmp7_);
path = _tmp11_;
iter = _tmp8_;
if (!_tmp9_) {
_g_free0 (self->priv->checksum);
self->priv->checksum = NULL;
result = FALSE;
_g_object_unref0 (model);
_gtk_tree_path_free0 (path);
_g_free0 (tag);
return result;
}
_tmp12_ = mpd_newSong ();
song = _tmp12_;
gtk_tree_model_get (model, &iter, 26, &row_type, -1);
if (row_type == MPD_DATA_TYPE_SONG) {
gchar* album;
gchar* _tmp13_;
gchar* _tmp14_;
album = NULL;
gtk_tree_model_get (model, &iter, 5, &tag, 6, &album, -1);
_tmp13_ = g_strdup (tag);
_g_free0 (song->artist);
song->artist = _tmp13_;
_tmp14_ = g_strdup (album);
_g_free0 (song->album);
song->album = _tmp14_;
_g_free0 (album);
} else {
if (row_type == MPD_DATA_TYPE_TAG) {
if (self->mtype == META_ARTIST_ART) {
gchar* _tmp15_;
gtk_tree_model_get (model, &iter, 7, &tag, -1);
_tmp15_ = g_strdup (tag);
_g_free0 (song->artist);
song->artist = _tmp15_;
} else {
if (self->mtype == META_ALBUM_ART) {
gchar* _tmp16_;
gchar* _tmp17_;
gtk_tree_model_get (model, &iter, 7, &tag, -1);
_tmp16_ = g_strdup (self->request_artist);
_g_free0 (song->artist);
song->artist = _tmp16_;
_tmp17_ = g_strdup (tag);
_g_free0 (song->album);
song->album = _tmp17_;
}
}
}
}
_tmp18_ = mpd_song_checksum (song);
new_check = _tmp18_;
if (g_strcmp0 (new_check, self->priv->checksum) != 0) {
_tmp19_ = self->priv->checksum != NULL;
} else {
_tmp19_ = FALSE;
}
if (_tmp19_) {
_g_free0 (self->priv->checksum);
self->priv->checksum = NULL;
result = FALSE;
_g_free0 (new_check);
_mpd_freeSong0 (song);
_g_object_unref0 (model);
_gtk_tree_path_free0 (path);
_g_free0 (tag);
return result;
}
if (g_strcmp0 (new_check, self->priv->checksum) != 0) {
gchar* _tmp20_;
MetaData* met;
MetaData* _tmp21_ = NULL;
MetaDataResult _tmp22_;
MetaDataResult _result_;
_tmp20_ = g_strdup (new_check);
_g_free0 (self->priv->checksum);
self->priv->checksum = _tmp20_;
met = NULL;
_tmp22_ = gmpc_meta_watcher_get_meta_path (gmw, song, self->mtype, &_tmp21_);
_meta_data_free0 (met);
met = _tmp21_;
_result_ = _tmp22_;
gmpc_mpd_data_treeview_tooltip_metadata_changed (self, gmw, song, self->mtype, _result_, met);
_meta_data_free0 (met);
}
_tmp23_ = gtk_image_get_storage_type (self->priv->image);
if (_tmp23_ == GTK_IMAGE_EMPTY) {
result = FALSE;
_g_free0 (new_check);
_mpd_freeSong0 (song);
_g_object_unref0 (model);
_gtk_tree_path_free0 (path);
_g_free0 (tag);
return result;
}
result = TRUE;
_g_free0 (new_check);
_mpd_freeSong0 (song);
_g_object_unref0 (model);
_gtk_tree_path_free0 (path);
_g_free0 (tag);
return result;
}
