Merge lp:~jassmith/window-picker-applet/task-item-rewrite into lp:window-picker-applet

[Jason Smith]

[Jason Smith (jassmith)]

- Window items are now their own class and self managing
- Window item icons are full size of the panel (contain small click detection bug)
- Active window item is fully opaque, inactive items are slightly transparent
- Title bar has lost extra icon
- Title bar contains bold text
- Title bar now properly prelights the close button, this however will need to be themed properly in the gtkrc file
- Window items that set the urgent status now slowly (around 1 second) fade in and out to indicate this, rather than sudden blinks. Very passive.

[lp:~jassmith/window-picker-applet/task-item-rewrite]

99. By Jason Smith <jason@t500> on 2009-08-21

modified:
  src/task-item.c : Added prelighting to buttons

[Neil J. Patel (njpatel)]

Nice job! Love the fading animation when window has the urgent hint, and definitely like the clean-up fo the code.

There are a couple of things I noticed that need to be fixed before merge:

- The icons no-longer pickup the colour of the panel if it's different from the standard Gtk colour (i.e. when using right-click->properities->background and setting it to a different colour/changing transparency or setting a background image).

- The 1px click-through area the top of the icons seems to effect the entire applet, so maybe the container border needs to be removed from the the main box thats holding the applet's content.

-- Below is not merge-critical as we can fix after feature freeze --:

- Using it for some time on a netbook, I don't think there's enough difference between an active window's icon and a non-active window's icon. We should try a hi-light behind the active icon as before, or a glow/etc.

review: Needs Fixing

[lp:~jassmith/window-picker-applet/task-item-rewrite]

100. By Jason Smith <jason@t500> on 2009-08-25

Actually draw on parent window. oops.
Fixes bug where buttons would have black background in some situations.

101. By Jason Smith <jason@t500> on 2009-08-25

Fix fitz law problem

[Jason Smith (jassmith)]

> Nice job! Love the fading animation when window has the urgent hint, and
> definitely like the clean-up fo the code.
>
> There are a couple of things I noticed that need to be fixed before merge:
>
> - The icons no-longer pickup the colour of the panel if it's different from
> the standard Gtk colour (i.e. when using right-click->properities->background
> and setting it to a different colour/changing transparency or setting a
> background image).

  Fixed

>
> - The 1px click-through area the top of the icons seems to effect the entire
> applet, so maybe the container border needs to be removed from the the main
> box thats holding the applet's content.

  Fixed AND grew the icons by 2px.

>
> -- Below is not merge-critical as we can fix after feature freeze --:
>
> - Using it for some time on a netbook, I don't think there's enough difference
> between an active window's icon and a non-active window's icon. We should try
> a hi-light behind the active icon as before, or a glow/etc.

Just let me know what you want. I will do a glow like effect and see if that helps. I will strive to make it very very obvious which one is active. We will need something other than what we had before however since in many cases, that wont be at all visible.

[lp:~jassmith/window-picker-applet/task-item-rewrite]

102. By Jason Smith <jason@t500> on 2009-08-25

task-item.c : fix render glitch, remember allocation

=== modified file 'src/Makefile.am'
--- src/Makefile.am	2008-06-14 15:09:30 +0000
+++ src/Makefile.am	2009-08-18 23:59:03 +0000
@@ -16,6 +16,8 @@
 
 window_picker_applet_SOURCES = \
 	applet.c \
+	task-item.c \
+	task-item.h \
 	task-list.c \
 	task-list.h \
 	task-title.c \

