Merge lp:~h4writer/awn/taskmanager-rewrite into lp:~awn-core/awn/trunk-rewrite

[haytjes]

[Mark Lee (malept)]

=== modified file 'applets/taskmanager/Makefile.am'
--- applets/taskmanager/Makefile.am 2009-05-19 01:06:12 +0000
+++ applets/taskmanager/Makefile.am 2009-06-26 11:00:10 +0000
@@ -17,14 +17,18 @@
        task-drag-indicator.h \
        task-icon.c \
        task-icon.h \
+ task-item.c \
+ task-item.h \
+ task-window.c \
+ task-window.h \
        task-launcher.c \
        task-launcher.h \
        task-manager.c \
        task-manager.h \
+ task-manager-api-wrapper.c \
+ task-manager-api-wrapper.h \
        task-settings.c \
        task-settings.h \
- task-window.c \
- task-window.h \
        $(builddir)/taskmanager-marshal.c \
        $(builddir)/taskmanager-marshal.h \
        xutils.c \
====

Why did task-window.* move?

=== modified file 'applets/taskmanager/task-drag-indicator.c'
--- applets/taskmanager/task-drag-indicator.c 2009-06-19 09:35:43 +0000
+++ applets/taskmanager/task-drag-indicator.c 2009-06-20 14:17:54 +0000
@@ -13,7 +13,7 @@
  * 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 <email address hidden>
+ * Authored by Hannes Verschore <email address hidden>
  *
  */

====

Any particular reason why you removed Neil as author here (and applets/taskmanager/task-drag-indicator.h)?

In general, you should make sure that all of the code that you commented out (instead of deleted) should be annotated with the reason why you're commenting it.

review: Needs Information (superreview)

[moonbeam (rcryderman)]

I'm not going to do a detailed review of this, purely based upon the extent of the modifications. A quick overview doesn't show anything particularly egregious, though I'm sure there are issues (but the current taskmanager code probably has even more fundamental ones). I think we are best served getting this merge, the sooner the better, get it tested and shake out the bugs (and any find design issues).

review: Approve (overview)

[haytjes (h4writer)]

> === modified file 'applets/taskmanager/Makefile.am'
> --- applets/taskmanager/Makefile.am 2009-05-19 01:06:12 +0000
> +++ applets/taskmanager/Makefile.am 2009-06-26 11:00:10 +0000
> @@ -17,14 +17,18 @@
> task-drag-indicator.h \
> task-icon.c \
> task-icon.h \
> + task-item.c \
> + task-item.h \
> + task-window.c \
> + task-window.h \
> task-launcher.c \
> task-launcher.h \
> task-manager.c \
> task-manager.h \
> + task-manager-api-wrapper.c \
> + task-manager-api-wrapper.h \
> task-settings.c \
> task-settings.h \
> - task-window.c \
> - task-window.h \
> $(builddir)/taskmanager-marshal.c \
> $(builddir)/taskmanager-marshal.h \
> xutils.c \
> ====
>
> Why did task-window.* move?

No particularly reason why it has moved. (I think I have removed it accidentally and then added again on the wrong place)

>
> === modified file 'applets/taskmanager/task-drag-indicator.c'
> --- applets/taskmanager/task-drag-indicator.c 2009-06-19 09:35:43 +0000
> +++ applets/taskmanager/task-drag-indicator.c 2009-06-20 14:17:54 +0000
> @@ -13,7 +13,7 @@
> * 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 <email address hidden>
> + * Authored by Hannes Verschore <email address hidden>
> *
> */
>
> ====
>
> Any particular reason why you removed Neil as author here (and
> applets/taskmanager/task-drag-indicator.h)?

Reason: I have made those files and if there are problems with them they should contact me. I copied the license when creating the file, but forgot to change the author.

>
> In general, you should make sure that all of the code that you commented out
> (instead of deleted) should be annotated with the reason why you're commenting
> it.

I think the only code that is commented out is the code for refreshing the launcher list. The code still need to get adapted so it works. I leave the code there for adapting later on.

[Mark Lee (malept)]

> > === modified file 'applets/taskmanager/Makefile.am'
> > --- applets/taskmanager/Makefile.am 2009-05-19 01:06:12 +0000
> > +++ applets/taskmanager/Makefile.am 2009-06-26 11:00:10 +0000
> > @@ -17,14 +17,18 @@
> > task-drag-indicator.h \
> > task-icon.c \
> > task-icon.h \
> > + task-item.c \
> > + task-item.h \
> > + task-window.c \
> > + task-window.h \
> > task-launcher.c \
> > task-launcher.h \
> > task-manager.c \
> > task-manager.h \
> > + task-manager-api-wrapper.c \
> > + task-manager-api-wrapper.h \
> > task-settings.c \
> > task-settings.h \
> > - task-window.c \
> > - task-window.h \
> > $(builddir)/taskmanager-marshal.c \
> > $(builddir)/taskmanager-marshal.h \
> > xutils.c \
> > ====
> >
> > Why did task-window.* move?
>
> No particularly reason why it has moved. (I think I have removed it
> accidentally and then added again on the wrong place)

Once the task-window.* entries are moved back (make sure you use tabs, not spaces), I have no objection to merging to rewrite.

[haytjes (h4writer)]

> > > === modified file 'applets/taskmanager/Makefile.am'
> > > --- applets/taskmanager/Makefile.am 2009-05-19 01:06:12 +0000
> > > +++ applets/taskmanager/Makefile.am 2009-06-26 11:00:10 +0000
> > > @@ -17,14 +17,18 @@
> > > task-drag-indicator.h \
> > > task-icon.c \
> > > task-icon.h \
> > > + task-item.c \
> > > + task-item.h \
> > > + task-window.c \
> > > + task-window.h \
> > > task-launcher.c \
> > > task-launcher.h \
> > > task-manager.c \
> > > task-manager.h \
> > > + task-manager-api-wrapper.c \
> > > + task-manager-api-wrapper.h \
> > > task-settings.c \
> > > task-settings.h \
> > > - task-window.c \
> > > - task-window.h \
> > > $(builddir)/taskmanager-marshal.c \
> > > $(builddir)/taskmanager-marshal.h \
> > > xutils.c \
> > > ====
> > >
> > > Why did task-window.* move?
> >
> > No particularly reason why it has moved. (I think I have removed it
> > accidentally and then added again on the wrong place)
>
> Once the task-window.* entries are moved back (make sure you use tabs, not
> spaces), I have no objection to merging to rewrite.

I will adjust it. But currently I'm doing a vacation job and I'm not home tonight. So it will be tomorrow evening. I will ask dolfje to do tonight, but I'm not sure if he will do it.

[Michal Hruby (mhr3)]

I basically agree with moonbeam, this is way too big to be reviewed into detail, so I'd also say let's merge it and solve the problems as they come up...

Anyway, I did notice one small issue:

681 + if (priv->overlay_text)
682 + {
683 + awn_overlayable_remove_overlay (AWN_OVERLAYABLE (icon),
684 + AWN_OVERLAY (priv->overlay_text));
685 + g_object_unref (priv->overlay_text);
686 + priv->overlay_text = NULL;
687 + }

Overlays are initially unowned, so you do not need to unref them (the remove_overlay method will destroy them).

review: Approve

[haytjes (h4writer)]

> I basically agree with moonbeam, this is way too big to be reviewed into
> detail, so I'd also say let's merge it and solve the problems as they come
> up...
>
> Anyway, I did notice one small issue:
>
> 681 + if (priv->overlay_text)
> 682 + {
> 683 + awn_overlayable_remove_overlay (AWN_OVERLAYABLE (icon),
> 684 + AWN_OVERLAY (priv->overlay_text));
> 685 + g_object_unref (priv->overlay_text);
> 686 + priv->overlay_text = NULL;
> 687 + }
>
> Overlays are initially unowned, so you do not need to unref them (the
> remove_overlay method will destroy them).

Ah, good to know. I was really doubting about it.

[haytjes (h4writer)]

Sorry that it takes so long. I have problems with creating time to work on it. I had 30min yesterday and I thought I could do those tiny adjustments within time, but it didn't worked :(. (A bit strange). I didn't investigate yet what the problem was, why it didn't work, but I will check tonight and commit it.

[haytjes (h4writer)]

Sorry that it takes so long. I have problems with creating time to work on it. I had 30min yesterday and I thought I could do those tiny adjustments within time, but it didn't worked :(. (A bit strange). I didn't investigate yet what the problem was, why it didn't work, but I will check tonight and commit it.

[lp:~h4writer/awn/taskmanager-rewrite]

953. By haytjes on 2009-07-02

- adjusted some bits before merge like suggested by malept and mhr3

[haytjes (h4writer)]

review: Approve

=== modified file 'applets/taskmanager/Makefile.am'
--- applets/taskmanager/Makefile.am	2009-05-19 01:06:12 +0000
+++ applets/taskmanager/Makefile.am	2009-06-26 11:00:10 +0000
@@ -17,14 +17,18 @@
 	task-drag-indicator.h \
 	task-icon.c \
 	task-icon.h \
+	task-item.c \
+	task-item.h \
+  task-window.c \
+  task-window.h \
 	task-launcher.c \
 	task-launcher.h \
 	task-manager.c \
 	task-manager.h \
+	task-manager-api-wrapper.c \
+	task-manager-api-wrapper.h \
 	task-settings.c \
 	task-settings.h \
-	task-window.c \
-	task-window.h \
 	$(builddir)/taskmanager-marshal.c \
 	$(builddir)/taskmanager-marshal.h \
 	xutils.c \

=== modified file 'applets/taskmanager/task-drag-indicator.c'
--- applets/taskmanager/task-drag-indicator.c	2009-06-19 09:35:43 +0000
+++ applets/taskmanager/task-drag-indicator.c	2009-06-20 14:17:54 +0000
@@ -13,7 +13,7 @@
  * 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]>
+ * Authored by Hannes Verschore <[e-mail]>
  *
  */
 
@@ -151,6 +151,12 @@
   GtkWidget *drag_indicator = NULL;
 
   drag_indicator = g_object_new (TASK_TYPE_DRAG_INDICATOR, NULL);
+  gtk_widget_hide (drag_indicator);
+
+  //BUG: AwnApplet calls upon start gtk_widget_show_all. So even when gtk_widget_hide
+  //     gets called, it will get shown. So I'm forcing it to not listen to 
+  //     'gtk_widget_show_all' with this function. FIXME: improve AwnApplet
+  gtk_widget_set_no_show_all (drag_indicator, TRUE);
 
   return drag_indicator;
 }

=== modified file 'applets/taskmanager/task-drag-indicator.h'
--- applets/taskmanager/task-drag-indicator.h	2009-05-27 15:57:06 +0000
+++ applets/taskmanager/task-drag-indicator.h	2009-06-20 14:17:54 +0000
@@ -13,7 +13,7 @@
  * 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]>
+ * Authored by Hannes Verschore <[e-mail]>
  *
  */
 

=== modified file 'applets/taskmanager/task-icon.c'
--- applets/taskmanager/task-icon.c	2009-06-19 09:35:43 +0000
+++ applets/taskmanager/task-icon.c	2009-06-26 11:00:10 +0000
@@ -14,6 +14,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by Neil Jagdish Patel <[e-mail]>
+ *             Hannes Verschore <[e-mail]>
  *
  */
 
@@ -33,7 +34,7 @@
 #include "task-launcher.h"
 #include "task-settings.h"
 
-G_DEFINE_TYPE (TaskIcon, task_icon, AWN_TYPE_ICON)
+G_DEFINE_TYPE (TaskIcon, task_icon, AWN_TYPE_THEMED_ICON)
 
 #define TASK_ICON_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj),\
   TASK_TYPE_ICON, \
@@ -41,7 +42,27 @@
 
 struct _TaskIconPrivate
 {
-  GSList *windows;
+  //List containing the TaskItems
+  GSList *items;
+
+  //The number of TaskItems that get shown
+  guint shown_items;
+
+  //The number of TaskWindows (subclass of TaskItem) that needs attention
+  guint needs_attention;
+
+  //The number of TaskWindows (subclass of TaskItem) that have the active state.
+  guint is_active;
+
+  //The main item being used for the icon (and if alone for the text)
+  TaskItem *main_item;
+
+  //Whetever this icon is visible or not
+  gboolean visible;
+
+  //An overlay for showing number of items
+  AwnOverlayText *overlay_text;
+  
   GdkPixbuf *icon;
   GtkWidget *dialog;
 
@@ -64,13 +85,12 @@
 {
   PROP_0,
 
-  PROP_WINDOW,
   PROP_DRAGGABLE
 };
 
 enum
 {
-  ENSURE_LAYOUT,
+  VISIBLE_CHANGED,
 
   SOURCE_DRAG_FAIL,
   SOURCE_DRAG_BEGIN,
@@ -113,7 +133,7 @@
 static gboolean  task_icon_dialog_unfocus       (GtkWidget      *widget,
                                                 GdkEventFocus   *event,
                                                 gpointer        null);
-/* Dnd 'source' forwards */
+/* Dnd forwards */
 static void      task_icon_drag_data_get        (GtkWidget *widget, 
                                                  GdkDragContext *context, 
                                                  GtkSelectionData *selection_data,
@@ -148,6 +168,9 @@
                                                      guint           time);
 
 static gboolean _update_geometry(GtkWidget *widget);
+static gboolean task_icon_refresh_geometry (TaskIcon *icon);
+static void     task_icon_refresh_visible  (TaskIcon *icon);
+static void     task_icon_search_main_item (TaskIcon *icon);
 
 /* GObject stuff */
 static void
@@ -161,11 +184,6 @@
 
   switch (prop_id)
   {
-    case PROP_WINDOW:
-      g_value_set_object (value, 
-                          priv->windows ? priv->windows->data : NULL); 
-      break;
-
     case PROP_DRAGGABLE:
       g_value_set_boolean (value, priv->draggable); 
       break;
@@ -185,10 +203,6 @@
 
   switch (prop_id)
   {
-    case PROP_WINDOW:
-      task_icon_append_window (icon, g_value_get_object (value));
-      break;
-
     case PROP_DRAGGABLE:
       task_icon_set_draggable (icon, g_value_get_boolean (value));
       break;
@@ -198,10 +212,15 @@
   }
 }
 
+/**
+ * Finalize the object and remove the list of windows, 
+ * the list of launchers and the timer of update_geometry.
+ */
 static void
 task_icon_dispose (GObject *object)
 {
   TaskIconPrivate *priv = TASK_ICON_GET_PRIVATE (object);
+  
   /*this needs to be done in dispose, not finalize, due to idiosyncracies of 
    AwnDialog*/
   if (priv->dialog)
@@ -209,6 +228,7 @@
     gtk_widget_destroy (priv->dialog);
     priv->dialog = NULL;
   }
+  
   G_OBJECT_CLASS (task_icon_parent_class)->dispose (object);  
 }
 
@@ -218,13 +238,15 @@
   TaskIconPrivate *priv = TASK_ICON_GET_PRIVATE (object);
 
   /* FIXME  Check to see if icon needs to be unreffed */
-  if (priv->windows)
+  if (priv->items)
   {
-    g_slist_free (priv->windows);
-    priv->windows = NULL;
+    g_slist_free (priv->items);
+    priv->items = NULL;
   }
   if(priv->update_geometry_id)
+  {
     g_source_remove(priv->update_geometry_id);
+  }
 
   G_OBJECT_CLASS (task_icon_parent_class)->finalize (object);
 }
@@ -234,13 +256,27 @@
 {
   TaskIconPrivate *priv = TASK_ICON (object)->priv;
   GtkWidget *widget = GTK_WIDGET(object);
- 
+
+  if ( G_OBJECT_CLASS (task_icon_parent_class)->constructed)
+  {
+    G_OBJECT_CLASS (task_icon_parent_class)->constructed (object);
+  }
+  
+  //update geometry of icon every second.
   priv->update_geometry_id = g_timeout_add_seconds (1, (GSourceFunc)_update_geometry, widget);
 }
