merged all the button and key handling work - looking good

3 files changed, 740 insertions, 210 deletions

diff --git a/src/indicator-sound.c b/src/indicator-sound.c
index 13f1529..7797f49 100644
--- a/src/indicator-sound.c
+++ b/src/indicator-sound.c
@@ -47,6 +47,7 @@ typedef struct _IndicatorSoundPrivate IndicatorSoundPrivate;
 struct _IndicatorSoundPrivate
 {
 	GtkWidget* volume_widget;
+  GList* transport_widgets_list;
 };
 
 #define INDICATOR_SOUND_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), INDICATOR_SOUND_TYPE, IndicatorSoundPrivate))
@@ -71,6 +72,7 @@ static void				indicator_sound_scroll (IndicatorObject* io, gint delta, Indicato
 //Slider related
 static gboolean new_volume_slider_widget(DbusmenuMenuitem * newitem, DbusmenuMenuitem * parent, DbusmenuClient * client);
 static gboolean key_press_cb(GtkWidget* widget, GdkEventKey* event, gpointer data);
+static gboolean key_release_cb(GtkWidget* widget, GdkEventKey* event, gpointer data);
 static void style_changed_cb(GtkWidget *widget, gpointer user_data);
 
 //player widget realisation methods
@@ -154,6 +156,8 @@ indicator_sound_init (IndicatorSound *self)
 	
 	IndicatorSoundPrivate* priv = INDICATOR_SOUND_GET_PRIVATE(self);
 	priv->volume_widget = NULL;
+  GList* t_list = NULL;
+  priv->transport_widgets_list = t_list;
 
 	g_signal_connect(G_OBJECT(self->service),
                    INDICATOR_SERVICE_MANAGER_SIGNAL_CONNECTION_CHANGE,
@@ -174,6 +178,10 @@ indicator_sound_dispose (GObject *object)
 
   free_the_animation_list();
 
+	IndicatorSoundPrivate* priv = INDICATOR_SOUND_GET_PRIVATE(INDICATOR_SOUND (self));
+
+  g_list_free ( priv->transport_widgets_list );
+
   G_OBJECT_CLASS (indicator_sound_parent_class)->dispose (object);
   return;
 }
@@ -221,7 +229,8 @@ get_menu (IndicatorObject * io)
   dbusmenu_client_add_type_handler(DBUSMENU_CLIENT(client), DBUSMENU_TITLE_MENUITEM_TYPE, new_title_widget);
 	// register Key-press listening on the menu widget as the slider does not allow this.
   g_signal_connect(menu, "key-press-event", G_CALLBACK(key_press_cb), io);
-
+  g_signal_connect(menu, "key-release-event", G_CALLBACK(key_release_cb), io);
+  
 	return GTK_MENU(menu);
 }
 
@@ -241,11 +250,16 @@ new_transport_widget(DbusmenuMenuitem * newitem, DbusmenuMenuitem * parent, Dbus
   //g_debug("indicator-sound: new_transport_bar() called ");
 
   GtkWidget* bar = NULL;
+  IndicatorObject *io = NULL;
 
   g_return_val_if_fail(DBUSMENU_IS_MENUITEM(newitem), FALSE);
   g_return_val_if_fail(DBUSMENU_IS_GTKCLIENT(client), FALSE);
 
   bar = transport_widget_new(newitem);
+	io = g_object_get_data (G_OBJECT (client), "indicator");
+	IndicatorSoundPrivate* priv = INDICATOR_SOUND_GET_PRIVATE(INDICATOR_SOUND (io));
+  priv->transport_widgets_list = g_list_append ( priv->transport_widgets_list, bar );
+
   GtkMenuItem *menu_transport_bar = GTK_MENU_ITEM(bar);
 
 	gtk_widget_show_all(bar);
@@ -706,9 +720,98 @@ key_press_cb(GtkWidget* widget, GdkEventKey* event, gpointer data)
     new_value = CLAMP(new_value, 0, 100);
     if (new_value != current_value && current_state != STATE_MUTED) {
       //g_debug("Attempting to set the range from the key listener to %f", new_value);
-			volume_widget_update(VOLUME_WIDGET(priv->volume_widget), new_value);
+			volume_widget_update(VOLUME_WIDGET(priv->volume_widget), new_value);      
     }
   }
+  else if (IS_TRANSPORT_WIDGET(menuitem) == TRUE) {
+    TransportWidget* transport_widget;
+    GList* elem;
+
+    for ( elem = priv->transport_widgets_list; elem; elem = elem->next ) {
+      transport_widget = TRANSPORT_WIDGET ( elem->data );
+      if ( transport_widget_is_selected( transport_widget ) ) 
+        break;
+    }
+
+    switch (event->keyval) {
+    case GDK_Right:
+      transport_widget_react_to_key_press_event ( transport_widget,
+                                                  TRANSPORT_NEXT );
+      digested = TRUE;         
+      break;        
+    case GDK_Left:
+      transport_widget_react_to_key_press_event ( transport_widget,
+                                                  TRANSPORT_PREVIOUS );
+      digested = TRUE;         
+      break;                  
+    case GDK_KEY_space:
+      transport_widget_react_to_key_press_event ( transport_widget,
+                                                  TRANSPORT_PLAY_PAUSE );        
+      digested = TRUE;         
+      break;
+    case GDK_Up:
+    case GDK_Down:
+      digested = FALSE;     
+      break;
+    default:
+      break;
+    }
+  } 
+  return digested;
+}
+
+
+/**
+key_release_cb:
+**/
+static gboolean
+key_release_cb(GtkWidget* widget, GdkEventKey* event, gpointer data)
+{
+  gboolean digested = FALSE;
+
+	g_return_val_if_fail(IS_INDICATOR_SOUND(data), FALSE);
+
+	IndicatorSound *indicator = INDICATOR_SOUND (data);
+
+	IndicatorSoundPrivate* priv = INDICATOR_SOUND_GET_PRIVATE(indicator);
+
+  GtkWidget *menuitem;
+
+  menuitem = GTK_MENU_SHELL (widget)->active_menu_item;
+  if (IS_TRANSPORT_WIDGET(menuitem) == TRUE) {
+    TransportWidget* transport_widget;
+    GList* elem;
+
+    for(elem = priv->transport_widgets_list; elem; elem = elem->next) {
+      transport_widget = TRANSPORT_WIDGET (elem->data);
+      if ( transport_widget_is_selected( transport_widget ) ) 
+        break;
+    }
+
+    switch (event->keyval) {
+    case GDK_Right:
+      transport_widget_react_to_key_release_event ( transport_widget,
+                                                    TRANSPORT_NEXT );
+      digested = TRUE;
+      break;        
+    case GDK_Left:
+      transport_widget_react_to_key_release_event ( transport_widget,
+                                                    TRANSPORT_PREVIOUS );
+      digested = TRUE;         
+      break;                  
+    case GDK_KEY_space:
+      transport_widget_react_to_key_release_event ( transport_widget,
+                                                    TRANSPORT_PLAY_PAUSE );        
+      digested = TRUE;         
+      break;
+    case GDK_Up:
+    case GDK_Down:
+      digested = FALSE;     
+      break;
+    default:
+      break;
+    }
+  } 
   return digested;
 }
 