=== added file 'src/task-item.c'
--- src/task-item.c	1970-01-01 00:00:00 +0000
+++ src/task-item.c	2009-08-21 07:06:29 +0000
@@ -0,0 +1,633 @@
+/*
+ * Copyright (C) 2008 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as 
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by Jason Smith <[e-mail]>
+ *
+ */
+
+#include "task-item.h"
+#include "task-list.h"
+
+#include <math.h>
+#include <cairo/cairo.h>
+
+G_DEFINE_TYPE (TaskItem, task_item, GTK_TYPE_EVENT_BOX);
+
+#define TASK_ITEM_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj),\
+  TASK_TYPE_ITEM, \
+  TaskItemPrivate))
+
+#define DEFAULT_TASK_ITEM_HEIGHT 24;  
+#define DEFAULT_TASK_ITEM_WIDTH 28
+
+struct _TaskItemPrivate
+{
+  WnckWindow *window;
+  WnckScreen *screen;
+  GdkPixbuf  *pixbuf;
+  
+  GTimeVal   urgent_time;
+  guint      timer;
+};
+
+enum {
+  TASK_ITEM_CLOSED_SIGNAL,
+  LAST_SIGNAL
+};
+
+/* D&D stuff */
+static const GtkTargetEntry drop_types[] =
+{
+  { "STRING", 0, 0 },
+  { "text/plain", 0, 0},
+  { "text/uri-list", 0, 0}
+};
+static const gint n_drop_types = G_N_ELEMENTS(drop_types);
+
+static guint task_item_signals[LAST_SIGNAL] = { 0 };
+
+static void
+update_hints (TaskItem *item)
+{
+  GtkWidget *parent;
+  GtkWidget *widget;
+  WnckWindow *window;
+  gint x, y, x1, y1;
+
+  widget = GTK_WIDGET (item);
+  window = item->priv->window;
+  /* Skip problems */
+  if (!WNCK_IS_WINDOW (window)) return;
+  if (!GTK_IS_WIDGET (widget)) return;
+
+  /* Skip invisible windows */
+  if (!GTK_WIDGET_VISIBLE (widget)) return;
+
+  x = y = 0;
+
+  /* Recursively compute the button's coordinates */
+  for (parent = widget; parent; parent = parent->parent)
+  {
+    if (parent->parent)
+    {
+      x += parent->allocation.x;
+      y += parent->allocation.y;
+    }
+    else
+    {
+      x1 = y1 = 0;
+      if (GDK_IS_WINDOW (parent->window))
+        gdk_window_get_origin (parent->window, &x1, &y1);
+      x += x1; y += y1;
+      break;
+    }
+  }
+    
+  /* Set the minimize hint for the window */
+  wnck_window_set_icon_geometry (window, x, y,
+                                 widget->allocation.width,
+                                 widget->allocation.height);
+}
+
+static gboolean 
+on_task_item_button_released (GtkWidget      *widget, 
+                              GdkEventButton *event,
+                              TaskItem       *item)
+{
+  WnckWindow *window;
+  WnckScreen *screen;
+  WnckWorkspace *workspace;
+  TaskItemPrivate *priv;
+  
+  g_return_val_if_fail (TASK_IS_ITEM (item), TRUE);
+  
+  priv = item->priv;
+  window = priv->window;
+  
+  g_return_val_if_fail (WNCK_IS_WINDOW (window), TRUE);
+  
+  screen = priv->screen;
+  workspace = wnck_window_get_workspace (window);
+  
+  if (event->button == 1)
+  {
+  
+    if (WNCK_IS_WORKSPACE (workspace) && workspace != wnck_screen_get_active_workspace (screen))
+    {
+      wnck_workspace_activate (workspace, GDK_CURRENT_TIME);
+    }
+    if (wnck_window_is_active (window))
+    {
+      wnck_window_minimize (window);
+    }
+    else
+    {
+      wnck_window_activate (window, GDK_CURRENT_TIME);
+    }
+  }
+  return TRUE;
+}
+
+static void
+task_item_set_visibility (TaskItem *item)
+{
+  WnckScreen *screen;
+  WnckWindow *window;
+  WnckWorkspace *workspace;
+
+  g_return_if_fail (TASK_IS_ITEM (item));
+  
+  TaskItemPrivate *priv = item->priv;
+  
+  if (!WNCK_IS_WINDOW (priv->window)) 
+  {
+    gtk_widget_hide (GTK_WIDGET (item));
+    return;
+  }
+  
+  window = priv->window;
+  
+  screen = priv->screen;
+  workspace = wnck_screen_get_active_workspace (screen);
+  
+  gboolean show_all = task_list_get_show_all_windows (TASK_LIST (task_list_get_default ()));
+  
+  if (wnck_window_is_skip_tasklist (window) || 
+      (!show_all && !wnck_window_is_on_workspace (window, workspace)))
+  {
+    gtk_widget_hide (GTK_WIDGET (item));
+  }
+  else
+  {
+    gtk_widget_show (GTK_WIDGET (item));
+  }
+}
+
+static void 
+task_item_size_request (GtkWidget      *widget,
+		       GtkRequisition *requisition)
+{
+  /* Candidate for terrible hack of the year award */
+  requisition->width  = DEFAULT_TASK_ITEM_WIDTH;
+  requisition->height = DEFAULT_TASK_ITEM_HEIGHT;
+}
+
+static GdkPixbuf *
+task_item_sized_pixbuf_for_window (TaskItem   *item,
+                                   WnckWindow *window,
+                                   gint size)
+{
+  GdkPixbuf *pbuf;
+  
+  g_return_val_if_fail (WNCK_IS_WINDOW (window), NULL);
+  
+  if (wnck_window_has_icon_name (window))
+  {
+    const gchar *icon_name = wnck_window_get_icon_name (window);
+    GtkIconTheme *icon_theme = gtk_icon_theme_get_default ();
+    
+    if (gtk_icon_theme_has_icon (icon_theme, icon_name))
+    {
+    
+      pbuf = gdk_pixbuf_copy (gtk_icon_theme_load_icon (icon_theme, 
+                                                        icon_name,
+                                                        size,
+                                                        GTK_ICON_LOOKUP_FORCE_SIZE,
+                                                        NULL));
+    }
+  }
+  
+  if (!pbuf)
+  {
+    pbuf = gdk_pixbuf_copy (wnck_window_get_icon (item->priv->window));
+  }
+  
+  gint width = gdk_pixbuf_get_width (pbuf);
+  gint height = gdk_pixbuf_get_height (pbuf);
+
+  if (width > size || height > size)
+  {
+    gdouble scale;
+    if (width > size)
+    {
+      scale = (gdouble) size / (gdouble) width;
+      width = size;
+      height = (int) (height * scale);
+    }
+    if (height > size)
+    {
+      scale = (gdouble) size / (gdouble) height;
+      height = size;
+      width = (int) (width * scale);
+    }
+  
+    GdkPixbuf *tmp = pbuf;
+    pbuf = gdk_pixbuf_scale_simple (tmp, width, height, GDK_INTERP_HYPER);
+    
+    g_object_unref (tmp);
+  }
+ 
+  return pbuf;
+}
+static gboolean
+task_item_expose_event (GtkWidget      *widget,
+		        GdkEventExpose *event)
+{
+  cairo_t *cr;
+  TaskItem *item;
+  GdkRectangle area;
+  TaskItemPrivate *priv;
+  
+  g_return_val_if_fail (widget != NULL, FALSE);
+  g_return_val_if_fail (TASK_IS_ITEM (widget), FALSE);
+  g_return_val_if_fail (event != NULL, FALSE);
+  
+  if (event->count > 0)
+  	return FALSE;
+  	
+  item = TASK_ITEM (widget);
+  priv = item->priv;
+  
+  g_return_val_if_fail (WNCK_IS_WINDOW (item->priv->window), FALSE);
+  
+  area = event->area;
+  cr = gdk_cairo_create (event->window);
+  
+  GdkPixbuf *pbuf = priv->pixbuf;
+  
+  gint size = MIN (area.height, area.width);
+  
+  if (GDK_IS_PIXBUF (pbuf) && (gdk_pixbuf_get_width (pbuf) > size ||
+                               gdk_pixbuf_get_height (pbuf) > size))
+  {
+  	g_object_unref (pbuf);
+  	pbuf = NULL;
+  }
+  
+  if (!pbuf)
+  {
+    pbuf = task_item_sized_pixbuf_for_window (item, priv->window, size);
+  }
+  
+  gdk_cairo_set_source_pixbuf (cr, 
+                               pbuf, 
+                               (area.width - gdk_pixbuf_get_width (pbuf)) / 2, 
+                               (area.height - gdk_pixbuf_get_height (pbuf)) / 2);
+  
+  g_object_unref (pbuf);
+  
+  if (wnck_window_or_transient_needs_attention (priv->window))
+  {
+    GTimeVal current_time;
+    g_get_current_time (&current_time);
+    
+    gdouble ms = (current_time.tv_sec - priv->urgent_time.tv_sec) * 1000 + 
+                 (current_time.tv_usec - priv->urgent_time.tv_usec) / 1000;
+    
+    gdouble alpha = .75 + (cos (ms / 500) / 4);
+    cairo_paint_with_alpha (cr, alpha);
+  }
+  else if (wnck_window_is_active (priv->window))
+  {
+    cairo_paint (cr);
+  }
+  else
+  {
+    cairo_paint_with_alpha (cr, .6);
+  }
+  
+  cairo_destroy (cr);
+  
+  return FALSE;
+}
+
+static void
+on_size_allocate (GtkWidget     *widget,
+                  GtkAllocation *allocation,
+                  TaskItem      *item)
+{
+  if (allocation->width != allocation->height)
+    gtk_widget_set_size_request (widget, allocation->height, -1);
+
+  update_hints (item);    
+}
+
+static gboolean
+on_button_pressed (GtkWidget      *button,
+                   GdkEventButton *event,
+                   TaskItem       *item)
+{
+  WnckWindow *window;
+  g_return_val_if_fail (TASK_IS_ITEM (item), FALSE);
+  window = item->priv->window;
+  g_return_val_if_fail (WNCK_IS_WINDOW (window), FALSE);
+
+  if (event->button == 3)
+  {
+    GtkWidget *menu = wnck_action_menu_new (window);
+    gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL,
+                    event->button, event->time);
+    return TRUE;
+  }
+
+  return FALSE;
+}
+
+static gboolean
+on_query_tooltip (GtkWidget *widget,
+                  gint x, gint y, 
+                  gboolean keyboard_mode, 
+                  GtkTooltip *tooltip,
+                  TaskItem *item)
+{
+  WnckWindow *window = item->priv->window;
+  g_return_val_if_fail (WNCK_IS_WINDOW (window), FALSE);
+
+  gtk_tooltip_set_text (tooltip, wnck_window_get_name(window));
+  gtk_tooltip_set_icon (tooltip, wnck_window_get_icon (window));
+
+  return TRUE;
+}
+
+static gboolean
+on_blink (TaskItem *item)
+{
+  g_return_val_if_fail (TASK_IS_ITEM (item), FALSE);
+
+  gtk_widget_queue_draw (GTK_WIDGET (item));
+
+  if (wnck_window_or_transient_needs_attention (item->priv->window))
+  {
+    return TRUE;
+  }
+  else
+  {
+    item->priv->timer = 0;
+    return FALSE;
+  }
+}
+
+static void
+on_window_state_changed (WnckWindow      *window, 
+                         WnckWindowState  changed_mask,
+                         WnckWindowState  new_state,
+                         TaskItem        *item)
+{
+  g_return_if_fail (WNCK_IS_WINDOW (window));
+  g_return_if_fail (TASK_IS_ITEM (item));
+  
+  TaskItemPrivate *priv = item->priv;
+  
+  if (new_state & WNCK_WINDOW_STATE_URGENT && !priv->timer)
+  {
+    priv->timer = g_timeout_add (30, (GSourceFunc)on_blink, item);
+    g_get_current_time (&priv->urgent_time);
+  }
+  
+  task_item_set_visibility (item);
+}
+
+static void
+on_window_workspace_changed (WnckWindow *window, TaskItem *item)
+{
+  g_return_if_fail (TASK_IS_ITEM (item));
+
+  task_item_set_visibility (item);
+}
+
+static void
+on_screen_active_window_changed (WnckScreen    *screen,
+                                 WnckWindow    *old_window,
+                                 TaskItem      *item)
+{
+  WnckWindow *window;
+  TaskItemPrivate *priv;
+
+  g_return_if_fail (TASK_IS_ITEM (item));
+
+  priv = item->priv;
+  window = priv->window;
+  
+  g_return_if_fail (WNCK_IS_WINDOW (window));
+  
+  if ((WNCK_IS_WINDOW (old_window) && window == old_window) || 
+       window == wnck_screen_get_active_window (screen))
+  {
+    /* queue a draw to reflect that we are [no longer] the active window */
+    gtk_widget_queue_draw (GTK_WIDGET (item));
+  }
+}
+
+static void
+on_screen_active_workspace_changed (WnckScreen    *screen,
+                                    WnckWorkspace *old_workspace,
+                                    TaskItem      *item)
+{
+  g_return_if_fail (TASK_IS_ITEM (item));
+
+  task_item_set_visibility (item);
+}
+
+static void
+on_screen_active_viewport_changed (WnckScreen    *screen,
+                                   TaskItem      *item)
+{
+  g_return_if_fail (TASK_IS_ITEM (item));
+
+  task_item_set_visibility (item);
+}
+
+static void
+on_screen_window_closed (WnckScreen  *screen,
+                         WnckWindow  *window,
+                         TaskItem    *item)
+{
+  TaskItemPrivate *priv;
+ 
+  g_return_if_fail (TASK_IS_ITEM (item));
+  priv = item->priv;
+  g_return_if_fail (WNCK_IS_WINDOW (priv->window));
+
+  if (priv->window == window)
+  {
+    g_signal_handlers_disconnect_by_func (screen, G_CALLBACK (on_screen_window_closed), item);
+    g_signal_handlers_disconnect_by_func (screen, G_CALLBACK (on_screen_active_window_changed), item);
+    g_signal_handlers_disconnect_by_func (screen, G_CALLBACK (on_screen_active_workspace_changed), item);
+    g_signal_handlers_disconnect_by_func (screen, G_CALLBACK (on_screen_window_closed), item);
+    g_signal_handlers_disconnect_by_func (window, G_CALLBACK (on_window_workspace_changed), item);
+    g_signal_handlers_disconnect_by_func (window, G_CALLBACK (on_window_state_changed), item);
+  
+    g_signal_emit (G_OBJECT (item), task_item_signals[TASK_ITEM_CLOSED_SIGNAL], 0);
+  }
+}
+
+static gboolean
+activate_window (GtkWidget *widget)
+{
+  gint active;
+
+  g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
+
+  active = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (widget), "drag-true"));
+
+  if (active)
+  { 
+    WnckWindow *window;
+
+    window = (WnckWindow*)g_object_get_data (G_OBJECT (widget), "WnckWindow");
+    if (WNCK_IS_WINDOW (window))
+      wnck_window_activate (window, time (NULL));
+  }
+  
+  g_object_set_data (G_OBJECT (widget), "drag-true", GINT_TO_POINTER (0));
+  
+  return FALSE;
+}
+
+static void
+on_drag_leave (GtkWidget      *item,
+               GdkDragContext *context,
+               guint           time)
+{
+  g_object_set_data (G_OBJECT (item), "drag-true", GINT_TO_POINTER (0));
+}
+
+static gboolean
+on_drag_motion (GtkWidget      *item,
+                GdkDragContext *context,
+                gint            x, 
+                gint            y,
+                guint           t)
+{
+  gint active;
+
+  active = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (item), "drag-true"));
+  
+  if (!active)
+  {
+    g_object_set_data (G_OBJECT (item), "drag-true", GINT_TO_POINTER (1));
+
+    g_timeout_add (1000, (GSourceFunc)activate_window, item);
+  }
+
+  return FALSE;
+}
+
+static void
+task_item_finalize (GObject *object)
+{
+  TaskItemPrivate *priv;
+  priv = TASK_ITEM_GET_PRIVATE (object);
+
+  /* remove timer */
+  if (priv->timer) g_source_remove (priv->timer);
+
+  G_OBJECT_CLASS (task_item_parent_class)->finalize (object);
+}
+
+static void
+task_item_class_init (TaskItemClass *klass)
+{
+  GObjectClass *obj_class      = G_OBJECT_CLASS (klass);
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+
+  obj_class->finalize = task_item_finalize;
+  widget_class->expose_event = task_item_expose_event;
+  widget_class->size_request = task_item_size_request;
+
+  g_type_class_add_private (obj_class, sizeof (TaskItemPrivate));
+  
+  task_item_signals [TASK_ITEM_CLOSED_SIGNAL] =
+    g_signal_new ("task-item-closed",
+                  G_TYPE_FROM_CLASS (klass),
+                  G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
+                  G_STRUCT_OFFSET (TaskItemClass, itemclosed),
+                  NULL, NULL,
+                  g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
+}
+
+static void
+task_item_init (TaskItem *item)
+{
+  TaskItemPrivate *priv;
+  priv = item->priv = TASK_ITEM_GET_PRIVATE (item);
+
+  priv->timer = 0;
+}
+
+GtkWidget *
+task_item_new (WnckWindow *window)
+{
+  GtkWidget *item = NULL;
+  TaskItem *task;
+  TaskItemPrivate *priv;
+  WnckScreen *screen;
+  
+  g_return_val_if_fail (WNCK_IS_WINDOW (window), item);
+
+  item = g_object_new (TASK_TYPE_ITEM, 
+                       "has-tooltip", TRUE,
+                       "visible-window", TRUE, 
+                       "above-child", TRUE, 
+                       NULL);
+                       
+  gtk_widget_add_events (item, GDK_ALL_EVENTS_MASK);
+  gtk_container_set_border_width (GTK_CONTAINER (item), 0);
+
+  task = TASK_ITEM (item);
+  priv = task->priv;  
+  priv->window = window;
+  
+  screen = wnck_window_get_screen (window);
+  priv->screen = screen;
+  
+  gtk_drag_dest_set (item,
+                     GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_DROP,
+                     drop_types, n_drop_types,
+                     GDK_ACTION_COPY);
+  gtk_drag_dest_add_uri_targets (item);
+  gtk_drag_dest_add_text_targets (item);
+  g_signal_connect (item, "drag-motion", 
+                    G_CALLBACK (on_drag_motion), NULL);
+  g_signal_connect (item, "drag-leave", 
+                    G_CALLBACK (on_drag_leave), NULL);
+  
+  g_signal_connect (screen, "viewports-changed",
+                    G_CALLBACK (on_screen_active_viewport_changed), item);
+  g_signal_connect (screen, "active-window-changed",
+                    G_CALLBACK (on_screen_active_window_changed), item);
+  g_signal_connect (screen, "active-workspace-changed",
+                    G_CALLBACK (on_screen_active_workspace_changed), item);
+  g_signal_connect (screen, "window-closed",
+                    G_CALLBACK (on_screen_window_closed), item);
+                    
+  g_signal_connect (window, "workspace-changed",
+  		    G_CALLBACK (on_window_workspace_changed), item);
+  g_signal_connect (window, "state-changed",
+                    G_CALLBACK (on_window_state_changed), item);
+  
+  g_signal_connect (item, "button-release-event",
+                    G_CALLBACK (on_task_item_button_released), item);
+  g_signal_connect (item, "button-press-event",
+                    G_CALLBACK (on_button_pressed), item);
+  g_signal_connect (item, "size-allocate",
+                    G_CALLBACK (on_size_allocate), item);
+  g_signal_connect (item, "query-tooltip", 
+                    G_CALLBACK (on_query_tooltip), item);
+                    
+  task_item_set_visibility (task);
+  
+  return item;
+}

=== added file 'src/task-item.h'
--- src/task-item.h	1970-01-01 00:00:00 +0000
+++ src/task-item.h	2009-08-20 23:49:02 +0000
@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2008 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as 
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Neil Jagdish Patel <[e-mail]>
+ *              Jason Smith        <[e-mail]>
+ *
+ */
+
+#ifndef _TASK_ITEM_H_
+#define _TASK_ITEM_H_
+
+#include <glib.h>
+#include <gtk/gtk.h>
+#include <libwnck/libwnck.h>
+
+#define TASK_TYPE_ITEM (task_item_get_type ())
+
+#define TASK_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj),\
+	TASK_TYPE_ITEM, TaskItem))
+
+#define TASK_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass),\
+	TASK_TYPE_ITEM, TaskItemClass))
+
+#define TASK_IS_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj),\
+	TASK_TYPE_ITEM))
+
+#define TASK_IS_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),\
+	TASK_TYPE_ITEM))
+
+#define TASK_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj),\
+	TASK_TYPE_ITEM, TaskItemClass))
+
+typedef struct _TaskItem        TaskItem;
+typedef struct _TaskItemClass   TaskItemClass;
+typedef struct _TaskItemPrivate TaskItemPrivate;
+ 
+struct _TaskItem
+{
+  GtkEventBox     parent;	
+
+  TaskItemPrivate *priv;
+};
+
+struct _TaskItemClass
+{
+  GtkEventBoxClass   parent_class;
+  
+  void (* itemclosed) (TaskItem *item);
+};
+
+GType task_item_get_type (void) G_GNUC_CONST;
+
+GtkWidget * task_item_new (WnckWindow *window);
+
+GtkWidget * task_item_get_default (void);
+
+gboolean    task_item_get_desktop_visible (TaskItem *item);
+
+#endif /* _TASK_ITEM_H_ */
+