- 
+
+/**
+ * Checks if the position of the widget has changed.
+ * Upon change it asks the icon to refresh.
+ * returns: TRUE when succeeds
+ *          FALSE when widget isn't an icon
+ */
 static gboolean 
 _update_geometry(GtkWidget *widget)
 {
+  return TRUE; //TODO solve
+  
   gint x,y;
   TaskIconPrivate *priv;
   GdkWindow *win;
@@ -251,6 +287,7 @@
 
   win = gtk_widget_get_window (widget);
   gdk_window_get_origin (win, &x, &y);
+
   if(priv->old_x != x || priv->old_y != y)
   {
     priv->old_x = x;
@@ -260,7 +297,86 @@
 
   return TRUE;
 }
- 
+
+/**
+ * Set the icon geometry of the windows in a task-icon.
+ * This equals to the minimize position of the window.
+ * TODO: not done (part2)
+ */
+static gboolean
+task_icon_refresh_geometry (TaskIcon *icon)
+{
+  TaskSettings *settings;
+  TaskIconPrivate *priv;
+  GtkWidget *widget;
+  GdkWindow *win;
+  GSList    *w;
+  gint      x, y, ww, width, height;
+  gint      i = 0, len = 0;
+
+  g_return_val_if_fail (TASK_IS_ICON (icon), FALSE);
+
+  priv = icon->priv;
+  widget = GTK_WIDGET (icon);
+
+  //get the position of the widget
+  win = gtk_widget_get_window (widget);
+  gdk_window_get_origin (win, &x, &y);
+
+  settings = task_settings_get_default ();
+
+  switch (settings->orient)
+  {
+    case AWN_ORIENTATION_RIGHT:
+    case AWN_ORIENTATION_LEFT:
+      ww = GTK_WIDGET (icon)->allocation.height;
+      break;
+    case AWN_ORIENTATION_TOP:
+    case AWN_ORIENTATION_BOTTOM:
+      ww = GTK_WIDGET (icon)->allocation.width;
+      break;
+    default:
+      g_error ("Orientation isn't right, left, top, bottom ??");
+      break;
+  }
+
+  /* FIXME: Do something clever here to allow the user to "scrub" the icon
+   * for the windows.
+   */
+  len = g_slist_length (priv->items);
+  ww = ww/len;
+  for (w = priv->items; w; w = w->next)
+  {
+    if (!TASK_IS_WINDOW (w->data)) continue;
+
+    TaskWindow *window = TASK_WINDOW (w->data);
+
+    switch (settings->orient)
+    {
+      case AWN_ORIENTATION_RIGHT:
+        width = settings->panel_size+settings->offset;
+        height = ww + (i*ww);
+        break;
+      case AWN_ORIENTATION_LEFT:
+        width = settings->panel_size+settings->offset;
+        height = ww + (i*ww);
+        break;
+      case AWN_ORIENTATION_TOP:
+        width = ww + (i*ww);
+        height = settings->panel_size+settings->offset;
+        break;
+      default:
+        width = ww + (i*ww);
+        height = settings->panel_size+settings->offset;
+        break;
+    }
+    task_window_set_icon_geometry (window, x, y, 
+                                   width,
+                                   height);
+    i++;
+  }
+  return FALSE;
+}
 
 static void
 task_icon_class_init (TaskIconClass *klass)
@@ -272,7 +388,7 @@
   obj_class->constructed  = task_icon_constructed;
   obj_class->set_property = task_icon_set_property;
   obj_class->get_property = task_icon_get_property;
-  obj_class->dispose     = task_icon_dispose;
+  obj_class->dispose      = task_icon_dispose;
   obj_class->finalize     = task_icon_finalize;
 
   wid_class->configure_event      = task_icon_configure_event;
@@ -285,15 +401,7 @@
   wid_class->drag_leave           = task_icon_dest_drag_leave;
   wid_class->drag_data_received   = task_icon_dest_drag_data_received;
 
-
   /* Install properties first */
-  pspec = g_param_spec_object ("taskwindow",
-                               "TaskWindow",
-                               "TaskWindow",
-                               TASK_TYPE_WINDOW,
-                               G_PARAM_READWRITE);
-  g_object_class_install_property (obj_class, PROP_WINDOW, pspec);
-
   pspec = g_param_spec_boolean ("draggable",
                                 "Draggable",
                                 "TaskIcon is draggable?",
@@ -302,11 +410,11 @@
   g_object_class_install_property (obj_class, PROP_DRAGGABLE, pspec);
 
   /* Install signals */
-  _icon_signals[ENSURE_LAYOUT] =
-		g_signal_new ("ensure-layout",
+  _icon_signals[VISIBLE_CHANGED] =
+		g_signal_new ("visible_changed",
 			      G_OBJECT_CLASS_TYPE (obj_class),
 			      G_SIGNAL_RUN_LAST,
-			      G_STRUCT_OFFSET (TaskIconClass, ensure_layout),
+			      G_STRUCT_OFFSET (TaskIconClass, visible_changed),
 			      NULL, NULL,
 			      g_cclosure_marshal_VOID__VOID, 
 			      G_TYPE_NONE, 0);
@@ -368,11 +476,17 @@
   g_signal_connect (G_OBJECT (priv->dialog),"focus-out-event",
                     G_CALLBACK (task_icon_dialog_unfocus),NULL);  
   priv->icon = NULL;
-  priv->windows = NULL;
+  priv->items = NULL;
   priv->drag_tag = 0;
   priv->drag_motion = FALSE;
   priv->gets_dragged = FALSE;
   priv->update_geometry_id = 0;
+  priv->shown_items = 0;
+  priv->needs_attention = 0;
+  priv->is_active = 0;
+  priv->main_item = NULL;
+  priv->visible = FALSE;
+  priv->overlay_text = NULL;
 
   awn_icon_set_orientation (AWN_ICON (icon), AWN_ORIENTATION_BOTTOM);
 
@@ -394,88 +508,46 @@
                        GDK_ACTION_MOVE);
 }
 
+/**
+ * Creates a new TaskIcon, hides it and returns it.
+ * (Hiding is because there are no visible TaskItems yet in the TaskIcon)  
+ */
 GtkWidget *
-task_icon_new_for_window (TaskWindow *window)
+task_icon_new ()
 {
-  GtkWidget *icon = NULL;
-
-  g_return_val_if_fail (TASK_IS_WINDOW (window), NULL);
-
-  icon = g_object_new (TASK_TYPE_ICON,
-                       "taskwindow", window,
-                       NULL);
+  GtkWidget *icon = g_object_new (TASK_TYPE_ICON, NULL);
+  gtk_widget_hide (icon);
+
+  //BUG: AwnApplet calls upon start gtk_widget_show_all. So even when gtk_widget_hide
+  //     gets called, it will get shown. So I'm forcing it to not listen to 
+  //     'gtk_widget_show_all' with this function. FIXME: improve AwnApplet
+  gtk_widget_set_no_show_all (icon, TRUE);
+  
   return icon;
 }
 
-/*
- * Public Functions
+/**
+ * The name of the main TaskItem in this TaskIcon changed.
+ * So update the tooltip text.
  */
-gboolean 
-task_icon_is_skip_taskbar (TaskIcon *icon)
-{
-  g_return_val_if_fail (TASK_IS_ICON (icon), FALSE);
-
-  /*if (TASK_IS_LAUNCHER_WINDOW (icon->priv->windows->data))
-    return FALSE;*/
-
-  if (icon->priv->windows)
-    return task_window_is_hidden (icon->priv->windows->data);
-
-  return FALSE;
-}
-
-gboolean  
-task_icon_is_in_viewport (TaskIcon *icon, WnckWorkspace *space)
-{
-  g_return_val_if_fail (TASK_IS_ICON (icon), FALSE);
-
-  /*if (TASK_IS_LAUNCHER_WINDOW (icon->priv->windows->data))
-    return TRUE;*/
-
-  if (icon->priv->windows)
-    return task_window_is_on_workspace (icon->priv->windows->data, space);
-
-  return TRUE;
-}
-
-static void
-window_closed (TaskIcon *icon, TaskWindow *old_window)
-{
-  TaskIconPrivate *priv;
-
-  g_return_if_fail (TASK_IS_ICON (icon));
-  g_return_if_fail (TASK_IS_WINDOW (old_window));
-  priv = icon->priv;
-
-  if (! TASK_IS_LAUNCHER(old_window))
-  {
-    priv->windows = g_slist_remove (priv->windows, old_window);
-  }
-
-  if (g_slist_length (priv->windows) == 0)
-  {
-    gtk_widget_destroy (GTK_WIDGET (icon));
-  }
-  else
-  {
-    /* Load up with new icon etc */
-  }
-}
-
-static void
-on_window_name_changed (TaskWindow  *window, 
-                        const gchar *name, 
-                        TaskIcon    *icon)
+static void
+on_main_item_name_changed (TaskItem    *item, 
+                           const gchar *name, 
+                           TaskIcon    *icon)
 {
   g_return_if_fail (TASK_IS_ICON (icon));
 
   awn_icon_set_tooltip_text (AWN_ICON (icon), name);
 }
 
+/**
+ * The icon of the main TaskItem in this TaskIcon changed.
+ * So update the icon of the TaskIcon (AwnIcon).
+ */
 static void
-on_window_icon_changed (TaskWindow *window, 
-                        GdkPixbuf  *pixbuf, 
-                        TaskIcon   *icon)
+on_main_item_icon_changed (TaskItem   *item, 
+                           GdkPixbuf  *pixbuf, 
+                           TaskIcon   *icon)
 {
   TaskIconPrivate *priv;
 
@@ -490,263 +562,460 @@
   awn_icon_set_from_pixbuf (AWN_ICON (icon), priv->icon);
 }
 
+/**
+ * The visibility of the main TaskItem in this TaskIcon changed.
+ * Because normally the main TaskItem should always be visible,
+ * it searches after a new main TaskItem.
+ */
+static void
+on_main_item_visible_changed (TaskItem  *item,
+                              gboolean   visible,
+                              TaskIcon  *icon)
+{
+  g_return_if_fail (TASK_IS_ICON (icon));
+
+  /* the main TaskItem should have been visible, so if
+     the main TaskItem becomes visible only now,
+     it indicates a bug. 
+     FIXME: this is possible atm in TaskWindow */
+  if (visible) return;
+
+  task_icon_search_main_item (icon);
+}
+
+/**
+ * Notify that the icon that a window is closed. The window gets
+ * removed from the list and when this icon doesn't has any 
+ * launchers and no windows it will get destroyed.
+ */
+static void
+_destroyed_task_item (TaskIcon *icon, TaskItem *old_item)
+{
+  TaskIconPrivate *priv;
+
+  g_return_if_fail (TASK_IS_ICON (icon));
+  g_return_if_fail (TASK_IS_ITEM (old_item));
+
+  priv = icon->priv;
+  priv->items = g_slist_remove (priv->items, old_item);
+
+  if (old_item == priv->main_item)
+  {
+    task_icon_search_main_item (icon);
+  }
+
+  task_icon_refresh_visible (icon);
+
+  if (g_slist_length (priv->items) == 0)
+  {
+    gtk_widget_destroy (GTK_WIDGET (icon));
+  }
+  else
+  {
+    /* TODO: Load up with new icon etc */
+  }
+}
+
+/**
+ * Searches for a new main item.
+ * A main item is used for displaying its icon and also the text (if there is only one item)
+ * Attention: this function doesn't check if it is needed to switch to a new main item.
+ */
+static void
+task_icon_search_main_item (TaskIcon *icon)
+{
+  TaskIconPrivate *priv;
+  GSList *i;
+  TaskItem *main_item = NULL;
+
+  g_return_if_fail (TASK_IS_ICON (icon));
+
+  priv = icon->priv;
+
+  for (i = priv->items; i; i = i->next)
+  {
+    TaskItem *item = i->data;
+
+    if (!task_item_is_visible (item)) continue;
+
+    main_item = item;
+    break;
+  }
+
+  //remove signals of old main_item
+  if (priv->main_item)
+  {
+    g_signal_handlers_disconnect_by_func(priv->main_item, 
+                                         G_CALLBACK (on_main_item_name_changed), icon);
+    g_signal_handlers_disconnect_by_func(priv->main_item, 
+                                         G_CALLBACK (on_main_item_icon_changed), icon);
+    g_signal_handlers_disconnect_by_func(priv->main_item, 
+                                         G_CALLBACK (on_main_item_visible_changed), icon);
+    priv->main_item = NULL;
+  }
+
+  if (main_item)
+  {
+    priv->main_item = main_item;
+    priv->icon = task_item_get_icon (priv->main_item);
+    awn_icon_set_from_pixbuf (AWN_ICON (icon), priv->icon);
+    awn_icon_set_tooltip_text (AWN_ICON (icon), 
+                               task_item_get_name (priv->main_item));
+    g_signal_connect (priv->main_item, "name-changed",
+                      G_CALLBACK (on_main_item_name_changed), icon);
+    g_signal_connect (priv->main_item, "icon-changed",
+                      G_CALLBACK (on_main_item_icon_changed), icon);
+    g_signal_connect (priv->main_item, "visible-changed",
+                      G_CALLBACK (on_main_item_visible_changed), icon);
+  }
+}
+
+/**
+ * 
+ */
+static void
+task_icon_refresh_visible (TaskIcon *icon)
+{
+  TaskIconPrivate *priv;
+  GSList *w;
+  guint count = 0;
+  guint count_windows = 0;
+
+  g_return_if_fail (TASK_IS_ICON (icon));
+
+  priv = icon->priv;
+
+  for (w = priv->items; w; w = w->next)
+  {
+    TaskItem *item = w->data;
+
+    if (!task_item_is_visible (item)) continue;
+    count++;
+
+    if (!TASK_IS_WINDOW (item)) continue;
+    count_windows++;
+  }
+
+  awn_icon_set_indicator_count (AWN_ICON (icon), (count_windows>0) ? 1 : 0);
+  
+  if (count != priv->shown_items)
+  {
+    g_debug("shown items changed: %i", count);
+
+    if (count > 1)
+    {
+      if (!priv->overlay_text)
+      {
+        priv->overlay_text = awn_overlay_text_new ();
+        awn_overlayable_add_overlay (AWN_OVERLAYABLE (icon), 
+                                     AWN_OVERLAY (priv->overlay_text));
+        g_object_set (G_OBJECT (priv->overlay_text),
+                      "gravity", GDK_GRAVITY_SOUTH_EAST, 
+                      "font-sizing", AWN_FONT_SIZE_LARGE,
+                      "text_color_astr", "#FFFFFFFF",
+                      "apply-effects", TRUE,
+                      NULL);
+      }
+      gchar* count_str = g_strdup_printf ("%i",count);
+      g_object_set (G_OBJECT (priv->overlay_text),
+                    "text", count_str,
+                    NULL);
+      g_free (count_str);
+    }
+    else
+    {
+      if (priv->overlay_text)
+      {
+        awn_overlayable_remove_overlay (AWN_OVERLAYABLE (icon), 
+                                        AWN_OVERLAY (priv->overlay_text));
+        g_object_unref (priv->overlay_text);
+        priv->overlay_text = NULL;
+      }
+    }
+    
+    if (count == 0)
+    {
+      priv->visible = FALSE;
+    }
+    else
+    {
+      if (!priv->main_item)
+        task_icon_search_main_item (icon);
+      
+      priv->visible = TRUE;
+    }
+
+    g_signal_emit (icon, _icon_signals[VISIBLE_CHANGED], 0);
+  }
+
+  priv->shown_items = count;
+}
+
+/**
+ * The 'active' state of a TaskWindow changed.
+ * If this is the only TaskWindow that's active,
+ * the TaskIcon will get an active state.
+ * If it the last TaskWindow that isn't active anymore
+ * the TaskIcon will get an inactive state too.
+ * STATE: adjusted
+ * PROBLEM: It shouldn't get called when the state didn't change.
+            Else the count of windows that need have the active state will be off.
+ */
 static void
 on_window_active_changed (TaskWindow *window, 
                           gboolean    is_active, 
                           TaskIcon   *icon)
 {
+  TaskIconPrivate *priv;
+  GSList *w;
+  guint count = 0;
+
   g_return_if_fail (TASK_IS_ICON (icon));
 
-  awn_icon_set_is_active (AWN_ICON (icon), is_active);
+  priv = icon->priv;
+
+  for (w = priv->items; w; w = w->next)
+  {
+    TaskItem *item = w->data;
+
+    if (!TASK_IS_WINDOW (item)) continue;
+    if (!task_item_is_visible (item)) continue;
+    if (!task_window_is_active (TASK_WINDOW (item))) continue;
+
+    count++;
+  }
+
+  if (priv->is_active == 0 && count == 1)
+  {
+      awn_icon_set_is_active (AWN_ICON (icon), TRUE);
+  }
+  else if (priv->is_active == 1 && count == 0)
+  {
+      awn_icon_set_is_active (AWN_ICON (icon), FALSE);
+  }
+  
+  priv->is_active = count;
 }
 
+/**
+ * The 'needs attention' state of a window changed.
+ * If a window needs attention and there isn't one yet, it will
+ * start the animation. When every window don't need attention anymore
+ * it will stop the animation.
+ * STATE: adjusted
+ * TODO: h4writer - check if it is possible to interupt animation mid-air,
+ * and let it start again, if there is a 2nd/3rd window that needs attention.
+ * BUG: when icon becomes visible again it needs to be checked if it needs attention again.
+ */
 static void
 on_window_needs_attention_changed (TaskWindow *window,
                                    gboolean    needs_attention,
                                    TaskIcon   *icon)
 {
+  TaskIconPrivate *priv;
+  GSList *w;
+  guint count = 0;
+
   g_return_if_fail (TASK_IS_ICON (icon));
 
-  if (needs_attention)
+  priv = icon->priv;
+
+  for (w = priv->items; w; w = w->next)
+  {
+    TaskItem *item = w->data;
+
+    if (!TASK_IS_WINDOW (item)) continue;
+    if (!task_item_is_visible (item)) continue;
+    if (!task_window_needs_attention (TASK_WINDOW (item))) continue;
+
+    count++;
+  }
+
+  if (priv->needs_attention == 0 && count == 1)
+  {
     awn_icon_set_effect (AWN_ICON (icon),AWN_EFFECT_ATTENTION);
-  else
-    awn_effects_stop (awn_overlayable_get_effects (AWN_OVERLAYABLE (icon)),
+  }
+  else if (priv->needs_attention == 1 && count == 0)
+  {
+    awn_effects_stop (awn_overlayable_get_effects (AWN_OVERLAYABLE (icon)), 
                       AWN_EFFECT_ATTENTION);
-}
-
-static void
-on_window_workspace_changed (TaskWindow    *window,  
-                             WnckWorkspace *space,
-                             TaskIcon      *icon)
-{
-  g_return_if_fail (TASK_IS_ICON (icon));
+  }
   
-  g_signal_emit (icon, _icon_signals[ENSURE_LAYOUT], 0);
-}
-
-static void
-on_window_message_changed (TaskWindow  *window, 
-                           const gchar *message,
-                           TaskIcon    *icon)
-{
-  g_return_if_fail (TASK_IS_ICON (icon));
-
-  awn_icon_set_message (AWN_ICON (icon), message);
-}
-
-static void
-on_window_progress_changed (TaskWindow *window,
-                            gfloat      progress,
+  priv->needs_attention = count;
+}
+
+/**
+ * When the progress of a TaskWindow has changed,
+ * it will recalculate the process of all the
+ * TaskWindows this TaskIcon contains.
+ * STATE: adjusted
+ */
+static void
+on_window_progress_changed (TaskWindow   *window,
+                            gfloat      adjusted_progress,
                             TaskIcon   *icon)
 {
-  g_return_if_fail (TASK_IS_ICON (icon));
-
-  awn_icon_set_progress (AWN_ICON (icon), progress);
-}
-
-static void
-on_window_hidden_changed (TaskWindow *window,
-                          gboolean    is_hidden,
-                          TaskIcon   *icon)
-{
-  g_return_if_fail (TASK_IS_ICON (icon));
-
-  g_signal_emit (icon, _icon_signals[ENSURE_LAYOUT], 0);
-}
-
-static void
-on_window_running_changed (TaskWindow *window, 
-                           gboolean    is_running,
-                           TaskIcon   *icon)
-{
-  g_return_if_fail (TASK_IS_ICON (icon));
-  awn_icon_set_indicator_count (AWN_ICON (icon), is_running ? 1 : 0);
-}
-
-void
-task_icon_remove_window (TaskIcon      *icon,
-                         WnckWindow    *window)
-{
-  GSList *  w;
-  TaskIconPrivate *priv;
-
-  g_return_if_fail (TASK_IS_ICON (icon));
-  g_return_if_fail (WNCK_IS_WINDOW (window));
-  priv = icon->priv;
-  for (w = priv->windows;w;w=w->next)
-  {
-    TaskWindow * task_win = w->data;
-    if (! TASK_IS_WINDOW(task_win) )
-    {
-      continue;
-    }
-    if (task_win->priv->window == window)
-    {
-      g_assert (TASK_IS_WINDOW(task_win));
-      if (! TASK_IS_LAUNCHER(task_win) )
-      {
-        priv->windows = g_slist_remove (priv->windows, task_win);
-      }
-    }
-  }
-}
-
-/*
- FIXME   2nd arg isn't the WnckWindow
- */
-static void
-_task_icon_launcher_change (TaskLauncher * launcher,
-                            WnckWindow   * wnck_win,
-                            TaskIcon    *  icon)
-{
-  GtkWidget * grouped_icon = NULL;  
-  if (wnck_win)
-  {
-    TaskWindow * taskwin = task_window_new (TASK_WINDOW(launcher)->priv->window);    
-    grouped_icon = task_icon_new_for_window (taskwin);
-    gtk_widget_show (grouped_icon);    
-    gtk_container_add (GTK_CONTAINER(icon->priv->dialog),grouped_icon);
-  }
-  
-}
-
-void
-task_icon_append_window (TaskIcon      *icon,
-                         TaskWindow    *window)
-{
-  TaskIconPrivate *priv;
-  gboolean first_window = FALSE;
-  static gboolean recursing = FALSE;
-  
-  g_assert (window);
+  TaskIconPrivate *priv;
+  GSList *w;
+  gfloat progress = 0;
+  guint len = 0;
+
+  g_return_if_fail (TASK_IS_ICON (icon));
+
+  priv = icon->priv;
+
+  for (w = priv->items; w; w = w->next)
+  {
+    TaskItem *item = w->data;
+
+    if (!TASK_IS_WINDOW (item)) continue;
+    if (!task_item_is_visible (item)) continue;
+
+    if (progress != -1)
+    {
+      progress += task_window_get_progress (TASK_WINDOW (item));
+      len++;
+    }
+  }
+
+  awn_icon_set_progress (AWN_ICON (icon), progress/len);
+}
+
+/**
+ * When a TaskWindow becomes visible or invisible,
+ * update the number of shown windows.
+ * If because of that the icon has no shown TaskWindows
+ * anymore it will get hidden. If there was no shown
+ * TaskWindow and now the first one gets visible,
+ * then show TaskIcon.
+ * STATE: adjusted
+ */
+static void
+on_item_visible_changed (TaskItem   *item,
+                         gfloat      visible,
+                         TaskIcon   *icon)
+{
+  g_return_if_fail (TASK_IS_ICON (icon));
+  g_return_if_fail (TASK_IS_ITEM (item));
+  
+  task_icon_refresh_visible (icon);
+}
+
+/**
+ * Public Functions
+ */
+
+/**
+ * Returns whetever this icon should be visible.
+ * (That means it should contain atleast 1 visible item)
+ */
+gboolean
+task_icon_is_visible (TaskIcon      *icon)
+{
+  g_return_val_if_fail (TASK_IS_ICON (icon), FALSE);
+  
+  return icon->priv->visible;
+}
+
+/**
+ * Returns whetever this icon contains atleast one (visible?) launcher.
+ * TODO: adapt TaskIcon so it has a guint with the numbers of TaskLaunchers/TaskWindows
+ */
+gboolean
+task_icon_contains_launcher (TaskIcon      *icon)
+{
+  TaskIconPrivate *priv;
+  GSList *w;
+
+  g_return_val_if_fail (TASK_IS_ICON (icon), FALSE);
+
+  priv = icon->priv;
+
+  for (w = priv->items; w; w = w->next)
+  {
+    TaskItem *item = w->data;
+
+    if (!task_item_is_visible (item)) continue;
+
+    if (TASK_IS_LAUNCHER (item))
+      return TRUE;
+  }
+  return FALSE;
+}
+
+guint
+task_icon_match_item (TaskIcon      *icon,
+                      TaskItem      *item_to_match)
+{
+  TaskIconPrivate *priv;
+  GSList *w;
+  guint max_score = 0;
+
+  g_return_val_if_fail (TASK_IS_ICON (icon), 0);
+  g_return_val_if_fail (TASK_IS_ITEM (item_to_match), 0);
+
+  priv = icon->priv;
+
+  for (w = priv->items; w; w = w->next)
+  {
+    TaskItem *item = w->data;
+    guint score;
+
+    if (!task_item_is_visible (item)) continue;
+    
+    score = task_item_match (item, item_to_match);
+    if (score > max_score)
+      max_score = score;
+  }
+  
+  return max_score;
+}
+
+/**
+ * Adds a TaskWindow to this task-icon
+ */
+void
+task_icon_append_item (TaskIcon      *icon,
+                       TaskItem      *item)
+{
+  TaskIconPrivate *priv;
+  
+  g_assert (item);
   g_assert (icon);
   g_return_if_fail (TASK_IS_ICON (icon));
-  g_return_if_fail (TASK_IS_WINDOW (window));
+  g_return_if_fail (TASK_IS_ITEM (item));
+
   priv = icon->priv;
 
-  /* Is this the first, main, window of this icon? */
-  if (priv->windows == NULL)
-    first_window = TRUE;
-
-  priv->windows = g_slist_append (priv->windows, window);
-  g_object_weak_ref (G_OBJECT (window), (GWeakNotify)window_closed, icon);
-
-  /* If it's the first window, let's set-up our icon accordingly */
-  if (first_window)
+  priv->items = g_slist_append (priv->items, item);
+  gtk_widget_show_all (GTK_WIDGET (item));
+  gtk_container_add (GTK_CONTAINER (priv->dialog), GTK_WIDGET (item));
+  
+  g_object_weak_ref (G_OBJECT (item), (GWeakNotify)_destroyed_task_item, icon);
+
+  task_icon_refresh_visible (icon);
+
+  /* Connect item signals */
+  g_signal_connect (item, "visible-changed",
+                    G_CALLBACK (on_item_visible_changed), icon);
+    
+  /* Connect window signals */
+  if (TASK_IS_WINDOW (item))
   {
-    priv->icon = task_window_get_icon (window);
-    awn_icon_set_from_pixbuf (AWN_ICON (icon), priv->icon);
-
-    awn_icon_set_tooltip_text (AWN_ICON (icon), task_window_get_name (window));
-    on_window_needs_attention_changed (window, 
-                                       task_window_needs_attention (window), 
-                                       icon);
-
-    awn_icon_set_indicator_count (AWN_ICON (icon), 
-                        task_window_get_is_running (window) ? 1 : 0);
-
-    g_signal_connect (window, "name-changed", 
-                      G_CALLBACK (on_window_name_changed), icon);
-    g_signal_connect (window, "icon-changed",
-                      G_CALLBACK (on_window_icon_changed), icon);
+    TaskWindow *window = TASK_WINDOW (item);
     g_signal_connect (window, "active-changed",
                       G_CALLBACK (on_window_active_changed), icon);
     g_signal_connect (window, "needs-attention",
                       G_CALLBACK (on_window_needs_attention_changed), icon);
-    g_signal_connect (window, "workspace-changed",
-                      G_CALLBACK (on_window_workspace_changed), icon);
-    g_signal_connect (window, "message-changed",
-                      G_CALLBACK (on_window_message_changed), icon);
     g_signal_connect (window, "progress-changed",
                       G_CALLBACK (on_window_progress_changed), icon);
-    g_signal_connect (window, "hidden-changed",
-                      G_CALLBACK (on_window_hidden_changed), icon);
-    g_signal_connect (window, "running-changed",
-                      G_CALLBACK (on_window_running_changed), icon);
-  }
-
-  if (!recursing)
-  {
-    recursing = TRUE;
-    GtkWidget * grouped_icon = NULL;
-    if (!TASK_IS_LAUNCHER(window))
-    {
-      g_assert (window->priv->window);
-      grouped_icon = task_icon_new_for_window (window);
-    }
-    else if (TASK_IS_LAUNCHER(window) )
-    {
-      TaskWindowPrivate *win_priv = window->priv;
-      g_signal_connect (G_OBJECT(window),"notify::taskwindow",
-                        G_CALLBACK(_task_icon_launcher_change),icon);
-      if (win_priv->window)
-      {
-        TaskWindow * taskwin = task_window_new (win_priv->window);
-        grouped_icon = task_icon_new_for_window (taskwin);
-      }
-    }
-    if (grouped_icon)
-    {
-      gtk_container_add (GTK_CONTAINER(priv->dialog),grouped_icon);
-//    g_object_weak_ref (G_OBJECT (window), (GWeakNotify)window_closed, grouped_icon);    
-      gtk_widget_show (grouped_icon);
-    }
-  }
-  recursing = FALSE;
-}
-
-gboolean 
-task_icon_is_launcher (TaskIcon      *icon)
-{
-  TaskIconPrivate *priv;
-
-  g_return_val_if_fail (TASK_IS_ICON (icon), FALSE);
-  priv = icon->priv;
-
-  if (priv->windows)
-  {
-    /* For now do it this way ?! */
-    if (TASK_IS_LAUNCHER (priv->windows->data))
-      return TRUE;
-  }
-  return FALSE;
-}
-
-TaskLauncher* 
-task_icon_get_launcher (TaskIcon      *icon)
-{
-  TaskIconPrivate *priv;
-
-  g_return_val_if_fail (TASK_IS_ICON (icon), FALSE);
-  priv = icon->priv;
-
-  if (priv->windows)
-  {
-    /* For now do it this way ?! */
-    if (TASK_IS_LAUNCHER (priv->windows->data))
-      return TASK_LAUNCHER(priv->windows->data);
-  }
-  return NULL;
-}
-
-TaskWindow* 
-task_icon_get_window (TaskIcon      *icon)
-{
-  TaskIconPrivate *priv;
-
-  g_return_val_if_fail (TASK_IS_ICON (icon), FALSE);
-  priv = icon->priv;
-
-  if (priv->windows)
-  {
-    /* For now do it this way ?! */
-//    if (TASK_IS_WINDOW (priv->windows->data))
-      return TASK_WINDOW(priv->windows->data);
-  }
-  return NULL;
-}
-
-
+  }
+}
+
+/**
+ * 
+ * TODO: h4writer - adjust 2nd round
+ */
 void
 task_icon_refresh_icon (TaskIcon      *icon)
 {
@@ -755,87 +1024,9 @@
   g_return_if_fail (TASK_IS_ICON (icon));
   priv = icon->priv;
 
-  if (priv->windows && priv->windows->data)
+  if (priv->items && priv->items->data)
     awn_icon_set_from_pixbuf (AWN_ICON (icon), 
-                              task_window_get_icon (priv->windows->data));
-}
-
-gboolean
-task_icon_refresh_geometry (TaskIcon *icon)
-{
-  TaskSettings *settings;
-  TaskIconPrivate *priv;
-  GtkWidget *widget;
-  GdkWindow *win;
-  GSList    *w;
-  gint      x, y, ww, width, height;
-  gint      i = 0, len = 0;
-
-  g_return_val_if_fail (TASK_IS_ICON (icon), FALSE);
-  priv = icon->priv;
-
-  widget = GTK_WIDGET (icon);
-
-  //get the position of the widget
-  win = gtk_widget_get_window (widget);
-  gdk_window_get_origin (win, &x, &y);
-
-  settings = task_settings_get_default ();
-
-  switch (settings->orient)
-  {
-    case AWN_ORIENTATION_RIGHT:
-      //x += settings->panel_size;
-      ww = GTK_WIDGET (icon)->allocation.height;
-      break;
-    case AWN_ORIENTATION_LEFT:
-      //x += settings->offset;
-      ww = GTK_WIDGET (icon)->allocation.height;
-      break;
-    case AWN_ORIENTATION_TOP:
-      //y += settings->offset;
-      ww = GTK_WIDGET (icon)->allocation.width;
-      break;
-    default:
-      //y += settings->panel_size;
-      ww = GTK_WIDGET (icon)->allocation.width;
-      break;
-  }
-
-  /* FIXME: Do something clever here to allow the user to "scrub" the icon
-   * for the windows.
-   */
-  len = g_slist_length (priv->windows);
-  ww = ww/len;
-  for (w = priv->windows; w; w = w->next)
-  {
-    TaskWindow *window = w->data;
-    switch (settings->orient)
-    {
-      case AWN_ORIENTATION_RIGHT:
-        width = settings->panel_size+settings->offset;
-        height = ww + (i*ww);
-        break;
-      case AWN_ORIENTATION_LEFT:
-        width = settings->panel_size+settings->offset;
-        height = ww + (i*ww);
-        break;
-      case AWN_ORIENTATION_TOP:
-        width = ww + (i*ww);
-        height = settings->panel_size+settings->offset;
-        break;
-      default:
-        width = ww + (i*ww);
-        height = settings->panel_size+settings->offset;
-        break;
-    }
-    task_window_set_icon_geometry (window, x, y, 
-                                   width,
-                                   height);
-    i++;
-  }
-
-  return FALSE;
+                              task_item_get_icon (priv->items->data));
 }
 
 /*
@@ -861,78 +1052,146 @@
   return TRUE;
 }
 
+/**
+ * Whenever there is a release event on the TaskIcon it will do the proper actions.
+ * left click: - start launcher = has no (visible) windows
+ *             - activate window = when there is only one (visible) window
+ *             - show dialog = when there are multiple (visible) windows
+ * middle click: - start launcher
+ * Returns: TRUE to stop other handlers from being invoked for the event. 
+ *          FALSE to propagate the event further.
+ * TODO: h4writer - adjust
+ */
 static gboolean
 task_icon_button_release_event (GtkWidget      *widget,
                                 GdkEventButton *event)
 {
   TaskIconPrivate *priv;
-  gint len;
+  TaskIcon *icon;
 
   g_return_val_if_fail (TASK_IS_ICON (widget), FALSE);
-  priv = TASK_ICON (widget)->priv;
-
-  len = g_slist_length (priv->windows);
-
-  if (event->button == 1)
+
+  icon = TASK_ICON (widget);
+  priv = icon->priv;
+
+  switch (event->button)
   {
-    if(priv->gets_dragged)
-    {
-      return FALSE;
-    }
-    if (len == 1)
-    {
-      task_window_activate (priv->windows->data, event->time);
-      return TRUE;
-    }
-    else if (len > 1)
-    {
-      if (GTK_WIDGET_VISIBLE(priv->dialog) )
-      {
-        gtk_widget_hide (priv->dialog);
+    case 1: // left click: (start launcher || activate window || show dialog)
+
+      if(priv->gets_dragged) return FALSE;
+    
+      if (priv->shown_items == 0)
+      {
+        g_critical ("TaskIcon: The icons shouldn't contain a visible (and clickable) icon");
+        return FALSE;
+      }
+      else if (priv->shown_items == 1)
+      {
+        GSList *w;
+        /* Find the window/launcher that is shown */
+        for (w = priv->items; w; w = w->next)
+        {
+          TaskItem *item = w->data;
+
+          if (!task_item_is_visible (item)) continue;
+          
+          task_item_left_click (item, event);
+
+          break;
+        }
+        return TRUE;
       }
       else
       {
-        gtk_widget_show_all (priv->dialog);  
+        GSList *w;
+        for (w = priv->items; w; w = w->next)
+        {
+          TaskItem *item = w->data;
+
+          if (!task_item_is_visible (item)) continue;
+          
+          g_debug ("clicked on: %s", task_item_get_name (item));
+        }
+        
+        //TODO: move to hover?
+        if (GTK_WIDGET_VISIBLE (priv->dialog) )
+        {
+          gtk_widget_hide (priv->dialog);
+        }
+        else
+        {
+          gtk_widget_show (priv->dialog);  
+        }
       }
-    }
-  }
-  else if (event->button == 2)
-  {
-    if (len >= 1 && TASK_IS_LAUNCHER (priv->windows->data))
-    {
-      task_launcher_middle_click (priv->windows->data, event);
-      return TRUE;
-    }
-  }
+      break;
+
+    case 2: // middle click: start launcher
+
+      g_warning ("TaskIcon: FIXME: No support for starting launcher on middle click");
+
+      //TODO: start launcher
+      /*if (len >= 1 && TASK_IS_LAUNCHER (priv->windows->data))
+      {
+        task_launcher_middle_click (priv->windows->data, event);
+        return TRUE;
+      }*/
+
+      break;
+
+    default:
+      break;
+  }
+
   return FALSE;
 }
 