@@ -730,7 +833,6 @@ indicator_sound_scroll (IndicatorObject *io, gint delta, IndicatorScrollDirectio
 
 	if (device_available == FALSE || current_state == STATE_MUTED)
     return;
-
 	IndicatorSoundPrivate* priv = INDICATOR_SOUND_GET_PRIVATE(INDICATOR_SOUND (io));
 	
 	GtkWidget* slider_widget = volume_widget_get_ido_slider(VOLUME_WIDGET(priv->volume_widget)); 
diff --git a/src/transport-widget.c b/src/transport-widget.c
index 26b7a98..5be9d4a 100644
--- a/src/transport-widget.c
+++ b/src/transport-widget.c
@@ -33,7 +33,7 @@ Uses code from ctk
 #define Y 7.0f
 #define X 80.0f
 #define INNER_RADIUS 12.5
-#define	MIDDLE_RADIUS 13.5f
+#define	MIDDLE_RADIUS 13.0f
 #define OUTER_RADIUS  14.5f
 #define CIRCLE_RADIUS 21.0f
 #define PREV_WIDTH  25.0f
@@ -59,24 +59,30 @@ Uses code from ctk
 #define PLAY_PADDING 5.0f
 #define INNER_START_SHADE 0.98
 #define INNER_END_SHADE 0.98
-#define MIDDLE_START_SHADE 0.7
-#define MIDDLE_END_SHADE 1.4
-#define OUTER_START_SHADE 0.96
-#define OUTER_END_SHADE 0.96
+#define MIDDLE_START_SHADE 1.0
+#define MIDDLE_END_SHADE 1.0
+#define OUTER_START_SHADE 0.75
+#define OUTER_END_SHADE 1.3
+#define SHADOW_BUTTON_SHADE 0.8
+#define OUTER_PLAY_START_SHADE 0.7
+#define OUTER_PLAY_END_SHADE 1.38
 #define BUTTON_START_SHADE 1.1
 #define BUTTON_END_SHADE 0.9
 #define BUTTON_SHADOW_SHADE 0.8
-#define INNER_COMPRESSED_START_SHADE 0.95
-#define INNER_COMPRESSED_END_SHADE 1.05
+#define INNER_COMPRESSED_START_SHADE 1.0
+#define INNER_COMPRESSED_END_SHADE 1.0
 
 typedef struct _TransportWidgetPrivate TransportWidgetPrivate;
 
 struct _TransportWidgetPrivate
 {
 	TransportWidgetEvent current_command;
+	TransportWidgetEvent key_event;
+	TransportWidgetEvent motion_event;
 	TransportWidgetState current_state;
 	GHashTable* 		 command_coordinates;	
   DbusmenuMenuitem*    twin_item;		
+  gboolean has_focus;
 };
 
 #define TRANSPORT_WIDGET_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TRANSPORT_WIDGET_TYPE, TransportWidgetPrivate))
@@ -98,7 +104,11 @@ static void draw (GtkWidget* button, cairo_t *cr);
 static gboolean transport_widget_button_press_event 	(GtkWidget      *menuitem,
                                                   		GdkEventButton  *event);
 static gboolean transport_widget_button_release_event   (GtkWidget      *menuitem,
-                                                    	GdkEventButton  *event);                                          
+                                                    	GdkEventButton  *event);
+static gboolean transport_widget_motion_notify_event    (GtkWidget      *menuitem,
+                                                    	GdkEventMotion *event);                
+static gboolean transport_widget_leave_notify_event    (GtkWidget      *menuitem,
+                                                    	GdkEventCrossing *event);  
 static void transport_widget_property_update ( DbusmenuMenuitem* item,
                                        	       gchar * property, 
                                        		   GValue * value,
@@ -110,10 +120,15 @@ static void transport_widget_notify ( GObject *item,
                                       gpointer          user_data );
 static TransportWidgetEvent transport_widget_determine_button_event ( TransportWidget* button,
                                                                       GdkEventButton* event);
+static TransportWidgetEvent transport_widget_determine_motion_event ( TransportWidget* button,
+                                                                      GdkEventMotion* event);
 static void transport_widget_react_to_button_release ( TransportWidget* button,
                                                        TransportWidgetEvent command);
 static void transport_widget_toggle_play_pause ( TransportWidget* button,
                                                  TransportWidgetState update);
+static void transport_widget_select (GtkItem* menu, gpointer Userdata);
+static void transport_widget_deselect (GtkItem* menu, gpointer Userdata);
+
 
 /// Init functions //////////////////////////////////////////////////////////
 
@@ -126,7 +141,9 @@ transport_widget_class_init (TransportWidgetClass *klass)
 	g_type_class_add_private (klass, sizeof (TransportWidgetPrivate));
 
   widget_class->button_press_event = transport_widget_button_press_event;
-  widget_class->button_release_event = transport_widget_button_release_event;	
+  widget_class->button_release_event = transport_widget_button_release_event;
+  widget_class->motion_notify_event = transport_widget_motion_notify_event;
+  widget_class->leave_notify_event = transport_widget_leave_notify_event;
  	widget_class->expose_event = transport_widget_expose;
   
 	gobject_class->dispose = transport_widget_dispose;
@@ -139,6 +156,9 @@ transport_widget_init (TransportWidget *self)
 	TransportWidgetPrivate* priv = TRANSPORT_WIDGET_GET_PRIVATE(self);	
 	priv->current_command	= TRANSPORT_NADA;
 	priv->current_state = PAUSE;
+	priv->key_event = TRANSPORT_NADA;
+	priv->motion_event = TRANSPORT_NADA;
+  priv->has_focus = FALSE;
 	priv->command_coordinates =  g_hash_table_new_full(g_direct_hash,
 	                                             				g_direct_equal,
 	                                             				NULL,
@@ -171,12 +191,21 @@ transport_widget_init (TransportWidget *self)
 	g_hash_table_insert(priv->command_coordinates,
                       GINT_TO_POINTER(TRANSPORT_NEXT),
                       next_list);
-	
 	gtk_widget_set_size_request(GTK_WIDGET(self), 200, 43);
   g_signal_connect (G_OBJECT(self),
                     "notify",
                     G_CALLBACK (transport_widget_notify),
-                    NULL);    
+                    NULL);
+  g_signal_connect (GTK_ITEM(self),
+                    "select",
+                    G_CALLBACK (transport_widget_select),
+                    NULL);
+  g_signal_connect (GTK_ITEM(self),
+                    "deselect",
+                    G_CALLBACK (transport_widget_deselect),
+                    NULL);  
+  gtk_widget_realize ( GTK_WIDGET (self) );
+
 }
 
 static void
@@ -209,6 +238,13 @@ transport_widget_expose (GtkWidget *button, GdkEventExpose *event)
 	return FALSE;
 }
 
+gboolean
+transport_widget_is_selected ( TransportWidget* widget )
+{
+	TransportWidgetPrivate* priv = TRANSPORT_WIDGET_GET_PRIVATE(widget);
+  return priv->has_focus;
+}
+
 static void
 transport_widget_toggle_play_pause(TransportWidget* button,
                                    TransportWidgetState update)
@@ -242,6 +278,40 @@ transport_widget_menu_hidden ( GtkWidget        *menu,
 	transport_widget_react_to_button_release(transport, TRANSPORT_NADA); 
 }
 