=== modified file 'src/task-list.c'
--- src/task-list.c	2009-04-08 10:19:27 +0000
+++ src/task-list.c	2009-08-21 07:06:29 +0000
@@ -18,6 +18,7 @@
  */
 
 #include "task-list.h"
+#include "task-item.h"
 
 #include <libwnck/libwnck.h>
 
@@ -44,109 +45,6 @@
   PROP_SHOW_ALL_WINDOWS
 };
 
-/* D&D stuff */
-static const GtkTargetEntry drop_types[] =
-{
-  { "STRING", 0, 0 },
-  { "text/plain", 0, 0},
-  { "text/uri-list", 0, 0}
-};
-static const gint n_drop_types = G_N_ELEMENTS(drop_types);
-
-static void
-update_hints (WnckWindow *window, GtkWidget *button)
-{
-  GtkWidget *parent;
-  gint x, y, x1, y1;
-
-  /* Skip problems */
-  if (!WNCK_IS_WINDOW (window)) return;
-  if (!GTK_IS_WIDGET (button)) return;
-
-  /* Skip invisible windows */
-  if (!GTK_WIDGET_VISIBLE (button)) return;
-
-  x = y = 0;
-
-  /* Recursively compute the button's coordinates */
-  for (parent = button; parent; parent = parent->parent)
-  {
-    if (parent->parent)
-    {
-      x += parent->allocation.x;
-      y += parent->allocation.y;
-    }
-    else
-    {
-      x1 = y1 = 0;
-      if (GDK_IS_WINDOW (parent->window))
-        gdk_window_get_origin (parent->window, &x1, &y1);
-      x += x1; y += y1;
-      break;
-    }
-  }
-    
-  /* Set the minimize hint for the window */
-  wnck_window_set_icon_geometry (window, x, y,
-                                 button->allocation.width,
-                                 button->allocation.height);
-}
-
-static void
-set_minimize_hints (TaskList *list)
-{
-  TaskListPrivate *priv;
-    
-  g_return_if_fail (TASK_IS_LIST (list));
-  priv = list->priv;
-
-  g_hash_table_foreach (priv->win_table,
-                        (GHFunc)update_hints,
-                        NULL);
-
-}
-
-/*
- * Show all windows code 
- */
-static gboolean
-ensure_list (TaskList *list)
-{
-  TaskListPrivate *priv = list->priv;
-  WnckWorkspace *current;
-  GList *children, *c;
-
-  current = wnck_screen_get_active_workspace (priv->screen);
-
-  if (!WNCK_IS_WORKSPACE (current))
-    return FALSE;
-
-  children = gtk_container_get_children (GTK_CONTAINER (list));
-  for (c = children; c; c = c->next)
-  { 
-    GtkWidget *widget = c->data;
-    WnckWindow *window = g_object_get_data (G_OBJECT (widget), "WnckWindow");
-
-    if (priv->show_all_windows 
-        || (wnck_window_is_on_workspace (window, current)
-            && wnck_window_is_in_viewport (window, current)))
-    {
-      if (!wnck_window_is_skip_tasklist (window))
-        gtk_widget_show (widget);
-    }
-    else
-    {
-      gtk_widget_hide (widget);
-    }
-  }
-  g_list_free (children);
-
-  /* Re-set minimize hints */
-  set_minimize_hints (list);
-
-  return FALSE;
-}
-
 static void
 task_list_set_show_all_windows (TaskList *list, gboolean show_all_windows)
 {
@@ -154,252 +52,16 @@
 
   priv->show_all_windows = show_all_windows;
 
-  ensure_list (list);
-
   g_debug ("Show all windows: %s", show_all_windows ? "true" : "false");
 }
 