+/**
+ * Whenever there is a press event on the TaskIcon it will do the proper actions.
+ * right click: - show the context menu if there is only one (visible) window
+ * Returns: TRUE to stop other handlers from being invoked for the event. 
+ *          FALSE to propagate the event further. 
+ */
 static gboolean  
 task_icon_button_press_event (GtkWidget      *widget,
                               GdkEventButton *event)
 {
   TaskIconPrivate *priv;
-  guint len;
+  TaskIcon *icon;
 
   g_return_val_if_fail (TASK_IS_ICON (widget), FALSE);
-  priv = TASK_ICON (widget)->priv;
-
-  if (event->button != 3)
+
+  icon = TASK_ICON (widget);
+  priv = icon->priv;
+
+  if (event->button != 3) return FALSE;
+
+  if (priv->shown_items == 0)
+  {
+    g_critical ("TaskIcon: The icons shouldn't contain a visible (and clickable) icon");
     return FALSE;
-
-  len = g_slist_length (priv->windows);
-
-  if (len == 1)
+  }
+  else if (priv->shown_items == 1)
   {
-    /* We can just ask the window to popup as normal */
-    task_window_popup_context_menu (priv->windows->data, event);
+    GSList *w;
+
+    /* Find the window/launcher that is shown */
+    for (w = priv->items; w; w = w->next)
+    {
+      TaskItem *item = w->data;
+
+      if (!task_item_is_visible (item)) continue;
+      
+      task_item_right_click (item, event);
+
+      break;
+    }
     return TRUE;
   }
   else
   {
     g_warning ("TaskIcon: FIXME: No support for multiple windows right-click");
+    return FALSE;
   }
-  return FALSE;
 }
 
 static gboolean  
@@ -976,6 +1235,9 @@
   //g_debug("draggable:%d", draggable);
 }
 
+/**
+ * TODO: h4writer - second stage
+ */
 static gboolean
 drag_timeout (TaskIcon *icon)
 {
@@ -984,12 +1246,12 @@
   g_return_val_if_fail (TASK_IS_ICON (icon), FALSE);
   priv = icon->priv;
 
-  if (priv->drag_motion == FALSE)
+/*  if (priv->drag_motion == FALSE)
     return FALSE;
   else if (priv->windows->data)
     if (!task_window_is_active(priv->windows->data))
       task_window_activate (priv->windows->data, priv->drag_time);
-
+*/
   return FALSE;
 }
 
@@ -1104,9 +1366,11 @@
     {
       /* If it is a launcher it should show that it accepts the drag.
          Else only the the timeout should get set to activate the window. */
-      if (!priv->windows || !TASK_IS_LAUNCHER (priv->windows->data))
-        gdk_drag_status (context, GDK_ACTION_DEFAULT, t);
-      else
+      
+      //TODO: h4writer - 2nd round
+      //if (!priv->items || !TASK_IS_LAUNCHER (priv->items->data))
+      //  gdk_drag_status (context, GDK_ACTION_DEFAULT, t);
+      //else
         gdk_drag_status (context, GDK_ACTION_COPY, t);
       return TRUE;
     }
@@ -1151,7 +1415,7 @@
   TaskIconPrivate *priv;
   GSList          *list;
   GError          *error;
-  TaskLauncher    *launcher;
+  //TaskLauncher    *launcher;
   GdkAtom         target;
   gchar           *target_name;
   gchar           *sdata_data;
@@ -1170,13 +1434,14 @@
   }
 
   /* If we are not a launcher, we don't care about this */
-  if (!priv->windows || !TASK_IS_LAUNCHER (priv->windows->data))
-  {
-    gtk_drag_finish (context, FALSE, FALSE, time_);
-    return;
-  }
-
-  launcher = priv->windows->data;
+  //TODO: h4writer - 2nd round
+  //if (!priv->windows || !TASK_IS_LAUNCHER (priv->windows->data))
+  //{
+  //  gtk_drag_finish (context, FALSE, FALSE, time_);
+  //  return;
+  //}
+  //
+  //launcher = priv->windows->data;
 
   sdata_data = (gchar*)gtk_selection_data_get_data (sdata);
   
@@ -1197,10 +1462,10 @@
   //FIXME: I think this function returns always FALSE (haytjes)
   // and I also think this isn't a bad idea to allow too.
   // I often drop a url on firefox, even when it is already open.
-  if (task_launcher_has_window (launcher))
-  {
-    gtk_drag_finish (context, FALSE, FALSE, time_);
-  }
+  //if (task_launcher_has_windows (launcher))
+  //{
+  //  gtk_drag_finish (context, FALSE, FALSE, time_);
+  //}
   
   error = NULL;
   list = awn_vfs_get_pathlist_from_string (sdata_data, &error);
@@ -1212,7 +1477,7 @@
     return;
   }
 
-  task_launcher_launch_with_data (launcher, list);
+  //task_launcher_launch_with_data (launcher, list);
 
   g_slist_foreach (list, (GFunc)g_free, NULL);
   g_slist_free (list);

=== modified file 'applets/taskmanager/task-icon.h'
--- applets/taskmanager/task-icon.h	2009-05-27 15:57:06 +0000
+++ applets/taskmanager/task-icon.h	2009-06-22 13:16:54 +0000
@@ -14,7 +14,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by Neil Jagdish Patel <[e-mail]>
- *
+ *             Hannes Verschore <[e-mail]>
  */
 
 #ifndef _TASK_ICON_H_
@@ -24,6 +24,7 @@
 #include <gtk/gtk.h>
 #include <libawn/libawn.h>
 
+#include "task-item.h"
 #include "task-window.h"
 #include "task-launcher.h"
 
