mpd_Song * mpd_playlist_get_current_song(MpdObj *mi)
{
if(!mpd_check_connected(mi))
{
debug_printf(DEBUG_WARNING, "Not Connected\n");
return NULL;
}
if(mpd_status_check(mi) != MPD_OK)
{
debug_printf(DEBUG_ERROR, "Failed to check status\n");
return NULL;
}
if(mi->CurrentSong != NULL && mi->CurrentSong->id != mi->status->songid)
{
debug_printf(DEBUG_WARNING, "Current song not up2date, updating\n");
mpd_freeSong(mi->CurrentSong);
mi->CurrentSong = NULL;
}
/* only update song when playing/pasing */
if(mi->CurrentSong == NULL &&
(mpd_player_get_state(mi) != MPD_PLAYER_STOP && mpd_player_get_state(mi) != MPD_PLAYER_UNKNOWN))
{
/* TODO: this to use the geT_current_song_id function */
mi->CurrentSong = mpd_playlist_get_song(mi, mpd_player_get_current_song_id(mi));
if(mi->CurrentSong == NULL)
{
debug_printf(DEBUG_ERROR, "Failed to grab song\n");
return NULL;
}
}
return mi->CurrentSong;
}
int mpd_player_pause(MpdObj * mi)
{
if (!mpd_check_connected(mi)) {
debug_printf(DEBUG_WARNING, "not connected\n");
return MPD_NOT_CONNECTED;
}
if (mpd_lock_conn(mi)) {
debug_printf(DEBUG_WARNING, "lock failed\n");
return MPD_LOCK_FAILED;
}
if (mpd_player_get_state(mi) == MPD_PLAYER_PAUSE) {
mpd_sendPauseCommand(mi->connection, 0);
mpd_finishCommand(mi->connection);
} else if (mpd_player_get_state(mi) == MPD_PLAYER_PLAY) {
mpd_sendPauseCommand(mi->connection, 1);
mpd_finishCommand(mi->connection);
}
mpd_unlock_conn(mi);
if (mpd_status_update(mi)) {
return MPD_STATUS_FAILED;
}
return MPD_OK;
}
/* -------------------------------------------------------------------------- */
static void mpd_state_changed_handler(MpdObj *mi, ChangedStatusType what, void *userdata)
{
struct lcd_stuff_mpd *mpd = (struct lcd_stuff_mpd *)userdata;
char *str;
mpd->current_state = mpd_player_get_state(mpd->mpd);
report(RPT_DEBUG, "State changed, %d\n", mpd->current_state);
mpd->song_displayed = false;
switch (mpd->current_state) {
case MPD_PLAYER_PAUSE:
str = "paused";
break;
case MPD_PLAYER_UNKNOWN:
str = "unknown";
break;
case MPD_PLAYER_STOP:
str = "stopped";
break;
case MPD_PLAYER_PLAY:
return;
default:
str = "";
break;
}
screen_clear(&mpd->screen);
}
static gboolean
gimmix_timer (void)
{
gchar time[15];
int new_status;
float fraction;
mpd_status_update (gmo);
new_status = mpd_player_get_state (gmo);
if (status == new_status)
{
if (status == MPD_PLAYER_PLAY || status == MPD_PLAYER_PAUSE)
{
gimmix_get_progress_status (gmo, &fraction, time);
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), fraction);
gtk_progress_bar_set_text (GTK_PROGRESS_BAR(progress), time);
/* Update the system tray tooltip progress bar */
if (strncasecmp(cfg_get_key_value(conf, "enable_systray"), "true", 4) == 0)
if (strncasecmp(cfg_get_key_value(conf, "enable_notification"), "true", 4) == 0)
{
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(tooltip->progressbar), fraction);
gtk_progress_bar_set_text (GTK_PROGRESS_BAR(tooltip->progressbar), time);
}
}
return TRUE;
}
else
{
status = new_status;
return TRUE;
}
}
void
gimmix_get_progress_status (MpdObj *mo, float *fraction, char *time)
{
int state;
int total, elapsed;
state = mpd_player_get_state (mo);
switch (state)
{
case MPD_PLAYER_PLAY:
case MPD_PLAYER_PAUSE:
mpd_status_update(mo);
total = mpd_status_get_total_song_time (mo);
elapsed = mpd_status_get_elapsed_song_time (mo);
snprintf (time, 20, "%02i:%02i / %02i:%02i", elapsed/60,
elapsed%60,
total/60,
total%60);
*fraction = (float)((float)elapsed/(float)total);
break;
case MPD_PLAYER_STOP:
case MPD_PLAYER_UNKNOWN:
time = NULL;
return;
}
return;
}
static void
gimmix_status_changed (MpdObj *mo, ChangedStatusType id)
{
if (id&MPD_CST_SONGID)
{
gimmix_set_song_info ();
gimmix_update_current_playlist ();
}
if (id&MPD_CST_STATE)
{
int state = mpd_player_get_state (gmo);
if (state == MPD_PLAYER_PLAY)
{
gtk_image_set_from_stock (GTK_IMAGE(image_play), "gtk-media-pause", GTK_ICON_SIZE_BUTTON);
gtk_tooltips_set_tip (play_button_tooltip, play_button, _("Pause <x or c>"), NULL);
gimmix_set_song_info ();
}
if (state == MPD_PLAYER_PAUSE)
{
gtk_image_set_from_stock (GTK_IMAGE(image_play), "gtk-media-play", GTK_ICON_SIZE_BUTTON);
gtk_tooltips_set_tip (play_button_tooltip, play_button, _("Play <x or c>"), NULL);
}
if (state == MPD_PLAYER_STOP)
{
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.0);
gtk_progress_bar_set_text (GTK_PROGRESS_BAR(progress), _("Stopped"));
if (strncasecmp(cfg_get_key_value(conf, "enable_systray"), "true", 4) == 0)
{
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(tooltip->progressbar), 0.0);
gtk_progress_bar_set_text (GTK_PROGRESS_BAR(tooltip->progressbar), _("Stopped"));
}
gimmix_show_ver_info ();
gtk_image_set_from_stock (GTK_IMAGE(image_play), "gtk-media-play", GTK_ICON_SIZE_BUTTON);
gtk_tooltips_set_tip (play_button_tooltip, play_button, _("Play <x or c>"), NULL);
}
g_object_ref_sink (play_button_tooltip);
gimmix_update_current_playlist ();
}
if (id&MPD_CST_PLAYLIST)
gimmix_update_current_playlist ();
if (id&MPD_CST_VOLUME)
gimmix_update_volume ();
if (id&MPD_CST_RANDOM)
gimmix_update_shuffle ();
if (id&MPD_CST_REPEAT)
gimmix_update_repeat ();
return;
}
int mpd_player_get_current_song_id(MpdObj * mi)
{
if (!mpd_check_connected(mi)) {
debug_printf(DEBUG_WARNING, "not connected\n");
return MPD_NOT_CONNECTED;
}
if (mpd_status_check(mi) != MPD_OK) {
debug_printf(DEBUG_ERROR, "Failed to get status\n");
return MPD_STATUS_FAILED;
}
/* check if in valid state */
if (mpd_player_get_state(mi) != MPD_PLAYER_PLAY &&
mpd_player_get_state(mi) != MPD_PLAYER_PAUSE) {
return MPD_PLAYER_NOT_PLAYING;
}
/* just to be sure check */
if (!mi->status->playlistLength) {
return MPD_PLAYLIST_EMPTY;
}
return mi->status->songid;
}
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;
}
GimmixStatus
gimmix_get_status (MpdObj *mo)
{
int status;
mpd_status_update (mo);
status = mpd_player_get_state (mo);
if (status == MPD_PLAYER_PAUSE)
return PAUSE;
else if (status == MPD_PLAYER_PLAY)
return PLAY;
else if (status == MPD_PLAYER_STOP)
return STOP;
return UNKNOWN;
}
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);
}
};
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;
}
bool
gimmix_play (MpdObj *mo)
{
if (mpd_playlist_get_playlist_length (mo))
{
int state;
state = mpd_player_get_state (mo);
if (state == MPD_PLAYER_PAUSE || state == MPD_PLAYER_STOP)
{
mpd_player_play (mo);
return true;
}
else if (state == MPD_PLAYER_PLAY)
{
mpd_player_pause (mo);
return false;
}
}
return false;
}
/**
* Constructor
*/
GtkWidget *create_control_window(GtkWidget *parent)
{
GtkWidget *pp_button, *next_button, *prev_button, *ff_button;
GtkWidget *vol, *progress, *hbox, *play_image;
int new_volume;
/* Create window */
GtkWidget *base = gtk_event_box_new();
GtkWidget *ali = gtk_alignment_new(0.5,0,0.6,1);
g_signal_connect(G_OBJECT(base), "enter-notify-event" ,
G_CALLBACK(control_window_enter_notify_event), NULL);
g_signal_connect(G_OBJECT(base), "leave-notify-event" ,
G_CALLBACK(control_window_leave_notify_event), NULL);
/* Overwrite background drawing */
gtk_widget_set_app_paintable(base, TRUE);
g_signal_connect(G_OBJECT(base), "draw",
G_CALLBACK(expose_window), NULL);
hbox = gtk_hbox_new(FALSE, 6);
g_object_set_data(G_OBJECT(base), "hbox" , hbox);
gtk_container_add(GTK_CONTAINER(base), ali);
gtk_container_add(GTK_CONTAINER(ali), hbox);
gtk_container_set_border_width(GTK_CONTAINER(ali), 1);
/* Previous button */
ff_button = gtk_button_new();
gtk_container_add(GTK_CONTAINER(ff_button),
gtk_image_new_from_stock(GTK_STOCK_LEAVE_FULLSCREEN,
GTK_ICON_SIZE_BUTTON));
gtk_button_set_relief(GTK_BUTTON(ff_button), GTK_RELIEF_NONE);
gtk_box_pack_start(GTK_BOX(hbox), ff_button, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(ff_button), "clicked",
G_CALLBACK(control_window_leave_fullscreen), parent);
/* Volume button */
vol = (GtkWidget *)gtk_volume_button_new();
gtk_box_pack_end(GTK_BOX(hbox), vol, FALSE, FALSE, 0);
new_volume = mpd_status_get_volume(connection);
gtk_scale_button_set_value(GTK_SCALE_BUTTON(vol), new_volume/100.0);
g_object_set_data(G_OBJECT(base), "vol", vol);
g_signal_connect(G_OBJECT(vol), "value_changed",
G_CALLBACK(playlist_player_volume_changed), NULL);
/* Progress */
progress = (GtkWidget *)gmpc_progress_new();
gmpc_progress_set_hide_text(GMPC_PROGRESS(progress), FALSE);
gtk_box_pack_start(GTK_BOX(hbox), progress, TRUE, TRUE, 0);
g_object_set_data(G_OBJECT(base), "progress", progress);
g_signal_connect(G_OBJECT(progress), "seek-event", G_CALLBACK(pl3_pb_seek_event),
NULL);
/* Previous button */
prev_button = gtk_button_new();
gtk_container_add(GTK_CONTAINER(prev_button),
gtk_image_new_from_stock("gtk-media-previous", GTK_ICON_SIZE_BUTTON));
gtk_activatable_set_related_action(GTK_ACTIVATABLE(prev_button),
GTK_ACTION(gtk_builder_get_object(pl3_xml, "MPDPrevious")));
gtk_button_set_relief(GTK_BUTTON(prev_button), GTK_RELIEF_NONE);
gtk_box_pack_start(GTK_BOX(hbox), prev_button, FALSE, FALSE, 0);
/* Play button */
pp_button = gtk_button_new();
if(mpd_player_get_state(connection) == MPD_PLAYER_PLAY)
{
play_image = gtk_image_new_from_stock("gtk-media-pause", GTK_ICON_SIZE_BUTTON);
}
else
{
play_image = gtk_image_new_from_stock("gtk-media-play", GTK_ICON_SIZE_BUTTON);
}
gtk_container_add(GTK_CONTAINER(pp_button), play_image);
g_object_set_data(G_OBJECT(base), "play_image", play_image);
gtk_activatable_set_related_action(GTK_ACTIVATABLE(pp_button),
GTK_ACTION(gtk_builder_get_object(pl3_xml, "MPDPlayPause")));
gtk_button_set_relief(GTK_BUTTON(pp_button), GTK_RELIEF_NONE);
gtk_box_pack_start(GTK_BOX(hbox), pp_button, FALSE, FALSE, 0);
/* Next */
next_button = gtk_button_new();
gtk_container_add(GTK_CONTAINER(next_button),
gtk_image_new_from_stock("gtk-media-next", GTK_ICON_SIZE_BUTTON));
gtk_activatable_set_related_action(GTK_ACTIVATABLE(next_button),
GTK_ACTION(gtk_builder_get_object(pl3_xml, "MPDNext")));
gtk_button_set_relief(GTK_BUTTON(next_button), GTK_RELIEF_NONE);
gtk_box_pack_start(GTK_BOX(hbox), next_button, FALSE, FALSE, 0);
/* Change colors */
control_window_modify_colors(base);
gtk_widget_show_all(base);
timeout = g_timeout_add_seconds(5, (GSourceFunc) gtk_widget_hide, hbox);
return base;
}
/* 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;
}
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
gimmix_init (void)
{
GtkWidget *widget;
GtkWidget *progressbox;
GtkAdjustment *vol_adj;
GdkPixbuf *app_icon;
gchar *path;
/* Set the application icon */
main_window = glade_xml_get_widget (xml, "main_window");
g_signal_connect (G_OBJECT(main_window), "delete-event", G_CALLBACK(cb_gimmix_main_window_delete_event), NULL);
gtk_window_set_default_size (GTK_WINDOW(main_window), -1, 80);
gtk_window_resize (GTK_WINDOW(main_window), atoi(cfg_get_key_value(conf, "window_width")), atoi(cfg_get_key_value(conf, "window_height")));
gtk_window_move (GTK_WINDOW(main_window), atoi(cfg_get_key_value(conf, "window_xpos")), atoi(cfg_get_key_value(conf, "window_ypos")));
path = gimmix_get_full_image_path (GIMMIX_APP_ICON);
app_icon = gdk_pixbuf_new_from_file_at_size (path, 48, 48, NULL);
gtk_window_set_icon (GTK_WINDOW(main_window), app_icon);
g_object_unref (app_icon);
g_free (path);
/* connect the key press signal */
g_signal_connect (G_OBJECT(main_window), "key-press-event", G_CALLBACK(cb_gimmix_key_press), NULL);
g_signal_connect (G_OBJECT(main_window), "configure-event", G_CALLBACK(cb_gimmix_main_window_configure_event), (gpointer)glade_xml_get_widget(xml, "volume_window"));
/* connect the destroy signal */
g_signal_connect(G_OBJECT(main_window), "destroy", G_CALLBACK(gtk_main_quit), NULL);
/* set icons for buttons */
gtk_image_set_from_stock (GTK_IMAGE(glade_xml_get_widget(xml, "image_prev")), "gtk-media-previous", GTK_ICON_SIZE_BUTTON);
gtk_image_set_from_stock (GTK_IMAGE(glade_xml_get_widget(xml, "image_play")), "gtk-media-play", GTK_ICON_SIZE_BUTTON);
gtk_image_set_from_stock (GTK_IMAGE(glade_xml_get_widget(xml, "image_next")), "gtk-media-next", GTK_ICON_SIZE_BUTTON);
gtk_image_set_from_stock (GTK_IMAGE(glade_xml_get_widget(xml, "image_stop")), "gtk-media-stop", GTK_ICON_SIZE_BUTTON);
g_signal_connect (G_OBJECT(glade_xml_get_widget (xml, "prev_button")), "clicked", G_CALLBACK(cb_prev_button_clicked), NULL);
g_signal_connect (G_OBJECT(glade_xml_get_widget (xml, "play_button")), "clicked", G_CALLBACK(cb_play_button_clicked), NULL);
g_signal_connect (G_OBJECT(glade_xml_get_widget (xml, "next_button")), "clicked", G_CALLBACK(cb_next_button_clicked), NULL);
g_signal_connect (G_OBJECT(glade_xml_get_widget (xml, "stop_button")), "clicked", G_CALLBACK(cb_stop_button_clicked), NULL);
g_signal_connect (G_OBJECT(glade_xml_get_widget (xml, "pref_button")), "clicked", G_CALLBACK(cb_pref_button_clicked), NULL);
shuffle_toggle_button = glade_xml_get_widget (xml, "shuffle_toggle");
repeat_toggle_button = glade_xml_get_widget (xml, "repeat_toggle");
volume_window = glade_xml_get_widget (xml, "volume_window");
volume_scale = glade_xml_get_widget (xml, "volume_scale");
volume_button = glade_xml_get_widget (xml, "volume_button");
playlist_button = glade_xml_get_widget (xml, "playlist_button");
playlist_box = glade_xml_get_widget (xml, "playlistbox");
song_label = glade_xml_get_widget (xml, "song_label");
artist_label = glade_xml_get_widget (xml, "artist_label");
search_entry = glade_xml_get_widget (xml, "search_label");
play_button = glade_xml_get_widget (xml, "play_button");
image_play = glade_xml_get_widget (xml, "image_play");
g_signal_connect (G_OBJECT(playlist_button), "button-press-event", G_CALLBACK(cb_playlist_button_press), NULL);
if (is_gimmix_repeat (gmo))
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(repeat_toggle_button), TRUE);
g_signal_connect (G_OBJECT(repeat_toggle_button), "toggled", G_CALLBACK(cb_repeat_button_toggled), NULL);
if (is_gimmix_shuffle (gmo))
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(shuffle_toggle_button), TRUE);
g_signal_connect (G_OBJECT(shuffle_toggle_button), "toggled", G_CALLBACK(cb_shuffle_button_toggled), NULL);
widget = glade_xml_get_widget (xml, "info_button");
g_signal_connect (G_OBJECT(widget), "button-release-event", G_CALLBACK(cb_info_button_press), NULL);
g_signal_connect (G_OBJECT(volume_scale), "value_changed", G_CALLBACK(cb_volume_scale_changed), NULL);
g_signal_connect (G_OBJECT(volume_scale), "scroll_event", G_CALLBACK(cb_volume_slider_scroll), NULL);
vol_adj = gtk_range_get_adjustment (GTK_RANGE(volume_scale));
gtk_adjustment_set_value (GTK_ADJUSTMENT(vol_adj), mpd_status_get_volume (gmo));
g_signal_connect (G_OBJECT(volume_button), "clicked", G_CALLBACK(cb_volume_button_clicked), volume_window);
g_signal_connect (G_OBJECT(volume_button), "scroll_event", G_CALLBACK(cb_volume_slider_scroll), NULL);
progress = glade_xml_get_widget (xml,"progress");
progressbox = glade_xml_get_widget (xml,"progress_event_box");
g_signal_connect (G_OBJECT(progressbox), "button_press_event", G_CALLBACK(cb_gimmix_progress_seek), NULL);
play_button_tooltip = gtk_tooltips_new ();
if (strncasecmp(cfg_get_key_value(conf, "enable_systray"), "true", 4) == 0)
{
gimmix_create_systray_icon ();
}
if (strncasecmp(cfg_get_key_value(conf, "full_view_mode"), "true", 4) == 0)
{
gtk_widget_show (playlist_box);
gtk_window_set_resizable (GTK_WINDOW(main_window), TRUE);
}
else
{
gtk_widget_hide (playlist_box);
gtk_window_set_resizable (GTK_WINDOW(main_window), FALSE);
}
mpd_status_update (gmo);
status = mpd_player_get_state (gmo);
if (status == MPD_PLAYER_PLAY)
{
gimmix_set_song_info ();
status = -1;
gtk_image_set_from_stock (GTK_IMAGE(image_play), "gtk-media-pause", GTK_ICON_SIZE_BUTTON);
gtk_tooltips_set_tip (play_button_tooltip, play_button, _("Pause <x or c>"), NULL);
}
else if (status == MPD_PLAYER_PAUSE)
{
gimmix_set_song_info ();
}
else if (status == MPD_PLAYER_STOP)
{
gtk_progress_bar_set_text (GTK_PROGRESS_BAR(progress), _("Stopped"));
if (strncasecmp(cfg_get_key_value(conf, "enable_systray"), "true", 4) == 0)
gtk_progress_bar_set_text (GTK_PROGRESS_BAR(tooltip->progressbar), _("Stopped"));
gimmix_show_ver_info ();
}
g_timeout_add (300, (GSourceFunc)gimmix_timer, NULL);
/* connect the main mpd callbacks */
mpd_signal_connect_status_changed (gmo, (StatusChangedCallback)gimmix_status_changed, NULL);
mpd_signal_connect_error (gmo, (ErrorCallback)gimmix_mpd_error, NULL);
/* initialize playlist and tag editor */
gimmix_playlist_init ();
gimmix_tag_editor_init ();
gimmix_update_current_playlist ();
/* initialize preferences dialog */
gimmix_prefs_init ();
g_object_unref (xml);
/* show the main window */
gtk_widget_show (main_window);
/* check if library needs to be updated on startup */
if (strncasecmp(cfg_get_key_value(conf, "update_on_startup"), "true", 4) == 0)
gimmix_library_update ();
return;
}
void control_window_status_update(MpdObj * mi, ChangedStatusType what, GtkWidget *base)
{
GtkWidget *volume_button, *progress, *play_image;
/* Bail out of base == NULL */
if(base == NULL) return;
/* Get the different subwidgets from the parent */
volume_button = g_object_get_data(G_OBJECT(base), "vol");
progress = g_object_get_data(G_OBJECT(base), "progress");
play_image = g_object_get_data(G_OBJECT(base), "play_image");
if (what & MPD_CST_STATE)
{
int state = mpd_player_get_state(mi);
switch (state)
{
case MPD_PLAYER_PLAY:
gtk_image_set_from_stock(GTK_IMAGE(play_image),
"gtk-media-pause", GTK_ICON_SIZE_BUTTON);
break;
case MPD_PLAYER_PAUSE:
gtk_image_set_from_stock(GTK_IMAGE(play_image),
"gtk-media-play", GTK_ICON_SIZE_BUTTON);
break;
default:
gtk_image_set_from_stock(GTK_IMAGE(play_image),
"gtk-media-play", GTK_ICON_SIZE_BUTTON);
/* Make sure it's reset correctly */
gmpc_progress_set_time(GMPC_PROGRESS(progress), 0, 0);
}
}
if (what & MPD_CST_ELAPSED_TIME)
{
if (mpd_check_connected(connection))
{
int totalTime = mpd_status_get_total_song_time(connection);
int elapsedTime = mpd_status_get_elapsed_song_time(connection);
gmpc_progress_set_time(GMPC_PROGRESS(progress), totalTime, elapsedTime);
} else
{
gmpc_progress_set_time(GMPC_PROGRESS(progress), 0, 0);
}
}
if (what & MPD_CST_VOLUME)
{
int volume = gtk_scale_button_get_value(GTK_SCALE_BUTTON(volume_button))*100;
int new_volume = mpd_status_get_volume(connection);
if (new_volume >= 0 &&
mpd_server_check_command_allowed(connection, "setvol") ==
MPD_SERVER_COMMAND_ALLOWED
)
{
gtk_widget_set_sensitive(volume_button, TRUE);
/* don't do anything if nothing is changed */
if (new_volume != volume)
{
gtk_scale_button_set_value(GTK_SCALE_BUTTON(volume_button), new_volume/100.0);
}
} else
{
gtk_widget_set_sensitive(volume_button, FALSE);
}
}
}
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");
}
}