-/* Callback */
-static gboolean
-on_leave_notify_event (GtkWidget        *button,
-                       GdkEventCrossing *event,
-                       TaskList         *list)
-{
-  g_return_val_if_fail (TASK_IS_LIST (list), FALSE);
-
-  gtk_widget_queue_draw (GTK_WIDGET (list));
-
-  return FALSE;
-}
-
-static gboolean
-on_button_released (GtkWidget      *button,
-                    GdkEventButton *event,
-                    WnckWindow     *window)
-{
-  g_return_val_if_fail (WNCK_IS_WINDOW (window), FALSE);
-
-  if (event->button == 1)
-  {
-    WnckWorkspace *space;
-
-    if (wnck_window_is_active (window))
-    {
-      wnck_window_minimize (window);
-    }
-    else
-    {
-      space = wnck_window_get_workspace (window);
-      wnck_workspace_activate (space, event->time);
-      wnck_window_activate (window, event->time);
-    }
-    
-    return TRUE;
-  }
-
-  return FALSE;
-}
-
-static gboolean
-on_button_pressed (GtkWidget      *button,
-                   GdkEventButton *event,
-                   WnckWindow     *window)
-{
-  g_return_val_if_fail (WNCK_IS_WINDOW (window), FALSE);
-
-  if (event->button == 3)
-  {
-    GtkWidget *menu = wnck_action_menu_new (window);
-    gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL,
-                    event->button, event->time);
-    return TRUE;
-  }
-
-  return FALSE;
-}
-
-static gboolean
-on_query_tooltip (GtkWidget *button,
-                  gint x, gint y, 
-                  gboolean keyboard_mode, 
-                  GtkTooltip *tooltip,
-                  WnckWindow *window)
-{
-  g_return_val_if_fail (WNCK_IS_WINDOW (window), FALSE);
-
-  gtk_tooltip_set_text (tooltip, wnck_window_get_name(window));
-  gtk_tooltip_set_icon (tooltip, wnck_window_get_icon (window));
-
-  return TRUE;
-}
-
-static gboolean
-activate_window (GtkWidget *button)
-{
-  gint active;
-
-  g_return_val_if_fail (GTK_IS_WIDGET (button), FALSE);
-
-  active = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (button), "drag-true"));
-
-  if (active)
-  { 
-    WnckWindow *window;
-
-    window = (WnckWindow*)g_object_get_data (G_OBJECT (button), "WnckWindow");
-    if (WNCK_IS_WINDOW (window))
-      wnck_window_activate (window, time (NULL));
-  }
-  
-  g_object_set_data (G_OBJECT (button), "drag-true", GINT_TO_POINTER (0));
-  
-  return FALSE;
-}
-
-static void
-on_drag_leave (GtkWidget      *button,
-               GdkDragContext *context,
-               guint           time)
-{
-  g_object_set_data (G_OBJECT (button), "drag-true", GINT_TO_POINTER (0));
-}
-
-static gboolean
-on_drag_motion (GtkWidget      *button,
-                GdkDragContext *context,
-                gint            x, 
-                gint            y,
-                guint           t)
-{
-  gint active;
-
-  active = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (button), "drag-true"));
-  
-  if (!active)
-  {
-    g_object_set_data (G_OBJECT (button), "drag-true", GINT_TO_POINTER (1));
-
-    g_timeout_add (1000, (GSourceFunc)activate_window, button);
-  }
-
-  return FALSE;
-}
-
-static void
-on_icon_changed (WnckWindow *window, GtkButton *button)
-{
-  if (WNCK_IS_WINDOW (window) && GTK_IS_BUTTON (button))
-  {
-    gtk_image_set_from_pixbuf (GTK_IMAGE (gtk_button_get_image (button)), 
-                               wnck_window_get_mini_icon (window));
-    gtk_widget_queue_draw (GTK_WIDGET (button));
-  }
-}
-
-static void
-set_state (WnckWindow *window, GtkButton *button, gboolean *found)
-{
-  TaskListPrivate *priv = TASK_LIST (task_list_get_default ())->priv;
-
-  /* Skip problems */
-  if (!WNCK_IS_WINDOW (window)) 
-    return;
-  if (!GTK_IS_WIDGET (button)) 
-    return;
-
-  /* Skip invisible windows */
-  if (!GTK_WIDGET_VISIBLE (button)) 
-    return;
-
-  /* Skip windows that don't need attention */
-  if (!wnck_window_or_transient_needs_attention (window)) 
-    return;
-
-  /* Blink the button */
-  gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), 
-                               priv->counter & 1);
-
-  /* Don't destroy the timeout */
-  *found = TRUE;
-}
-
-static gboolean
-on_blink (TaskList *list)
-{
-  TaskListPrivate *priv;
-  gboolean found = FALSE;
-
-  g_return_val_if_fail (TASK_IS_LIST (list), FALSE);
-  priv = list->priv;
-
-  /* Increment the blink counter */
-  priv->counter ++;
-
-  g_hash_table_foreach (priv->win_table, 
-                        (GHFunc)set_state,
-                        &found);
-
-  /* Continue the periodic timeout if needed */
-  if (!found) priv->timer = 0;
-  return found;
-}
-
-static void
-on_state_changed (WnckWindow      *window, 
-                  WnckWindowState  changed_mask,
-                  WnckWindowState  new_state,
-                  TaskList        *list)
-{
-  TaskListPrivate *priv;
-  GtkWidget *button;
-  WnckWorkspace *current;
-
-  g_return_if_fail (WNCK_IS_WINDOW (window));
-  g_return_if_fail (TASK_IS_LIST (list));
-  priv = list->priv;
-
-  /* Get the button */
-  button = g_hash_table_lookup (priv->win_table, window);
-  g_return_if_fail (GTK_IS_WIDGET (button));
-
-  /* Get the workspace */
-  current = wnck_screen_get_active_workspace (priv->screen);
-
-  /* Check if the button should be hidden */
-  if (wnck_window_is_skip_tasklist (window)
-      || (current
-      && !wnck_window_is_on_workspace (window, current)
-      && !priv->show_all_windows))
-    gtk_widget_hide (button);
-  else
-  {
-    gtk_widget_show (button);
-    
-    /* If the window needs attention and there is no timer... */
-    if (!priv->timer &&
-        wnck_window_or_transient_needs_attention (window) )
-    {
-      /* Start the timer */
-      priv->timer = g_timeout_add (500, (GSourceFunc)on_blink, list);
-      priv->counter = 0;
-    }
-  }
-
-  /* Update the button's state */
-  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
-    wnck_screen_get_active_window (priv->screen) == window);
-
-  /* Re-set minimize hints */
-  ensure_list (list);
-  set_minimize_hints (list);
-}
-
-static void
-on_workspace_changed (WnckWindow *window, TaskList *list)
-{
-  g_return_if_fail (TASK_IS_LIST (list));
-
-  ensure_list (list);
+static void
+on_task_item_closed (TaskItem *item,
+                     TaskList *list)
+{
+  gtk_container_remove (GTK_CONTAINER (list),
+                        GTK_WIDGET (item));
+  gtk_widget_destroy (GTK_WIDGET (item));
 }
 
 static void
@@ -409,7 +71,6 @@
 {
   TaskListPrivate *priv;
   WnckWindowType type;
-  GtkWidget *button;
 
   g_return_if_fail (TASK_IS_LIST (list));
   priv = list->priv;
@@ -422,123 +83,21 @@
       || type == WNCK_WINDOW_MENU)
     return;
 
-  button = g_object_new (GTK_TYPE_TOGGLE_BUTTON,
-                         "has-tooltip", TRUE,
-                         "image", gtk_image_new_from_pixbuf (
-                                    wnck_window_get_mini_icon (window)),
-                         "name", "tasklist-button2", 
-                         "relief", GTK_RELIEF_NONE,
-                         NULL);
-  /* D&D */
-	gtk_widget_add_events (GTK_WIDGET (button),GDK_ALL_EVENTS_MASK);
-	gtk_drag_dest_set (GTK_WIDGET (button),
-                           GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_DROP,
-                           drop_types, n_drop_types,
-                           GDK_ACTION_COPY);
-	gtk_drag_dest_add_uri_targets (GTK_WIDGET (button));
-	gtk_drag_dest_add_text_targets (GTK_WIDGET (button));
-  g_signal_connect (button, "drag-motion", 
-                    G_CALLBACK (on_drag_motion), NULL);
-  g_signal_connect (button, "drag-leave", 
-                    G_CALLBACK (on_drag_leave), NULL);
- 
-  gtk_box_pack_start (GTK_BOX (list), button, FALSE, FALSE, 0);
-  
-  g_signal_connect (button, "button-release-event",
-                    G_CALLBACK (on_button_released), window);
-  g_signal_connect (button, "button-press-event",
-                    G_CALLBACK (on_button_pressed), window);
-  g_signal_connect (button, "leave-notify-event",
-                    G_CALLBACK (on_leave_notify_event), list);
-  g_signal_connect (button, "query-tooltip", 
-                    G_CALLBACK (on_query_tooltip), window);
-  g_signal_connect (window, "icon-changed",
-                    G_CALLBACK (on_icon_changed), button);
-  g_signal_connect (window, "state-changed",
-                    G_CALLBACK (on_state_changed), list);
-  g_signal_connect (window, "workspace-changed",
-                    G_CALLBACK (on_workspace_changed), list);
-  
-  g_hash_table_insert (priv->win_table, window, button);
-  g_object_set_data (G_OBJECT (button), "WnckWindow", window);
-
-  /* Do an initial state change to avoid code duplication here */
-  on_state_changed (window, 0xFFFFFFFF, wnck_window_get_state (window), list);
-
-  /* Show the window if it's button is visible (why??) */
+  /* Show the window if it's button is visible (why??)
+     BECAUSE IT'S DUMB, that explains the urgency behavior....
   if (GTK_WIDGET_VISIBLE (button))
-    wnck_window_activate (window, GDK_CURRENT_TIME);
-}
-
-static void
-on_window_closed (WnckScreen *screen, 
-                  WnckWindow *window,
-                  TaskList   *list)
-{
-  TaskListPrivate *priv;
-  GtkWidget *button;
-
-  g_return_if_fail (TASK_IS_LIST (list));
-  priv = list->priv;
-
-  button = g_hash_table_lookup (priv->win_table, window);
-
-  if (GTK_IS_WIDGET (button))
-    gtk_widget_destroy (button);
-
-  g_hash_table_remove (priv->win_table, window);
-
-  /* Set minimize hints */
-  set_minimize_hints (list);
-}
-
-static void
-on_active_window_changed (WnckScreen *screen, 
-                          WnckWindow *old_window,
-                          TaskList   *list)
-{
-  TaskListPrivate *priv;
-  WnckWindow *act_window;
-  GtkWidget *old_button;
-  GtkWidget *act_button;
-
-  g_return_if_fail (TASK_IS_LIST (list));
-  priv = list->priv;
-
-  old_button = g_hash_table_lookup (priv->win_table, old_window);
-  if (GTK_IS_WIDGET (old_button))
-  {
-    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (old_button), FALSE);
-  }
-
-  act_window = wnck_screen_get_active_window (priv->screen);
-  act_button = g_hash_table_lookup (priv->win_table, act_window);
-  if (GTK_IS_WIDGET (act_button))
-  {
-    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (act_button), TRUE);
-  }
-
-  ensure_list (list);
-}
-
-static void
-on_active_workspace_changed (WnckScreen    *screen,
-                             WnckWorkspace *old_workspace,
-                             TaskList      *list)
-{
-  g_return_if_fail (TASK_IS_LIST (list));
-
-  ensure_list (list);
-}
-
-static void
-on_active_viewport_changed (WnckScreen    *screen,
-                            TaskList      *list)
-{
-  g_return_if_fail (TASK_IS_LIST (list));
-
-  ensure_list (list);
-}
+    wnck_window_activate (window, GDK_CURRENT_TIME); */
+    
+  GtkWidget *item = task_item_new (window);
+  
+  if (item)
+  {
+    gtk_box_pack_start (GTK_BOX (list), item, FALSE, FALSE, 0);
+    g_signal_connect (TASK_ITEM (item), "task-item-closed",
+                      G_CALLBACK (on_task_item_closed), list);
+  }
+}
+
 /* GObject stuff */
 static void
 task_list_finalize (GObject *object)