@@ -50,19 +51,19 @@
  
 struct _TaskIcon
 {
-  AwnIcon        parent;	
+  AwnThemedIcon        parent;	
 
   TaskIconPrivate *priv;
 };
 
 struct _TaskIconClass
 {
-  AwnIconClass   parent_class;
+  AwnThemedIconClass   parent_class;
 
   /*< vtable, not signals >*/
   
   /*< signals >*/
-  void (*ensure_layout) (TaskIcon *icon);
+  void (*visible_changed) (TaskIcon *icon);
   void (*source_drag_fail) (TaskIcon *icon);
   void (*source_drag_begin) (TaskIcon *icon);
   void (*source_drag_end) (TaskIcon *icon);
@@ -72,27 +73,24 @@
 
 GType           task_icon_get_type        (void) G_GNUC_CONST;
 
-GtkWidget*      task_icon_new_for_window  (TaskWindow    *window);
-
-gboolean        task_icon_is_skip_taskbar (TaskIcon      *icon);
-
-gboolean        task_icon_is_in_viewport  (TaskIcon      *icon,
-                                           WnckWorkspace *space);
-
-void            task_icon_append_window   (TaskIcon      *icon,
-                                           TaskWindow    *window);
-void            task_icon_remove_window   (TaskIcon      *icon,
-                                          WnckWindow    *window);
-gboolean        task_icon_is_launcher     (TaskIcon      *icon);
-TaskLauncher*   task_icon_get_launcher    (TaskIcon      *icon);
-TaskWindow*     task_icon_get_window      (TaskIcon      *icon);
-
-void            task_icon_refresh_icon    (TaskIcon      *icon);
-
-gboolean        task_icon_refresh_geometry (TaskIcon     *icon);
-
-void            task_icon_set_draggable   (TaskIcon      *icon, 
-                                           gboolean       draggable);
+GtkWidget*      task_icon_new ();
+
+gboolean        task_icon_is_visible        (TaskIcon      *icon);
+gboolean        task_icon_contains_launcher (TaskIcon      *icon);
+
+void            task_icon_append_item       (TaskIcon      *icon,
+                                             TaskItem      *item);
+void            task_icon_remove_item       (TaskIcon      *icon,
+                                             TaskItem      *item);
+guint           task_icon_match_item        (TaskIcon      *icon,
+                                             TaskItem      *item);
+
+//void            task_icon_remove_windows  (TaskIcon      *icon);
+
+void            task_icon_refresh_icon      (TaskIcon      *icon);
+
+void            task_icon_set_draggable     (TaskIcon      *icon, 
+                                             gboolean       draggable);
 
 #endif /* _TASK_ICON_H_ */
 

=== added file 'applets/taskmanager/task-item.c'
--- applets/taskmanager/task-item.c	1970-01-01 00:00:00 +0000
+++ applets/taskmanager/task-item.c	2009-06-28 01:53:46 +0000
@@ -0,0 +1,301 @@
+/*
+ * Copyright (C) 2008 Neil Jagdish Patel <[e-mail]>
+ *
+ * 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 Hannes Verschore <[e-mail]>
+ *
+ */
+
+#include "task-item.h"
+
+#include <libawn/libawn.h>
+
+G_DEFINE_ABSTRACT_TYPE (TaskItem, task_item, GTK_TYPE_EVENT_BOX)
+
+#define TASK_ITEM_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj),\
+  TASK_TYPE_ITEM, \
+  TaskItemPrivate))
+
+struct _TaskItemPrivate
+{
+  GtkWidget *box;
+  GtkWidget *name;
+  GtkWidget *icon;
+};
+
+enum
+{
+  PROP_0
+};
+
+enum
+{
+  NAME_CHANGED,
+  ICON_CHANGED,
+  VISIBLE_CHANGED,
+
+  LAST_SIGNAL
+};
+static guint32 _item_signals[LAST_SIGNAL] = { 0 };
+
+/* Forwards */
+static void task_item_name_changed      (TaskItem *item, const gchar   *name);
+static void task_item_icon_changed      (TaskItem *item, GdkPixbuf     *icon);
+static void task_item_visible_changed   (TaskItem *item, gboolean       visible);
+
+static gboolean  task_item_button_release_event (GtkWidget      *widget,
+                                                 GdkEventButton *event);
+static gboolean  task_item_button_press_event   (GtkWidget      *widget,
+                                                 GdkEventButton *event);
+
+/* GObject stuff */
+static void
+task_item_class_init (TaskItemClass *klass)
+{
+  //GParamSpec   *pspec;
+  GObjectClass *obj_class = G_OBJECT_CLASS (klass);
+  GtkWidgetClass *wid_class = GTK_WIDGET_CLASS (klass);
+
+  wid_class->button_release_event = task_item_button_release_event;
+  wid_class->button_press_event   = task_item_button_press_event;
+  
+  /* We implement the necessary funtions for a normal item */
+  klass->get_name        = NULL;
+  klass->get_icon        = NULL;
+  klass->is_visible      = NULL;
+  klass->match           = NULL;
+
+  /* Install signals */
+  _item_signals[NAME_CHANGED] =
+		g_signal_new ("name-changed",
+			      G_OBJECT_CLASS_TYPE (obj_class),
+			      G_SIGNAL_RUN_LAST,
+			      G_STRUCT_OFFSET (TaskItemClass, name_changed),
+			      NULL, NULL,
+			      g_cclosure_marshal_VOID__STRING, 
+			      G_TYPE_NONE,
+            1, G_TYPE_STRING); 
+
+  _item_signals[ICON_CHANGED] =
+		g_signal_new ("icon-changed",
+			      G_OBJECT_CLASS_TYPE (obj_class),
+			      G_SIGNAL_RUN_LAST,
+			      G_STRUCT_OFFSET (TaskItemClass, icon_changed),
+			      NULL, NULL,
+			      g_cclosure_marshal_VOID__OBJECT, 
+			      G_TYPE_NONE,
+            1, GDK_TYPE_PIXBUF);
+
+  _item_signals[VISIBLE_CHANGED] =
+		g_signal_new ("visible-changed",
+			      G_OBJECT_CLASS_TYPE (obj_class),
+			      G_SIGNAL_RUN_LAST,
+			      G_STRUCT_OFFSET (TaskItemClass, visible_changed),
+			      NULL, NULL,
+			      g_cclosure_marshal_VOID__BOOLEAN, 
+			      G_TYPE_NONE, 
+            1, G_TYPE_BOOLEAN);
+
+  g_type_class_add_private (obj_class, sizeof (TaskItemPrivate));
+}
+
+static void
+task_item_init (TaskItem *item)
+{
+  TaskItemPrivate *priv;
+
+  /* get and save private struct */
+  priv = item->priv = TASK_ITEM_GET_PRIVATE (item);
+
+  /* let this eventbox listen to every events */
+  gtk_event_box_set_above_child (GTK_EVENT_BOX (item), TRUE);
+  
+  /* create content */
+  priv->box = gtk_hbox_new (FALSE, 10);
+  gtk_container_add (GTK_CONTAINER (item), priv->box);
+
+  priv->icon = awn_icon_new ();
+  gtk_box_pack_start (GTK_BOX (priv->box), priv->icon, FALSE, FALSE, 0);
+  
+  priv->name = gtk_label_new ("");
+  gtk_box_pack_start (GTK_BOX (priv->box), priv->name, TRUE, FALSE, 10);
+
+  /* connect to signals */
+  g_signal_connect (G_OBJECT (item), "name-changed",
+                    G_CALLBACK (task_item_name_changed), NULL);
+  g_signal_connect (G_OBJECT (item), "icon-changed",
+                    G_CALLBACK (task_item_icon_changed), NULL);
+  g_signal_connect (G_OBJECT (item), "visible-changed",
+                    G_CALLBACK (task_item_visible_changed), NULL);
+}
+
+static gboolean
+task_item_button_release_event (GtkWidget      *widget,
+                                GdkEventButton *event)
+{
+  g_return_val_if_fail (TASK_IS_ITEM (widget), FALSE);
+
+  task_item_left_click (TASK_ITEM (widget), event);
+
+  return TRUE;
+}
+
+static gboolean
+task_item_button_press_event (GtkWidget      *widget,
+                              GdkEventButton *event)
+{
+  g_return_val_if_fail (TASK_IS_ITEM (widget), FALSE);
+
+  if (event->button != 3) return FALSE;
+
+  task_item_right_click (TASK_ITEM (widget), event);
+
+  return TRUE;
+}
+
+static void 
+task_item_name_changed (TaskItem *item, const gchar *name)
+{
+  TaskItemPrivate *priv = TASK_ITEM_GET_PRIVATE (item);
+
+  gtk_label_set_text (GTK_LABEL (priv->name), name);
+}
+
+
+static void 
+task_item_icon_changed (TaskItem *item, GdkPixbuf *icon)
+{
+  TaskItemPrivate *priv = TASK_ITEM_GET_PRIVATE (item);
+
+  awn_icon_set_from_pixbuf (AWN_ICON (priv->icon), icon);
+}
+
+static void
+task_item_visible_changed (TaskItem *item, gboolean visible)
+{
+  if (visible)
+    gtk_widget_show (GTK_WIDGET (item));
+  else
+    gtk_widget_hide (GTK_WIDGET (item));
+}
+
+/**
+ * Public functions
+ */
+
+const gchar * 
+task_item_get_name (TaskItem    *item)
+{
+  TaskItemClass *klass;
+
+  g_return_val_if_fail (TASK_IS_ITEM (item), NULL);
+  
+  klass = TASK_ITEM_GET_CLASS (item);
+  g_return_val_if_fail (klass->get_name, NULL);
+        
+  return klass->get_name (item);
+}
+
+GdkPixbuf *
+task_item_get_icon (TaskItem    *item)
+{
+  TaskItemClass *klass;
+
+  g_return_val_if_fail (TASK_IS_ITEM (item), NULL);
+  
+  klass = TASK_ITEM_GET_CLASS (item);
+  g_return_val_if_fail (klass->get_icon, NULL);
+        
+  return klass->get_icon (item);
+}
+
+gboolean
+task_item_is_visible (TaskItem    *item)
+{
+  TaskItemClass *klass;
+
+  g_return_val_if_fail (TASK_IS_ITEM (item), FALSE);
+  
+  klass = TASK_ITEM_GET_CLASS (item);  
+  g_return_val_if_fail (klass->is_visible, FALSE);
+        
+  return klass->is_visible (item);
+}
+
+void
+task_item_left_click (TaskItem *item, GdkEventButton *event)
+{
+  TaskItemClass *klass;
+
+  g_return_if_fail (TASK_IS_ITEM (item));
+  
+  klass = TASK_ITEM_GET_CLASS (item);
+  g_return_if_fail (klass->left_click);
+        
+  klass->left_click (item, event);
+}
+
+void
+task_item_right_click (TaskItem *item, GdkEventButton *event)
+{
+  TaskItemClass *klass;
+
+  g_return_if_fail (TASK_IS_ITEM (item));
+  
+  klass = TASK_ITEM_GET_CLASS (item);
+  g_return_if_fail (klass->right_click);
+        
+  klass->right_click (item, event);
+}
+
+guint
+task_item_match (TaskItem *item, TaskItem *item_to_match)
+{
+  TaskItemClass *klass;
+
+  g_return_val_if_fail (TASK_IS_ITEM (item), 0);
+  
+  klass = TASK_ITEM_GET_CLASS (item);
+  g_return_val_if_fail (klass->match, 0);
+        
+  return klass->match (item, item_to_match);
+}
+
+/**
+ * Protected functions (used only by derived classes)
+ */
+
+void
+task_item_emit_name_changed (TaskItem *item, const gchar *name)
+{
+  g_return_if_fail (TASK_IS_ITEM (item));
+  
+  g_signal_emit (item, _item_signals[NAME_CHANGED], 0, name);
+}
+
+void
+task_item_emit_icon_changed (TaskItem *item, GdkPixbuf *icon)
+{
+  g_return_if_fail (TASK_IS_ITEM (item));
+
+  g_signal_emit (item, _item_signals[ICON_CHANGED], 0, icon);
+}
+
+void
+task_item_emit_visible_changed (TaskItem *item, gboolean visible)
+{
+  g_return_if_fail (TASK_IS_ITEM (item));
+
+  g_signal_emit (item, _item_signals[VISIBLE_CHANGED], 0, visible);
+}
\ No newline at end of file

=== added file 'applets/taskmanager/task-item.h'
--- applets/taskmanager/task-item.h	1970-01-01 00:00:00 +0000
+++ applets/taskmanager/task-item.h	2009-06-20 10:58:03 +0000
@@ -0,0 +1,98 @@
+/*
+ * Copyright (C) 2008 Neil Jagdish Patel <[e-mail]>
+ *
+ * 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 Hannes Verschore <[e-mail]>
+ *
+ */
+
+#ifndef _TASK_ITEM_H_
+#define _TASK_ITEM_H_
+
+#include <glib-object.h>
+#include <gtk/gtk.h>
+
+G_BEGIN_DECLS
+
+#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
+{
+  GtkBox     parent;	
+
+  TaskItemPrivate *priv;
+};
+
+struct _TaskItemClass
+{
+  GtkBoxClass   parent_class;
+
+  /*< vtable, not signals >*/
+  const gchar * (*get_name)        (TaskItem *item);
+  GdkPixbuf   * (*get_icon)        (TaskItem *item);
+  gboolean      (*is_visible)      (TaskItem *item);
+  void          (*left_click)      (TaskItem *item, GdkEventButton *event);
+  void          (*right_click)     (TaskItem *item, GdkEventButton *event);
+  guint         (*match)           (TaskItem *item, TaskItem *item_to_match);
+
+  /*< signals >*/
+  void (*name_changed)      (TaskItem *item, const gchar *name);
+  void (*icon_changed)      (TaskItem *item, GdkPixbuf   *icon);
+  void (*visible_changed)   (TaskItem *item, gboolean     visible);
+};
+
+GType           task_item_get_type        (void) G_GNUC_CONST;
+
+const gchar * task_item_get_name      (TaskItem *item);
+GdkPixbuf   * task_item_get_icon      (TaskItem *item);
+gboolean      task_item_is_visible    (TaskItem *item);
+void          task_item_left_click    (TaskItem *item, GdkEventButton *event);
+void          task_item_right_click   (TaskItem *item, GdkEventButton *event);
+guint         task_item_match         (TaskItem *item, TaskItem *item_to_match);
+
+//TODO: 2nd round: implement
+//const gchar   * task_item_get_name          (TaskItem    *item);
+//void            task_item_set_name          (TaskItem    *item,
+//                                             const gchar   *name);
+//GdkPixbuf     * task_item_get_icon          (TaskItem    *item);
+//void            task_item_update_icon       (TaskItem    *item,
+//                                             GdkPixbuf     *pixbuf);
+
+/* These should be "protected" (used only by derived classes) */
+void task_item_emit_name_changed    (TaskItem *item, const gchar *name);
+void task_item_emit_icon_changed    (TaskItem *item, GdkPixbuf   *icon);
+void task_item_emit_visible_changed (TaskItem *item, gboolean     visible);
+
+G_END_DECLS
+
+#endif /* _TASK_ITEM_H_ */

=== modified file 'applets/taskmanager/task-launcher.c'
--- applets/taskmanager/task-launcher.c	2009-04-18 00:36:20 +0000
+++ applets/taskmanager/task-launcher.c	2009-06-20 14:17:54 +0000
@@ -14,7 +14,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by Neil Jagdish Patel <[e-mail]>
- *
+ *             Hannes Verschore <[e-mail]>
  */
 
 #include <stdio.h>
@@ -28,19 +28,18 @@
 #include <libawn/libawn.h>
 
 #include "task-launcher.h"
+#include "task-item.h"
 #include "task-window.h"
 
 #include "task-settings.h"
 #include "xutils.h"
 
-G_DEFINE_TYPE (TaskLauncher, task_launcher, TASK_TYPE_WINDOW)
+G_DEFINE_TYPE (TaskLauncher, task_launcher, TASK_TYPE_ITEM)
 
 #define TASK_LAUNCHER_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj),\
   TASK_TYPE_LAUNCHER, \
   TaskLauncherPrivate))
 
-#define GET_WINDOW_PRIVATE(obj) (TASK_WINDOW(obj)->priv)
-
 struct _TaskLauncherPrivate
 {
   gchar          *path;
@@ -59,15 +58,15 @@
 };
 
 /* Forwards */
-static gint          _get_pid         (TaskWindow     *window);
-static const gchar * _get_name        (TaskWindow     *window);
-static GdkPixbuf   * _get_icon        (TaskWindow     *window);
-static gboolean      _is_on_workspace (TaskWindow     *window,
-                                       WnckWorkspace  *space);
-static void          _activate        (TaskWindow     *window,
-                                       guint32         timestamp);
-static void          _popup_menu      (TaskWindow     *window,
-                                       GtkMenu        *menu);
+static const gchar * _get_name        (TaskItem       *item);
+static GdkPixbuf   * _get_icon        (TaskItem       *item);
+static gboolean      _is_visible      (TaskItem       *item);
+static void          _left_click      (TaskItem       *item,
+                                       GdkEventButton *event);
+static void          _right_click     (TaskItem       *item,
+                                       GdkEventButton *event);
+static guint         _match           (TaskItem       *item,
+                                       TaskItem       *item_to_match);
 
 static void   task_launcher_set_desktop_file (TaskLauncher *launcher,
                                               const gchar  *path);
