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"); } }