@@ -635,14 +194,6 @@
 
   g_signal_connect (priv->screen, "window-opened",
                     G_CALLBACK (on_window_opened), list);
-  g_signal_connect (priv->screen, "window-closed",
-                    G_CALLBACK (on_window_closed), list);
-  g_signal_connect (priv->screen, "active-workspace-changed",
-                    G_CALLBACK (on_active_workspace_changed), list);
-  g_signal_connect (priv->screen, "viewports-changed",
-                    G_CALLBACK (on_active_viewport_changed), list);
-  g_signal_connect (priv->screen, "active-window-changed",
-                    G_CALLBACK (on_active_window_changed), list);
 }
 
 GtkWidget *
@@ -656,8 +207,6 @@
                        "spacing", 2, 
                        NULL);
   
-  g_idle_add ((GSourceFunc)ensure_list, list);
-  
   return list;
 }
 
@@ -675,23 +224,28 @@
 gboolean    
 task_list_get_desktop_visible (TaskList *list)
 {
-  GList *children, *c;
+  GList *windows, *w;
   gboolean all_minimised = TRUE;
 
   g_return_val_if_fail (TASK_IS_LIST (list), TRUE);
 
-  children = gtk_container_get_children (GTK_CONTAINER (list));
-  for (c = children; c; c = c->next)
+  windows = wnck_screen_get_windows (list->priv->screen);
+  for (w = windows; w; w = w->next)
   {
     WnckWindow *window;
     
-    window = g_object_get_data (G_OBJECT (c->data), "WnckWindow");
+    window = w->data;
 
     if (WNCK_IS_WINDOW (window) && !wnck_window_is_minimized (window))
       all_minimised = FALSE;
   }
-  g_list_free (children);
 
   return all_minimised;
 }
 