@@ -115,19 +114,19 @@
 task_launcher_class_init (TaskLauncherClass *klass)
 {
   GParamSpec   *pspec;
-  GObjectClass    *obj_class = G_OBJECT_CLASS (klass);
-  TaskWindowClass *win_class = TASK_WINDOW_CLASS (klass);
+  GObjectClass  *obj_class = G_OBJECT_CLASS (klass);
+  TaskItemClass *item_class = TASK_ITEM_CLASS (klass);
 
   obj_class->set_property = task_launcher_set_property;
   obj_class->get_property = task_launcher_get_property;
 
   /* We implement the necessary funtions for a normal window */
-  win_class->get_pid         = _get_pid;
-  win_class->get_name        = _get_name;
-  win_class->get_icon        = _get_icon;
-  win_class->is_on_workspace = _is_on_workspace;
-  win_class->activate        = _activate;
-  win_class->popup_menu      = _popup_menu;
+  item_class->get_name         = _get_name;
+  item_class->get_icon         = _get_icon;
+  item_class->is_visible       = _is_visible;
+  item_class->match            = _match;
+  item_class->left_click       = _left_click;
+  item_class->right_click      = _right_click;
 
   /* Install properties */
   pspec = g_param_spec_string ("desktopfile",
@@ -151,19 +150,19 @@
   priv->item = NULL;
 }
 
-TaskLauncher   * 
+TaskItem * 
 task_launcher_new_for_desktop_file (const gchar *path)
 {
-  TaskLauncher *win = NULL;
+  TaskItem *item = NULL;
 
   if (!g_file_test (path, G_FILE_TEST_EXISTS))
     return NULL;
 
-  win = g_object_new (TASK_TYPE_LAUNCHER,
-                      "desktopfile", path,
-                      NULL);
+  item = g_object_new (TASK_TYPE_LAUNCHER,
+                       "desktopfile", path,
+                       NULL);
 
-  return win;
+  return item;
 }
 
 const gchar   * 
@@ -178,6 +177,8 @@
 task_launcher_set_desktop_file (TaskLauncher *launcher, const gchar *path)
 {
   TaskLauncherPrivate *priv;
+  TaskSettings * s = task_settings_get_default ();
+  GdkPixbuf *pixbuf;
   gchar * exec_key = NULL;
   gchar * needle = NULL;
  
@@ -210,194 +211,161 @@
   priv->exec = exec_key;
   priv->icon_name = awn_desktop_item_get_icon_name (priv->item);
 
+  task_item_emit_name_changed (TASK_ITEM (launcher), priv->name);
+  pixbuf = awn_desktop_item_get_icon (priv->item, s->panel_size);
+  task_item_emit_icon_changed (TASK_ITEM (launcher), pixbuf);
+  g_object_unref (pixbuf);
+  task_item_emit_visible_changed (TASK_ITEM (launcher), TRUE);
+
   g_debug ("LAUNCHER: %s", priv->name);
 }
 
 /*
  * Implemented functions for a standard window without a launcher
  */
-static gint 
-_get_pid (TaskWindow *window)
-{
-  TaskLauncher *launcher = TASK_LAUNCHER (window);
-  
-  if (WNCK_IS_WINDOW (window->priv->window))
-  {
-		gint value = -1;
-    value = wnck_window_get_pid (window->priv->window);
-		value = value ? value : -1;
-		return value;
-  }
-  else
-  {
-    return launcher->priv->pid;
-  }
-}
-
 static const gchar * 
-_get_name (TaskWindow    *window)
+_get_name (TaskItem *item)
 {
-  TaskLauncher *launcher = TASK_LAUNCHER (window);
-
-  if (WNCK_IS_WINDOW (window->priv->window))
-  {
-    return wnck_window_get_name (window->priv->window);
-  }
-  else
-  {
-    return launcher->priv->name;
-  }
+  return TASK_LAUNCHER (item)->priv->name;
 }
 
 static GdkPixbuf * 
-_get_icon (TaskWindow    *window)
+_get_icon (TaskItem *item)
 {
-  TaskLauncher *launcher = TASK_LAUNCHER (window);
   TaskSettings *s = task_settings_get_default ();
 
-  if (WNCK_IS_WINDOW (window->priv->window))
-  {
-    return _wnck_get_icon_at_size (window->priv->window, 
-                                   s->panel_size, s->panel_size);
-  }
-  else
-  {
-    return awn_desktop_item_get_icon (launcher->priv->item, s->panel_size);
-  }
+  return awn_desktop_item_get_icon (TASK_LAUNCHER (item)->priv->item, s->panel_size);
 }
 
-static gboolean 
-_is_on_workspace (TaskWindow *window,
-                  WnckWorkspace *space)
+static gboolean
+_is_visible (TaskItem *item)
 {
   return TRUE;
 }
 
-static void   
-_activate (TaskWindow    *window,
-           guint32        timestamp)
-{
-  TaskLauncher *launcher = TASK_LAUNCHER (window);
-  GError *error = NULL;
-
-  launcher->priv->pid = awn_desktop_item_launch (launcher->priv->item,
-                                                 NULL, &error);
-
-  if (error)
-  {
-    g_warning ("Unable to launch %s: %s", 
-               launcher->priv->name,
-               error->message);
-    g_error_free (error);
-  }
-}
-
-/*
- * Public functions
+/**
+ * Match the launcher with the provided window. 
+ * The higher the number it returns the more it matches the window.
+ * 100 = definitly matches
+ * 0 = doesn't match
  */
-gboolean   
-task_launcher_has_window (TaskLauncher *launcher)
-{
-  g_return_val_if_fail (TASK_IS_LAUNCHER (launcher), TRUE);
-
-  if (WNCK_IS_WINDOW (TASK_WINDOW (launcher)->priv->window))
-    return TRUE;
-  return FALSE;
-}
-
-gboolean   
-task_launcher_try_match (TaskLauncher *launcher,
-                         gint          pid,
-                         const gchar  *res_name,
-                         const gchar  *class_name)
+static guint   
+_match (TaskItem *item,
+        TaskItem *item_to_match)
 {
   TaskLauncherPrivate *priv;
-
-  g_return_val_if_fail (launcher, FALSE);
+  TaskLauncher *launcher;
+  TaskWindow   *window;
+  gchar   *res_name = NULL;
+  gchar   *class_name = NULL;
+  gchar   *temp;
+  gint     pid;
+
+  g_return_val_if_fail (TASK_IS_LAUNCHER(item), 0);
+
+  if (!TASK_IS_WINDOW (item_to_match)) return 0;
+
+  launcher = TASK_LAUNCHER (item);
   priv = launcher->priv;
+  
+  window = TASK_WINDOW (item_to_match);
 
   /* Try simple pid-match first */
+  pid = task_window_get_pid(window);
   if ( pid && (priv->pid == pid))
-    return TRUE;
+    return 100;
 
   /* Now try resource name, which should (hopefully) be 99% of the cases */
-  if ( res_name && strlen(res_name) && priv->exec)
+  task_window_get_wm_class(window, &res_name, &class_name);
+
+  if (res_name)
   {
-    if ( g_strstr_len (priv->exec, strlen (priv->exec), res_name) ||
-         g_strstr_len (res_name, strlen (res_name), priv->exec))
+    temp = res_name;
+    res_name = g_utf8_strdown (temp, -1);
+    g_free (temp);
+
+    if ( strlen(res_name) && priv->exec)
     {
-      return TRUE;
+      if ( g_strstr_len (priv->exec, strlen (priv->exec), res_name) ||
+           g_strstr_len (res_name, strlen (res_name), priv->exec))
+      {
+        g_free (res_name);
+        g_free (class_name);
+        return 70;
+      }
     }
   }
-  
+
   /* Try a class_name to exec line match */
-  if ( class_name && strlen(class_name) && priv->exec)
-  {
-    if (g_strstr_len (priv->exec, strlen (priv->exec), class_name))
-      return TRUE;
-  }
-
-  return FALSE; 
-}
-
-static void
-on_window_closed (TaskLauncher *launcher, WnckWindow *old_window)
-{
-  TaskWindowPrivate *priv;
-  TaskSettings *s = task_settings_get_default ();
-  GdkPixbuf *pixbuf;
-
-  g_return_if_fail (TASK_IS_LAUNCHER (launcher));
-  priv = TASK_WINDOW (launcher)->priv;
-
-  /* NULLify the window pointer */
-  priv->window = NULL;
-
-  /* Reset name */
-  task_window_set_name (TASK_WINDOW (launcher), launcher->priv->name);  
-
-  /* Reset icon */
-  pixbuf = xutils_get_named_icon (launcher->priv->icon_name,
-                                  s->panel_size, s->panel_size);
-
-  task_window_update_icon (TASK_WINDOW (launcher), pixbuf);
-
-  g_object_unref (pixbuf);
-}
-
-void       
-task_launcher_set_window (TaskLauncher *launcher,
-                          WnckWindow   *window)
-{
-  g_return_if_fail (TASK_IS_LAUNCHER (launcher));
-  g_return_if_fail (WNCK_IS_WINDOW (window));
-
-  g_object_set (launcher, "taskwindow", window, NULL);
-
-  task_window_set_name (TASK_WINDOW (launcher), wnck_window_get_name (window));
-
-  g_object_weak_ref (G_OBJECT (window), 
-                     (GWeakNotify)on_window_closed,
-                     launcher);
-}
-
-static void 
-_popup_menu (TaskWindow     *window,
-             GtkMenu        *menu)
-{
-  TaskWindowPrivate *priv;
-  GtkWidget         *item;
-  
-  g_return_if_fail (TASK_IS_WINDOW (window));
-  priv = window->priv;
-
-  if (!WNCK_IS_WINDOW (priv->window))
-  {
-    item = gtk_image_menu_item_new_from_stock (GTK_STOCK_EXECUTE, NULL);
-    gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
-    gtk_widget_show (item);
-  }
-}
+  if (class_name)
+  {
+    temp = class_name;
+    class_name = g_utf8_strdown (temp, -1);
+    g_free (temp);
+
+    if (strlen(class_name) && priv->exec)
+    {
+      if (g_strstr_len (priv->exec, strlen (priv->exec), class_name))
+      {
+        g_free (res_name);
+        g_free (class_name);
+        return 50;
+      }
+    }
+  }
+
+  g_free (res_name);
+  g_free (class_name);
+  return 0; 
+}
+
+static void
+_left_click (TaskItem *item, GdkEventButton *event)
+{
+  TaskLauncherPrivate *priv;
+  TaskLauncher *launcher;
+  GError *error = NULL;
+  
+  g_return_if_fail (TASK_IS_LAUNCHER (item));
+  
+  launcher = TASK_LAUNCHER (item);
+  priv = launcher->priv;
+
+  priv->pid = awn_desktop_item_launch (priv->item, NULL, &error);
+
+  if (error)
+  {
+    g_warning ("Unable to launch %s: %s", 
+               task_item_get_name (item),
+               error->message);
+    g_error_free (error);
+  }
+}
+
+static void
+_right_click (TaskItem *item, GdkEventButton *event)
+{
+  TaskLauncherPrivate *priv;
+  TaskLauncher *launcher;
+  GtkWidget *menu_item,
+            *menu;
+  
+  g_return_if_fail (TASK_IS_LAUNCHER (item));
+  
+  launcher = TASK_LAUNCHER (item);
+  priv = launcher->priv;
+
+  menu = gtk_menu_new ();
+  menu_item = gtk_image_menu_item_new_from_stock (GTK_STOCK_EXECUTE, NULL);
+  gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item);
+  gtk_widget_show (menu_item);
+  gtk_menu_popup (GTK_MENU (menu), NULL, NULL, 
+                  NULL, NULL, event->button, event->time);
+}
+
+/*
+ * Public functions
+ */
 
 void 
 task_launcher_launch_with_data (TaskLauncher *launcher,
@@ -429,10 +397,7 @@
   g_return_if_fail (TASK_IS_LAUNCHER (launcher));
   priv = launcher->priv;
 
-  if (WNCK_IS_WINDOW (TASK_WINDOW (launcher)->priv->window))
-    awn_desktop_item_launch (priv->item, NULL, &error);
-  else
-    priv->pid = awn_desktop_item_launch (priv->item, NULL, &error);
+  priv->pid = awn_desktop_item_launch (priv->item, NULL, &error);
 
   if (error)
   {

=== modified file 'applets/taskmanager/task-launcher.h'
--- applets/taskmanager/task-launcher.h	2008-12-26 15:19:53 +0000
+++ applets/taskmanager/task-launcher.h	2009-06-20 14:17:54 +0000
@@ -14,6 +14,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by Neil Jagdish Patel <[e-mail]>
+ *             Hannes Verschore <[e-mail]>
  *
  */
 
@@ -24,7 +25,7 @@
 #include <gtk/gtk.h>
 #include <libwnck/libwnck.h>
 
-#include "task-window.h"
+#include "task-item.h"
 
 #define TASK_TYPE_LAUNCHER (task_launcher_get_type ())
 
@@ -49,38 +50,24 @@
  
 struct _TaskLauncher
 {
-  TaskWindow        parent;	
+  TaskItem        parent;	
 
   TaskLauncherPrivate *priv;
 };
 
 struct _TaskLauncherClass
 {
-  TaskWindowClass   parent_class;
+  TaskItemClass   parent_class;
 
   /*< signals >*/
-  void (*launcher0) (void);
-  void (*launcher1) (void);
-  void (*launcher2) (void);
-  void (*launcher3) (void);
 };
 
 GType           task_launcher_get_type             (void) G_GNUC_CONST;
 
-TaskLauncher  * task_launcher_new_for_desktop_file (const gchar    *path);
+TaskItem      * task_launcher_new_for_desktop_file (const gchar    *path);
 
 const gchar   * task_launcher_get_desktop_path     (TaskLauncher   *launcher);
 
-gboolean        task_launcher_has_window           (TaskLauncher   *launcher);
-
-gboolean        task_launcher_try_match            (TaskLauncher   *launcher,
-                                                    gint            pid,
-                                                    const gchar    *res_name,
-                                                    const gchar    *class_name);
-
-void            task_launcher_set_window           (TaskLauncher   *launcher,
-                                                    WnckWindow     *window);
-
 void            task_launcher_launch_with_data     (TaskLauncher   *launcher,
                                                     GSList         *list);
 

=== added file 'applets/taskmanager/task-manager-api-wrapper.c'
--- applets/taskmanager/task-manager-api-wrapper.c	1970-01-01 00:00:00 +0000
+++ applets/taskmanager/task-manager-api-wrapper.c	2009-06-26 11:00:10 +0000
@@ -0,0 +1,509 @@
+/*
+ * Copyright (C) 2008 Neil Jagdish Patel <[e-mail]>
+ *
+ * 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 Hannes Verschore <[e-mail]>
+ */
+
+
+#include "task-manager-api-wrapper.h"
+
+#include <libawn/libawn.h>
+
+G_DEFINE_TYPE (TaskManagerApiWrapper, task_manager_api_wrapper, G_TYPE_OBJECT)
+
+#define TASK_MANAGER_API_WRAPPER_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj),\
+  TASK_TYPE_MANAGER_API_WRAPPER, \
+  TaskManagerApiWrapperPrivate))
+
+struct _TaskManagerApiWrapperPrivate
+{
+  TaskManager *manager;
+};
+
+enum
+{
+  PROP_0,
+  PROP_MANAGER
+};
+
+/* GObject stuff */
+
+static void
+task_manager_api_wrapper_set_manager (TaskManagerApiWrapper *wrapper, 
+                                      TaskManager *manager)
+{
+  g_return_if_fail (TASK_IS_MANAGER_API_WRAPPER (wrapper));
+  g_return_if_fail (TASK_IS_MANAGER (manager));
+
+  wrapper->priv->manager = manager;
+}
+
+static void
+task_manager_api_wrapper_get_property (GObject    *object,
+                                       guint       prop_id,
+                                       GValue     *value,
+                                       GParamSpec *pspec)
+{
+  TaskManagerApiWrapper *wrapper = TASK_MANAGER_API_WRAPPER (object);
+
+  switch (prop_id)
+  {
+    case PROP_MANAGER:
+      g_value_set_object (value, wrapper->priv->manager); 
+      break;
+    
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+  }
+}
+
+static void
+task_manager_api_wrapper_set_property (GObject      *object,
+                                       guint         prop_id,
+                                       const GValue *value,
+                                       GParamSpec   *pspec)
+{
+  TaskManagerApiWrapper *wrapper = TASK_MANAGER_API_WRAPPER (object);
+
+  switch (prop_id)
+  {
+    case PROP_MANAGER:
+      task_manager_api_wrapper_set_manager (wrapper, g_value_get_object (value));
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+  }
+}
+
+/* GObject stuff */
+static void
+task_manager_api_wrapper_class_init (TaskManagerApiWrapperClass *klass)
+{
+  GParamSpec   *pspec;
+  GObjectClass *obj_class = G_OBJECT_CLASS (klass);
+
+  obj_class->set_property = task_manager_api_wrapper_set_property;
+  obj_class->get_property = task_manager_api_wrapper_get_property;
+  
+  /* Install properties */
+  pspec = g_param_spec_object ("manager",
+                               "Manager",
+                               "TaskManager",
+                               TASK_TYPE_MANAGER,
+                               G_PARAM_READWRITE);
+  g_object_class_install_property (obj_class, PROP_MANAGER, pspec);  
+  
+  g_type_class_add_private (obj_class, sizeof (TaskManagerApiWrapperPrivate));
+}
+
+static void
+task_manager_api_wrapper_init (TaskManagerApiWrapper *wrapper)
+{
+  TaskManagerApiWrapperPrivate *priv;
+
+  /* get and save private struct */
+  priv = wrapper->priv = TASK_MANAGER_API_WRAPPER_GET_PRIVATE (wrapper);
+  priv->manager = NULL;
+}
+
+
+TaskManagerApiWrapper *
+task_manager_api_wrapper_new (TaskManager *manager)
+{
+  TaskManagerApiWrapper *wrapper = NULL;
+
+  wrapper = g_object_new (TASK_TYPE_MANAGER_API_WRAPPER,
+                          "manager", manager,
+                          NULL);
+
+  return wrapper;
+}
+
+gboolean
+task_manager_api_wrapper_set_task_icon_by_name (TaskManagerApiWrapper *wrapper,
+                                            		gchar     *name,
+                                             		gchar     *icon_path,
+                                                GError    **error)
+{
+  TaskManagerApiWrapperPrivate *priv;
+  gboolean succeeded;
+  GValue window = {0};
+  GHashTable *hints;
+  const gchar *key = "icon-file";
+  GValue value = {0};
+  
+  g_return_val_if_fail (TASK_IS_MANAGER_API_WRAPPER (wrapper), FALSE);
+
+  priv = wrapper->priv;
+  
+  g_value_init (&window, G_TYPE_STRING);
+  g_value_set_string (&window, name);
+
+  g_value_init (&value, G_TYPE_STRING);
+  g_value_set_string (&value, icon_path);
+  
+  hints = g_hash_table_new (g_str_hash, g_str_equal);
+  g_hash_table_insert (hints, (gpointer)key, &value);
+  
+  succeeded = task_manager_update (priv->manager,
+                                   &window,
+                                   hints,
+                                   error);
+  g_value_unset (&window);
+  g_value_unset (&value);
+  g_hash_table_destroy (hints);
+
+  return succeeded;
+}
+
+gboolean
+task_manager_api_wrapper_unset_task_icon_by_name (TaskManagerApiWrapper *wrapper,
+			                                        		gchar     *name,
+			                                        		GError   	**error)
+{
+  TaskManagerApiWrapperPrivate *priv;
+  gboolean succeeded;
+  GValue window = {0};
+  GHashTable *hints;
+  const gchar *key = "icon-file";
+  GValue value = {0};
+  
+  g_return_val_if_fail (TASK_IS_MANAGER_API_WRAPPER (wrapper), FALSE);
+
+  priv = wrapper->priv;
+  
+  g_value_init (&window, G_TYPE_STRING);
+  g_value_set_string (&window, name);
+
+  g_value_init (&value, G_TYPE_STRING);
+  g_value_set_string (&value, "");
+  
+  hints = g_hash_table_new (g_str_hash, g_str_equal);
+  g_hash_table_insert (hints, (gpointer)key, &value);
+  
+  succeeded = task_manager_update (priv->manager,
+                                   &window,
+                                   hints,
+                                   error);
+  g_value_unset (&window);
+  g_value_unset (&value);
+  g_hash_table_destroy (hints);
+
+  return succeeded;
+}
+
+gboolean
+task_manager_api_wrapper_set_info_by_name (TaskManagerApiWrapper *wrapper,
+                                           gchar    *name,
+                                           gchar    *info,
+                                           GError   **error)
+{
+  TaskManagerApiWrapperPrivate *priv;
+  gboolean succeeded;
+  GValue window = {0};
+  GHashTable *hints;
+  const gchar *key = "message";
+  GValue value = {0};
+  
+  g_return_val_if_fail (TASK_IS_MANAGER_API_WRAPPER (wrapper), FALSE);
+
+  priv = wrapper->priv;
+  
+  g_value_init (&window, G_TYPE_STRING);
+  g_value_set_string (&window, name);
+
+  g_value_init (&value, G_TYPE_STRING);
+  g_value_set_string (&value, info);
+  
+  hints = g_hash_table_new (g_str_hash, g_str_equal);
+  g_hash_table_insert (hints, (gpointer)key, &value);
+  
+  succeeded = task_manager_update (priv->manager,
+                                   &window,
+                                   hints,
+                                   error);
+  g_value_unset (&window);
+  g_value_unset (&value);
+  g_hash_table_destroy (hints);
+
+  return succeeded;
+}
+
+gboolean
+task_manager_api_wrapper_unset_info_by_name (TaskManagerApiWrapper *wrapper,
+                                             gchar     *name,
+                                             GError    **error)
+{
+  TaskManagerApiWrapperPrivate *priv;
+  gboolean succeeded;
+  GValue window = {0};
+  GHashTable *hints;
+  const gchar *key = "message";
+  GValue value = {0};
+  
+  g_return_val_if_fail (TASK_IS_MANAGER_API_WRAPPER (wrapper), FALSE);
+
+  priv = wrapper->priv;
+  
+  g_value_init (&window, G_TYPE_STRING);
+  g_value_set_string (&window, name);
+
+  g_value_init (&value, G_TYPE_STRING);
+  g_value_set_string (&value, "");
+  
+  hints = g_hash_table_new (g_str_hash, g_str_equal);
+  g_hash_table_insert (hints, (gpointer)key, &value);
+  
+  succeeded = task_manager_update (priv->manager,
+                                   &window,
+                                   hints,
+                                   error);
+  g_value_unset (&window);
+  g_value_unset (&value);
+  g_hash_table_destroy (hints);
+
+  return succeeded;
+}
+
+gboolean
+task_manager_api_wrapper_set_progress_by_name (TaskManagerApiWrapper *wrapper,
+                                               gchar    *name,
+                                               gint     progress,
+                                               GError   **error)
+{
+  TaskManagerApiWrapperPrivate *priv;
+  gboolean succeeded;
+  GValue window = {0};
+  GHashTable *hints;
+  const gchar *key = "message";
+  GValue value = {0};
+  
+  g_return_val_if_fail (TASK_IS_MANAGER_API_WRAPPER (wrapper), FALSE);
+
+  priv = wrapper->priv;
+  
+  g_value_init (&window, G_TYPE_STRING);
+  g_value_set_string (&window, name);
+
+  //difference between old and new api
+  //unsetting progress indicator by setting progress to -1;
+  if (progress == 100) progress = -1;
+
+  g_value_init (&value, G_TYPE_INT);
+  g_value_set_int (&value, progress);
+  
+  hints = g_hash_table_new (g_str_hash, g_str_equal);
+  g_hash_table_insert (hints, (gpointer)key, &value);
+  
+  succeeded = task_manager_update (priv->manager,
+                                   &window,
+                                   hints,
+                                   error);
+  g_value_unset (&window);
+  g_value_unset (&value);
+  g_hash_table_destroy (hints);
+
+  return succeeded;
+}
+
+/*     XID variants     */
+
+gboolean
+task_manager_api_wrapper_set_task_icon_by_xid (TaskManagerApiWrapper *wrapper,
+                                              gint64    xid,
+                                              gchar     *icon_path,
+                                              GError    **error)
+{
+  TaskManagerApiWrapperPrivate *priv;
+  gboolean succeeded;
+  GValue window = {0};
+  GHashTable *hints;
+  const gchar *key = "icon-file";
+  GValue value = {0};
+  
+  g_return_val_if_fail (TASK_IS_MANAGER_API_WRAPPER (wrapper), FALSE);
+
+  priv = wrapper->priv;
+  
+  g_value_init (&window, G_TYPE_INT64);
+  g_value_set_int64 (&window, xid);
+
+  g_value_init (&value, G_TYPE_STRING);
+  g_value_set_string (&value, icon_path);
+  
+  hints = g_hash_table_new (g_str_hash, g_str_equal);
+  g_hash_table_insert (hints, (gpointer)key, &value);
+  
+  succeeded = task_manager_update (priv->manager,
+                                   &window,
+                                   hints,
+                                   error);
+  g_value_unset (&window);
+  g_value_unset (&value);
+  g_hash_table_destroy (hints);
+
+  return succeeded;
+}
+
+gboolean
+task_manager_api_wrapper_unset_task_icon_by_xid (TaskManagerApiWrapper *wrapper,
+                                                 gint64    xid,
+                                                 GError    **error)
+{
+  TaskManagerApiWrapperPrivate *priv;
+  gboolean succeeded;
+  GValue window = {0};
+  GHashTable *hints;
+  const gchar *key = "icon-file";
+  GValue value = {0};
+  
+  g_return_val_if_fail (TASK_IS_MANAGER_API_WRAPPER (wrapper), FALSE);
+
+  priv = wrapper->priv;
+  
+  g_value_init (&window, G_TYPE_INT64);
+  g_value_set_int64 (&window, xid);
+
+  g_value_init (&value, G_TYPE_STRING);
+  g_value_set_string (&value, "");
+  
+  hints = g_hash_table_new (g_str_hash, g_str_equal);
+  g_hash_table_insert (hints, (gpointer)key, &value);
+  
+  succeeded = task_manager_update (priv->manager,
+                                   &window,
+                                   hints,
+                                   error);
+  g_value_unset (&window);
+  g_value_unset (&value);
+  g_hash_table_destroy (hints);
+
+  return succeeded;
+}
+
+gboolean
+task_manager_api_wrapper_set_info_by_xid (TaskManagerApiWrapper *wrapper,
+                                          gint64    xid,
+                                          gchar     *info,
+                                          GError    **error)
+{
+  TaskManagerApiWrapperPrivate *priv;
+  gboolean succeeded;
+  GValue window = {0};
+  GHashTable *hints;
+  const gchar *key = "message";
+  GValue value = {0};
+  
+  g_return_val_if_fail (TASK_IS_MANAGER_API_WRAPPER (wrapper), FALSE);
+
+  priv = wrapper->priv;
+  
+  g_value_init (&window, G_TYPE_INT64);
+  g_value_set_int64 (&window, xid);
+
+  g_value_init (&value, G_TYPE_STRING);
+  g_value_set_string (&value, info);
+  
+  hints = g_hash_table_new (g_str_hash, g_str_equal);
+  g_hash_table_insert (hints, (gpointer)key, &value);
+  
+  succeeded = task_manager_update (priv->manager,
+                                   &window,
+                                   hints,
+                                   error);
+  g_value_unset (&window);
+  g_value_unset (&value);
+  g_hash_table_destroy (hints);
+
+  return succeeded;
+}
+
+gboolean
+task_manager_api_wrapper_unset_info_by_xid (TaskManagerApiWrapper *wrapper,
+                                            gint64    xid,
+                                            GError    **error)
+{
+  TaskManagerApiWrapperPrivate *priv;
+  gboolean succeeded;
+  GValue window = {0};
+  GHashTable *hints;
+  const gchar *key = "message";
+  GValue value = {0};
+  
+  g_return_val_if_fail (TASK_IS_MANAGER_API_WRAPPER (wrapper), FALSE);
+
+  priv = wrapper->priv;
+  
+  g_value_init (&window, G_TYPE_INT64);
+  g_value_set_int64 (&window, xid);
+
+  g_value_init (&value, G_TYPE_STRING);
+  g_value_set_string (&value, "");
+  
+  hints = g_hash_table_new (g_str_hash, g_str_equal);
+  g_hash_table_insert (hints, (gpointer)key, &value);
+  
+  succeeded = task_manager_update (priv->manager,
+                                   &window,
+                                   hints,
+                                   error);
+  g_value_unset (&window);
+  g_value_unset (&value);
+  g_hash_table_destroy (hints);
+
+  return succeeded;
+}
+
+gboolean
+task_manager_api_wrapper_set_progress_by_xid (TaskManagerApiWrapper *wrapper,
+                                              gint64    xid,
+                                              gint      progress,
+                                              GError    **error)
+{
+  TaskManagerApiWrapperPrivate *priv;
+  gboolean succeeded;
+  GValue window = {0};
+  GHashTable *hints;
+  const gchar *key = "message";
+  GValue value = {0};
+  
+  g_return_val_if_fail (TASK_IS_MANAGER_API_WRAPPER (wrapper), FALSE);
+
+  priv = wrapper->priv;
+  
+  g_value_init (&window, G_TYPE_INT64);
+  g_value_set_int64 (&window, xid);
+
+  //difference between old and new api
+  //unsetting progress indicator by setting progress to -1;
+  if (progress == 100) progress = -1;
+
+  g_value_init (&value, G_TYPE_INT);
+  g_value_set_int (&value, progress);
+  
+  hints = g_hash_table_new (g_str_hash, g_str_equal);
+  g_hash_table_insert (hints, (gpointer)key, &value);
+  
+  succeeded = task_manager_update (priv->manager,
+                                   &window,
+                                   hints,
+                                   error);
+  g_value_unset (&window);
+  g_value_unset (&value);
+  g_hash_table_destroy (hints);
+
+  return succeeded;
+}