+static gboolean
+transport_widget_motion_notify_event (GtkWidget *menuitem, 
+                                    	GdkEventMotion *event)
+{
+	g_return_val_if_fail ( IS_TRANSPORT_WIDGET(menuitem), FALSE );
+	TransportWidgetPrivate* priv = TRANSPORT_WIDGET_GET_PRIVATE ( TRANSPORT_WIDGET(menuitem) );
+	TransportWidgetEvent result = transport_widget_determine_motion_event ( TRANSPORT_WIDGET(menuitem),
+                                                                            event);
+
+	priv->motion_event = result;
+    cairo_t *cr;
+    cr = gdk_cairo_create (menuitem->window);
+    draw ( menuitem, cr );
+    cairo_destroy ( cr );
+
+	return TRUE;
+}
+
+static gboolean
+transport_widget_leave_notify_event (GtkWidget *menuitem, 
+                                     GdkEventCrossing *event)
+{
+	g_return_val_if_fail ( IS_TRANSPORT_WIDGET(menuitem), FALSE );
+	TransportWidgetPrivate* priv = TRANSPORT_WIDGET_GET_PRIVATE ( TRANSPORT_WIDGET(menuitem) );
+	
+	priv->motion_event = TRANSPORT_NADA;
+    cairo_t *cr;
+    cr = gdk_cairo_create (menuitem->window);
+    draw ( menuitem, cr );
+    cairo_destroy ( cr );
+
+	return TRUE;
+}
+
 /* keyevents */
 static gboolean
 transport_widget_button_press_event (GtkWidget *menuitem, 
@@ -249,9 +319,9 @@ transport_widget_button_press_event (GtkWidget *menuitem,
 {
 	g_return_val_if_fail ( IS_TRANSPORT_WIDGET(menuitem), FALSE );
 	TransportWidgetPrivate* priv = TRANSPORT_WIDGET_GET_PRIVATE ( TRANSPORT_WIDGET(menuitem) );
-
   TransportWidgetEvent result = transport_widget_determine_button_event ( TRANSPORT_WIDGET(menuitem),
                                                                             event);
+    
 	if(result != TRANSPORT_NADA){
     priv->current_command = result;
     cairo_t *cr;
@@ -270,7 +340,6 @@ transport_widget_button_release_event (GtkWidget *menuitem,
   g_return_val_if_fail(IS_TRANSPORT_WIDGET(menuitem), FALSE);
   TransportWidget* transport = TRANSPORT_WIDGET(menuitem);
   TransportWidgetPrivate * priv = TRANSPORT_WIDGET_GET_PRIVATE ( transport );	
-
   TransportWidgetEvent result = transport_widget_determine_button_event ( transport,
                                                                           event );
   if(result != TRANSPORT_NADA){
@@ -283,12 +352,76 @@ transport_widget_button_release_event (GtkWidget *menuitem,
                                      &value,
                                      0 );
   }
-
   transport_widget_react_to_button_release ( transport,
                                              result );
   return TRUE;
 }
 
+static void 
+transport_widget_select (GtkItem* item, gpointer Userdata)
+{
+  TransportWidget* transport = TRANSPORT_WIDGET(item);
+  TransportWidgetPrivate * priv = TRANSPORT_WIDGET_GET_PRIVATE ( transport );	
+  priv->has_focus = TRUE;
+}
+
+static void 
+transport_widget_deselect (GtkItem* item, gpointer Userdata)
+{
+  TransportWidget* transport = TRANSPORT_WIDGET(item);
+  TransportWidgetPrivate * priv = TRANSPORT_WIDGET_GET_PRIVATE ( transport );	
+  priv->has_focus = FALSE;
+}
+
+void
+transport_widget_react_to_key_press_event ( TransportWidget* transport,
+                                            TransportWidgetEvent transport_event )
+{
+  if(transport_event != TRANSPORT_NADA){
+    TransportWidgetPrivate * priv = TRANSPORT_WIDGET_GET_PRIVATE ( transport );
+    priv->current_command = transport_event;
+    priv->key_event = transport_event;
+/*    printf("transport_widget_react_to_key_press_event: before drawing\n");*/
+    gtk_widget_realize ( GTK_WIDGET(transport) );
+
+    printf ( "transport widget - react to key press event -> is the window null: %i",
+              gtk_widget_get_window (GTK_WIDGET (transport) ) == NULL );
+    cairo_t *cr;
+
+    printf("transport_widget_react_to_key_press_event: before drawing\n");
+    cr = gdk_cairo_create ( GTK_WIDGET(transport)->window );
+    draw ( GTK_WIDGET(transport), cr );
+	  cairo_destroy (cr);
+  } 
+}
+
+void
+transport_widget_react_to_key_release_event ( TransportWidget* transport,
+                                              TransportWidgetEvent transport_event )
+{
+  if(transport_event != TRANSPORT_NADA){
+    TransportWidgetPrivate * priv = TRANSPORT_WIDGET_GET_PRIVATE ( transport );	    
+    GValue value = {0};
+    g_value_init(&value, G_TYPE_INT);
+    //g_debug("TransportWidget::menu_press_event - going to send value %i", (int)result);
+    g_value_set_int(&value, (int)transport_event);	
+    dbusmenu_menuitem_handle_event ( priv->twin_item,
+                                     "Transport state change",
+                                     &value,
+                                     0 );
+  }
+  transport_widget_react_to_button_release ( transport,
+                                             transport_event );  
+}
+
+void
+transport_widget_focus_update ( TransportWidget* transport, gboolean focus )
+{
+  TransportWidgetPrivate * priv = TRANSPORT_WIDGET_GET_PRIVATE ( transport );	    
+  priv->has_focus = focus;  
+  g_debug("new focus update = %i", focus);
+}
+
 static TransportWidgetEvent
 transport_widget_determine_button_event( TransportWidget* button,
                                          GdkEventButton* event )
@@ -312,6 +445,28 @@ transport_widget_determine_button_event( TransportWidget* button,
 	return button_event;  
 }
 
+static TransportWidgetEvent
+transport_widget_determine_motion_event( TransportWidget* button,
+                                         GdkEventMotion* event )
+{
+/*	g_debug("event x coordinate = %f", event->x);*/
+/*	g_debug("event y coordinate = %f", event->y);*/
+	TransportWidgetEvent motion_event = TRANSPORT_NADA;
+	// For now very simple rectangular collision detection
+	if(event->x > 67 && event->x < 112
+	   && event->y > 12 && event->y < 40){
+		motion_event = TRANSPORT_PREVIOUS;
+	}
+	else if(event->x > 111 && event->x < 153
+	   && event->y > 5 && event->y < 47){
+		motion_event = TRANSPORT_PLAY_PAUSE;	
+	}
+	else if(event->x > 152 && event->x < 197
+	   && event->y > 12 && event->y < 40){
+		motion_event = TRANSPORT_NEXT;
+	}	
+	return motion_event;  
+}
 
 static void 
 transport_widget_react_to_button_release ( TransportWidget* button,
@@ -319,21 +474,18 @@ transport_widget_react_to_button_release ( TransportWidget* button,
 {
 	g_return_if_fail(IS_TRANSPORT_WIDGET(button));
 	TransportWidgetPrivate* priv = TRANSPORT_WIDGET_GET_PRIVATE(button);	
-	if(priv->current_command == TRANSPORT_NADA){
-		//g_debug("returning from the playbutton release because my previous command was nada");
-		return;
-	}
-	else if(priv->current_command != TRANSPORT_NADA &&
+	if(priv->current_command != TRANSPORT_NADA &&
 	        command != TRANSPORT_NADA){						
 		priv->current_command = command;
 	}
 	cairo_t *cr;	
 	cr = gdk_cairo_create ( GTK_WIDGET(button)->window );
-	priv->current_command = TRANSPORT_NADA;
 
+	priv->current_command = TRANSPORT_NADA;
+  priv->key_event = TRANSPORT_NADA;
 	draw ( GTK_WIDGET(button), cr );
 	cairo_destroy (cr);
-}    
+}
 
 /// internal helper functions //////////////////////////////////////////////////
 
@@ -364,7 +516,7 @@ draw_gradient (cairo_t* cr,
 		   90.0f * G_PI / 180.0f,
 		   270.0f * G_PI / 180.0f);
 	cairo_close_path (cr);
-
+	
 	pattern = cairo_pattern_create_linear (x, y, x, y + 2.0f * r);
 	cairo_pattern_add_color_stop_rgba (pattern,
 	                                   0.0f,
@@ -512,8 +664,7 @@ _mask_play (cairo_t* cr,
 	     double   x,
 	     double   y,
 	     double   tri_width,
-	     double   tri_height
-	     /*double   tri_offset*/)
+	     double   tri_height)
 {
 	if (!cr)
 		return;
@@ -578,6 +729,28 @@ _finalize (cairo_t*          cr,
 }
 
 static void
+_finalize_repaint (cairo_t*          cr,
+	           cairo_t**         cr_surf,
+	           cairo_surface_t** surf,
+	           double            x,
+	           double            y,
+	           int               repaints)
+{
+	if (!cr || !cr_surf || !surf)
+		return;
+
+	while (repaints > 0)
+	{
+		cairo_set_source_surface (cr, *surf, x, y);
+		cairo_paint (cr);
+		repaints--;
+	}
+
+	cairo_surface_destroy (*surf);
+	cairo_destroy (*cr_surf);
+}
+
+static void
 _color_rgb_to_hls (gdouble *r,
                    gdouble *g,
                    gdouble *b)
@@ -654,7 +827,7 @@ _color_rgb_to_hls (gdouble *r,
 
 static void
 _color_hls_to_rgb (gdouble *h,
-                   gdouble *l,
+                   gdouble *l, 
                    gdouble *s)
 {
 	gdouble hue;
@@ -995,177 +1168,380 @@ draw (GtkWidget* button, cairo_t *cr)
 
 	GtkStyle *style;
 
-	CairoColorRGB bg_normal, fg_normal;
-	CairoColorRGB color_inner[2], color_middle[2], color_outer[2], color_button[3], color_inner_compressed[2];
+	CairoColorRGB bg_color, fg_color, bg_selected, bg_prelight;
+	CairoColorRGB color_middle[2], color_middle_prelight[2], color_outer[2], color_outer_prelight[2],
+	              color_play_outer[2], color_play_outer_prelight[2],
+	              color_button[4], color_button_shadow, color_inner[2], color_inner_compressed[2];
 
 	style = gtk_widget_get_style (button);
 
-	bg_normal.r = style->bg[0].red/65535.0;
-	bg_normal.g = style->bg[0].green/65535.0;
-	bg_normal.b = style->bg[0].blue/65535.0;
-
-	fg_normal.r = style->fg[0].red/65535.0;
-	fg_normal.g = style->fg[0].green/65535.0;
-	fg_normal.b = style->fg[0].blue/65535.0;
-
-	_color_shade (&bg_normal, INNER_START_SHADE, &color_inner[0]);
-	_color_shade (&bg_normal, INNER_END_SHADE, &color_inner[1]);
-	_color_shade (&bg_normal, MIDDLE_START_SHADE, &color_middle[0]);
-	_color_shade (&bg_normal, MIDDLE_END_SHADE, &color_middle[1]);
-	_color_shade (&bg_normal, OUTER_START_SHADE, &color_outer[0]);
-	_color_shade (&bg_normal, OUTER_END_SHADE, &color_outer[1]);
-	_color_shade (&fg_normal, BUTTON_START_SHADE, &color_button[0]);
-	_color_shade (&fg_normal, BUTTON_END_SHADE, &color_button[1]);
-	_color_shade (&bg_normal, BUTTON_SHADOW_SHADE, &color_button[2]);
-	_color_shade (&bg_normal, INNER_COMPRESSED_START_SHADE, &color_inner_compressed[0]);
-	_color_shade (&bg_normal, INNER_COMPRESSED_END_SHADE, &color_inner_compressed[1]);
-
-	double MIDDLE_END[] = {color_middle[0].r, color_middle[0].g, color_middle[0].b, 1.0f};
+	bg_color.r = style->bg[0].red/65535.0;
+	bg_color.g = style->bg[0].green/65535.0;
+	bg_color.b = style->bg[0].blue/65535.0;
+
+	bg_prelight.r = style->bg[GTK_STATE_PRELIGHT].red/65535.0;
+	bg_prelight.g = style->bg[GTK_STATE_PRELIGHT].green/65535.0;
+	bg_prelight.b = style->bg[GTK_STATE_PRELIGHT].blue/65535.0;
+
+	bg_selected.r = style->bg[GTK_STATE_SELECTED].red/65535.0;
+	bg_selected.g = style->bg[GTK_STATE_SELECTED].green/65535.0;
+	bg_selected.b = style->bg[GTK_STATE_SELECTED].blue/65535.0;
+
+	fg_color.r = style->fg[0].red/65535.0;
+	fg_color.g = style->fg[0].green/65535.0;
+	fg_color.b = style->fg[0].blue/65535.0;
+
+	_color_shade (&bg_color,    MIDDLE_START_SHADE, &color_middle[0]);
+	_color_shade (&bg_color,    MIDDLE_END_SHADE, &color_middle[1]);
+	_color_shade (&bg_prelight, MIDDLE_START_SHADE, &color_middle_prelight[0]);
+	_color_shade (&bg_prelight, MIDDLE_END_SHADE, &color_middle_prelight[1]);
+	_color_shade (&bg_color,    OUTER_START_SHADE, &color_outer[0]);
+	_color_shade (&bg_color,    OUTER_END_SHADE, &color_outer[1]);
+	_color_shade (&bg_prelight, OUTER_START_SHADE, &color_outer_prelight[0]);
+	_color_shade (&bg_prelight, OUTER_END_SHADE, &color_outer_prelight[1]);
+	_color_shade (&bg_color,    OUTER_PLAY_START_SHADE, &color_play_outer[0]);
+	_color_shade (&bg_color,    OUTER_PLAY_END_SHADE, &color_play_outer[1]);
+	_color_shade (&bg_prelight, OUTER_PLAY_START_SHADE, &color_play_outer_prelight[0]);
+	_color_shade (&bg_prelight, OUTER_PLAY_END_SHADE, &color_play_outer_prelight[1]);
+	_color_shade (&bg_color, INNER_START_SHADE, &color_inner[0]);
+	_color_shade (&bg_color, INNER_END_SHADE, &color_inner[1]);
+	_color_shade (&fg_color, BUTTON_START_SHADE, &color_button[0]);
+	_color_shade (&fg_color, BUTTON_END_SHADE, &color_button[1]);
+	_color_shade (&bg_color, BUTTON_SHADOW_SHADE, &color_button[2]);
+	_color_shade (&bg_color, SHADOW_BUTTON_SHADE, &color_button_shadow);
+	_color_shade (&bg_selected, 1.0, &color_button[3]);
+	_color_shade (&bg_color, INNER_COMPRESSED_START_SHADE, &color_inner_compressed[0]);
+	_color_shade (&bg_color, INNER_COMPRESSED_END_SHADE, &color_inner_compressed[1]);
+
+	double MIDDLE_END[]   = {color_middle[0].r, color_middle[0].g, color_middle[0].b, 1.0f};
 	double MIDDLE_START[] = {color_middle[1].r, color_middle[1].g, color_middle[1].b, 1.0f};
-	double OUTER_END[] = {color_outer[0].r, color_outer[0].g, color_outer[0].b, 1.0f};
+	double MIDDLE_END_PRELIGHT[]   = {color_middle_prelight[0].r, color_middle_prelight[0].g, color_middle_prelight[0].b, 1.0f};
+	double MIDDLE_START_PRELIGHT[] = {color_middle_prelight[1].r, color_middle_prelight[1].g, color_middle_prelight[1].b, 1.0f};
+	double OUTER_END[]   = {color_outer[0].r, color_outer[0].g, color_outer[0].b, 1.0f};
 	double OUTER_START[] = {color_outer[1].r, color_outer[1].g, color_outer[1].b, 1.0f};
+	double OUTER_END_PRELIGHT[]   = {color_outer_prelight[0].r, color_outer_prelight[0].g, color_outer_prelight[0].b, 1.0f};
+	double OUTER_START_PRELIGHT[] = {color_outer_prelight[1].r, color_outer_prelight[1].g, color_outer_prelight[1].b, 1.0f};
+	double SHADOW_BUTTON[] = {color_button_shadow.r, color_button_shadow.g, color_button_shadow.b, 0.3f};
+	double OUTER_PLAY_END[] = {color_play_outer[0].r, color_play_outer[0].g, color_play_outer[0].b, 1.0f};
+	double OUTER_PLAY_START[] = {color_play_outer[1].r, color_play_outer[1].g, color_play_outer[1].b, 1.0f};
+	double OUTER_PLAY_END_PRELIGHT[] = {color_play_outer_prelight[0].r, color_play_outer_prelight[0].g, color_play_outer_prelight[0].b, 1.0f};
+	double OUTER_PLAY_START_PRELIGHT[] = {color_play_outer_prelight[1].r, color_play_outer_prelight[1].g, color_play_outer_prelight[1].b, 1.0f};
 	double BUTTON_END[] = {color_button[0].r, color_button[0].g, color_button[0].b, 1.0f};
 	double BUTTON_START[] = {color_button[1].r, color_button[1].g, color_button[1].b, 1.0f};
 	double BUTTON_SHADOW[] = {color_button[2].r, color_button[2].g, color_button[2].b, 0.75f};
+	double BUTTON_SHADOW_FOCUS[] = {color_button[3].r, color_button[3].g, color_button[3].b, 1.0f};
 	double INNER_COMPRESSED_END[] = {color_inner_compressed[1].r, color_inner_compressed[1].g, color_inner_compressed[1].b, 1.0f};
 	double INNER_COMPRESSED_START[] = {color_inner_compressed[0].r, color_inner_compressed[0].g, color_inner_compressed[0].b, 1.0f};  
- 
-	// prev/next-background
+
+
 	draw_gradient (cr,
-		 X,
-		 Y,
-		 RECT_WIDTH,
-		 OUTER_RADIUS,
-		 OUTER_START,
-		 OUTER_END);
+	               X,
+	               Y,
+	               RECT_WIDTH,
+	               OUTER_RADIUS,
+	               OUTER_START,
+	               OUTER_END);
+
 	draw_gradient (cr,
-		 X,
-		 Y + 1,
-		 RECT_WIDTH - 2,
-		 MIDDLE_RADIUS,
-		 MIDDLE_START,
-		 MIDDLE_END);
+	               X,
+	               Y + 1,
+	               RECT_WIDTH - 2,
+	               MIDDLE_RADIUS,
+	               MIDDLE_START,
+	               MIDDLE_END);
+
 	draw_gradient (cr,
-               X,
-               Y + 2,
-               RECT_WIDTH - 4,
-               MIDDLE_RADIUS,
-               MIDDLE_START,
-               MIDDLE_END);
-
-	if(priv->current_command == TRANSPORT_PREVIOUS){
+	               X,
+	               Y + 2,
+	               RECT_WIDTH - 4,
+	               MIDDLE_RADIUS,
+	               MIDDLE_START,
+	               MIDDLE_END);
+
+	//prev/next button
+	if(priv->current_command == TRANSPORT_PREVIOUS)
+	{
+		draw_gradient (cr,
+		               X,
+		               Y,
+		               RECT_WIDTH/2,
+		               OUTER_RADIUS,
+		               OUTER_END,
+		               OUTER_START);
+
+		draw_gradient (cr,
+		               X,
+		               Y + 1,
+		               RECT_WIDTH/2,
+		               MIDDLE_RADIUS,
+		               INNER_COMPRESSED_START,
+		               INNER_COMPRESSED_END);
+
 		draw_gradient (cr,
 		               X,
 		               Y + 2,
 		               RECT_WIDTH/2,
-		               INNER_RADIUS,
+		               MIDDLE_RADIUS,
 		               INNER_COMPRESSED_START,
 		               INNER_COMPRESSED_END);
-	}	
-	else if(priv->current_command == TRANSPORT_NEXT){
+	}
+	else if(priv->current_command == TRANSPORT_NEXT)
+	{
+		draw_gradient (cr,
+		               RECT_WIDTH / 2 + X,
+		               Y,
+		               RECT_WIDTH/2,
+		               OUTER_RADIUS,
+		               OUTER_END,
+		               OUTER_START);
+	
+		draw_gradient (cr,
+		               RECT_WIDTH / 2 + X,
+		               Y + 1,
+		               (RECT_WIDTH - 7)/2,
+		               MIDDLE_RADIUS,
+		               INNER_COMPRESSED_START,
+		               INNER_COMPRESSED_END);
+
 		draw_gradient (cr,
 		               RECT_WIDTH / 2 + X,
 		               Y + 2,
 		               (RECT_WIDTH - 7)/2,
-		               INNER_RADIUS,
+		               MIDDLE_RADIUS,
 		               INNER_COMPRESSED_START,
-		               INNER_COMPRESSED_END);		
+		               INNER_COMPRESSED_END);
 	}
+	else if (priv->motion_event == TRANSPORT_PREVIOUS)
+	{
+		draw_gradient (cr,
+		               X,
+		               Y,
+		               RECT_WIDTH/2,
+		               OUTER_RADIUS,
+		               OUTER_START_PRELIGHT,
+		               OUTER_END_PRELIGHT);
+	
+		draw_gradient (cr,
+		               X,
+		               Y + 1,
+		               RECT_WIDTH/2,
+		               MIDDLE_RADIUS,
+		               MIDDLE_START_PRELIGHT,
+		               MIDDLE_END_PRELIGHT);
 
-	// play/pause-background
-	draw_circle (cr,
-			X + RECT_WIDTH / 2.0f - 2.0f * OUTER_RADIUS - 5.5f,
-			Y - ((CIRCLE_RADIUS - OUTER_RADIUS)),
-			CIRCLE_RADIUS,
-			OUTER_START,
-			OUTER_END);
-	draw_circle (cr,
-	               X + RECT_WIDTH / 2.0f - 2.0f * OUTER_RADIUS - 5.5f + 0.5f,
-	               Y - ((CIRCLE_RADIUS - OUTER_RADIUS)) + 0.5f,
-	               CIRCLE_RADIUS - 0.75f,
-	               MIDDLE_START,
-	               MIDDLE_END);
+		draw_gradient (cr,
+		               X,
+		               Y + 2,
+		               RECT_WIDTH/2,
+		               MIDDLE_RADIUS,
+		               MIDDLE_START_PRELIGHT,
+		               MIDDLE_END_PRELIGHT);
+	}
+	else if (priv->motion_event == TRANSPORT_NEXT)
+	{
+		draw_gradient (cr,
+		               RECT_WIDTH / 2 + X,
+		               Y,
+		               RECT_WIDTH/2,
+		               OUTER_RADIUS,
+		               OUTER_START_PRELIGHT,
+		               OUTER_END_PRELIGHT);
 
-	if(priv->current_command == TRANSPORT_PLAY_PAUSE){
-	    draw_circle (cr,
-			 X + RECT_WIDTH / 2.0f - 2.0f * OUTER_RADIUS - 5.5f + 1.5f,
-			 Y - ((CIRCLE_RADIUS - OUTER_RADIUS)) + 1.5f,
-			 CIRCLE_RADIUS - 1.5f,
-		     		 INNER_COMPRESSED_START,
-			 INNER_COMPRESSED_END);
+		draw_gradient (cr,
+		               RECT_WIDTH / 2 + X,
+		               Y + 1,
+		               (RECT_WIDTH - 7)/2,
+		               MIDDLE_RADIUS,
+		               MIDDLE_START_PRELIGHT,
+		               MIDDLE_END_PRELIGHT);
+
+		draw_gradient (cr,
+		               RECT_WIDTH / 2 + X,
+		               Y + 2,
+		               (RECT_WIDTH - 7)/2,
+		               MIDDLE_RADIUS,
+		               MIDDLE_START_PRELIGHT,
+		               MIDDLE_END_PRELIGHT);
 	}
-	else{        
+
+	// play/pause shadow
+	if(priv->current_command != TRANSPORT_PLAY_PAUSE)
+	{
+		cairo_save (cr);
+		cairo_rectangle (cr, X, Y, RECT_WIDTH, MIDDLE_RADIUS*2);
+		cairo_clip (cr);
+
+		draw_circle (cr,
+		             X + RECT_WIDTH / 2.0f - 2.0f * OUTER_RADIUS - 5.5f - 1.0f,
+		             Y - ((CIRCLE_RADIUS - OUTER_RADIUS)) - 1.0f,
+		             CIRCLE_RADIUS + 1.0f,
+		             SHADOW_BUTTON,
+		             SHADOW_BUTTON);
+
+		cairo_restore (cr);
+	}
+
+	// play/pause button
+	if(priv->current_command == TRANSPORT_PLAY_PAUSE)
+	{
+		draw_circle (cr,
+		             X + RECT_WIDTH / 2.0f - 2.0f * OUTER_RADIUS - 5.5f,
+		             Y - ((CIRCLE_RADIUS - OUTER_RADIUS)) ,
+		             CIRCLE_RADIUS,
+		             OUTER_PLAY_END,
+		             OUTER_PLAY_START);
+
 		draw_circle (cr,
-               X + RECT_WIDTH / 2.0f - 2.0f * OUTER_RADIUS - 5.5f + 1.5f,
-               Y - ((CIRCLE_RADIUS - OUTER_RADIUS)) + 1.5f,
-               CIRCLE_RADIUS - 1.5f,
-               MIDDLE_START,
-               MIDDLE_END);
-	}					
+		             X + RECT_WIDTH / 2.0f - 2.0f * OUTER_RADIUS - 5.5f + 1.25f,
+		             Y - ((CIRCLE_RADIUS - OUTER_RADIUS)) + 1.25f,
+		             CIRCLE_RADIUS - 1.25,
+		             INNER_COMPRESSED_START,
+		             INNER_COMPRESSED_END);
+	}
+	else if (priv->motion_event == TRANSPORT_PLAY_PAUSE)
+	{
+		/* this subtle offset is to fix alpha borders, should be removed once this draw routine will be refactored */
+		draw_circle (cr,
+		             X + RECT_WIDTH / 2.0f - 2.0f * OUTER_RADIUS - 5.5f + 0.1,
+		             Y - ((CIRCLE_RADIUS - OUTER_RADIUS)) + 0.1,
+		             CIRCLE_RADIUS - 0.1,
+		             OUTER_PLAY_START_PRELIGHT,
+		             OUTER_PLAY_END_PRELIGHT);
+
+		draw_circle (cr,
+		             X + RECT_WIDTH / 2.0f - 2.0f * OUTER_RADIUS - 5.5f + 1.25f,
+		             Y - ((CIRCLE_RADIUS - OUTER_RADIUS)) + 1.25f,
+		             CIRCLE_RADIUS - 1.25,
+		             MIDDLE_START_PRELIGHT,
+		             MIDDLE_END_PRELIGHT);
+	}
+	else
+	{
+		draw_circle (cr,
+		             X + RECT_WIDTH / 2.0f - 2.0f * OUTER_RADIUS - 5.5f,
+		             Y - ((CIRCLE_RADIUS - OUTER_RADIUS)),
+		             CIRCLE_RADIUS,
+		             OUTER_PLAY_START,
+		             OUTER_PLAY_END);
+
+		draw_circle (cr,
+		             X + RECT_WIDTH / 2.0f - 2.0f * OUTER_RADIUS - 5.5f + 1.25f,
+		             Y - ((CIRCLE_RADIUS - OUTER_RADIUS)) + 1.25f,
+		             CIRCLE_RADIUS - 1.25,
+		             MIDDLE_START,
+		             MIDDLE_END);
+	}
+
 	// draw previous-button drop-shadow
-	_setup (&cr_surf, &surf, PREV_WIDTH, PREV_HEIGHT);
-	_mask_prev (cr_surf,
-		    (PREV_WIDTH - (2.0f * TRI_WIDTH - TRI_OFFSET)) / 2.0f,
-		    (PREV_HEIGHT - TRI_HEIGHT) / 2.0f,
-		    TRI_WIDTH,
-		    TRI_HEIGHT,
-		    TRI_OFFSET);
-	_fill (cr_surf,
-               (PREV_WIDTH - (2.0f * TRI_WIDTH - TRI_OFFSET)) / 2.0f,
-               (PREV_HEIGHT - TRI_HEIGHT) / 2.0f,
-               (PREV_WIDTH - (2.0f * TRI_WIDTH - TRI_OFFSET)) / 2.0f,
-	       (double) TRI_HEIGHT,
-	       BUTTON_SHADOW,
-	       BUTTON_SHADOW,
-	       FALSE);
-	_surface_blur (surf, 1);
-	_finalize (cr, &cr_surf, &surf, PREV_X, PREV_Y + 1.0f);
+	if (priv->has_focus && priv->key_event == TRANSPORT_PREVIOUS)
+	{
+		_setup (&cr_surf, &surf, PREV_WIDTH+6, PREV_HEIGHT+6);
+		_mask_prev (cr_surf,
+		            (PREV_WIDTH - (2.0f * TRI_WIDTH - TRI_OFFSET)) / 2.0f,
+		            (PREV_HEIGHT - TRI_HEIGHT) / 2.0f,
+		            TRI_WIDTH,
+		            TRI_HEIGHT,
+		            TRI_OFFSET);
+		_fill (cr_surf,
+		       (PREV_WIDTH - (2.0f * TRI_WIDTH - TRI_OFFSET)) / 2.0f,
+		       (PREV_HEIGHT - TRI_HEIGHT) / 2.0f,
+		       (PREV_WIDTH - (2.0f * TRI_WIDTH - TRI_OFFSET)) / 2.0f,
+		       (double) TRI_HEIGHT,
+		       BUTTON_SHADOW_FOCUS,
+		       BUTTON_SHADOW_FOCUS,
+		       FALSE);
+		_surface_blur (surf, 3);
+		_finalize_repaint (cr, &cr_surf, &surf, PREV_X, PREV_Y + 0.5f, 3);
+	}
+	else
+	{
+		_setup (&cr_surf, &surf, PREV_WIDTH, PREV_HEIGHT);
+		_mask_prev (cr_surf,
+		            (PREV_WIDTH - (2.0f * TRI_WIDTH - TRI_OFFSET)) / 2.0f,
+		            (PREV_HEIGHT - TRI_HEIGHT) / 2.0f,
+		            TRI_WIDTH,
+		            TRI_HEIGHT,
+		            TRI_OFFSET);
+		_fill (cr_surf,
+		       (PREV_WIDTH - (2.0f * TRI_WIDTH - TRI_OFFSET)) / 2.0f,
+		       (PREV_HEIGHT - TRI_HEIGHT) / 2.0f,
+		       (PREV_WIDTH - (2.0f * TRI_WIDTH - TRI_OFFSET)) / 2.0f,
+		       (double) TRI_HEIGHT,
+		       BUTTON_SHADOW,
+		       BUTTON_SHADOW,
+		       FALSE);
+		_surface_blur (surf, 1);
+		_finalize (cr, &cr_surf, &surf, PREV_X, PREV_Y + 1.0f);
+	}
 
 	// draw previous-button
 	_setup (&cr_surf, &surf, PREV_WIDTH, PREV_HEIGHT);
 	_mask_prev (cr_surf,
-		    (PREV_WIDTH - (2.0f * TRI_WIDTH - TRI_OFFSET)) / 2.0f,
-		    (PREV_HEIGHT - TRI_HEIGHT) / 2.0f,
-		    TRI_WIDTH,
-		    TRI_HEIGHT,
-		    TRI_OFFSET);
+	            (PREV_WIDTH - (2.0f * TRI_WIDTH - TRI_OFFSET)) / 2.0f,
+	            (PREV_HEIGHT - TRI_HEIGHT) / 2.0f,
+	            TRI_WIDTH,
+	            TRI_HEIGHT,
+	            TRI_OFFSET);
 	_fill (cr_surf,
-		     (PREV_WIDTH - (2.0f * TRI_WIDTH - TRI_OFFSET)) / 2.0f,
-		     (PREV_HEIGHT - TRI_HEIGHT) / 2.0f,
-		     (PREV_WIDTH - (2.0f * TRI_WIDTH - TRI_OFFSET)) / 2.0f,
-		     (double) TRI_HEIGHT,
-		     BUTTON_START,
-		     BUTTON_END,
-		     FALSE);		
+	     (PREV_WIDTH - (2.0f * TRI_WIDTH - TRI_OFFSET)) / 2.0f,
+	     (PREV_HEIGHT - TRI_HEIGHT) / 2.0f,
+	     (PREV_WIDTH - (2.0f * TRI_WIDTH - TRI_OFFSET)) / 2.0f,
+	     (double) TRI_HEIGHT,
+	     BUTTON_START,
+	     BUTTON_END,
+	     FALSE);
 	_finalize (cr, &cr_surf, &surf, PREV_X, PREV_Y);
 
 	// draw next-button drop-shadow
-	_setup (&cr_surf, &surf, NEXT_WIDTH, NEXT_HEIGHT);
-	_mask_next (cr_surf,
-		    (NEXT_WIDTH - (2.0f * TRI_WIDTH - TRI_OFFSET)) / 2.0f,
-		    (NEXT_HEIGHT - TRI_HEIGHT) / 2.0f,
-		    TRI_WIDTH,
-		    TRI_HEIGHT,
-		    TRI_OFFSET);
-	_fill (cr_surf,
-	       (NEXT_WIDTH - (2.0f * TRI_WIDTH - TRI_OFFSET)) / 2.0f,
-	       (NEXT_HEIGHT - TRI_HEIGHT) / 2.0f,
-	       (NEXT_WIDTH - (2.0f * TRI_WIDTH - TRI_OFFSET)) / 2.0f,
-	       (double) TRI_HEIGHT,
-	       BUTTON_SHADOW,
-	       BUTTON_SHADOW,
-	       FALSE);
-	_surface_blur (surf, 1);
-	_finalize (cr, &cr_surf, &surf, NEXT_X, NEXT_Y + 1.0f);
+	if (priv->has_focus && priv->key_event == TRANSPORT_NEXT)
+	{
+		_setup (&cr_surf, &surf, NEXT_WIDTH+6, NEXT_HEIGHT+6);
+		_mask_next (cr_surf,
+		            (NEXT_WIDTH - (2.0f * TRI_WIDTH - TRI_OFFSET)) / 2.0f,
+		            (NEXT_HEIGHT - TRI_HEIGHT) / 2.0f,
+		            TRI_WIDTH,
+		            TRI_HEIGHT,
+		            TRI_OFFSET);
+		_fill (cr_surf,
+		       (NEXT_WIDTH - (2.0f * TRI_WIDTH - TRI_OFFSET)) / 2.0f,
+		       (NEXT_HEIGHT - TRI_HEIGHT) / 2.0f,
+		       (NEXT_WIDTH - (2.0f * TRI_WIDTH - TRI_OFFSET)) / 2.0f,
+		       (double) TRI_HEIGHT,
+		       BUTTON_SHADOW_FOCUS,
+		       BUTTON_SHADOW_FOCUS,
+		       FALSE);
+		_surface_blur (surf, 3); 
+		_finalize_repaint (cr, &cr_surf, &surf, NEXT_X, NEXT_Y + 0.5f, 3);
+	}
+	else
+	{
+		_setup (&cr_surf, &surf, NEXT_WIDTH, NEXT_HEIGHT);
+		_mask_next (cr_surf,
+		            (NEXT_WIDTH - (2.0f * TRI_WIDTH - TRI_OFFSET)) / 2.0f,
+		            (NEXT_HEIGHT - TRI_HEIGHT) / 2.0f,
+		            TRI_WIDTH,
+		            TRI_HEIGHT,
+		            TRI_OFFSET);
+		_fill (cr_surf,
+		       (NEXT_WIDTH - (2.0f * TRI_WIDTH - TRI_OFFSET)) / 2.0f,
+		       (NEXT_HEIGHT - TRI_HEIGHT) / 2.0f,
+		       (NEXT_WIDTH - (2.0f * TRI_WIDTH - TRI_OFFSET)) / 2.0f,
+		       (double) TRI_HEIGHT,
+		       BUTTON_SHADOW,
+		       BUTTON_SHADOW,
+		       FALSE);
+		_surface_blur (surf, 1); 
+		_finalize (cr, &cr_surf, &surf, NEXT_X, NEXT_Y + 1.0f);
+	}
 
 	// draw next-button
 	_setup (&cr_surf, &surf, NEXT_WIDTH, NEXT_HEIGHT);
 	_mask_next (cr_surf,
-		    (NEXT_WIDTH - (2.0f * TRI_WIDTH - TRI_OFFSET)) / 2.0f,
-		    (NEXT_HEIGHT - TRI_HEIGHT) / 2.0f,
-		    TRI_WIDTH,
-		    TRI_HEIGHT,
-		    TRI_OFFSET);
+	            (NEXT_WIDTH - (2.0f * TRI_WIDTH - TRI_OFFSET)) / 2.0f,
+	            (NEXT_HEIGHT - TRI_HEIGHT) / 2.0f,
+	            TRI_WIDTH,
+	            TRI_HEIGHT,
+	            TRI_OFFSET);
 	_fill (cr_surf,
 	       (NEXT_WIDTH - (2.0f * TRI_WIDTH - TRI_OFFSET)) / 2.0f,
 	       (NEXT_HEIGHT - TRI_HEIGHT) / 2.0f,
@@ -1177,60 +1553,108 @@ draw (GtkWidget* button, cairo_t *cr)
 	_finalize (cr, &cr_surf, &surf, NEXT_X, NEXT_Y);
 
 	// draw pause-button drop-shadow
-	if(priv->current_state == PLAY){
-		_setup (&cr_surf, &surf, PAUSE_WIDTH, PAUSE_HEIGHT);
-		_mask_pause (cr_surf,
-				   (PAUSE_WIDTH - (2.0f * BAR_WIDTH + BAR_OFFSET)) / 2.0f,
-				   (PAUSE_HEIGHT - BAR_HEIGHT) / 2.0f,
-				   BAR_WIDTH,
-				   BAR_HEIGHT - 2.0f * BAR_WIDTH,
-				   BAR_OFFSET);
-		_fill (cr_surf,
-			     (PAUSE_WIDTH - (2.0f * BAR_WIDTH + BAR_OFFSET)) / 2.0f,
-			     (PAUSE_HEIGHT - BAR_HEIGHT) / 2.0f,
-			     (PAUSE_WIDTH - (2.0f * BAR_WIDTH + BAR_OFFSET)) / 2.0f,
-			     (double) BAR_HEIGHT,
-			     BUTTON_SHADOW,
-			     BUTTON_SHADOW,
-			     TRUE);
-		_surface_blur (surf, 1);
-		_finalize (cr, &cr_surf, &surf, PAUSE_X, PAUSE_Y + 1.0f);
+	if(priv->current_state == PLAY)
+	{
+		if (priv->has_focus && (priv->key_event == TRANSPORT_NADA || priv->key_event == TRANSPORT_PLAY_PAUSE))
+		{
+			_setup (&cr_surf, &surf, PAUSE_WIDTH+6, PAUSE_HEIGHT+6);
+			_mask_pause (cr_surf,
+			             (PAUSE_WIDTH - (2.0f * BAR_WIDTH + BAR_OFFSET)) / 2.0f,
+			             (PAUSE_HEIGHT - BAR_HEIGHT) / 2.0f,
+			             BAR_WIDTH,
+			             BAR_HEIGHT - 2.0f * BAR_WIDTH,
+			             BAR_OFFSET);
+			_fill (cr_surf,
+			       (PAUSE_WIDTH - (2.0f * BAR_WIDTH + BAR_OFFSET)) / 2.0f,
+			       (PAUSE_HEIGHT - BAR_HEIGHT) / 2.0f,
+			       (PAUSE_WIDTH - (2.0f * BAR_WIDTH + BAR_OFFSET)) / 2.0f,
+			       (double) BAR_HEIGHT,
+			       BUTTON_SHADOW_FOCUS,
+			       BUTTON_SHADOW_FOCUS,
+			       TRUE);
+			_surface_blur (surf, 3);
+			_finalize_repaint (cr, &cr_surf, &surf, PAUSE_X, PAUSE_Y + 0.5f, 3);
+		}
+		else
+		{
+			_setup (&cr_surf, &surf, PAUSE_WIDTH, PAUSE_HEIGHT);
+			_mask_pause (cr_surf,
+			             (PAUSE_WIDTH - (2.0f * BAR_WIDTH + BAR_OFFSET)) / 2.0f,
+			             (PAUSE_HEIGHT - BAR_HEIGHT) / 2.0f,
+			             BAR_WIDTH,
+			             BAR_HEIGHT - 2.0f * BAR_WIDTH,
+			             BAR_OFFSET);
+			_fill (cr_surf,
+			       (PAUSE_WIDTH - (2.0f * BAR_WIDTH + BAR_OFFSET)) / 2.0f,
+			       (PAUSE_HEIGHT - BAR_HEIGHT) / 2.0f,
+			       (PAUSE_WIDTH - (2.0f * BAR_WIDTH + BAR_OFFSET)) / 2.0f,
+			       (double) BAR_HEIGHT,
+			       BUTTON_SHADOW,
+			       BUTTON_SHADOW,
+			       TRUE);
+			_surface_blur (surf, 1);
+			_finalize (cr, &cr_surf, &surf, PAUSE_X, PAUSE_Y + 1.0f);
+		}
 
 		// draw pause-button
 		_setup (&cr_surf, &surf, PAUSE_WIDTH, PAUSE_HEIGHT);
 		_mask_pause (cr_surf,
-				   (PAUSE_WIDTH - (2.0f * BAR_WIDTH + BAR_OFFSET)) / 2.0f,
-				   (PAUSE_HEIGHT - BAR_HEIGHT) / 2.0f,
-				   BAR_WIDTH,
-				   BAR_HEIGHT - 2.0f * BAR_WIDTH,
-				   BAR_OFFSET);
+		             (PAUSE_WIDTH - (2.0f * BAR_WIDTH + BAR_OFFSET)) / 2.0f,
+		             (PAUSE_HEIGHT - BAR_HEIGHT) / 2.0f,
+		             BAR_WIDTH,
+		             BAR_HEIGHT - 2.0f * BAR_WIDTH,
+		             BAR_OFFSET);
 		_fill (cr_surf,
-			     (PAUSE_WIDTH - (2.0f * BAR_WIDTH + BAR_OFFSET)) / 2.0f,
-			     (PAUSE_HEIGHT - BAR_HEIGHT) / 2.0f,
-			     (PAUSE_WIDTH - (2.0f * BAR_WIDTH + BAR_OFFSET)) / 2.0f,
-			     (double) BAR_HEIGHT,
-			     BUTTON_START,
-			     BUTTON_END,
-			     TRUE);
+		       (PAUSE_WIDTH - (2.0f * BAR_WIDTH + BAR_OFFSET)) / 2.0f,
+		       (PAUSE_HEIGHT - BAR_HEIGHT) / 2.0f,
+		       (PAUSE_WIDTH - (2.0f * BAR_WIDTH + BAR_OFFSET)) / 2.0f,
+		       (double) BAR_HEIGHT,
+		       BUTTON_START,
+		       BUTTON_END,
+		       TRUE);
 		_finalize (cr, &cr_surf, &surf, PAUSE_X, PAUSE_Y);
 	}
-	else if(priv->current_state == PAUSE){
-		_setup (&cr_surf, &surf, PLAY_WIDTH, PLAY_HEIGHT);
-		_mask_play (cr_surf,
-		            PLAY_PADDING,
-		            PLAY_PADDING,
-		            PLAY_WIDTH - (2*PLAY_PADDING),
-		            PLAY_HEIGHT - (2*PLAY_PADDING));		            
-		_fill (cr_surf,
-		       PLAY_PADDING,
-		       PLAY_PADDING,
-		       PLAY_WIDTH - (2*PLAY_PADDING),
-		       PLAY_HEIGHT - (2*PLAY_PADDING),
-			     BUTTON_SHADOW,
-			     BUTTON_SHADOW,
-			     FALSE);
-		_surface_blur (surf, 1);
-		_finalize (cr, &cr_surf, &surf, PAUSE_X-0.75f, PAUSE_Y + 1.0f);
+	else if(priv->current_state == PAUSE)
+	{
+		if (priv->has_focus && (priv->key_event == TRANSPORT_NADA || priv->key_event == TRANSPORT_PLAY_PAUSE))
+		{
+			_setup (&cr_surf, &surf, PLAY_WIDTH+6, PLAY_HEIGHT+6);
+			_mask_play (cr_surf, 
+			            PLAY_PADDING,
+			            PLAY_PADDING,
+			            PLAY_WIDTH - (2*PLAY_PADDING),
+			            PLAY_HEIGHT - (2*PLAY_PADDING));
+			_fill (cr_surf,
+			       PLAY_PADDING,
+			       PLAY_PADDING,
+			       PLAY_WIDTH - (2*PLAY_PADDING),
+			       PLAY_HEIGHT - (2*PLAY_PADDING),
+			       BUTTON_SHADOW_FOCUS,
+			       BUTTON_SHADOW_FOCUS,
+			       FALSE);
+			_surface_blur (surf, 3);
+			_finalize_repaint (cr, &cr_surf, &surf, PAUSE_X-0.5f, PAUSE_Y + 0.5f, 3);
+		}
+		else
+		{
+			_setup (&cr_surf, &surf, PLAY_WIDTH, PLAY_HEIGHT);
+			_mask_play (cr_surf, 
+			            PLAY_PADDING,
+			            PLAY_PADDING,
+			            PLAY_WIDTH - (2*PLAY_PADDING),
+			            PLAY_HEIGHT - (2*PLAY_PADDING));
+			_fill (cr_surf,
+			       PLAY_PADDING,
+			       PLAY_PADDING,
+			       PLAY_WIDTH - (2*PLAY_PADDING),
+			       PLAY_HEIGHT - (2*PLAY_PADDING),
+			       BUTTON_SHADOW,
+			       BUTTON_SHADOW,
+			       FALSE);
+			_surface_blur (surf, 1);
+			_finalize (cr, &cr_surf, &surf, PAUSE_X-0.75f, PAUSE_Y + 1.0f);
+		}
+
 		// draw play-button
 		_setup (&cr_surf, &surf, PLAY_WIDTH, PLAY_HEIGHT);
 		cairo_set_line_width (cr, 10.5);
@@ -1240,15 +1664,15 @@ draw (GtkWidget* button, cairo_t *cr)
 		            PLAY_PADDING,
 		            PLAY_PADDING,
 		            PLAY_WIDTH - (2*PLAY_PADDING),
-		            PLAY_HEIGHT - (2*PLAY_PADDING));		            
+		            PLAY_HEIGHT - (2*PLAY_PADDING));
 		_fill (cr_surf,
 		       PLAY_PADDING,
 		       PLAY_PADDING,
 		       PLAY_WIDTH - (2*PLAY_PADDING),
 		       PLAY_HEIGHT - (2*PLAY_PADDING),
-			     BUTTON_START,
-			     BUTTON_END,
-			     FALSE);
+		       BUTTON_START,
+		       BUTTON_END,
+		       FALSE);
 		_finalize (cr, &cr_surf, &surf, PAUSE_X-0.5f, PAUSE_Y);
 	}
 }
@@ -1271,7 +1695,7 @@ transport_widget_set_twin_item(TransportWidget* self,
 /**
 * transport_widget_update_state()
 * Callback for updates from the other side of dbus
-**/
+**/ 
 static void 
 transport_widget_property_update(DbusmenuMenuitem* item, gchar* property, 
                                  GValue* value, gpointer userdata)
diff --git a/src/transport-widget.h b/src/transport-widget.h
index 6ccce05..70ce6aa 100644
--- a/src/transport-widget.h
+++ b/src/transport-widget.h
@@ -66,7 +66,11 @@ typedef struct
 void _color_shade (const CairoColorRGB *a, float k, CairoColorRGB *b);
 GType transport_widget_get_type (void);
 GtkWidget* transport_widget_new ( DbusmenuMenuitem *item );
-
+void transport_widget_react_to_key_press_event ( TransportWidget* widget,
+                                                 TransportWidgetEvent transport_event );
+void transport_widget_react_to_key_release_event ( TransportWidget* widget,
+                                                   TransportWidgetEvent transport_event );
+gboolean transport_widget_is_selected ( TransportWidget* widget );
 G_END_DECLS
 
 #endif