void status_changed(MpdObj *obj, ChangedStatusType what) {
mpd_Song *song = NULL;
size_t size;
char *str = NULL;
if(what & MPD_CST_SONGID) {
song = mpd_playlist_get_current_song(obj);
if(song) {
size = strlen(song->artist) + strlen(song->title) + 5;
str = malloc(size);
snprintf(str, size, "%s - %s\n", song->artist, song->title);
}
} else if(what & MPD_CST_STATE) {
switch(mpd_player_get_state(obj)) {
case MPD_PLAYER_STOP:
str = malloc(2);
snprintf(str, 2, "\n");
break;
case MPD_PLAYER_PLAY:
song = mpd_playlist_get_current_song(obj);
if(song) {
size = strlen(song->artist) + strlen(song->title) + 5;
str = malloc(size);
snprintf(str, size, "%s - %s\n", song->artist, song->title);
}
break;
case MPD_PLAYER_PAUSE:
song = mpd_playlist_get_current_song(obj);
if(song) {
size = strlen(song->artist) + strlen(song->title) + 6;
str = malloc(size);
snprintf(str, size, "%s - %s*\n", song->artist, song->title);
}
break;
default:
break;
}
}
if(str) {
write(fd, str, size);
free(str);
}
};
GdkPixbuf*
gimmix_covers_plugin_get_cover_image_of_size (guint width, guint height)
{
GdkPixbuf *pixbuf = NULL;
int status;
//g_print ("gimmix_covers_plugin_get_cover_image_of_size() called\n");
status = gimmix_get_status (gmo);
if (status == STOP || status == ERROR)
{
/* set default image */
pixbuf = gimmix_covers_plugin_get_default_cover (width, height);
}
else
{
mpd_Song *s = NULL;
sleep (2);
s = mpd_playlist_get_current_song (gmo);
gimmix_covers_plugin_find_cover (s);
if (s == NULL || cover_image_path == NULL)
{
/* set default image */
//g_print ("cover_image_path is NULL\n");
pixbuf = gimmix_covers_plugin_get_default_cover (width, height);
}
else
{
pixbuf = gdk_pixbuf_new_from_file_at_size (cover_image_path, width, height, NULL);
}
}
return pixbuf;
}
void
gimmix_tag_editor_show (void)
{
GimmixStatus status;
mpd_Song *info;
gchar *song = NULL;
status = gimmix_get_status (gmo);
if (status == PLAY || status == PAUSE)
{
info = mpd_playlist_get_current_song (gmo);
#if HAVE_TAGEDITOR
song = g_strdup_printf ("%s/%s", cfg_get_key_value(conf, "music_directory"), info->file);
if (gimmix_tag_editor_populate (song))
gtk_widget_show (GTK_WIDGET(tag_editor_window));
#else
if (gimmix_tag_editor_populate (info))
gtk_widget_show (GTK_WIDGET(tag_editor_window));
#endif
else
{
#ifdef HAVE_TAGEDITOR
g_warning (_("Invalid music directory."));
gimmix_tag_editor_error (dir_error);
#else
gimmix_tag_editor_error (_("An error occurred while trying to get song information. Please try again."));
#endif
}
g_free (song);
}
return;
}
static void playlist3_header_album(void)
{
mpd_Song *song = mpd_playlist_get_current_song(connection);
if (song && song->artist && song->album)
{
GtkTreeView *tree = (GtkTreeView *) gtk_builder_get_object(pl3_xml, "cat_tree");
gmpc_browsers_metadata_select_browser(browsers_metadata, tree);
gmpc_browsers_metadata_set_album(browsers_metadata, song->artist, song->album);
}
}
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);
}
void status_changed(MpdObj *mi, ChangedStatusType what)
{
pthread_mutex_lock(&lockit);
mpd_Song *song = mpd_playlist_get_current_song(mi);
if(song) {
if (song->artist!=NULL) {
strncpy(track_info.artist,song->artist,99);
} else {
track_info.artist[0] = 0;
}
if (song->title!=NULL) {
strncpy(track_info.title,song->title,99);
} else {
track_info.title[0] = 0;
}
}
if(what&MPD_CST_CROSSFADE){
// printf(GREEN"X-Fade:"RESET" %i sec.\n",mpd_status_get_crossfade(mi));
}
if(what&MPD_CST_PLAYLIST)
{
// printf(GREEN"Playlist changed"RESET"\n");
track_info.totalsongs_in_playlist = mpd_playlist_get_playlist_length(mi);
}
if(what&MPD_CST_ELAPSED_TIME && !voltimeout){
track_info.elapsed = mpd_status_get_elapsed_song_time(mi);
track_info.total = mpd_status_get_total_song_time(mi);
}
if(what&MPD_CST_VOLUME){
voltimeout=100;
track_info.volume = mpd_status_get_volume(mi);
}
if(what&MPD_CST_STATE) {
track_info.playstate = mpd_player_get_state(mi);
}
track_info.repeat = mpd_player_get_repeat(obj);
track_info.random = mpd_player_get_random(obj);
pthread_mutex_unlock(&lockit);
usleep(10*1000);
}
void
gimmix_lyrics_plugin_update_lyrics (void)
{
LYRICS_NODE *node = NULL;
mpd_Song *s = NULL;
mpd_Song *sng = (mpd_Song*)malloc (sizeof(mpd_Song));
memset (sng, 0, sizeof(mpd_Song));
sleep (2);
if (mpd_player_get_state(gmo)!=MPD_PLAYER_STOP)
{
if (mpd_playlist_get_playlist_length(gmo))
s = mpd_playlist_get_current_song (gmo);
else
s = NULL;
}
if (s)
{
memcpy (sng, s, sizeof(mpd_Song));
if (sng->artist)
gimmix_covers_plugin_set_artist (sng->artist);
if (sng->title)
gimmix_covers_plugin_set_songtitle (sng->title);
#ifndef HAVE_COVER_PLUGIN
gimmix_metadata_set_song_details (sng, NULL);
#else
if (!gimmix_config_get_bool("coverart_enable"))
{
gimmix_metadata_set_song_details (sng, NULL);
}
#endif
}
node = lyrics_search ();
gimmix_lyrics_populate_textview (node);
if (node)
{
if (node->lyrics)
g_free (node->lyrics);
g_free (node);
}
if (sng)
{
free (sng);
}
return;
}
void
gimmix_lyrics_plugin_update_lyrics (void)
{
LYRICS_NODE *node = NULL;
mpd_Song *s = NULL;
sleep (2);
if (mpd_player_get_state(gmo)!=MPD_PLAYER_STOP)
{
if (mpd_playlist_get_playlist_length(gmo))
s = mpd_playlist_get_current_song (gmo);
else
s = NULL;
}
if (s)
{
if (s->artist)
gimmix_covers_plugin_set_artist (s->artist);
if (s->title)
gimmix_covers_plugin_set_songtitle (s->title);
#ifndef HAVE_COVER_PLUGIN
gimmix_metadata_set_song_details (s, NULL);
#else
if (!strncasecmp(cfg_get_key_value(conf,"coverart_enable"),"false",5))
{
gimmix_metadata_set_song_details (s, NULL);
}
#endif
}
node = lyrics_search ();
gimmix_lyrics_populate_textview (node);
if (node)
{
if (node->lyrics)
g_free (node->lyrics);
g_free (node);
}
return;
}
SongInfo *
gimmix_get_song_info (MpdObj *mo)
{
mpd_Song *ms;
SongInfo *s = (SongInfo *)malloc(sizeof(SongInfo));
mpd_status_update(mo);
ms = mpd_playlist_get_current_song(mo);
s->file = (ms->file) ? strdup (ms->file) : NULL;
s->title = (ms->title) ? strdup (ms->title) : NULL;
s->artist = (ms->artist) ? strdup (ms->artist) : NULL;
s->album = (ms->album) ? strdup (ms->album) : NULL;
s->genre = (ms->genre) ? strdup (ms->genre) : NULL;
s->length = ms->time;
if (gimmix_get_status(mo) == PLAY)
s->bitrate = mpd_status_get_bitrate (mo);
else
s->bitrate = -1;
return s;
}
/* -------------------------------------------------------------------------- */
static struct song *mpd_get_current_song(struct lcd_stuff_mpd *mpd)
{
mpd_Song *current;
gchar **strings;
struct song *ret;
current = mpd_playlist_get_current_song(mpd->mpd);
if (!current || mpd->current_state != MPD_PLAYER_PLAY) {
ret = mpd_song_new("", "");
} else if (!current->title) {
ret = mpd_song_new("(unknown)", "");
} else {
strings = g_strsplit(current->title, " - ", 2);
if (g_strv_length(strings) == 2) {
ret = mpd_song_new(strings[0], strings[1]);
} else {
ret = mpd_song_new(current->artist ? current->artist : "",
current->title ? current->title : "");
}
g_strfreev(strings);
}
return ret;
}
SongInfo *
gimmix_get_song_info (MpdObj *mo)
{
mpd_Song *ms;
SongInfo *s = (SongInfo *)malloc(sizeof(SongInfo));
mpd_status_update (mo);
ms = mpd_playlist_get_current_song (mo);
if (ms->file != NULL)
s->file = strdup (ms->file);
else
s->file = NULL;
if (ms->title != NULL)
s->title = strdup (ms->title);
else
s->title = NULL;
if (ms->artist != NULL)
s->artist = strdup (ms->artist);
else
s->artist = NULL;
if (ms->album != NULL)
s->album = strdup (ms->album);
else
s->album = NULL;
if (ms->genre != NULL)
s->genre = strdup (ms->genre);
else
s->genre = NULL;
return s;
}
void playlist3_update_header(void)
{
char buffer[1024];
if (header_labels[0] == NULL)
return;
if (mpd_check_connected(connection))
{
mpd_Song *song = mpd_playlist_get_current_song(connection);
/** Set new header */
if (mpd_player_get_state(connection) != MPD_STATUS_STATE_STOP && song)
{
mpd_song_markup(buffer, 1024, "[%title%|%shortfile%][ (%name%)]", song);
gmpc_clicklabel_set_text(GMPC_CLICKLABEL(header_labels[0]), buffer);
gmpc_clicklabel_set_sensitive(GMPC_CLICKLABEL(header_labels[0]), TRUE);
if (song->artist)
{
gtk_widget_show(header_labels[1]);
gtk_widget_show(header_labels[2]);
gmpc_clicklabel_set_text(GMPC_CLICKLABEL(header_labels[2]), song->artist);
} else
{
gtk_widget_hide(header_labels[1]);
gtk_widget_hide(header_labels[2]);
}
if (song->album)
{
gtk_widget_show(header_labels[3]);
gtk_widget_show(header_labels[4]);
if (song->date)
{
gchar *text = g_strdup_printf("%s (%s)", song->album, song->date);
gmpc_clicklabel_set_text(GMPC_CLICKLABEL(header_labels[4]), text);
g_free(text);
} else
{
gmpc_clicklabel_set_text(GMPC_CLICKLABEL(header_labels[4]), song->album);
}
} else
{
gtk_widget_hide(header_labels[3]);
gtk_widget_hide(header_labels[4]);
}
} else
{
gmpc_clicklabel_set_text(GMPC_CLICKLABEL(header_labels[0]), _("Not Playing"));
gmpc_clicklabel_set_sensitive(GMPC_CLICKLABEL(header_labels[0]), FALSE);
gtk_widget_hide(header_labels[1]);
gtk_widget_hide(header_labels[2]);
gtk_widget_hide(header_labels[3]);
gtk_widget_hide(header_labels[4]);
}
} else
{
gmpc_clicklabel_set_text(GMPC_CLICKLABEL(header_labels[0]), _("Not Connected"));
gmpc_clicklabel_set_sensitive(GMPC_CLICKLABEL(header_labels[0]), FALSE);
gtk_widget_hide(header_labels[1]);
gtk_widget_hide(header_labels[2]);
gtk_widget_hide(header_labels[3]);
gtk_widget_hide(header_labels[4]);
}
}
void *Lkeys_thread() {
int keystate = 0;
int volume;
struct pollfd fds;
char ver[5];
strncpy(ver,G15DAEMON_VERSION,3);
float g15v;
sscanf(ver,"%f",&g15v);
fds.fd = g15screen_fd;
fds.events = POLLIN;
while(!leaving){
int foo=0;
current_fg_check = g15_send_cmd (g15screen_fd, G15DAEMON_IS_FOREGROUND, foo);
static int last_fg_check = 0;
if(playlist_mode && last_fg_check != current_fg_check){
if(own_keyboard){
if(current_fg_check==0){
own_keyboard=0;
}
}else if(current_fg_check && !own_keyboard) {
own_keyboard=1;
}
last_fg_check = current_fg_check;
}
/* g15daemon series 1.2 need key request packets */
pthread_mutex_lock(&daemon_mutex);
if((g15v*10)<=18) {
keystate = g15_send_cmd (g15screen_fd, G15DAEMON_GET_KEYSTATE, foo);
} else {
if ((poll(&fds, 1, 5)) > 0)
read (g15screen_fd, &keystate, sizeof (keystate));
}
pthread_mutex_unlock(&daemon_mutex);
if (keystate)
{
switch (keystate)
{
case G15_KEY_L1:
exit(1); // FIXME quick hack to exit
break;
case G15_KEY_L2:
menulevel++;
if(menulevel>=MAX_MENU_MODES)
menulevel=0;
break;
case G15_KEY_L3:
if(!own_keyboard){
own_keyboard=playlist_mode=1;
mpd_Song *song = mpd_playlist_get_current_song(obj);
if(song)
if(song->pos)
track_info.currentsong=song->pos;
}else{ //de-activate
own_keyboard=playlist_mode=0;
}
break;
case G15_KEY_L4:
if(menulevel==MENU_MODE1){
mpd_player_set_random(obj,mpd_player_get_random(obj)^1);
}
if(menulevel==MENU_MODE2){
volume=mpd_status_get_volume(obj);
if(volume>0)
volume-=10;
mpd_status_set_volume (obj,volume);
}
break;
case G15_KEY_L5:
if(menulevel==MENU_MODE1){
mpd_player_set_repeat(obj, mpd_player_get_repeat(obj)^1);
}
if(menulevel==MENU_MODE2){
volume=mpd_status_get_volume(obj);
if(volume<100)
volume+=10;
mpd_status_set_volume (obj,volume);
}
break;
default:
break;
}
keystate = 0;
}
usleep(100*1000);
}
return NULL;
}
void status_changed(MpdObj *mi, ChangedStatusType what, thread_data *my_data)
{
if(what&MPD_CST_SONGID)
{
mpd_Song *song = mpd_playlist_get_current_song(mi);
if(song)
{
printf( "Song:"" %s - %s\n", song->artist, song->title);
}
}
if(what&MPD_CST_REPEAT){
printf("Repeat:"" %s\n", mpd_player_get_repeat(mi)? "On":"Off");
}
if(what&MPD_CST_RANDOM){
printf("Random:"" %s\n", mpd_player_get_random(mi)? "On":"Off");
}
if(what&MPD_CST_VOLUME){
printf("Volume:"" %03i%%\n",
mpd_status_get_volume(mi));
my_data->mainLCD->printVolume(mpd_status_get_volume(mi));
try
{
my_data->ptr_MPD_info->volume= mpd_status_get_volume(mi);
}
catch (...)
{
log_file_mutex.mutex_lock();
log_file_cout << ERROR << "problem z wpisaniem volume "<< std::endl;
log_file_mutex.mutex_unlock();
}
}
if(what&MPD_CST_CROSSFADE){
printf("X-Fade:"" %i sec.\n",
mpd_status_get_crossfade(mi));
}
if(what&MPD_CST_UPDATING)
{
if(mpd_status_db_is_updating(mi))
{
printf("Started updating DB""\n");
}
else
{
printf("Updating DB finished""\n");
}
}
if(what&MPD_CST_DATABASE)
{
printf("Databased changed""\n");
}
if(what&MPD_CST_PLAYLIST)
{
printf("Playlist changed2""\n");
if (check_title_song_to==true)
{
mpd_Song *song = mpd_playlist_get_current_song(mi);
// std::cout <<" SONG: " << song->artist<<" "<< song->title << std::endl;
printf("aktualnie gramy:"" %s - %s\n", song->artist, song->title);
try
{
my_data->ptr_MPD_info->title = std::string( song->title);
}
catch (...)
{
my_data->myEventHandler.run("mpd")->addEvent("wrong title");
my_data->ptr_MPD_info->title = "no data";
}
try
{
my_data->ptr_MPD_info->artist = std::string( song->artist);
}
catch (...)
{
my_data->myEventHandler.run("mpd")->addEvent("wrong artist");
my_data->ptr_MPD_info->artist = "no data";
}
if (song->name != NULL){
_msg = song->name;
try
{
my_data->ptr_MPD_info->radio = _msg;
}
catch (...)
{
my_data->myEventHandler.run("mpd")->addEvent("wrong radio station name");
}
my_data->mainLCD->printRadioName(true,0,0,_msg);
my_data->mainLCD->set_lcd_STATE(5);
std::string temp_str="";
temp_str = send_to_arduino(my_data,"temperature:2;");
temp_str.erase(temp_str.size()-2,temp_str.size());
my_data->mainLCD->printString(false,0,1,"temp:"+temp_str+" c");
updatePlayList(mi,my_data);
}
if (song->title != NULL ){
_msg = song->title;
if (_msg.size() < 7 )
{
_msg = song->name;
_msg += " - brak nazwy ";
}
}
else if (song->artist != NULL){
_msg = song->artist;
}
else
{
_msg += " - brak nazwy ";
}
// my_data->ptr_MPD_info->title = _msg;
my_data->mainLCD->printSongName(_msg);
}
}
if(what&MPD_CST_STATE)
{
printf("State:");
switch(mpd_player_get_state(mi))
{
case MPD_PLAYER_PLAY:
printf("Playing\n");
check_title_song_to=true;
my_data->mainLCD->play_Y_N=true;
my_data->ptr_MPD_info->isPlay=true;
digitalWrite(GPIO_SPIK, LOW);
my_data->mainLCD->set_lcd_STATE(1);
my_data->mainLCD->song_printstr();
updatePlayList(mi,my_data);
my_data->myEventHandler.run("mpd")->addEvent("MPD playing");
break;
case MPD_PLAYER_PAUSE:
printf("Paused\n");
my_data->mainLCD->set_lcd_STATE( -1);
my_data->mainLCD->printString(true ,0,1," PAUSE");
my_data->myEventHandler.run("mpd")->addEvent("MPD pause");
break;
case MPD_PLAYER_STOP:
printf("Stopped\n");
if (my_data->ptr_MPD_info->isPlay ==true){
send_to_arduino(my_data,"LED_CLEAR:44;");
}
check_title_song_to=false;
my_data->mainLCD->play_Y_N=false;
my_data->ptr_MPD_info->isPlay=false;
my_data->ptr_MPD_info->title="* * * *";
digitalWrite(GPIO_SPIK,HIGH);
my_data->mainLCD->noBacklight();
sleep(1);
my_data->myEventHandler.run("mpd")->addEvent("MPD stopped");
break;
default:
break;
}
}
/* not yet implemented signals */
if(what&MPD_CST_AUDIO){
printf("Audio Changed""\n");
}
if(what&MPD_CST_TOTAL_TIME){
printf("Total song time changed:"" %02i:%02i\n",
mpd_status_get_total_song_time(mi)/60,
mpd_status_get_total_song_time(mi)%60);
}
if(what&MPD_CST_ELAPSED_TIME){
/* printf(GREEN"Time elapsed changed:"RESET" %02i:%02i\n",
mpd_status_get_elapsed_song_time(mi)/60,
mpd_status_get_elapsed_song_time(mi)%60);
*/ }
if(what&MPD_CST_PERMISSION){
printf( "Permission:"" Changed\n");
}
}
/* if default = TRUE, set the default cover */
void
gimmix_covers_plugin_update_cover (gboolean defaultc)
{
guint height;
GdkPixbuf *pixbuf = NULL;
mpd_Song *s = NULL;
g_mutex_lock (mutex);
height = h3_size;
if (defaultc)
{
pixbuf = gimmix_covers_plugin_get_default_cover (96, height);
gtk_image_set_from_pixbuf (GTK_IMAGE(gimmix_plcbox_image), pixbuf);
g_object_unref (pixbuf);
pixbuf = gimmix_covers_plugin_get_default_cover (64, 64);
gimmix_covers_plugin_set_metadata_image (pixbuf);
g_object_unref (pixbuf);
if (gimmix_config_get_bool("enable_systray"))
{
if (gimmix_config_get_bool("enable_notification"))
{
pixbuf = gimmix_covers_plugin_get_default_cover (48, 48);
gimmix_tooltip_set_icon (tooltip, pixbuf);
g_object_unref (pixbuf);
}
}
g_mutex_unlock (mutex);
goto ret;
}
else
{
pixbuf = gimmix_covers_plugin_get_cover_image_of_size (96, height);
}
sleep (2);
g_print ("sleep over\n");
if (mpd_player_get_state(gmo)!=MPD_PLAYER_STOP)
{
if (mpd_playlist_get_playlist_length(gmo))
s = mpd_playlist_get_current_song (gmo);
else
s = NULL;
}
if (pixbuf != NULL)
{
char *areview = NULL;
/* main window cover art */
gtk_image_set_from_pixbuf (GTK_IMAGE(gimmix_plcbox_image), pixbuf);
g_object_unref (pixbuf);
/* metadata cover art */
if (s!=NULL)
pixbuf = gimmix_covers_plugin_get_cover_image_of_size (64, 64);
else
pixbuf = gimmix_covers_plugin_get_default_cover (64, 64);
gimmix_covers_plugin_set_metadata_image (pixbuf);
g_object_unref (pixbuf);
/* metadata albuminfo */
s = mpd_playlist_get_current_song (gmo);
areview = gimmix_covers_plugin_get_albuminfo (s);
gimmix_metadata_set_song_details (s, areview);
if (areview)
g_free (areview);
/* also system tray tooltip image */
if (!strncasecmp(cfg_get_key_value(conf,"enable_systray"),"true",4))
{
if (!strncasecmp(cfg_get_key_value(conf,"enable_notification"),"true",4))
{
pixbuf = gimmix_covers_plugin_get_cover_image_of_size (48, 48);
gimmix_tooltip_set_icon (tooltip, pixbuf);
g_object_unref (pixbuf);
}
}
}
g_mutex_unlock (mutex);
ret:
/*while (gtk_events_pending())
gtk_main_iteration ();*/
return;
}
static void
cb_gimmix_covers_plugin_set_cover_from_file (void)
{
GtkWidget *dialog;
GtkFileFilter *filter = NULL;
GtkImage *preview;
mpd_Song *song = NULL;
gchar *artist = NULL;
gchar *album = NULL;
if (!(song=mpd_playlist_get_current_song(gmo)))
return;
artist = (song->artist != NULL) ? g_strdup (song->artist) : NULL;
album = (song->album != NULL) ? g_strdup (song->album) : NULL;
dialog = gtk_file_chooser_dialog_new ("Open File",
GTK_WINDOW(main_window),
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
preview = (GtkImage*)gtk_image_new ();
gtk_file_chooser_set_preview_widget (GTK_FILE_CHOOSER(dialog), GTK_WIDGET(preview));
g_signal_connect (GTK_FILE_CHOOSER(dialog), "update-preview", G_CALLBACK (cb_gimmix_covers_plugin_cover_file_preview), preview);
filter = gtk_file_filter_new ();
gtk_file_filter_set_name (filter, "Images (.jpg)");
gtk_file_filter_add_pattern (filter, "*.jpg");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(dialog), filter);
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
{
char *filename = NULL;
gchar *contents = NULL;
gsize len = 0;
filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
if (g_file_get_contents(filename, &contents, &len, NULL))
{
gchar *temp = NULL;
char *p = cfg_get_path_to_config_file (COVERS_DIR);
temp = g_strdup_printf ("%s/temp.jpg", p);
g_free (p);
if (g_file_set_contents (temp, contents, len, NULL))
{
if (artist!=NULL && album!=NULL)
{
gimmix_cover_plugin_save_cover (artist, album);
g_thread_create ((GThreadFunc)gimmix_covers_plugin_update_cover,
FALSE,
FALSE,
NULL);
g_free (artist);
g_free (album);
}
}
else
{
gimmix_error ("There was an error while setting the album cover. Please try using a different image.");
}
g_free (temp);
}
g_free (filename);
}
gtk_widget_destroy (dialog);
return;
}