=== added file 'applets/taskmanager/task-manager-api-wrapper.h'
--- applets/taskmanager/task-manager-api-wrapper.h	1970-01-01 00:00:00 +0000
+++ applets/taskmanager/task-manager-api-wrapper.h	2009-06-26 11:00:10 +0000
@@ -0,0 +1,125 @@
+/*
+ * Copyright (C) 2008 Neil Jagdish Patel <[e-mail]>
+ *
+ * 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 Hannes Verschore <[e-mail]>
+ */
+
+#ifndef _TASK_MANAGER_API_WRAPPER_H_
+#define _TASK_MANAGER_API_WRAPPER_H_
+
+#include <glib-object.h>
+#include <libawn/libawn.h>
+
+#include "task-manager.h"
+
+#define TASK_TYPE_MANAGER_API_WRAPPER (task_manager_api_wrapper_get_type ())
+
+#define TASK_MANAGER_API_WRAPPER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj),\
+	TASK_TYPE_MANAGER_API_WRAPPER, TaskManagerApiWrapper))
+
+#define TASK_MANAGER_API_WRAPPER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass),\
+	TASK_TYPE_MANAGER_API_WRAPPER, TaskManagerApiWrapperClass))
+
+#define TASK_IS_MANAGER_API_WRAPPER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj),\
+	TASK_TYPE_MANAGER_API_WRAPPER))
+
+#define TASK_IS_MANAGER_API_WRAPPER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),\
+	TASK_TYPE_MANAGER_API_WRAPPER))
+
+#define TASK_MANAGER_API_WRAPPER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj),\
+	TASK_TYPE_MANAGER_API_WRAPPER, TaskManagerApiWrapperClass))
+
+typedef struct _TaskManagerApiWrapper        TaskManagerApiWrapper;
+typedef struct _TaskManagerApiWrapperClass   TaskManagerApiWrapperClass;
+typedef struct _TaskManagerApiWrapperPrivate TaskManagerApiWrapperPrivate;
+ 
+struct _TaskManagerApiWrapper
+{
+  GObject parent;	
+
+  TaskManagerApiWrapperPrivate *priv;
+};
+
+struct _TaskManagerApiWrapperClass
+{
+  GObjectClass parent_class;
+};
+
+GType       task_manager_api_wrapper_get_type (void) G_GNUC_CONST;
+
+TaskManagerApiWrapper * task_manager_api_wrapper_new (TaskManager *manager);
+
+/* name variants */
+
+gboolean
+task_manager_api_wrapper_set_task_icon_by_name (TaskManagerApiWrapper *wrapper,
+                                            		gchar     *name,
+                                             		gchar     *icon_path,
+                                                GError    **error);
+
+gboolean
+task_manager_api_wrapper_unset_task_icon_by_name (TaskManagerApiWrapper *wrapper,
+			                                        		gchar     *name,
+			                                        		GError   	**error);
+
+gboolean
+task_manager_api_wrapper_set_info_by_name (TaskManagerApiWrapper *wrapper,
+                                           gchar    *name,
+                                           gchar    *info,
+                                           GError   **error);
+
+gboolean
+task_manager_api_wrapper_unset_info_by_name (TaskManagerApiWrapper *wrapper,
+                                             gchar     *name,
+                                             GError    **error);
+
+gboolean
+task_manager_api_wrapper_set_progress_by_name (TaskManagerApiWrapper *wrapper,
+                                               gchar    *name,
+                                               gint     progress,
+                                               GError   **error);
+
+/*     XID variants     */
+
+gboolean
+task_manager_api_wrapper_set_task_icon_by_xid (TaskManagerApiWrapper *wrapper,
+                                              gint64    xid,
+                                              gchar     *icon_path,
+                                              GError    **error);
+
+gboolean
+task_manager_api_wrapper_unset_task_icon_by_xid (TaskManagerApiWrapper *wrapper,
+                                                 gint64    xid,
+                                                 GError    **error);
+
+gboolean
+task_manager_api_wrapper_set_info_by_xid (TaskManagerApiWrapper *wrapper,
+                                          gint64    xid,
+                                          gchar     *info,
+                                          GError    **error);
+
+gboolean
+task_manager_api_wrapper_unset_info_by_xid (TaskManagerApiWrapper *wrapper,
+                                            gint64    xid,
+                                            GError    **error);
+
+gboolean
+task_manager_api_wrapper_set_progress_by_xid (TaskManagerApiWrapper *wrapper,
+                                              gint64    xid,
+                                              gint      progress,
+                                              GError    **error);
+
+#endif /* _TASK_MANAGER_API_WRAPPER_H_ */
+

=== modified file 'applets/taskmanager/task-manager.c'
--- applets/taskmanager/task-manager.c	2009-06-11 05:04:21 +0000
+++ applets/taskmanager/task-manager.c	2009-06-28 01:53:46 +0000
@@ -14,7 +14,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by Neil Jagdish Patel <[e-mail]>
- *
+ *             Hannes Verschore <[e-mail]>
  */
 
 #include <stdio.h>
@@ -29,9 +29,9 @@
 
 #include "task-drag-indicator.h"
 #include "task-icon.h"
-#include "task-launcher.h"
+//#include "task-launcher.h"
+//#include "task-window.h"
 #include "task-settings.h"
-#include "task-window.h"
 #include "xutils.h"
 
 G_DEFINE_TYPE (TaskManager, task_manager, AWN_TYPE_APPLET)
@@ -48,17 +48,15 @@
   TaskSettings    *settings;
   WnckScreen      *screen;
 
-
   /* Dragging properties */
   TaskIcon          *dragged_icon;
   TaskDragIndicator *drag_indicator;
   gint               drag_timeout;
 
   /* This is what the icons are packed into */
-  GtkWidget *box;
+  GtkWidget  *box;
   GSList     *icons;
   GSList     *windows;
-  GSList     *launchers;
   GHashTable *win_table;
 
   /* Properties */
@@ -66,7 +64,7 @@
   gboolean  show_all_windows;
   gboolean  only_show_launchers;
   gboolean  drag_and_drop;
-  gint      grouping_mode;
+  gint      match_strength;
 };
 
 enum
@@ -77,30 +75,20 @@
   PROP_ONLY_SHOW_LAUNCHERS,
   PROP_LAUNCHER_PATHS,
   PROP_DRAG_AND_DROP,
-  PROP_GROUPING_MODE
-};
-
-enum
-{
-  GROUPING_NONE,
-  GROUPING_UTIL,
-  GROUPING_PID,
-  GROUPING_WNCK_APP,
-  GROUPING_WMCLASS,
-  GROUPING_END
+  PROP_MATCH_STRENGTH
 };
 
 /* Forwards */
-static void ensure_layout               (TaskManager   *manager);
+static void update_icon_visible         (TaskManager *manager, 
+                                         TaskIcon *icon);
+static void on_icon_visible_changed     (TaskManager *manager, 
+                                         TaskIcon      *icon);
 static void on_window_opened            (WnckScreen    *screen, 
                                          WnckWindow    *window,
                                          TaskManager   *manager);
 static void on_active_window_changed    (WnckScreen    *screen, 
                                          WnckWindow    *old_window,
                                          TaskManager   *manager);
-static void on_wnck_window_closed (WnckScreen *screen, 
-                                   WnckWindow *window, 
-                                   TaskManager *manager);
 static void task_manager_set_show_all_windows    (TaskManager *manager,
                                                   gboolean     show_all);
 static void task_manager_set_show_only_launchers (TaskManager *manager, 
@@ -110,14 +98,15 @@
 static void task_manager_set_drag_and_drop (TaskManager *manager, 
                                             gboolean     drag_and_drop);
 
-static void task_manager_set_grouping_mode (TaskManager *manager, 
-                                            gint     drag_and_drop);
+static void task_manager_set_match_strength (TaskManager *manager, 
+                                             gint     drag_and_drop);
 
 static void task_manager_orient_changed (AwnApplet *applet, 
                                          AwnOrientation orient);
 static void task_manager_size_changed   (AwnApplet *applet,
                                          gint       size);
 
+
 /* D&D Forwards */
 static void _drag_dest_motion (TaskManager *manager,
                                gint x,
@@ -163,9 +152,9 @@
     case PROP_DRAG_AND_DROP:
       g_value_set_boolean (value, manager->priv->drag_and_drop);
       break;
-      
-    case PROP_GROUPING_MODE:
-      g_value_set_int (value, manager->priv->grouping_mode);
+
+    case PROP_MATCH_STRENGTH:
+      g_value_set_int (value, manager->priv->match_strength);
       break;
 
     default:
@@ -200,11 +189,10 @@
     case PROP_DRAG_AND_DROP:
       task_manager_set_drag_and_drop (manager, 
                                       g_value_get_boolean (value));
-      break;
-    
-    case PROP_GROUPING_MODE:
-      task_manager_set_grouping_mode (manager, 
-                                      g_value_get_int (value));
+
+    case PROP_MATCH_STRENGTH:
+      task_manager_set_match_strength (manager, 
+                                       g_value_get_int (value));
       break;
 
       
@@ -250,8 +238,8 @@
                           AWN_CONFIG_CLIENT_DEFAULT_GROUP, "drag_and_drop",
                           object, "drag_and_drop");
   awn_config_bridge_bind (bridge, priv->client, 
-                          AWN_CONFIG_CLIENT_DEFAULT_GROUP, "grouping_mode",
-                          object, "grouping_mode");
+                          AWN_CONFIG_CLIENT_DEFAULT_GROUP, "match_strength",
+                          object, "match_strength");
 }
 
 static void
@@ -296,14 +284,14 @@
                                 G_PARAM_CONSTRUCT | G_PARAM_READWRITE);
   g_object_class_install_property (obj_class, PROP_DRAG_AND_DROP, pspec);
 
-  pspec = g_param_spec_int ("grouping_mode",
-                                "grouping_mode",
-                                "Window Grouping Mode",
-                                0,
-                                GROUPING_END-1,
-                                0,
-                                G_PARAM_READWRITE);
-  g_object_class_install_property (obj_class, PROP_GROUPING_MODE, pspec);
+  pspec = g_param_spec_int ("match_strength",
+                            "match_strength",
+                            "How radical matching is applied for grouping items",
+                            0,
+                            99,
+                            0,
+                            G_PARAM_READWRITE);
+  g_object_class_install_property (obj_class, PROP_MATCH_STRENGTH, pspec);
   
   g_type_class_add_private (obj_class, sizeof (TaskManagerPrivate));
 }
@@ -342,12 +330,6 @@
                     G_CALLBACK (on_window_opened), manager);
   g_signal_connect (priv->screen, "active-window-changed",  
                     G_CALLBACK (on_active_window_changed), manager);
-  g_signal_connect_swapped (priv->screen, "active-workspace-changed",
-                            G_CALLBACK (ensure_layout), manager);
-  g_signal_connect_swapped (priv->screen, "viewports-changed",
-                            G_CALLBACK (ensure_layout), manager);
-  g_signal_connect (priv->screen, "window-closed",
-                    G_CALLBACK(on_wnck_window_closed),manager);        
 }
 
 AwnApplet *
@@ -411,80 +393,15 @@
 }
 
 /*
- * The guts of the show or hide logic
- */
-static void
-ensure_layout (TaskManager *manager)
-{
-  TaskManagerPrivate *priv = manager->priv;
-  WnckWorkspace *space;
-  GSList         *i;
-
-  space = wnck_screen_get_active_workspace (priv->screen);
-
-  if (!WNCK_IS_WORKSPACE (space))
-  {
-    return;
-  }
-
-  /* Go through all the TaskIcons to make sure that they should be shown */
-  for (i = priv->icons; i; i = i->next)
-  {
-    TaskIcon *icon = i->data;
-    
-    if (!TASK_IS_ICON (icon))
-      continue;
-    
-    /* If the icon gets dragged, it shouldn't be shown */
-    if( icon == priv->dragged_icon )
-    {
-      gtk_widget_hide (GTK_WIDGET (icon));
-      continue;
-    }
-
-    /* Show launchers regardless of workspace */
-    if (task_icon_is_launcher (icon))
-    {
-      gtk_widget_show (GTK_WIDGET (icon));
-      continue;
-    }
-
-    /* FIXME: Add support for start-up notification icons too */
-
-    /* 
-     * Only show normal window icons if a) the use wants to see them and b) if
-     * they are on the correct workspace
-     */
-    if (priv->only_show_launchers)
-    {
-      gtk_widget_hide (GTK_WIDGET (icon));
-    }
-    else if (task_icon_is_skip_taskbar (icon))
-    {
-      gtk_widget_hide (GTK_WIDGET (icon));
-    } 
-    else if (task_icon_is_in_viewport (icon, space))
-    {
-      gtk_widget_show (GTK_WIDGET (icon));
-    }
-    else if (priv->show_all_windows)
-    {
-      gtk_widget_show (GTK_WIDGET (icon));  
-    }
-    else
-    {
-      gtk_widget_hide (GTK_WIDGET (icon));
-    }
-  }
-  
-  /* Hide drag_indicator if there is no AwnIcon currently dragged */
-  if(priv->dragged_icon == NULL)
-    gtk_widget_hide (GTK_WIDGET(priv->drag_indicator));
-}
-
-/*
  * WNCK_SCREEN CALLBACKS
  */