+gboolean
+task_list_get_show_all_windows (TaskList *list)
+{
+  return list->priv->show_all_windows;
+}
+

=== modified file 'src/task-list.h'
--- src/task-list.h	2009-03-04 16:14:38 +0000
+++ src/task-list.h	2009-08-21 07:06:29 +0000
@@ -64,5 +64,7 @@
 
 gboolean    task_list_get_desktop_visible (TaskList *list);
 
+gboolean    task_list_get_show_all_windows (TaskList *list);
+
 #endif /* _TASK_LIST_H_ */
 

=== modified file 'src/task-title.c'
--- src/task-title.c	2009-05-04 19:57:27 +0000
+++ src/task-title.c	2009-08-21 09:12:47 +0000
@@ -43,13 +43,13 @@
   WnckWindow *window;
   GtkWidget *align;
   GtkWidget *box;
-  GtkWidget *image;
   GtkWidget *label;
   GtkWidget *button;
   GtkWidget *button_image;
   GdkPixbuf *quit_icon;
 
   gboolean show_home_title;
+  gboolean mouse_in_close_button;
 };
 
 static void disconnect_window (TaskTitle *title);
@@ -87,6 +87,60 @@
   return TRUE;
 }
 
+static gboolean
+on_enter_notify (GtkWidget *widget,
+                 GdkEventCrossing *event,
+                 TaskTitle *title)
+{
+  g_return_val_if_fail (TASK_IS_TITLE (title), FALSE);
+  
+  title->priv->mouse_in_close_button = TRUE;
+  gtk_widget_queue_draw (widget);
+  
+  return FALSE;
+}
+
+static gboolean
+on_leave_notify (GtkWidget *widget,
+                 GdkEventCrossing *event,
+                 TaskTitle *title)
+{
+  g_return_val_if_fail (TASK_IS_TITLE (title), FALSE);
+  
+  title->priv->mouse_in_close_button = FALSE;
+  gtk_widget_queue_draw (widget);
+
+  return FALSE;
+}
+
+static gboolean
+on_button_expose (GtkWidget *widget, 
+                  GdkEventExpose *event,
+                  TaskTitle *title)
+{
+  g_return_val_if_fail (TASK_IS_TITLE (title), FALSE);
+
+  TaskTitlePrivate *priv;
+  priv = title->priv;
+  
+  if (priv->mouse_in_close_button)
+  {
+    GtkStyle *style = gtk_widget_get_style (widget);
+    gtk_paint_box (style, 
+                   event->window,
+                   GTK_STATE_PRELIGHT,
+                   GTK_SHADOW_NONE,
+                   NULL,
+                   NULL,
+                   NULL,
+                   event->area.x,
+                   event->area.y + 2,
+                   event->area.width,
+                   event->area.height - 4); 
+  }
+  return FALSE;
+}
+
 static void
 on_name_changed (WnckWindow *window, TaskTitle *title)
 {
@@ -119,8 +173,6 @@
   if (priv->window != window)
     return;
 
-  gtk_image_set_from_pixbuf (GTK_IMAGE (title->priv->image),
-                             wnck_window_get_mini_icon (window));
   gtk_widget_queue_draw (GTK_WIDGET (title));
 }
 
