src/GUI/control_window.c.orig

   1 #include <gtk/gtk.h>
   2 #include "control_window.h"
   3 #include "gmpc-extras.h"
   4 #include "main.h"
   5
   6 /**
   7  * Reuse code from playlist3.
   8  */
   9 extern GtkBuilder *pl3_xml;
  10 gboolean playlist_player_volume_changed(GtkWidget * vol_but, int new_vol);
  11 void pl3_pb_seek_event(GtkWidget * pb, guint seek_time, gpointer user_data);
  12
  13 /**
  14  * Draw background of control box.
  15  */
  16 static gboolean
  17 expose_window(GtkWidget *widget, GdkEventExpose *event, gpointer date)
  18 {
  19     cairo_t *cr;
  20     cr = gdk_cairo_create(widget->window);
  21
  22     cairo_set_source_rgba(cr, 0.0, 0.0, 0.0, .7);
  23     cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
  24     cairo_paint(cr);             /* paint source */
  25
  26     cairo_set_source_rgba(cr, .8, .8, .8, .7);
  27     cairo_rectangle(cr, 0.5,0.5,
  28         widget->allocation.width-1.0,
  29         widget->allocation.height-1.0);
  30     cairo_stroke(cr);
  31     cairo_destroy(cr);
  32
  33     return FALSE;
  34 }
  35
  36
  37 /**
  38  * change the colors recursively.
  39  * Background black, text/fg white.
  40  */
  41 static void control_window_modify_colors(GtkWidget *base)
  42 {
  43     GList *iter;
  44     if(GTK_IS_HSCALE(base) == FALSE)
  45     {
  46         gtk_widget_modify_bg(base, GTK_STATE_NORMAL,&(base->style->black));
  47         gtk_widget_modify_fg(base, GTK_STATE_NORMAL,&(base->style->white));
  48         gtk_widget_modify_text(base, GTK_STATE_NORMAL,&(base->style->white));
  49     }
  50     if(GTK_IS_CONTAINER(base))
  51     {
  52         for (iter = gtk_container_get_children(GTK_CONTAINER(base));
  53             iter != NULL;
  54             iter = g_list_next(iter))
  55         {
  56             control_window_modify_colors(iter->data);
  57         }
  58     }
  59 }
  60
  61
  62 /**
  63  * Leave fullscreen
  64  */
  65 static void control_window_leave_fullscreen(GtkWidget *button, GtkWidget *parent)
  66 {
  67     gtk_window_unfullscreen(GTK_WINDOW(parent));
  68 }
  69 /**
  70  * Constructor
  71  */
  72 GtkWidget *create_control_window(GtkWidget *parent)
  73 {
  74     gint width, height;
  75     GtkWidget *pp_button, *next_button, *prev_button, *ff_button;
  76     GtkWidget *vol, *progress, *hbox, *play_image;
  77     GdkScreen *screen = gtk_window_get_screen(GTK_WINDOW(parent));
  78     int new_volume;
  79
  80     /* Create window */
  81     GtkWidget *base = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  82     gtk_window_set_type_hint(GTK_WINDOW(base), GDK_WINDOW_TYPE_HINT_DOCK);
  83     gtk_window_set_skip_pager_hint(GTK_WINDOW(base), TRUE);
  84     gtk_window_set_skip_taskbar_hint(GTK_WINDOW(base), TRUE);
  85     gtk_window_set_decorated(GTK_WINDOW(base), FALSE);
  86     gtk_window_set_resizable(GTK_WINDOW(base), FALSE);
  87     gtk_window_set_transient_for(GTK_WINDOW(base), GTK_WINDOW(parent));
  88     gtk_container_set_border_width(GTK_CONTAINER(base), 4);
  89
  90     /* Overwrite background drawing */
  91     gtk_widget_set_app_paintable(base, TRUE);
  92     g_signal_connect(G_OBJECT(base), "expose-event",
  93         G_CALLBACK(expose_window), NULL);
  94
  95     hbox = gtk_hbox_new(FALSE, 6);
  96     gtk_container_add(GTK_CONTAINER(base), hbox);
  97
  98     /* Previous button */
  99     ff_button = gtk_button_new();
 100     gtk_container_add(GTK_CONTAINER(ff_button),
 101         gtk_image_new_from_stock(GTK_STOCK_LEAVE_FULLSCREEN,
 102             GTK_ICON_SIZE_BUTTON));
 103     gtk_button_set_relief(GTK_BUTTON(ff_button), GTK_RELIEF_NONE);
 104     gtk_box_pack_start(GTK_BOX(hbox), ff_button, FALSE, FALSE, 0);
 105     g_signal_connect(G_OBJECT(ff_button), "clicked",
 106         G_CALLBACK(control_window_leave_fullscreen), parent);
 107     /* Volume button */
 108     vol = (GtkWidget *)gmpc_widgets_volume_new();
 109     gtk_box_pack_end(GTK_BOX(hbox), vol, FALSE, FALSE, 0);
 110     new_volume = mpd_status_get_volume(connection);
 111     gmpc_widgets_volume_set_volume_level(GMPC_WIDGETS_VOLUME(vol), new_volume );
 112     g_object_set_data(G_OBJECT(base), "vol", vol);
 113     g_signal_connect(G_OBJECT(vol), "value_changed",
 114         G_CALLBACK(playlist_player_volume_changed), NULL);
 115     /* Progress */
 116     progress = (GtkWidget *)gmpc_progress_new();
 117     gmpc_progress_set_hide_text(GMPC_PROGRESS(progress), FALSE);
 118     gtk_box_pack_start(GTK_BOX(hbox), progress, TRUE, TRUE, 0);
 119     g_object_set_data(G_OBJECT(base), "progress", progress);
 120     g_signal_connect(G_OBJECT(progress), "seek-event", G_CALLBACK(pl3_pb_seek_event), NULL);
 121
 122     /* Previous button */
 123     prev_button = gtk_button_new();
 124     gtk_container_add(GTK_CONTAINER(prev_button),
 125         gtk_image_new_from_stock("gtk-media-previous", GTK_ICON_SIZE_BUTTON));
 126     gtk_activatable_set_related_action(GTK_ACTIVATABLE(prev_button),
 127         GTK_ACTION(gtk_builder_get_object(pl3_xml, "MPDPrevious")));
 128     gtk_button_set_relief(GTK_BUTTON(prev_button), GTK_RELIEF_NONE);
 129     gtk_box_pack_start(GTK_BOX(hbox), prev_button, FALSE, FALSE, 0);
 130
 131     /* Play button */
 132     pp_button = gtk_button_new();
 133     if(mpd_player_get_state(connection) == MPD_PLAYER_PLAY)
 134     {
 135         play_image = gtk_image_new_from_stock("gtk-media-pause", GTK_ICON_SIZE_BUTTON);
 136     }
 137     else
 138     {
 139         play_image = gtk_image_new_from_stock("gtk-media-play", GTK_ICON_SIZE_BUTTON);
 140     }
 141     gtk_container_add(GTK_CONTAINER(pp_button), play_image);
 142     g_object_set_data(G_OBJECT(base), "play_image", play_image);
 143
 144     gtk_activatable_set_related_action(GTK_ACTIVATABLE(pp_button),
 145         GTK_ACTION(gtk_builder_get_object(pl3_xml, "MPDPlayPause")));
 146     gtk_button_set_relief(GTK_BUTTON(pp_button), GTK_RELIEF_NONE);
 147     gtk_box_pack_start(GTK_BOX(hbox), pp_button, FALSE, FALSE, 0);
 148
 149     /* Next */
 150     next_button = gtk_button_new();
 151     gtk_container_add(GTK_CONTAINER(next_button),
 152         gtk_image_new_from_stock("gtk-media-next", GTK_ICON_SIZE_BUTTON));
 153     gtk_activatable_set_related_action(GTK_ACTIVATABLE(next_button),
 154         GTK_ACTION(gtk_builder_get_object(pl3_xml, "MPDNext")));
 155     gtk_button_set_relief(GTK_BUTTON(next_button), GTK_RELIEF_NONE);
 156     gtk_box_pack_start(GTK_BOX(hbox), next_button, FALSE, FALSE, 0);
 157
 158
 159     /* Move window to right location and set size */
 160     gtk_window_get_size(GTK_WINDOW(parent), &width, &height);
 161     gtk_widget_set_size_request(GTK_WIDGET(base), width*0.6, height*0.05);
 162     gtk_window_move(GTK_WINDOW(base), width*0.2, height);
 163
 164     if (gdk_screen_is_composited(screen))
 165     {
 166         GdkColormap *colormap = gdk_screen_get_rgba_colormap(screen);
 167         if (colormap)
 168             gtk_widget_set_colormap(base, colormap);
 169         gtk_window_set_opacity(GTK_WINDOW(base), 0.7);
 170     }
 171     /* Change colors */
 172     control_window_modify_colors(base);
 173     gtk_widget_show_all(base);
 174
 175     return base;
 176 }
 177
 178
 179 void control_window_status_update(MpdObj * mi, ChangedStatusType what, GtkWidget *base)
 180 {
 181     GtkWidget *volume_button, *progress, *play_image;
 182     if(base == NULL) return;
 183     volume_button = g_object_get_data(G_OBJECT(base), "vol");
 184     progress = g_object_get_data(G_OBJECT(base), "progress");
 185     play_image = g_object_get_data(G_OBJECT(base), "play_image");
 186
 187     if (what & MPD_CST_STATE)
 188     {
 189         int state = mpd_player_get_state(mi);
 190         switch (state)
 191         {
 192             case MPD_PLAYER_PLAY:
 193                 gtk_image_set_from_stock(GTK_IMAGE(play_image),
 194                     "gtk-media-pause", GTK_ICON_SIZE_BUTTON);
 195                 break;
 196             case MPD_PLAYER_PAUSE:
 197                 gtk_image_set_from_stock(GTK_IMAGE(play_image),
 198                     "gtk-media-play", GTK_ICON_SIZE_BUTTON);
 199                 break;
 200             default:
 201                 gtk_image_set_from_stock(GTK_IMAGE(play_image),
 202                     "gtk-media-play", GTK_ICON_SIZE_BUTTON);
 203                 /* Make sure it's reset correctly */
 204                 gmpc_progress_set_time(GMPC_PROGRESS(progress), 0, 0);
 205         }
 206     }
 207     if (what & MPD_CST_ELAPSED_TIME)
 208     {
 209         if (mpd_check_connected(connection))
 210         {
 211             int totalTime = mpd_status_get_total_song_time(connection);
 212             int elapsedTime = mpd_status_get_elapsed_song_time(connection);
 213             gmpc_progress_set_time(GMPC_PROGRESS(progress), totalTime, elapsedTime);
 214         } else
 215         {
 216             gmpc_progress_set_time(GMPC_PROGRESS(progress), 0, 0);
 217         }
 218     }
 219     if (what & MPD_CST_VOLUME)
 220     {
 221         int volume = gmpc_widgets_volume_get_volume_level(GMPC_WIDGETS_VOLUME(volume_button));
 222         int new_volume = mpd_status_get_volume(connection);
 223         if (new_volume >= 0 &&
 224             mpd_server_check_command_allowed(connection, "setvol") == MPD_SERVER_COMMAND_ALLOWED
 225             )
 226         {
 227             gtk_widget_set_sensitive(volume_button, TRUE);
 228             /* don't do anything if nothing is changed */
 229             if (new_volume != volume)
 230             {
 231                 gmpc_widgets_volume_set_volume_level(GMPC_WIDGETS_VOLUME(volume_button), new_volume );
 232             }
 233         } else
 234         {
 235             gtk_widget_set_sensitive(volume_button, FALSE);
 236         }
 237     }
 238 }
 239
 240
 241 /**
 242  *  Destructor
 243  */
 244 void control_window_destroy(GtkWidget *cw)
 245 {
 246     if(cw == NULL) return;
 247     gtk_widget_destroy(cw);
 248
 249 }