+
+/**
+ * This signal is only connected for windows which were of type normal/utility
+ * and were initially "skip-tasklist". If they are not skip-tasklist anymore
+ * we treat them as newly opened windows.
+ * STATE: done
+ */
 static void
 on_window_state_changed (WnckWindow      *window,
                          WnckWindowState  changed_mask,
@@ -493,10 +410,7 @@
 {
   g_return_if_fail (TASK_IS_MANAGER (manager));
 
-  /* This signal is only connected for windows which were of type normal/utility
-   * and were initially "skip-tasklist". If they are not skip-tasklist anymore
-   * we treat them as newly opened windows
-   */
+  // test if they don't skip-tasklist anymore
   if (!wnck_window_is_skip_tasklist (window))
   {
     g_signal_handlers_disconnect_by_func (window, 
@@ -506,315 +420,145 @@
   }
 }
 
+/**
+ * The active WnckWindow has changed.
+ * Retrieve the TaskWindows and update there active state 
+ */
 static void 
-on_wnck_window_closed (WnckScreen *screen, WnckWindow *window, TaskManager *manager)
-{
-  GSList *i;  
-  TaskManagerPrivate *priv = manager->priv;  
-  for (i = priv->icons; i; i = i->next)
-  {
-    TaskIcon *taskicon = i->data;
-    if (!TASK_IS_ICON (taskicon))
-      continue;
-    task_icon_remove_window (taskicon, window);            
-  }
-}
-
-static gboolean
-check_wmclass(TaskWindow *taskwin,gchar * win_res_name, gchar *win_class_name)
-{
-  gboolean result;
-  gchar   *temp;
-  gchar   *res_name = NULL;
-  gchar   *class_name = NULL;
-
-  _wnck_get_wmclass (task_window_get_xid (taskwin), &res_name, &class_name);
-  if (res_name)
-  {
-    temp = res_name;
-    res_name = g_utf8_strdown (temp, -1);
-    g_free (temp);
-  }
-  
-  if (class_name)
-  {
-    temp = class_name;
-    class_name = g_utf8_strdown (temp, -1);
-    g_free (temp);
-  }
-  result =  ( 
-              (g_strcmp0 (res_name,win_res_name)==0) 
-              ||
-              (g_strcmp0 (class_name,win_class_name)==0)
-             );
-  g_free (res_name);
-  g_free (class_name);
-
-  return result;
-}
-
-static gboolean
-try_to_place_window_by_wmclass (TaskManager *manager, WnckWindow *window)
-{
-  GSList *i;
-  TaskManagerPrivate *priv = manager->priv;
-  gchar   *temp;
-  gchar   *res_name = NULL;
-  gchar   *class_name = NULL;
-
-  /* Grab the appropriete info */
-  _wnck_get_wmclass (wnck_window_get_xid (window), &res_name, &class_name);
-
-  if (res_name)
-  { 
-    temp = res_name;
-    res_name = g_utf8_strdown (temp, -1);
-    g_free (temp);
-  }
-  
-  if (class_name)
-  {
-    temp = class_name;
-    class_name = g_utf8_strdown (temp, -1);
-    g_free (temp);
-  }
-  
-  for (i = priv->icons; i; i = i->next)
-  {
-    TaskIcon *taskicon = i->data;
-    TaskWindow *taskwin = NULL;
-    
-    if (!TASK_IS_ICON (taskicon))
-      continue;
-    
-    taskwin = task_icon_get_window(taskicon);
-
-    if ( check_wmclass (taskwin,res_name,class_name) )
-    {
-      task_icon_append_window (taskicon, task_window_new (window));
-      g_object_set_qdata (G_OBJECT (window), win_quark, taskwin);
-      g_free (res_name);
-      g_free (class_name);
-      return TRUE;
-    }
-  }
-
-  g_free (res_name);
-  g_free (class_name);
-  return FALSE;  
-}
-
-static gboolean
-try_to_place_window_by_wnck_app (TaskManager *manager, WnckWindow *window)
-{
-  TaskManagerPrivate *priv = manager->priv;
-  GSList *i;
-  WnckApplication *taskwin_app;
-
-  for (i = priv->icons; i; i = i->next)
-  {
-    TaskIcon *taskicon = i->data;
-    TaskWindow *taskwin = NULL;
-    
-    if (!TASK_IS_ICON (taskicon))
-      continue;
-    
-    taskwin = task_icon_get_window(taskicon);
-		taskwin_app = task_window_get_application (taskwin);
-    if ( taskwin_app && (taskwin_app == wnck_window_get_application (window)))
-    {
-      task_icon_append_window (taskicon, task_window_new (window));
-      g_object_set_qdata (G_OBJECT (window), win_quark, taskwin);
-      return TRUE;
-    }
-  }
-  
-  return FALSE;  
-}
-
-static gboolean
-try_to_place_window_by_pid (TaskManager *manager, WnckWindow *window)
-{
-  TaskManagerPrivate *priv = manager->priv;
-  GSList *i;
-	gint taskwin_pid = -1;
-  gint matches = 0;
-
-  for (i = priv->icons; i; i = i->next)
-  {
-    TaskIcon *taskicon = i->data;
-    TaskWindow *taskwin = NULL;
-    
-    if (!TASK_IS_ICON (taskicon))
-      continue;
-    
-    taskwin = task_icon_get_window(taskicon);
-		taskwin_pid = task_window_get_pid (taskwin);
-    if ( taskwin_pid && (taskwin_pid == wnck_window_get_pid (window)))
-    {
-      if (matches)
-      {
-        task_icon_append_window (taskicon, task_window_new (window));
-        g_object_set_qdata (G_OBJECT (window), win_quark, taskwin);
-        return TRUE;
-      }
-      matches++;
-    }
-  }
-  return FALSE;
-}
-
-static gboolean
-try_to_place_util_window (TaskManager *manager, WnckWindow *window)
-{
-  WnckWindowType type = wnck_window_get_window_type (window);
-  TaskManagerPrivate *priv = manager->priv;
-  GSList *w;
-  gint taskwin_pid = -1;
-  gint matches = 0;
-  
-  if ( (type !=  WNCK_WINDOW_UTILITY) && (type != WNCK_WINDOW_DIALOG) )
-  {
-    return FALSE;
-  }
-  
-  for (w = priv->icons; w; w = w->next)
-  {
-    TaskIcon *taskicon = w->data;
-    TaskWindow *taskwin = NULL;
-    
-    if (!TASK_IS_ICON (taskicon))
-      continue;
-    
-    taskwin = task_icon_get_window(taskicon);
-    taskwin_pid = task_window_get_pid (taskwin);
-    if ( taskwin_pid && (taskwin_pid == wnck_window_get_pid (window)))
-    {
-      if (matches)
-      {
-        task_icon_append_window (taskicon, task_window_new (window));
-        g_object_set_qdata (G_OBJECT (window), win_quark, taskwin);
-        return TRUE;
-      }
-      matches++;
-    }
-  } 
-  return FALSE;
-} 
-
-static gboolean
-try_to_place_window (TaskManager *manager, WnckWindow *window)
-{
-  TaskManagerPrivate *priv = manager->priv;
-  gboolean result = FALSE;
-  switch(priv->grouping_mode)
-  {
-    case GROUPING_WMCLASS:  /*Fall through*/
-      result =result?result:try_to_place_window_by_wmclass(manager,window);
-    case GROUPING_WNCK_APP:/*Fall through*/
-      result =result?result:try_to_place_window_by_wnck_app(manager,window);      
-    case GROUPING_PID: /*Don't Fall through*/
-      result =result?result:try_to_place_window_by_pid(manager,window);
-      break;
-    case GROUPING_UTIL:/*Don't Fall through*/
-      result =result?result:try_to_place_util_window(manager,window);
-      break;
-    case GROUPING_NONE:
-      break;
-    default:
-      g_assert_not_reached();
-  }
-  return result;
-}
-
-static gboolean
-try_to_match_window_to_launcher (TaskManager *manager, WnckWindow *window)
-{
-  TaskManagerPrivate *priv = manager->priv;
-  GSList  *l;
-  gchar   *temp;
-  gchar   *res_name = NULL;
-  gchar   *class_name = NULL;
-  gint     pid;
-  gboolean res = FALSE;
-
-  /* Grab the appropriete info */
-  pid = wnck_window_get_pid (window);
-  _wnck_get_wmclass (wnck_window_get_xid (window), &res_name, &class_name);
-
-  if (res_name)
-  {
-    temp = res_name;
-    res_name = g_utf8_strdown (temp, -1);
-    g_free (temp);
-  }
-  
-  if (class_name)
-  {
-    temp = class_name;
-    class_name = g_utf8_strdown (temp, -1);
-    g_free (temp);
-  }
-
-  /* Try and match */
-  for (l = priv->launchers; l; l = l->next)
-  {
-    TaskLauncher *launcher = l->data;
-
-    if (!TASK_IS_LAUNCHER (launcher))
-      continue;
-
-    if (task_launcher_has_window (launcher))
-      continue;
-    
-    if (!task_launcher_try_match (launcher, pid, res_name, class_name))
-      continue;
-
-    /* As it matched this launcher, we can set the window to the launcher and
-     * get on with it
-     */
-    task_launcher_set_window (launcher, window);
-    g_object_set_qdata (G_OBJECT (window), win_quark, launcher);
-    res = TRUE;
-  }
-  g_free (res_name);
-  g_free (class_name);
-
-  return res;
-}
-
-static gboolean
-try_to_match_window_to_sn_context (TaskManager *manager, WnckWindow *window)
-{
-  return FALSE;
-}
-
-static void
-window_closed (TaskManager *manager, GObject *old_window)
-{
-  TaskManagerPrivate *priv;
-
-  g_return_if_fail (TASK_IS_MANAGER (manager));
-  priv = manager->priv;
-
-  priv->windows = g_slist_remove (priv->windows, old_window);
-
-  ensure_layout (manager);
-}
-
+on_active_window_changed (WnckScreen    *screen, 
+                          WnckWindow    *old_window,
+                          TaskManager   *manager)
+{
+  TaskManagerPrivate *priv;
+  WnckWindow         *active = NULL;
+  TaskWindow         *taskwin = NULL;
+  TaskWindow         *old_taskwin = NULL;
+  
+  g_return_if_fail (TASK_IS_MANAGER (manager));
+  priv = manager->priv;
+
+  active = wnck_screen_get_active_window (priv->screen);
+
+  if (WNCK_IS_WINDOW (old_window))
+    old_taskwin = (TaskWindow *)g_object_get_qdata (G_OBJECT (old_window),
+                                                    win_quark);
+  if (WNCK_IS_WINDOW (active))
+    taskwin = (TaskWindow *)g_object_get_qdata (G_OBJECT (active), win_quark);
+
+  if (TASK_IS_WINDOW (old_taskwin))
+    task_window_set_is_active (old_taskwin, FALSE);
+  if (TASK_IS_WINDOW (taskwin))
+    task_window_set_is_active (taskwin, TRUE);
+}
+
+/**
+ * When the property 'show_all_windows' is False,
+ * workspace switches are monitored. Whenever one happens
+ * all TaskWindows are notified.
+ */
+static void
+on_workspace_changed (TaskManager *manager) //... has more arguments
+{
+  TaskManagerPrivate *priv;
+  GSList             *w;
+  WnckWorkspace      *space;
+  
+  g_return_if_fail (TASK_IS_MANAGER (manager));
+
+  priv = manager->priv;
+  space = wnck_screen_get_active_workspace (priv->screen);
+  
+  for (w = priv->windows; w; w = w->next)
+  {
+    TaskWindow *window = w->data;
+
+    if (!TASK_IS_WINDOW (window)) continue;
+
+    task_window_set_active_workspace (window, space);
+  }
+}
+
+/*
+ * TASK_ICON CALLBACKS
+ */
+
+static void
+update_icon_visible (TaskManager *manager, TaskIcon *icon)
+{
+  TaskManagerPrivate *priv;
+
+  g_return_if_fail (TASK_IS_MANAGER (manager));
+
+  priv = manager->priv;
+  
+  if (task_icon_is_visible (icon))
+  {
+    if (priv->only_show_launchers && !task_icon_contains_launcher (icon))
+    {
+      gtk_widget_hide (GTK_WIDGET (icon));
+    }
+    else
+    {
+      if (!GTK_WIDGET_VISIBLE (icon))
+      {
+        awn_effects_start_ex (awn_overlayable_get_effects (AWN_OVERLAYABLE (icon)), 
+                              AWN_EFFECT_OPENING, 1, FALSE, FALSE);
+        gtk_widget_show (GTK_WIDGET (icon));
+      }
+    }
+  }
+  else
+  {
+    gtk_widget_hide (GTK_WIDGET (icon));
+  }
+}
+
+static void
+on_icon_visible_changed (TaskManager *manager, TaskIcon *icon)
+{
+  g_return_if_fail (TASK_IS_MANAGER (manager));
+
+  update_icon_visible (manager, icon);
+}
+
+/**
+ * This function gets called whenever a task-window gets finalized.
+ * It removes the task-window from the list.
+ * State: done
+ */
+static void
+window_closed (TaskManager *manager, GObject *old_item)
+{
+  TaskManagerPrivate *priv;
+
+  g_return_if_fail (TASK_IS_MANAGER (manager));
+
+  priv = manager->priv;
+  priv->windows = g_slist_remove (priv->windows, old_item);
+}
+
+/**
+ * This function gets called whenever a task-icon gets finalized.
+ * It removes the task-icon from the gslist and update layout
+ * (so it gets removed from the bar)
+ * State: done
+ */
 static void
 icon_closed (TaskManager *manager, GObject *old_icon)
 {
   TaskManagerPrivate *priv;
 
   g_return_if_fail (TASK_IS_MANAGER (manager));
+
   priv = manager->priv;
-
   priv->icons = g_slist_remove (priv->icons, old_icon);
-
-  ensure_layout (manager);
 }
 
+/**
+ * Whenever a new window gets opened it will try to place it
+ * in an awn-icon or will create a new awn-icon.
+ * State: adjusted
+ */
 static void 
 on_window_opened (WnckScreen    *screen, 
                   WnckWindow    *window,
@@ -822,13 +566,17 @@
 {
   TaskManagerPrivate *priv;
   GtkWidget          *icon;
-  TaskWindow         *taskwin;
+  TaskItem           *item;
   WnckWindowType      type;
+  GSList             *w;
+  TaskIcon *match      = NULL;
+  gint match_score     = 0;
+  gint max_match_score = 0;
 
   g_return_if_fail (TASK_IS_MANAGER (manager));
   g_return_if_fail (WNCK_IS_WINDOW (window));
+
   priv = manager->priv;
-
   type = wnck_window_get_window_type (window);
 
   switch (type)
@@ -855,84 +603,52 @@
     return;
   }
 
-  /*
-   */
-    
-  if ( priv->grouping_mode && try_to_place_window (manager,window))
-  {
-    g_debug ("WINDOW PLACED: %s", wnck_window_get_name (window));
-    return;
-  }
- 
-  /* Okay, time to check the launchers if we can get a match */
-  if (try_to_match_window_to_launcher (manager, window))
-  {
-    g_debug ("WINDOW MATCHED: %s", wnck_window_get_name (window));
-    return;
-  }
-
-  /* Try the startup-notification windows */
-  if (try_to_match_window_to_sn_context (manager, window))
-  {
-    g_debug ("WINDOW STARTUP: %s", wnck_window_get_name (window));
-    return;
-  }
-
-  /* 
-   * We couldn't append the window to a pre-existing TaskWindow, so we'll need
-   * to make a new one
-   */
-  taskwin = task_window_new (window);
-  priv->windows = g_slist_append (priv->windows, taskwin);
-  g_object_weak_ref (G_OBJECT (taskwin), (GWeakNotify)window_closed, manager);
-  g_object_set_qdata (G_OBJECT (window), win_quark, taskwin); 
-  
-  /* If we've come this far, the window deserves a spot on the task-manager!
-   * Time to create a TaskIcon for it
-   */
-  icon = task_icon_new_for_window (taskwin);
-  gtk_container_add (GTK_CONTAINER (priv->box), icon);
-  gtk_widget_show (icon);
-
-  priv->icons = g_slist_append (priv->icons, icon);
-  g_signal_connect_swapped (icon, "ensure_layout", 
-                            G_CALLBACK (ensure_layout), manager);
-
-  /* reordening through D&D */
-  if(priv->drag_and_drop)
-    _drag_add_signals(manager, icon);
-
-  g_object_weak_ref (G_OBJECT (icon), (GWeakNotify)icon_closed, manager);  
-  
-  /* Finally, make sure all is well on the taskbar */
-  ensure_layout (manager);
-}
-
-static void 
-on_active_window_changed (WnckScreen    *screen, 
-                          WnckWindow    *old_window,
-                          TaskManager   *manager)
-{
-  TaskManagerPrivate *priv;
-  WnckWindow         *active = NULL;
-  TaskWindow         *taskwin = NULL;
-  TaskWindow         *old_taskwin = NULL;
-  
-  g_return_if_fail (TASK_IS_MANAGER (manager));
-  priv = manager->priv;
-
-  active = wnck_screen_get_active_window (priv->screen);
-
-  if (WNCK_IS_WINDOW (old_window))
-    old_taskwin = (TaskWindow *)g_object_get_qdata (G_OBJECT (old_window),
-                                                    win_quark);
-  if (WNCK_IS_WINDOW (active))
-    taskwin = (TaskWindow *)g_object_get_qdata (G_OBJECT (active), win_quark);
-
-  if (TASK_IS_WINDOW (old_taskwin))
-    task_window_set_is_active (old_taskwin, FALSE);
-  if (TASK_IS_WINDOW (taskwin))
-    task_window_set_is_active (taskwin, TRUE);
+  // create a new TaskWindow containing the WnckWindow
+  item = task_window_new (window);
+  g_object_set_qdata (G_OBJECT (window), win_quark, TASK_WINDOW (item));
+
+  priv->windows = g_slist_append (priv->windows, item);
+  g_object_weak_ref (G_OBJECT (item), (GWeakNotify)window_closed, manager);
+  
+  // see if there is a icon that matches
+  for (w = priv->icons; w; w = w->next)
+  {
+    TaskIcon *taskicon = w->data;
+
+    if (!TASK_IS_ICON (taskicon)) continue;
+
+    match_score = task_icon_match_item (taskicon, item);
+    if (match_score > max_match_score)
+    {
+      max_match_score = match_score;
+      match = taskicon;
+    }
+  }
+
+  g_debug("Matching score: %i, must be bigger then:%i, groups: %i", max_match_score, 99-priv->match_strength, max_match_score > 99-priv->match_strength);
+  
+  if (max_match_score > 99-priv->match_strength)
+  {
+    task_icon_append_item (match, item);
+  }
+  else
+  {
+    icon = task_icon_new();
+    task_icon_append_item (TASK_ICON (icon), item);
+
+    priv->icons = g_slist_append (priv->icons, icon);
+    gtk_container_add (GTK_CONTAINER (priv->box), icon);
+
+    /* reordening through D&D */
+    if(priv->drag_and_drop)
+      _drag_add_signals(manager, icon);
+
+    g_object_weak_ref (G_OBJECT (icon), (GWeakNotify)icon_closed, manager);
+    g_signal_connect_swapped (icon, "visible-changed",
+                              G_CALLBACK (on_icon_visible_changed), manager);
+
+    update_icon_visible (manager, TASK_ICON (icon));
+  }
 }
 
 /*
@@ -942,26 +658,86 @@
 task_manager_set_show_all_windows (TaskManager *manager,
                                    gboolean     show_all)
 {
+  TaskManagerPrivate *priv;
+  GSList             *w;
+  WnckWorkspace      *space = NULL;
+  
   g_return_if_fail (TASK_IS_MANAGER (manager));
+
+  priv = manager->priv;
+
+  if (priv->show_all_windows == show_all) return;
+ 
   manager->priv->show_all_windows = show_all;
 
-  ensure_layout (manager);
-
+  if (show_all)
+  {
+    // Remove signals of workspace changes
+    g_signal_handlers_disconnect_by_func(priv->screen, 
+                                         G_CALLBACK (on_workspace_changed), 
+                                         manager);
+    
+    // Set workspace to NULL, so TaskWindows aren't tied to workspaces anymore
+    space = NULL;
+  }
+  else
+  {
+    // Add signals to WnckScreen for workspace changes
+    g_signal_connect_swapped (priv->screen, "viewports-changed",
+                              G_CALLBACK (on_workspace_changed), manager);
+    g_signal_connect_swapped (priv->screen, "active-workspace-changed",
+                              G_CALLBACK (on_workspace_changed), manager);
+
+    // Retrieve the current active workspace
+    space = wnck_screen_get_active_workspace (priv->screen);
+  }
+
+  /* Update the workspace for every TaskWindow.
+   * NULL if the windows aren't tied to a workspace anymore */
+  for (w = priv->windows; w; w = w->next)
+  {
+    TaskWindow *window = w->data;
+    if (!TASK_IS_WINDOW (window)) continue;
+    task_window_set_active_workspace (window, space);
+  }
+  
   g_debug ("%s", show_all ? "showing all windows":"not showing all windows");
 }
 
+/**
+ * The property 'show_only_launchers' changed.
+ * So update the property and update the visiblity of every icon.
+ */
 static void
 task_manager_set_show_only_launchers (TaskManager *manager, 
-                                      gboolean     show_only)
+                                      gboolean     only_show_launchers)
 {
+  TaskManagerPrivate *priv;
+  GSList             *w;
+
   g_return_if_fail (TASK_IS_MANAGER (manager));
-  manager->priv->only_show_launchers = show_only;
-
-  ensure_layout (manager);
-
-  g_debug ("%s", show_only ? "only show launchers":"show everything");
+
+  priv = manager->priv;
+  priv->only_show_launchers = only_show_launchers;
+
+  for (w = priv->icons; w; w = w->next)
+  {
+    TaskIcon *icon = w->data;
+
+    if (!TASK_IS_ICON (icon)) continue;
+
+    update_icon_visible (manager, icon);
+  }
+  
+  g_debug ("%s", only_show_launchers ? "only show launchers":"show everything");
 }
 
+/**
+ * Checks when launchers got added/removed in the list in gconf/file.
+ * It removes the launchers from the task-icons and add those
+ * that aren't already on the bar.
+ * State: partial - TODO: refresh of a list
+ */
 static void 
 task_manager_refresh_launcher_paths (TaskManager *manager,
                                      GSList      *list)
@@ -979,41 +755,23 @@
   for (d = list; d; d = d->next)
   {
     GtkWidget    *icon;
-    TaskLauncher *launcher = NULL;
-    GSList        *l;
-
-    for (l = priv->launchers; l; l = l->next)
-    {
-      TaskLauncher *launch = l->data;
-
-      if (!TASK_IS_LAUNCHER (launch))
-        continue;
-      
-      if (g_strcmp0 (d->data, task_launcher_get_desktop_path (launch)) == 0)
-      {
-        launcher = launch;
-        break;
-      }
-    }
-
-    if (TASK_IS_LAUNCHER (launcher))
-      continue;
+    TaskItem     *launcher = NULL;
 
     launcher = task_launcher_new_for_desktop_file (d->data);
 
-    if (!launcher)
-      continue;
+    if (!launcher) continue;
 
-    priv->launchers = g_slist_append (priv->launchers, launcher);
-    
-    icon = task_icon_new_for_window (TASK_WINDOW (launcher));
+    icon = task_icon_new ();
+    task_icon_append_item (TASK_ICON (icon), launcher);
     gtk_container_add (GTK_CONTAINER (priv->box), icon);
-    gtk_widget_show (icon);
 
     priv->icons = g_slist_append (priv->icons, icon);
-    g_signal_connect_swapped (icon, "ensure_layout", 
-                               G_CALLBACK (ensure_layout), manager);
+
     g_object_weak_ref (G_OBJECT (icon), (GWeakNotify)icon_closed, manager);
+    g_signal_connect_swapped (icon, "visible-changed",
+                              G_CALLBACK (on_icon_visible_changed), manager);
+
+    update_icon_visible (manager, TASK_ICON (icon));
 
     /* reordening through D&D */
     if(priv->drag_and_drop)
@@ -1023,19 +781,14 @@
   for (d = list; d; d = d->next)
     g_free (d->data);
   g_slist_free (list);
-
-  /* Finally, make sure all is well on the taskbar */
-  ensure_layout (manager);
 }
 
 static void
-task_manager_set_grouping_mode (TaskManager *manager,
-                                   gint grouping_mode)
+task_manager_set_match_strength (TaskManager *manager,
+                                 gint match_strength)
 {
   g_return_if_fail (TASK_IS_MANAGER (manager));
-  manager->priv->grouping_mode = grouping_mode;
-
-  ensure_layout (manager);
+  manager->priv->match_strength = match_strength;
 }
 
 static void
@@ -1049,37 +802,189 @@
 
   priv->drag_and_drop = drag_and_drop;
 
+  //connect or dissconnect the dragging signals
+  for (i = priv->icons; i; i = i->next)
+  {
+    TaskIcon *icon = i->data;
+    
+    if (!TASK_IS_ICON (icon)) continue;
+
+    if(drag_and_drop)
+    {
+      _drag_add_signals (manager, GTK_WIDGET(icon));
+    }
+    else
+    {
+      //FIXME: Stop any ongoing move
+      _drag_remove_signals (manager, GTK_WIDGET(icon));
+    }
+  }
   if(drag_and_drop)
   {
-    //connect to the dragging signals
-    for (i = priv->icons; i; i = i->next)
-    {
-      TaskIcon *icon = i->data;
-      
-      if (!TASK_IS_ICON (icon)) continue;
-
-      _drag_add_signals (manager, GTK_WIDGET(icon));
-    }
     _drag_add_signals (manager, GTK_WIDGET(priv->drag_indicator));
   }
   else
   {
-    //disconnect the dragging signals
-    for (i = priv->icons; i; i = i->next)
-    {
-      TaskIcon *icon = i->data;
-      
-      if (!TASK_IS_ICON (icon)) continue;
-
-      _drag_remove_signals (manager, GTK_WIDGET(icon));
-    }
     _drag_remove_signals (manager, GTK_WIDGET(priv->drag_indicator));
-    //FIXME: Stop any ongoing move
   }
 
   g_debug("%s", drag_and_drop?"D&D is on":"D&D is off");
 }
 