@@ -196,8 +248,6 @@
   { 
     if (priv->show_home_title)
     {
-      gtk_image_set_from_stock (GTK_IMAGE (priv->image), 
-                                GTK_STOCK_HOME, GTK_ICON_SIZE_MENU);
       gtk_label_set_text (GTK_LABEL (priv->label), _("Home"));
       gtk_image_set_from_pixbuf (GTK_IMAGE (priv->button_image), 
                                  priv->quit_icon);
@@ -217,8 +267,6 @@
   }
   else
   {
-    gtk_image_set_from_pixbuf (GTK_IMAGE (priv->image), 
-                               wnck_window_get_mini_icon (act_window));
     gtk_label_set_text (GTK_LABEL (priv->label), 
                         wnck_window_get_name (act_window));
     gtk_image_set_from_stock (GTK_IMAGE (priv->button_image), 
@@ -250,8 +298,6 @@
     if (task_list_get_desktop_visible (TASK_LIST (task_list_get_default ()))
         && priv->show_home_title)
     {
-      gtk_image_set_from_stock (GTK_IMAGE (priv->image), 
-                                GTK_STOCK_HOME, GTK_ICON_SIZE_MENU);
       gtk_label_set_text (GTK_LABEL (priv->label), _("Home"));
       gtk_image_set_from_pixbuf (GTK_IMAGE (priv->button_image), 
                                  priv->quit_icon);
@@ -380,13 +426,15 @@
   gtk_widget_set_no_show_all (priv->box, TRUE);
   gtk_widget_show (priv->box);
 
-  priv->image = gtk_image_new_from_stock (GTK_STOCK_HOME, GTK_ICON_SIZE_MENU);
-  gtk_box_pack_start (GTK_BOX (priv->box), priv->image, FALSE, FALSE, 0);
-  gtk_widget_show (priv->image);
-
   priv->label = gtk_label_new (_("Home"));
   gtk_label_set_ellipsize (GTK_LABEL (priv->label), PANGO_ELLIPSIZE_END);
   gtk_misc_set_alignment (GTK_MISC (priv->label), 0.0, 0.5);
+  
+  PangoAttrList *attr_list = pango_attr_list_new ();
+  PangoAttribute *attr = pango_attr_weight_new (PANGO_WEIGHT_BOLD);
+  pango_attr_list_insert (attr_list, attr);
+  gtk_label_set_attributes (GTK_LABEL (priv->label), attr_list);
+  
   gtk_box_pack_start (GTK_BOX (priv->box), priv->label, TRUE, TRUE, 0);
   gtk_widget_show (priv->label);
 
@@ -396,8 +444,15 @@
                                NULL);
   gtk_box_pack_start (GTK_BOX (priv->box), priv->button, FALSE, FALSE, 0);
   gtk_widget_show (priv->button);
+  
   g_signal_connect (priv->button, "button-release-event", 
                     G_CALLBACK (on_close_clicked), title);
+  g_signal_connect (priv->button, "enter-notify-event",
+                    G_CALLBACK (on_enter_notify), title);
+  g_signal_connect (priv->button, "leave-notify-event",
+                    G_CALLBACK (on_leave_notify), title);
+  g_signal_connect (priv->button, "expose-event",
+                    G_CALLBACK (on_button_expose), title);
 
   /* Load the quit icon.  We have to do this in such a god-forsaken way
      because of http://bugzilla.gnome.org/show_bug.cgi?id=581359 and the