+/**
+ * D-BUS functionality
+ */
+
+gboolean
+task_manager_get_capabilities (TaskManager *manager,
+                               GStrv *supported_keys,
+                               GError **error)
+{
+  const gchar *known_keys[] =
+  {
+    "icon-file",
+    "progress",
+    "message",
+    "visible",
+    NULL
+  };
+
+  *supported_keys = g_strdupv ((char **)known_keys);
+
+  return TRUE;
+}
+
+/**
+ * Find the window that corresponds to the given window name.
+ * First try to match the application name, then the normal name.
+ */
+static TaskWindow*
+_match_name (TaskManager *manager, const gchar* window)
+{
+  TaskManagerPrivate *priv;
+  WnckApplication *wnck_app = NULL;
+  const gchar *name = NULL;
+  GSList *w;
+
+  g_return_val_if_fail (TASK_IS_MANAGER (manager), FALSE);
+  priv = manager->priv;  
+  
+  for (w = priv->windows; w; w = w->next)
+  {
+    TaskWindow *taskwindow = w->data;
+
+    if (!TASK_IS_WINDOW (taskwindow)) continue;
+
+    wnck_app = task_window_get_application (taskwindow);
+    if (WNCK_IS_APPLICATION(wnck_app))
+    {
+      name = wnck_application_get_name(wnck_app);
+      if (name && strcmp (window, name) == 0)
+        return taskwindow;
+    }
+
+    name = task_window_get_name (taskwindow);
+    if (name && strcmp (window, name) == 0)
+      return taskwindow;
+  }
+  
+  return NULL;
+}
+
+/**
+ * Find the window that corresponds to the given xid
+ */
+static TaskWindow*
+_match_xid (TaskManager *manager, gint64 window)
+{
+  TaskManagerPrivate *priv;
+  gint64 xid;
+  GSList *w;
+
+  g_return_val_if_fail (TASK_IS_MANAGER (manager), FALSE);
+  priv = manager->priv;
+  
+  for (w = priv->windows; w; w = w->next)
+  {
+    TaskWindow *taskwindow = w->data;
+    
+    if (!TASK_IS_WINDOW (taskwindow)) continue;
+
+    xid = task_window_get_xid (taskwindow);
+    if (xid && window == xid)
+      return taskwindow;
+  }
+  
+  return NULL;
+}
+
+gboolean
+task_manager_update (TaskManager *manager,
+                     GValue *window,
+                     GHashTable *hints, /* mappings from string to GValue */
+                     GError **error)
+{
+  TaskManagerPrivate *priv;
+  TaskWindow *matched_window = NULL;
+
+  g_return_val_if_fail (TASK_IS_MANAGER (manager), FALSE);
+  
+  priv = manager->priv;
+  
+  if (G_VALUE_HOLDS_STRING (window))
+  {
+    matched_window = _match_name (manager, g_value_get_string (window));
+  }
+  else if (G_VALUE_HOLDS_INT64 (window))
+  {
+    matched_window = _match_xid (manager, g_value_get_int64 (window));
+  }
+  else
+  {
+    //G_ERROR stuff
+    return FALSE;
+  }
+
+  if (matched_window)
+  {
+    GHashTableIter iter;
+    gpointer key, value;
+
+    g_hash_table_iter_init (&iter, hints);
+    while (g_hash_table_iter_next (&iter, &key, &value)) 
+    {
+      gchar *key_name = (gchar *)key;
+      if (strcmp ("icon-file", key_name) == 0)
+      {
+
+      }
+      else if (strcmp ("progress", key_name) == 0)
+      {
+
+      }
+      else if (strcmp ("message", key_name) == 0)
+      {
+
+      }
+      else if (strcmp ("visible", key_name) == 0)
+      {
+        
+      }
+      else
+      {
+        g_debug ("Taskmanager doesn't understand the key: %s", key_name);
+      }
+    }
+    
+    return TRUE;
+  }
+  else
+  {
+    return FALSE;
+  }
+}
+
+
 /*
  * Position Icons through dragging
  */
@@ -1212,11 +1117,11 @@
   TaskManagerPrivate *priv;
   gint move_to;
   GList* childs;
-  GSList* d;
-  GSList* launchers = NULL;
-  TaskLauncher* launcher;
-  gchar* launcher_path;
-  GError *err = NULL;
+  //GSList* d;
+  //GSList* launchers = NULL;
+  //TaskLauncher* launcher;
+  //gchar* launcher_path;
+  //GError *err = NULL;
 
   g_return_if_fail (TASK_IS_MANAGER (manager));
 
@@ -1252,7 +1157,7 @@
   // Update the position in the config (Gconf) if the AwnIcon is a launcher.
   // FIXME: support multiple launchers in one AwnIcon?
 
-  if (task_icon_is_launcher (priv->dragged_icon))
+/*  if (task_icon_is_launcher (priv->dragged_icon))
   {
     // get the updated list
     childs = gtk_container_get_children (GTK_CONTAINER(priv->box));
@@ -1283,6 +1188,7 @@
       return;
     }
   }
+*/
 
   priv->dragged_icon = NULL;
 }

=== modified file 'applets/taskmanager/task-manager.h'
--- applets/taskmanager/task-manager.h	2009-03-03 00:58:39 +0000
+++ applets/taskmanager/task-manager.h	2009-06-21 23:03:17 +0000
@@ -64,5 +64,14 @@
                                    gint         offset,
                                    gint         height);
 
+gboolean task_manager_get_capabilities (TaskManager *manager,
+                                        GStrv *supported_keys,
+                                        GError **error);
+
+gboolean task_manager_update (TaskManager *manager,
+                              GValue *window,
+                              GHashTable *hints, /* mappings from string to GValue */
+                              GError **error);
+
 #endif /* _TASK_MANAGER_H_ */
 

=== removed file 'applets/taskmanager/task-window-private.h'
--- applets/taskmanager/task-window-private.h	2009-03-24 16:39:41 +0000
+++ applets/taskmanager/task-window-private.h	1970-01-01 00:00:00 +0000
@@ -1,35 +0,0 @@
-/*
- * Copyright (C) 2008 Neil Jagdish Patel <[e-mail]>
- *
- * 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]>
- *
- */
-
-#define TASK_WINDOW_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj),\
-  TASK_TYPE_WINDOW, \
-  TaskWindowPrivate))
-
-struct _TaskWindowPrivate
-{
-  WnckWindow *window;
-
-  /* Properties */
-  gchar   *message;
-  gfloat   progress;
-  gboolean hidden;
-  gboolean needs_attention;
-  gboolean is_active;
-};
-

=== modified file 'applets/taskmanager/task-window.c'
--- applets/taskmanager/task-window.c	2009-06-11 05:04:21 +0000
+++ applets/taskmanager/task-window.c	2009-06-26 11:00:10 +0000
@@ -14,6 +14,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by Neil Jagdish Patel <[e-mail]>
+ *             Hannes Verschore <[e-mail]>
  *
  */
 
@@ -26,11 +27,33 @@
 #include <libwnck/libwnck.h>
 
 #include "task-window.h"
-#include "task-launcher.h"
 #include "task-settings.h"
 #include "xutils.h"
 
-G_DEFINE_TYPE (TaskWindow, task_window, G_TYPE_OBJECT)
+G_DEFINE_TYPE (TaskWindow, task_window, TASK_TYPE_ITEM)
+
+#define TASK_WINDOW_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj),\
+  TASK_TYPE_WINDOW, \
+  TaskWindowPrivate))
+
+struct _TaskWindowPrivate
+{
+  WnckWindow *window;
+
+  // Workspace where the window should be in, before being visible.
+  // NULL if it isn't important
+  WnckWorkspace *workspace;
+
+  // Is this window in the workspace. If workspace is NULL, this is always TRUE;
+  gboolean in_workspace;
+
+  /* Properties */
+  gchar   *message;
+  gfloat   progress;
+  gboolean hidden;
+  gboolean needs_attention;
+  gboolean is_active;
+};
 
 enum
 {
@@ -40,27 +63,25 @@
 
 enum
 {
-  NAME_CHANGED,
-  ICON_CHANGED,
   ACTIVE_CHANGED,
   NEEDS_ATTENTION,
   WORKSPACE_CHANGED,
   MESSAGE_CHANGED,
   PROGRESS_CHANGED,
   HIDDEN_CHANGED,
-  RUNNING_CHANGED,
 
   LAST_SIGNAL
 };
 static guint32 _window_signals[LAST_SIGNAL] = { 0 };
 
 /* Forwards */
-static WnckApplication * _get_application (TaskWindow *window);
-static gint          _get_pid         (TaskWindow     *window);
-static const gchar * _get_name        (TaskWindow     *window);
-static GdkPixbuf   * _get_icon        (TaskWindow     *window);
-static gboolean      _is_on_workspace (TaskWindow     *window,
-                                       WnckWorkspace  *space);
+static const gchar * _get_name        (TaskItem       *item);
+static GdkPixbuf   * _get_icon        (TaskItem       *item);
+static gboolean      _is_visible      (TaskItem       *item);
+static void          _left_click      (TaskItem *item, GdkEventButton *event);
+static void          _right_click     (TaskItem *item, GdkEventButton *event);
+static guint         _match           (TaskItem *item, TaskItem *item_to_match);
+
 static void   task_window_set_window (TaskWindow *window,
                                       WnckWindow *wnckwin);
 
@@ -104,51 +125,24 @@
 }
 
 static void
-task_window_constructed (GObject *object)
-{
-  /*TaskWindowPrivate *priv = TASK_WINDOW (object)->priv;*/
-}
-
-static void
 task_window_class_init (TaskWindowClass *klass)
 {
-  GParamSpec   *pspec;
-  GObjectClass *obj_class = G_OBJECT_CLASS (klass);
-
-  obj_class->constructed  = task_window_constructed;
+  GParamSpec    *pspec;
+  GObjectClass  *obj_class  = G_OBJECT_CLASS (klass);
+  TaskItemClass *item_class = TASK_ITEM_CLASS (klass);
+  
   obj_class->set_property = task_window_set_property;
   obj_class->get_property = task_window_get_property;
-
-  /* We implement the necessary funtions for a normal window */
-  klass->get_application = _get_application;
-  klass->get_pid         = _get_pid;
-  klass->get_name        = _get_name;
-  klass->get_icon        = _get_icon;
-  klass->is_on_workspace = _is_on_workspace;
-  klass->activate        = NULL;
-  klass->popup_menu      = NULL;
-
+  
+  /* We implement the necessary funtions for an item */
+  item_class->get_name        = _get_name;
+  item_class->get_icon        = _get_icon;
+  item_class->is_visible      = _is_visible;
+  item_class->left_click      = _left_click;
+  item_class->right_click      = _right_click;
+  item_class->match           = _match;
+  
   /* Install signals */
-  _window_signals[NAME_CHANGED] =
-		g_signal_new ("name-changed",
-			      G_OBJECT_CLASS_TYPE (obj_class),
-			      G_SIGNAL_RUN_LAST,
-			      G_STRUCT_OFFSET (TaskWindowClass, name_changed),
-			      NULL, NULL,
-			      g_cclosure_marshal_VOID__STRING, 
-			      G_TYPE_NONE,
-            1, G_TYPE_STRING); 
-
-  _window_signals[ICON_CHANGED] =
-		g_signal_new ("icon-changed",
-			      G_OBJECT_CLASS_TYPE (obj_class),
-			      G_SIGNAL_RUN_LAST,
-			      G_STRUCT_OFFSET (TaskWindowClass, icon_changed),
-			      NULL, NULL,
-			      g_cclosure_marshal_VOID__OBJECT, 
-			      G_TYPE_NONE,
-            1, GDK_TYPE_PIXBUF); 
-  
   _window_signals[ACTIVE_CHANGED] =
 		g_signal_new ("active-changed",
 			      G_OBJECT_CLASS_TYPE (obj_class),
@@ -209,17 +203,6 @@
 			      G_TYPE_NONE,
             1, G_TYPE_BOOLEAN);
 
-  _window_signals[RUNNING_CHANGED] =
-		g_signal_new ("running-changed",
-			      G_OBJECT_CLASS_TYPE (obj_class),
-			      G_SIGNAL_RUN_LAST,
-			      G_STRUCT_OFFSET (TaskWindowClass, running_changed),
-			      NULL, NULL,
-			      g_cclosure_marshal_VOID__BOOLEAN,
-			      G_TYPE_NONE,
-            1, G_TYPE_BOOLEAN);
-
-
   /* Install properties */
   pspec = g_param_spec_object ("taskwindow",
                                "Window",
@@ -237,6 +220,8 @@
   	
   priv = window->priv = TASK_WINDOW_GET_PRIVATE (window);
 
+  priv->workspace = NULL;
+  priv->in_workspace = TRUE;
   priv->message = NULL;
   priv->progress = 0;
   priv->hidden = FALSE;
@@ -244,14 +229,14 @@
   priv->is_active = FALSE;
 }
 
-TaskWindow *
+TaskItem *
 task_window_new (WnckWindow *window)
 {
-  TaskWindow *win = NULL;
+  TaskItem *win = NULL;
 
   win = g_object_new (TASK_TYPE_WINDOW,
-                         "taskwindow", window,
-                         NULL);
+                      "taskwindow", window,
+                      NULL);
 
   return win;
 }
@@ -262,11 +247,8 @@
  */
 static void
 window_closed (TaskWindow *window, WnckWindow *old_window)
-{
-  g_signal_emit (window, _window_signals[RUNNING_CHANGED], 0, FALSE);
-  
-  if (!TASK_IS_LAUNCHER (window))
-    g_object_unref (G_OBJECT (window));
+{  
+  gtk_widget_destroy (GTK_WIDGET (window));
 }
 
 static void
@@ -278,8 +260,7 @@
   g_return_if_fail (WNCK_IS_WINDOW (wnckwin));
   priv = window->priv;
 
-  g_signal_emit (window, _window_signals[NAME_CHANGED], 
-                 0, wnck_window_get_name (wnckwin));
+  task_item_emit_name_changed (TASK_ITEM (window), wnck_window_get_name (wnckwin));
 }
 
 static void
@@ -292,7 +273,7 @@
   g_return_if_fail (WNCK_IS_WINDOW (wnckwin));
   
   pixbuf = _wnck_get_icon_at_size (wnckwin, s->panel_size, s->panel_size);
-  task_window_update_icon (window, pixbuf);
+  task_item_emit_icon_changed (TASK_ITEM (window), pixbuf);
   g_object_unref (pixbuf);
 }
 
@@ -303,7 +284,17 @@
     
   g_return_if_fail (TASK_IS_WINDOW (window));
   g_return_if_fail (WNCK_IS_WINDOW (wnckwin));
+
   priv = window->priv;
+  if (priv->workspace==NULL)
+    priv->in_workspace = TRUE;
+  else
+    priv->in_workspace = wnck_window_is_in_viewport (priv->window, priv->workspace);
+
+  if (priv->in_workspace && !priv->hidden)
+    task_item_emit_visible_changed (TASK_ITEM (window), TRUE);
+  else
+    task_item_emit_visible_changed (TASK_ITEM (window), FALSE);
   
   g_signal_emit (window, _window_signals[WORKSPACE_CHANGED], 
                  0, wnck_window_get_workspace (wnckwin));
@@ -329,7 +320,11 @@
   if (priv->hidden != hidden)
   {
     priv->hidden = hidden;
-    g_signal_emit (window, _window_signals[HIDDEN_CHANGED], 0, hidden);
+
+    if (priv->in_workspace && !priv->hidden)
+      task_item_emit_visible_changed (TASK_ITEM (window), TRUE);
+    else
+      task_item_emit_visible_changed (TASK_ITEM (window), FALSE);      
   }
 
   needs_attention = wnck_window_or_transient_needs_attention (wnckwin);
@@ -342,14 +337,19 @@
   }
 }
 
+/**
+ * TODO: remove old signals and weak_ref...
+ */
 static void
 task_window_set_window (TaskWindow *window, WnckWindow *wnckwin)
 {
   TaskWindowPrivate *priv;
-
+  GdkPixbuf    *pixbuf;
+  TaskSettings *s = task_settings_get_default ();
+  
   g_return_if_fail (TASK_IS_WINDOW (window));
+
   priv = window->priv;
-
   priv->window = wnckwin;
 
   g_object_weak_ref (G_OBJECT (priv->window), 
@@ -364,14 +364,33 @@
   g_signal_connect (wnckwin, "state-changed", 
                     G_CALLBACK (on_window_state_changed), window);
 
-  g_signal_emit (window, _window_signals[RUNNING_CHANGED], 0, TRUE);
+  task_item_emit_name_changed (TASK_ITEM (window), wnck_window_get_name (wnckwin));
+  pixbuf = _wnck_get_icon_at_size (wnckwin, s->panel_size, s->panel_size);
+  task_item_emit_icon_changed (TASK_ITEM (window), pixbuf);
+  g_object_unref (pixbuf);
+  task_item_emit_visible_changed (TASK_ITEM (window), TRUE);
 }
 
 /*
  * Public functions
  */
+
+/**
+ * Returns the name of the WnckWindow.
+ */
+const gchar *
+task_window_get_name (TaskWindow *window)
+{
+  g_return_val_if_fail (TASK_IS_WINDOW (window), "");
+
+  if (WNCK_IS_WINDOW (window->priv->window))
+    return wnck_window_get_name (window->priv->window);
+  
+  return "";
+}
+
 WnckScreen * 
-task_window_get_screen (TaskWindow    *window)
+task_window_get_screen (TaskWindow *window)
 {
   g_return_val_if_fail (TASK_IS_WINDOW (window), wnck_screen_get_default ());
 
@@ -382,7 +401,7 @@
 }
 
 gulong 
-task_window_get_xid (TaskWindow    *window)
+task_window_get_xid (TaskWindow *window)
 {
   g_return_val_if_fail (TASK_IS_WINDOW (window), 0);
 
@@ -393,29 +412,29 @@
 }
 
 gint 
-task_window_get_pid (TaskWindow    *window)
+task_window_get_pid (TaskWindow *window)
 {
-  TaskWindowClass *klass;
-
-	g_return_val_if_fail (TASK_IS_WINDOW (window), -1);
-  
-  klass = TASK_WINDOW_GET_CLASS (window);
-  g_return_val_if_fail (klass->get_pid, -1);
-	
-	return klass->get_pid (window);
+  g_return_val_if_fail (TASK_IS_WINDOW (window), -1);
+  
+	gint pid = -1;
+  if (WNCK_IS_WINDOW (window->priv->window))
+	{
+    pid = wnck_window_get_pid (window->priv->window);
+		pid = pid ? pid : -1; 		/* if the pid is 0 return -1.  Bad wnck! Bad! */
+	}
+  
+	return pid;  
 }
 
 WnckApplication *
-task_window_get_application (TaskWindow    *window)
+task_window_get_application (TaskWindow *window)
 {
-  TaskWindowClass *klass;
-
-        g_return_val_if_fail (TASK_IS_WINDOW (window), NULL);
-  
-  klass = TASK_WINDOW_GET_CLASS (window);
-  g_return_val_if_fail (klass->get_application, NULL);
-        
-        return klass->get_application (window);
+  g_return_val_if_fail (TASK_IS_WINDOW (window), NULL);
+
+  if (WNCK_IS_WINDOW (window->priv->window))
+    return wnck_window_get_application (window->priv->window);
+
+  return NULL;
 }
 
 
@@ -424,7 +443,7 @@
                           gchar        **res_name,
                           gchar        **class_name)
 {
-  g_return_val_if_fail (TASK_IS_WINDOW (window), -1);
+  g_return_val_if_fail (TASK_IS_WINDOW (window), FALSE);
  
   *res_name = NULL;
   *class_name = NULL;
@@ -441,51 +460,6 @@
   return FALSE;
 }
 
-const gchar * 
-task_window_get_name (TaskWindow    *window)
-{
-  TaskWindowClass *klass;
-
-  g_return_val_if_fail (TASK_IS_WINDOW (window), NULL);
-  
-  klass = TASK_WINDOW_GET_CLASS (window);
-  g_return_val_if_fail (klass->get_name, NULL);
-
-  return klass->get_name (window);
-}
-
-void
-task_window_set_name (TaskWindow    *window,
-                      const gchar   *name)
-{
-  g_return_if_fail (TASK_IS_WINDOW (window));
-
-  g_signal_emit (window, _window_signals[NAME_CHANGED], 0, name);
-}
-
-GdkPixbuf     * 
-task_window_get_icon (TaskWindow    *window)
-{
-  TaskWindowClass *klass;
-
-  g_return_val_if_fail (TASK_IS_WINDOW (window), NULL);
-  
-  klass = TASK_WINDOW_GET_CLASS (window);
-  g_return_val_if_fail (klass->get_icon, NULL);
-
-  return klass->get_icon (window);