Add StatusNotifier support to the Notification Area applet

The StatusNotifier part of the implementation is based off
gnome-panel's status-notifier applet.

10 files changed, 3091 insertions, 0 deletions

diff --git a/applets/notification_area/system-tray/Makefile.am b/applets/notification_area/system-tray/Makefile.am
new file mode 100644
index 00000000..f3e8c360
--- /dev/null
+++ b/applets/notification_area/system-tray/Makefile.am
@@ -0,0 +1,42 @@
+
+noinst_LTLIBRARIES = libsystem-tray.la
+
+AM_CPPFLAGS =							\
+	$(NOTIFICATION_AREA_CFLAGS)				\
+	-I$(srcdir)						\
+	-I$(srcdir)/..						\
+	-DMATELOCALEDIR=\""$(datadir)/locale"\"			\
+	-DG_LOG_DOMAIN=\""notification-area-applet"\"		\
+	$(DISABLE_DEPRECATED_CFLAGS)
+
+AM_CFLAGS = $(WARN_CFLAGS)
+
+libsystem_tray_la_SOURCES =	\
+	fixedtip.h		\
+	fixedtip.c		\
+	na-marshal.c		\
+	na-marshal.h		\
+	na-tray.c		\
+	na-tray.h		\
+	na-tray-child.c		\
+	na-tray-child.h		\
+	na-tray-manager.c	\
+	na-tray-manager.h
+
+libsystem_tray_la_LIBADD =		\
+	$(X_LIBS)			\
+	$(NOTIFICATION_AREA_LIBS)
+
+na-marshal.h: na-marshal.list $(GLIB_GENMARSHAL)
+	$(AM_V_GEN)$(GLIB_GENMARSHAL) $< --header --prefix=_na_marshal > $@
+
+na-marshal.c: na-marshal.list $(GLIB_GENMARSHAL)
+	$(AM_V_GEN)echo "#include \"na-marshal.h\"" > $@ && \
+	$(GLIB_GENMARSHAL) $< --body --prefix=_na_marshal >> $@
+
+BUILT_SOURCES = na-marshal.c na-marshal.h
+
+EXTRA_DIST =		\
+	na-marshal.list
+
+-include $(top_srcdir)/git.mk
diff --git a/applets/notification_area/system-tray/fixedtip.c b/applets/notification_area/system-tray/fixedtip.c
new file mode 100644
index 00000000..6356de9b
--- /dev/null
+++ b/applets/notification_area/system-tray/fixedtip.c
@@ -0,0 +1,281 @@
+/* Marco fixed tooltip routine */
+
+/*
+ * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2003-2006 Vincent Untz
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301, USA.
+ */
+
+#include "fixedtip.h"
+
+/* Signals */
+enum
+{
+  CLICKED,
+  LAST_SIGNAL
+};
+
+static guint fixedtip_signals[LAST_SIGNAL] = { 0 };
+
+struct _NaFixedTipPrivate
+{
+  GtkWidget      *parent;
+  GtkWidget      *label;
+  GtkOrientation  orientation;
+};
+
+G_DEFINE_TYPE (NaFixedTip, na_fixed_tip, GTK_TYPE_WINDOW)
+
+static gboolean
+button_press_handler (GtkWidget      *fixedtip,
+                      GdkEventButton *event,
+                      gpointer        data)
+{
+  if (event->button == 1 && event->type == GDK_BUTTON_PRESS)
+    g_signal_emit (fixedtip, fixedtip_signals[CLICKED], 0);
+
+  return FALSE;
+}
+
+static gboolean
+na_fixed_tip_draw (GtkWidget *widget, cairo_t *cr)
+{
+  GtkStyleContext *context;
+  GtkStateFlags state;
+  int width, height;
+
+  width = gtk_widget_get_allocated_width (widget);
+  height = gtk_widget_get_allocated_height (widget);
+
+  state = gtk_widget_get_state_flags (widget);
+  context = gtk_widget_get_style_context (widget);
+  gtk_style_context_save (context);
+  gtk_style_context_add_class (context, GTK_STYLE_CLASS_TOOLTIP);
+  gtk_style_context_set_state (context, state);
+
+  cairo_save (cr);
+  gtk_render_background (context, cr,
+                         0., 0.,
+                         (gdouble)width,
+                         (gdouble)height);
+  cairo_restore (cr);
+
+  gtk_style_context_restore (context);
+
+  return FALSE;
+}
+
+static void
+na_fixed_tip_class_init (NaFixedTipClass *class)
+{
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
+  widget_class->draw = na_fixed_tip_draw;
+
+  fixedtip_signals[CLICKED] =
+    g_signal_new ("clicked",
+		  G_OBJECT_CLASS_TYPE (class),
+		  G_SIGNAL_RUN_LAST,
+		  G_STRUCT_OFFSET (NaFixedTipClass, clicked),
+		  NULL, NULL,
+		  g_cclosure_marshal_VOID__VOID,
+		  G_TYPE_NONE, 0);
+
+  g_type_class_add_private (class, sizeof (NaFixedTipPrivate));
+}
+
+/* Did you already see this code? Yes, it's gtk_tooltips_ force_window() ;-) */
+static void
+na_fixed_tip_init (NaFixedTip *fixedtip)
+{
+  GtkWidget *label;
+
+  fixedtip->priv = G_TYPE_INSTANCE_GET_PRIVATE (fixedtip, NA_TYPE_FIXED_TIP,
+                                                NaFixedTipPrivate);
+
+  gtk_window_set_type_hint (GTK_WINDOW (fixedtip),
+                            GDK_WINDOW_TYPE_HINT_TOOLTIP);
+
+  gtk_widget_set_app_paintable (GTK_WIDGET (fixedtip), TRUE);
+  gtk_window_set_resizable (GTK_WINDOW (fixedtip), FALSE);
+  gtk_widget_set_name (GTK_WIDGET (fixedtip), "gtk-tooltips");
+  gtk_container_set_border_width (GTK_CONTAINER (fixedtip), 4);
+
+  label = gtk_label_new (NULL);
+  gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
+#if GTK_CHECK_VERSION (3, 16, 0)
+  gtk_label_set_xalign (GTK_LABEL (label), 0.5);
+  gtk_label_set_yalign (GTK_LABEL (label), 0.5);
+#else
+  gtk_misc_set_alignment (GTK_MISC (label), 0.5, 0.5);
+#endif
+  gtk_widget_show (label);
+  gtk_container_add (GTK_CONTAINER (fixedtip), label);
+  fixedtip->priv->label = label;
+
+  gtk_widget_add_events (GTK_WIDGET (fixedtip), GDK_BUTTON_PRESS_MASK);
+
+  g_signal_connect (fixedtip, "button_press_event",
+                    G_CALLBACK (button_press_handler), NULL);
+
+  fixedtip->priv->orientation = GTK_ORIENTATION_HORIZONTAL;
+}
+
+static void
+na_fixed_tip_position (NaFixedTip *fixedtip)
+{
+  GdkScreen      *screen;
+  GdkWindow      *parent_window;
+  GtkRequisition  req;
+  int             root_x;
+  int             root_y;
+  int             parent_width;
+  int             parent_height;
+  int             screen_width;
+  int             screen_height;
+
+  screen = gtk_widget_get_screen (fixedtip->priv->parent);
+  parent_window = gtk_widget_get_window (fixedtip->priv->parent);
+
+  gtk_window_set_screen (GTK_WINDOW (fixedtip), screen);
+
+  gtk_widget_get_preferred_size (GTK_WIDGET (fixedtip), &req, NULL);
+
+  gdk_window_get_origin (parent_window, &root_x, &root_y);
+  parent_width = gdk_window_get_width(parent_window);
+  parent_height = gdk_window_get_height(parent_window);
+
+  screen_width = gdk_screen_get_width (screen);
+  screen_height = gdk_screen_get_height (screen);
+
+  /* pad between panel and message window */
+#define PAD 5
+
+  if (fixedtip->priv->orientation == GTK_ORIENTATION_VERTICAL)
+    {
+      if (root_x <= screen_width / 2)
+        root_x += parent_width + PAD;
+      else
+        root_x -= req.width + PAD;
+    }
+  else
+    {
+      if (root_y <= screen_height / 2)
+        root_y += parent_height + PAD;
+      else
+        root_y -= req.height + PAD;
+    }
+
+  /* Push onscreen */
+  if ((root_x + req.width) > screen_width)
+    root_x = screen_width - req.width;
+
+  if ((root_y + req.height) > screen_height)
+    root_y = screen_height - req.height;
+
+  gtk_window_move (GTK_WINDOW (fixedtip), root_x, root_y);
+}
+
+static void
+na_fixed_tip_parent_size_allocated (GtkWidget     *parent,
+                                    GtkAllocation *allocation,
+                                    NaFixedTip    *fixedtip)
+{
+  na_fixed_tip_position (fixedtip);
+}
+
+static void
+na_fixed_tip_parent_screen_changed (GtkWidget  *parent,
+                                    GdkScreen  *new_screen,
+                                    NaFixedTip *fixedtip)
+{
+  na_fixed_tip_position (fixedtip);
+}
+
+GtkWidget *
+na_fixed_tip_new (GtkWidget      *parent,
+                  GtkOrientation  orientation)
+{
+  NaFixedTip *fixedtip;
+
+  g_return_val_if_fail (parent != NULL, NULL);
+
+  fixedtip = g_object_new (NA_TYPE_FIXED_TIP,
+                           "type", GTK_WINDOW_POPUP,
+                           NULL);
+
+  fixedtip->priv->parent = parent;
+
+#if 0
+  //FIXME: would be nice to be able to get the toplevel for the tip, but this
+  //doesn't work
+  GtkWidget  *toplevel;
+
+  toplevel = gtk_widget_get_toplevel (parent);
+  /*
+  if (toplevel && gtk_widget_is_toplevel (toplevel) && GTK_IS_WINDOW (toplevel))
+    gtk_window_set_transient_for (GTK_WINDOW (fixedtip), GTK_WINDOW (toplevel));
+    */
+#endif
+
+  fixedtip->priv->orientation = orientation;
+
+  //FIXME: would be nice to move the tip when the notification area moves
+  g_signal_connect_object (parent, "size-allocate",
+                           G_CALLBACK (na_fixed_tip_parent_size_allocated),
+                           fixedtip, 0);
+  g_signal_connect_object (parent, "screen-changed",
+                           G_CALLBACK (na_fixed_tip_parent_screen_changed),
+                           fixedtip, 0);
+
+  na_fixed_tip_position (fixedtip);
+
+  return GTK_WIDGET (fixedtip);
+}
+
+void
+na_fixed_tip_set_markup (GtkWidget  *widget,
+                         const char *markup_text)
+{
+  NaFixedTip *fixedtip;
+
+  g_return_if_fail (NA_IS_FIXED_TIP (widget));
+
+  fixedtip = NA_FIXED_TIP (widget);
+
+  gtk_label_set_markup (GTK_LABEL (fixedtip->priv->label),
+                        markup_text);
+
+  na_fixed_tip_position (fixedtip);
+}
+
+void
+na_fixed_tip_set_orientation (GtkWidget      *widget,
+                              GtkOrientation  orientation)
+{
+  NaFixedTip *fixedtip;
+
+  g_return_if_fail (NA_IS_FIXED_TIP (widget));
+
+  fixedtip = NA_FIXED_TIP (widget);
+
+  if (orientation == fixedtip->priv->orientation)
+    return;
+
+  fixedtip->priv->orientation = orientation;
+
+  na_fixed_tip_position (fixedtip);
+}
diff --git a/applets/notification_area/system-tray/fixedtip.h b/applets/notification_area/system-tray/fixedtip.h
new file mode 100644
index 00000000..c220f103
--- /dev/null
+++ b/applets/notification_area/system-tray/fixedtip.h
@@ -0,0 +1,72 @@
+/* Fixed tooltip routine */
+
+/*
+ * Copyright (C) 2001 Havoc Pennington, 2002 Red Hat Inc.
+ * Copyright (C) 2003-2006 Vincent Untz
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301, USA.
+ */
+
+#ifndef FIXED_TIP_H
+#define FIXED_TIP_H
+
+#include <gtk/gtk.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define NA_TYPE_FIXED_TIP			(na_fixed_tip_get_type ())
+#define NA_FIXED_TIP(obj)			(G_TYPE_CHECK_INSTANCE_CAST ((obj), NA_TYPE_FIXED_TIP, NaFixedTip))
+#define NA_FIXED_TIP_CLASS(klass)		(G_TYPE_CHECK_CLASS_CAST ((klass), NA_TYPE_FIXED_TIP, NaFixedTipClass))
+#define NA_IS_FIXED_TIP(obj)			(G_TYPE_CHECK_INSTANCE_TYPE ((obj), NA_TYPE_FIXED_TIP))
+#define NA_IS_FIXED_TIP_CLASS(klass)		(G_TYPE_CHECK_CLASS_TYPE ((klass), NA_TYPE_FIXED_TIP))
+#define NA_FIXED_TIP_GET_CLASS(obj)		(G_TYPE_INSTANCE_GET_CLASS ((obj), NA_TYPE_FIXED_TIP, NaFixedTipClass))
+
+typedef struct _NaFixedTip	  NaFixedTip;
+typedef struct _NaFixedTipPrivate NaFixedTipPrivate;
+typedef struct _NaFixedTipClass   NaFixedTipClass;
+
+struct _NaFixedTip
+{
+  GtkWindow parent_instance;
+
+  NaFixedTipPrivate *priv;
+};
+
+struct _NaFixedTipClass
+{
+  GtkWindowClass parent_class;
+
+  void (* clicked)    (NaFixedTip *fixedtip);
+};
+
+GType      na_fixed_tip_get_type (void);
+
+GtkWidget *na_fixed_tip_new (GtkWidget      *parent,
+                             GtkOrientation  orientation);
+
+void       na_fixed_tip_set_markup (GtkWidget  *widget,
+                                    const char *markup_text);
+
+void       na_fixed_tip_set_orientation (GtkWidget      *widget,
+                                         GtkOrientation  orientation);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FIXED_TIP_H */
diff --git a/applets/notification_area/system-tray/na-marshal.list b/applets/notification_area/system-tray/na-marshal.list
new file mode 100644
index 00000000..e3fc3993
--- /dev/null
+++ b/applets/notification_area/system-tray/na-marshal.list
@@ -0,0 +1,3 @@
+VOID:OBJECT,OBJECT
+VOID:OBJECT,STRING,LONG,LONG
+VOID:OBJECT,LONG
diff --git a/applets/notification_area/system-tray/na-tray-child.c b/applets/notification_area/system-tray/na-tray-child.c
new file mode 100644
index 00000000..2a87f1e1
--- /dev/null
+++ b/applets/notification_area/system-tray/na-tray-child.c
@@ -0,0 +1,715 @@
+/* na-tray-child.c
+ * Copyright (C) 2002 Anders Carlsson <[email protected]>
+ * Copyright (C) 2003-2006 Vincent Untz
+ * Copyright (C) 2008 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include <config.h>
+#include <string.h>
+
+#include "na-tray-child.h"
+
+#include <glib/gi18n.h>
+#include <gtk/gtk.h>
+#include <gdk/gdk.h>
+#include <gdk/gdkx.h>
+#include <X11/Xatom.h>
+
+#include "na-item.h"
+
+enum
+{
+  PROP_0,
+  PROP_ORIENTATION
+};
+
+static void na_item_init (NaItemInterface *iface);
+
+G_DEFINE_TYPE_WITH_CODE (NaTrayChild, na_tray_child, GTK_TYPE_SOCKET,
+                         G_IMPLEMENT_INTERFACE (GTK_TYPE_ORIENTABLE, NULL)
+                         G_IMPLEMENT_INTERFACE (NA_TYPE_ITEM, na_item_init))
+
+static void
+na_tray_child_finalize (GObject *object)
+{
+  NaTrayChild *child = NA_TRAY_CHILD (object);
+
+  g_clear_pointer (&child->id, g_free);
+
+  G_OBJECT_CLASS (na_tray_child_parent_class)->finalize (object);
+}
+
+static void
+na_tray_child_realize (GtkWidget *widget)
+{
+  NaTrayChild *child = NA_TRAY_CHILD (widget);
+  GdkVisual *visual = gtk_widget_get_visual (widget);
+  GdkWindow *window;
+
+  GTK_WIDGET_CLASS (na_tray_child_parent_class)->realize (widget);
+
+  window = gtk_widget_get_window (widget);
+
+  if (child->has_alpha)
+    {
+      /* We have real transparency with an ARGB visual and the Composite
+       * extension. */
+
+      /* Set a transparent background */
+      cairo_pattern_t *transparent = cairo_pattern_create_rgba (0, 0, 0, 0);
+      gdk_window_set_background_pattern (window, transparent);
+      gdk_window_set_composited (window, TRUE);
+      cairo_pattern_destroy (transparent);
+
+      child->parent_relative_bg = FALSE;
+    }
+  else if (visual == gdk_window_get_visual(gdk_window_get_parent(window)))
+    {
+      /* Otherwise, if the visual matches the visual of the parent window, we
+       * can use a parent-relative background and fake transparency. */
+      gdk_window_set_background_pattern (window, NULL);
+
+      child->parent_relative_bg = TRUE;
+    }
+  else
+    {
+      /* Nothing to do; the icon will sit on top of an ugly gray box */
+      child->parent_relative_bg = FALSE;
+    }
+
+  gdk_window_set_composited (window, child->composited);
+
+  gtk_widget_set_app_paintable (GTK_WIDGET (child),
+                                child->parent_relative_bg || child->has_alpha);
+
+  /* Double-buffering will interfere with the parent-relative-background fake
+   * transparency, since the double-buffer code doesn't know how to fill in the
+   * background of the double-buffer correctly.
+   */
+  gtk_widget_set_double_buffered (GTK_WIDGET (child),
+                                  child->parent_relative_bg);
+}
+
+static void
+na_tray_child_style_set (GtkWidget *widget,
+                         GtkStyle  *previous_style)
+{
+  /* The default handler resets the background according to the new style.
+   * We either use a transparent background or a parent-relative background
+   * and ignore the style background. So, just don't chain up.
+   */
+}
+
+static void
+na_tray_child_get_preferred_width (GtkWidget *widget,
+                                   gint      *minimal_width,
+                                  gint      *natural_width)
+{
+  GTK_WIDGET_CLASS (na_tray_child_parent_class)->get_preferred_width (widget,
+                                                                      minimal_width,
+                                                                      natural_width);
+
+  if (*minimal_width < 16)
+    *minimal_width = 16;
+
+  if (*natural_width < 16)
+    *natural_width = 16;
+}
+
+static void
+na_tray_child_get_preferred_height (GtkWidget *widget,
+                                    gint      *minimal_height,
+                                    gint      *natural_height)
+{
+  GTK_WIDGET_CLASS (na_tray_child_parent_class)->get_preferred_height (widget,
+                                                                       minimal_height,
+                                                                       natural_height);
+
+  if (*minimal_height < 16)
+    *minimal_height = 16;
+
+  if (*natural_height < 16)
+    *natural_height = 16;
+}
+
+static void
+na_tray_child_size_allocate (GtkWidget      *widget,
+                             GtkAllocation  *allocation)
+{
+  NaTrayChild *child = NA_TRAY_CHILD (widget);
+  GtkAllocation widget_allocation;
+  gboolean moved, resized;
+
+  gtk_widget_get_allocation (widget, &widget_allocation);
+
+  moved = (allocation->x != widget_allocation.x ||
+	   allocation->y != widget_allocation.y);
+  resized = (allocation->width != widget_allocation.width ||
+	     allocation->height != widget_allocation.height);
+
+  /* When we are allocating the widget while mapped we need special handling
+   * for both real and fake transparency.
+   *
+   * Real transparency: we need to invalidate and trigger a redraw of the old
+   *   and new areas. (GDK really should handle this for us, but doesn't as of
+   *   GTK+-2.14)
+   *
+   * Fake transparency: if the widget moved, we need to force the contents to
+   *   be redrawn with the new offset for the parent-relative background.
+   */
+  if ((moved || resized) && gtk_widget_get_mapped (widget))
+    {
+      if (na_tray_child_has_alpha (child))
+        gdk_window_invalidate_rect (gdk_window_get_parent (gtk_widget_get_window (widget)),
+                                    &widget_allocation, FALSE);
+    }
+
+  GTK_WIDGET_CLASS (na_tray_child_parent_class)->size_allocate (widget,
+                                                                allocation);
+
+  if ((moved || resized) && gtk_widget_get_mapped (widget))
+    {
+      if (na_tray_child_has_alpha (NA_TRAY_CHILD (widget)))
+        gdk_window_invalidate_rect (gdk_window_get_parent (gtk_widget_get_window (widget)),
+                                    &widget_allocation, FALSE);
+      else if (moved && child->parent_relative_bg)
+        na_tray_child_force_redraw (child);
+    }
+}
+
+/* The plug window should completely occupy the area of the child, so we won't
+ * get an expose event. But in case we do (the plug unmaps itself, say), this
+ * expose handler draws with real or fake transparency.
+ */
+static gboolean
+na_tray_child_draw (GtkWidget *widget,
+                    cairo_t *cr)
+{
+  NaTrayChild *child = NA_TRAY_CHILD (widget);
+
+  if (na_tray_child_has_alpha (child))
+    {
+      /* Clear to transparent */
+      cairo_set_source_rgba (cr, 0, 0, 0, 0);
+      cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
+      cairo_paint (cr);
+    }
+  else if (child->parent_relative_bg)
+    {
+      /* Clear to parent-relative pixmap */
+      GdkWindow *window;
+      cairo_surface_t *target;
+      GdkRectangle clip_rect;
+
+      window = gtk_widget_get_window (widget);
+      target = cairo_get_group_target (cr);
+
+      gdk_cairo_get_clip_rectangle (cr, &clip_rect);
+
+      /* Clear to parent-relative pixmap
+       * We need to use direct X access here because GDK doesn't know about
+       * the parent relative pixmap. */
+      cairo_surface_flush (target);
+
+      XClearArea (GDK_WINDOW_XDISPLAY (window),
+                  GDK_WINDOW_XID (window),
+                  clip_rect.x, clip_rect.y,
+                  clip_rect.width, clip_rect.height,
+                  False);
+      cairo_surface_mark_dirty_rectangle (target,
+                                          clip_rect.x, clip_rect.y,
+                                          clip_rect.width, clip_rect.height);
+    }
+
+  return FALSE;
+}
+
+/* Children with alpha channels have been set to be composited by calling
+ * gdk_window_set_composited(). We need to paint these children ourselves.
+ *
+ * FIXME: is that still needed on GTK3?  Seems like it could be done in draw().
+ */
+static gboolean
+na_tray_child_draw_on_parent (NaItem    *item,
+                              GtkWidget *parent,
+                              cairo_t   *parent_cr)
+{
+  if (na_tray_child_has_alpha (NA_TRAY_CHILD (item)))
+    {
+      GtkWidget    *widget = GTK_WIDGET (item);
+      GtkAllocation parent_allocation = { 0 };
+      GtkAllocation allocation;
+
+      /* if the parent doesn't have a window, our allocation is not relative to
+       * the context coordinates but to the parent's allocation */
+      if (! gtk_widget_get_has_window (parent))
+	gtk_widget_get_allocation (parent, &parent_allocation);
+
+      gtk_widget_get_allocation (widget, &allocation);
+      allocation.x -= parent_allocation.x;
+      allocation.y -= parent_allocation.y;
+
+      cairo_save (parent_cr);
+      gdk_cairo_set_source_window (parent_cr,
+                                   gtk_widget_get_window (widget),
+                                   allocation.x,
+                                   allocation.y);
+      cairo_rectangle (parent_cr, allocation.x, allocation.y, allocation.width, allocation.height);
+      cairo_clip (parent_cr);
+      cairo_paint (parent_cr);
+      cairo_restore (parent_cr);
+    }
+
+  return TRUE;
+}
+
+static void
+na_tray_child_get_property (GObject    *object,
+                            guint       property_id,
+                            GValue     *value,
+                            GParamSpec *pspec)
+{
+  switch (property_id)
+    {
+      case PROP_ORIENTATION:
+        /* whatever */
+        g_value_set_enum (value, GTK_ORIENTATION_HORIZONTAL);
+        break;
+
+      default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+        break;
+    }
+}
+
+static void
+na_tray_child_set_property (GObject      *object,
+                            guint         property_id,
+                            const GValue *value,
+                            GParamSpec   *pspec)
+{
+  switch (property_id)
+    {
+      case PROP_ORIENTATION:
+	/* we so don't care */
+        break;
+
+      default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+        break;
+    }
+}
+
+static const gchar *
+na_tray_child_get_id (NaItem *item)
+{
+  NaTrayChild *child = NA_TRAY_CHILD (item);
+
+  if (! child->id)
+    {
+      char *res_name = NULL;
+
+      na_tray_child_get_wm_class (child, &res_name, NULL);
+      child->id = g_strdup_printf ("%s-%lu", res_name, child->icon_window);
+      g_free (res_name);
+    }
+
+  return child->id;
+}
+
+static NaItemCategory
+na_tray_child_get_category (NaItem *item)
+{
+  const struct
+  {
+    const gchar *wm_class;
+    NaItemCategory category;
+  } wmclass_categories[] = {
+/* FIXME: get the same order as it used to be, without fake categories.
+ * from right to left:
+const char *ordered_roles[] = {
+  "keyboard",
+  "volume",
+  "bluetooth",
+  "network",
+  "battery",
+  NULL
+};
+
+const char *wmclass_roles[] = {
+  "Bluetooth-applet", "bluetooth",
+  "Mate-volume-control-applet", "volume",
+  "Nm-applet", "network",
+  "Mate-power-manager", "battery",
+  "keyboard", "keyboard",
+  NULL,
+};
+*/
+    { "Bluetooth-applet", NA_ITEM_CATEGORY_FAKE_BLUETOOTH },
+    { "Mate-volume-control-applet", NA_ITEM_CATEGORY_FAKE_VOLUME },
+    { "Nm-applet", NA_ITEM_CATEGORY_FAKE_NETWORK },
+    { "Mate-power-manager", NA_ITEM_CATEGORY_FAKE_BATTERY },
+    { "keyboard", NA_ITEM_CATEGORY_FAKE_KEYBOARD }
+  };
+  guint i;
+  NaItemCategory category = NA_ITEM_CATEGORY_APPLICATION_STATUS;
+  char *res_class = NULL;
+
+  na_tray_child_get_wm_class (NA_TRAY_CHILD (item), NULL, &res_class);
+
+  for (i = 0; i < G_N_ELEMENTS (wmclass_categories); i++)
+    {
+      if (g_strcmp0 (res_class, wmclass_categories[i].wm_class) == 0)
+	{
+	  category = wmclass_categories[i].category;
+	  break;
+	}
+    }
+
+  return category;
+}
+
+static void
+na_item_init (NaItemInterface *iface)
+{
+  iface->get_id = na_tray_child_get_id;
+  iface->get_category = na_tray_child_get_category;
+
+  iface->draw_on_parent = na_tray_child_draw_on_parent;
+}
+
+static void
+na_tray_child_init (NaTrayChild *child)
+{
+  child->id = NULL;
+}
+
+static void
+na_tray_child_class_init (NaTrayChildClass *klass)
+{
+  GObjectClass *gobject_class;
+  GtkWidgetClass *widget_class;
+
+  gobject_class = (GObjectClass *)klass;
+  widget_class = (GtkWidgetClass *)klass;
+
+  gobject_class->finalize = na_tray_child_finalize;
+  gobject_class->get_property = na_tray_child_get_property;
+  gobject_class->set_property = na_tray_child_set_property;
+
+  widget_class->style_set = na_tray_child_style_set;
+  widget_class->realize = na_tray_child_realize;
+  widget_class->get_preferred_width = na_tray_child_get_preferred_width;
+  widget_class->get_preferred_height = na_tray_child_get_preferred_height;
+  widget_class->size_allocate = na_tray_child_size_allocate;
+  widget_class->draw = na_tray_child_draw;
+
+  /* we don't really care actually */
+  g_object_class_override_property (gobject_class, PROP_ORIENTATION, "orientation");
+}
+
+GtkWidget *
+na_tray_child_new (GdkScreen *screen,
+                   Window     icon_window)
+{
+  XWindowAttributes window_attributes;
+  Display *xdisplay;
+  NaTrayChild *child;
+  GdkVisual *visual;
+  gboolean visual_has_alpha;
+  int red_prec, green_prec, blue_prec, depth;
+  int result;
+
+  g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
+  g_return_val_if_fail (icon_window != None, NULL);
+
+  xdisplay = GDK_SCREEN_XDISPLAY (screen);
+
+  /* We need to determine the visual of the window we are embedding and create
+   * the socket in the same visual.
+   */
+
+  gdk_error_trap_push ();
+  result = XGetWindowAttributes (xdisplay, icon_window,
+                                 &window_attributes);
+  gdk_error_trap_pop_ignored ();
+
+  if (!result) /* Window already gone */
+    return NULL;
+
+  visual = gdk_x11_screen_lookup_visual (screen,
+                                         window_attributes.visual->visualid);
+  if (!visual) /* Icon window is on another screen? */
+    return NULL;
+
+  child = g_object_new (NA_TYPE_TRAY_CHILD, NULL);
+  child->icon_window = icon_window;
+
+  gtk_widget_set_visual (GTK_WIDGET (child), visual);
+
+  /* We have alpha if the visual has something other than red, green,
+   * and blue */
+  gdk_visual_get_red_pixel_details (visual, NULL, NULL, &red_prec);
+  gdk_visual_get_green_pixel_details (visual, NULL, NULL, &green_prec);
+  gdk_visual_get_blue_pixel_details (visual, NULL, NULL, &blue_prec);
+  depth = gdk_visual_get_depth (visual);
+
+  visual_has_alpha = red_prec + blue_prec + green_prec < depth;
+  child->has_alpha = (visual_has_alpha &&
+                      gdk_display_supports_composite (gdk_screen_get_display (screen)));
+
+  child->composited = child->has_alpha;
+
+  return GTK_WIDGET (child);
+}
+
+char *
+na_tray_child_get_title (NaTrayChild *child)
+{
+  char *retval = NULL;
+  GdkDisplay *display;
+  Atom utf8_string, atom, type;
+  int result;
+  int format;
+  gulong nitems;
+  gulong bytes_after;
+  gchar *val;
+
+  g_return_val_if_fail (NA_IS_TRAY_CHILD (child), NULL);
+
+  display = gtk_widget_get_display (GTK_WIDGET (child));
+
+  utf8_string = gdk_x11_get_xatom_by_name_for_display (display, "UTF8_STRING");
+  atom = gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_NAME");
+
+  gdk_error_trap_push ();
+
+  result = XGetWindowProperty (GDK_DISPLAY_XDISPLAY (display),
+                               child->icon_window,
+                               atom,
+                               0, G_MAXLONG,
+                               False, utf8_string,
+                               &type, &format, &nitems,
+                               &bytes_after, (guchar **)&val);
+
+  if (gdk_error_trap_pop () || result != Success)
+    return NULL;
+
+  if (type != utf8_string ||
+      format != 8 ||
+      nitems == 0)
+    {
+      if (val)
+        XFree (val);
+      return NULL;
+    }
+
+  if (!g_utf8_validate (val, nitems, NULL))
+    {
+      XFree (val);
+      return NULL;
+    }
+
+  retval = g_strndup (val, nitems);
+
+  XFree (val);
+
+  return retval;
+}
+
+/**
+ * na_tray_child_has_alpha;
+ * @child: a #NaTrayChild
+ *
+ * Checks if the child has an ARGB visual and real alpha transparence.
+ * (as opposed to faked alpha transparency with an parent-relative
+ * background)
+ *
+ * Return value: %TRUE if the child has an alpha transparency
+ */
+gboolean
+na_tray_child_has_alpha (NaTrayChild *child)
+{
+  g_return_val_if_fail (NA_IS_TRAY_CHILD (child), FALSE);
+
+  return child->has_alpha;
+}
+
+/**
+ * na_tray_child_set_composited;
+ * @child: a #NaTrayChild
+ * @composited: %TRUE if the child's window should be redirected
+ *
+ * Sets whether the #GdkWindow of the child should be set redirected
+ * using gdk_window_set_composited(). By default this is based off of
+ * na_tray_child_has_alpha(), but it may be useful to override it in
+ * certain circumstances; for example, if the #NaTrayChild is added
+ * to a parent window and that parent window is composited against the
+ * background.
+ */
+void
+na_tray_child_set_composited (NaTrayChild *child,
+                              gboolean     composited)
+{
+  g_return_if_fail (NA_IS_TRAY_CHILD (child));
+
+  if (child->composited == composited)
+    return;
+
+  child->composited = composited;
+  if (gtk_widget_get_realized (GTK_WIDGET (child)))
+    gdk_window_set_composited (gtk_widget_get_window (GTK_WIDGET (child)),
+                               composited);
+}
+
+/* If we are faking transparency with a window-relative background, force a
+ * redraw of the icon. This should be called if the background changes or if
+ * the child is shifted with respect to the background.
+ */
+void
+na_tray_child_force_redraw (NaTrayChild *child)
+{
+  GtkWidget *widget = GTK_WIDGET (child);
+
+  if (gtk_widget_get_mapped (widget) && child->parent_relative_bg)
+    {
+#if 1
+      /* Sending an ExposeEvent might cause redraw problems if the
+       * icon is expecting the server to clear-to-background before
+       * the redraw. It should be ok for GtkStatusIcon or EggTrayIcon.
+       */
+      Display *xdisplay = GDK_DISPLAY_XDISPLAY (gtk_widget_get_display (widget));
+      XEvent xev;
+      GdkWindow *plug_window;
+      GtkAllocation allocation;
+
+      plug_window = gtk_socket_get_plug_window (GTK_SOCKET (child));
+      gtk_widget_get_allocation (widget, &allocation);
+
+      xev.xexpose.type = Expose;
+      xev.xexpose.window = GDK_WINDOW_XID (plug_window);
+      xev.xexpose.x = 0;
+      xev.xexpose.y = 0;
+      xev.xexpose.width = allocation.width;
+      xev.xexpose.height = allocation.height;
+      xev.xexpose.count = 0;
+
+      gdk_error_trap_push ();
+      XSendEvent (GDK_DISPLAY_XDISPLAY (gtk_widget_get_display (widget)),
+                  xev.xexpose.window,
+                  False, ExposureMask,
+                  &xev);
+      /* We have to sync to reliably catch errors from the XSendEvent(),
+       * since that is asynchronous.
+       */
+      XSync (xdisplay, False);
+      gdk_error_trap_pop_ignored ();
+#else
+      /* Hiding and showing is the safe way to do it, but can result in more
+       * flickering.
+       */
+      gdk_window_hide (widget->window);
+      gdk_window_show (widget->window);
+#endif
+    }
+}
+
+/* from libwnck/xutils.c, comes as LGPLv2+ */
+static char *
+latin1_to_utf8 (const char *latin1)
+{
+  GString *str;
+  const char *p;
+
+  str = g_string_new (NULL);
+
+  p = latin1;
+  while (*p)
+    {
+      g_string_append_unichar (str, (gunichar) *p);
+      ++p;
+    }
+
+  return g_string_free (str, FALSE);
+}
+
+/* derived from libwnck/xutils.c, comes as LGPLv2+ */
+static void
+_get_wmclass (Display *xdisplay,
+              Window   xwindow,
+              char   **res_class,
+              char   **res_name)
+{
+  XClassHint ch;
+
+  ch.res_name = NULL;
+  ch.res_class = NULL;
+
+  gdk_error_trap_push ();
+  XGetClassHint (xdisplay, xwindow, &ch);
+  gdk_error_trap_pop_ignored ();
+
+  if (res_class)
+    *res_class = NULL;
+
+  if (res_name)
+    *res_name = NULL;
+
+  if (ch.res_name)
+    {
+      if (res_name)
+        *res_name = latin1_to_utf8 (ch.res_name);
+
+      XFree (ch.res_name);
+    }
+
+  if (ch.res_class)
+    {
+      if (res_class)
+        *res_class = latin1_to_utf8 (ch.res_class);
+
+      XFree (ch.res_class);
+    }
+}
+
+/**
+ * na_tray_child_get_wm_class;
+ * @child: a #NaTrayChild
+ * @res_name: return location for a string containing the application name of
+ * @child, or %NULL
+ * @res_class: return location for a string containing the application class of
+ * @child, or %NULL
+ *
+ * Fetches the resource associated with @child.
+ */
+void
+na_tray_child_get_wm_class (NaTrayChild  *child,
+                            char        **res_name,
+                            char        **res_class)
+{
+  GdkDisplay *display;
+
+  g_return_if_fail (NA_IS_TRAY_CHILD (child));
+
+  display = gtk_widget_get_display (GTK_WIDGET (child));
+
+  _get_wmclass (GDK_DISPLAY_XDISPLAY (display),
+                child->icon_window,
+                res_class,
+                res_name);
+}
diff --git a/applets/notification_area/system-tray/na-tray-child.h b/applets/notification_area/system-tray/na-tray-child.h
new file mode 100644
index 00000000..6641fe88
--- /dev/null
+++ b/applets/notification_area/system-tray/na-tray-child.h
@@ -0,0 +1,78 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+/* na-tray-child.h
+ * Copyright (C) 2002 Anders Carlsson <[email protected]>
+ * Copyright (C) 2003-2006 Vincent Untz
+ * Copyright (C) 2008 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __NA_TRAY_CHILD_H__
+#define __NA_TRAY_CHILD_H__
+
+#include <gtk/gtk.h>
+#include <gdk/gdkx.h>
+#include <gtk/gtkx.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define NA_TYPE_TRAY_CHILD		(na_tray_child_get_type ())
+#define NA_TRAY_CHILD(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), NA_TYPE_TRAY_CHILD, NaTrayChild))
+#define NA_TRAY_CHILD_CLASS(klass)	(G_TYPE_CHECK_CLASS_CAST ((klass), NA_TYPE_TRAY_CHILD, NaTrayChildClass))
+#define NA_IS_TRAY_CHILD(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), NA_TYPE_TRAY_CHILD))
+#define NA_IS_TRAY_CHILD_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE ((klass), NA_TYPE_TRAY_CHILD))
+#define NA_TRAY_CHILD_GET_CLASS(obj)	(G_TYPE_INSTANCE_GET_CLASS ((obj), NA_TYPE_TRAY_CHILD, NaTrayChildClass))
+
+typedef struct _NaTrayChild	  NaTrayChild;
+typedef struct _NaTrayChildClass  NaTrayChildClass;
+typedef struct _NaTrayChildChild  NaTrayChildChild;
+
+struct _NaTrayChild
+{
+  GtkSocket parent_instance;
+  Window icon_window;
+  guint has_alpha : 1;
+  guint composited : 1;
+  guint parent_relative_bg : 1;
+
+  gchar *id;
+};
+
+struct _NaTrayChildClass
+{
+  GtkSocketClass parent_class;
+};
+
+GType           na_tray_child_get_type        (void);
+
+GtkWidget      *na_tray_child_new            (GdkScreen    *screen,
+                                              Window        icon_window);
+char           *na_tray_child_get_title      (NaTrayChild  *child);
+gboolean        na_tray_child_has_alpha      (NaTrayChild  *child);
+void            na_tray_child_set_composited (NaTrayChild  *child,
+                                              gboolean      composited);
+void            na_tray_child_force_redraw   (NaTrayChild  *child);
+void            na_tray_child_get_wm_class   (NaTrayChild  *child,
+					      char        **res_name,
+					      char        **res_class);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __NA_TRAY_CHILD_H__ */
diff --git a/applets/notification_area/system-tray/na-tray-manager.c b/applets/notification_area/system-tray/na-tray-manager.c
new file mode 100644
index 00000000..94d3003d
--- /dev/null
+++ b/applets/notification_area/system-tray/na-tray-manager.c
@@ -0,0 +1,988 @@
+/* na-tray-manager.c
+ * Copyright (C) 2002 Anders Carlsson <[email protected]>
+ * Copyright (C) 2003-2006 Vincent Untz
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ *
+ * Used to be: eggtraymanager.c
+ */
+
+#include <config.h>
+#include <string.h>
+#include <libintl.h>
+
+#include "na-tray-manager.h"
+
+#include <gtk/gtk.h>
+#include <glib/gi18n.h>
+#include <gdk/gdkx.h>
+#include <X11/Xatom.h>
+
+#include "na-marshal.h"
+
+/* Signals */
+enum
+{
+  TRAY_ICON_ADDED,
+  TRAY_ICON_REMOVED,
+  MESSAGE_SENT,
+  MESSAGE_CANCELLED,
+  LOST_SELECTION,
+  LAST_SIGNAL
+};
+
+enum {
+  PROP_0,
+  PROP_ORIENTATION
+};
+
+typedef struct
+{
+  long id, len;
+  long remaining_len;
+
+  long timeout;
+  char *str;
+#ifdef GDK_WINDOWING_X11
+  Window window;
+#endif
+} PendingMessage;
+
+static guint manager_signals[LAST_SIGNAL] = { 0 };
+
+#define SYSTEM_TRAY_REQUEST_DOCK    0
+#define SYSTEM_TRAY_BEGIN_MESSAGE   1
+#define SYSTEM_TRAY_CANCEL_MESSAGE  2
+
+#define SYSTEM_TRAY_ORIENTATION_HORZ 0
+#define SYSTEM_TRAY_ORIENTATION_VERT 1
+
+#ifdef GDK_WINDOWING_X11
+static gboolean na_tray_manager_check_running_screen_x11 (GdkScreen *screen);
+#endif
+
+static void na_tray_manager_finalize     (GObject      *object);
+static void na_tray_manager_set_property (GObject      *object,
+					  guint         prop_id,
+					  const GValue *value,
+					  GParamSpec   *pspec);
+static void na_tray_manager_get_property (GObject      *object,
+					  guint         prop_id,
+					  GValue       *value,
+					  GParamSpec   *pspec);
+
+static void na_tray_manager_unmanage (NaTrayManager *manager);
+
+G_DEFINE_TYPE (NaTrayManager, na_tray_manager, G_TYPE_OBJECT)
+
+static void
+na_tray_manager_init (NaTrayManager *manager)
+{
+  manager->invisible = NULL;
+  manager->socket_table = g_hash_table_new (NULL, NULL);
+
+  manager->padding = 0;
+  manager->icon_size = 0;
+
+  manager->fg.red = 0.0;
+  manager->fg.green = 0.0;
+  manager->fg.blue = 0.0;
+  manager->fg.alpha = 1.0;
+
+  manager->error.red = 1.0;
+  manager->error.green = 0.0;
+  manager->error.blue = 0.0;
+  manager->error.alpha = 1.0;
+
+  manager->warning.red = 1.0;
+  manager->warning.green = 1.0;
+  manager->warning.blue = 0.0;
+  manager->warning.alpha = 1.0;
+
+  manager->success.red = 0.0;
+  manager->success.green = 1.0;
+  manager->success.blue = 0.0;
+  manager->success.alpha = 1.0;
+}
+
+static void
+na_tray_manager_class_init (NaTrayManagerClass *klass)
+{
+  GObjectClass *gobject_class;
+
+  gobject_class = (GObjectClass *)klass;
+
+  gobject_class->finalize = na_tray_manager_finalize;
+  gobject_class->set_property = na_tray_manager_set_property;
+  gobject_class->get_property = na_tray_manager_get_property;
+
+  g_object_class_install_property (gobject_class,
+				   PROP_ORIENTATION,
+				   g_param_spec_enum ("orientation",
+						      "orientation",
+						      "orientation",
+						      GTK_TYPE_ORIENTATION,
+						      GTK_ORIENTATION_HORIZONTAL,
+						      G_PARAM_READWRITE |
+						      G_PARAM_CONSTRUCT |
+						      G_PARAM_STATIC_NAME |
+						      G_PARAM_STATIC_NICK |
+						      G_PARAM_STATIC_BLURB));
+
+  manager_signals[TRAY_ICON_ADDED] =
+    g_signal_new ("tray_icon_added",
+		  G_OBJECT_CLASS_TYPE (klass),
+		  G_SIGNAL_RUN_LAST,
+		  G_STRUCT_OFFSET (NaTrayManagerClass, tray_icon_added),
+		  NULL, NULL,
+		  g_cclosure_marshal_VOID__OBJECT,
+		  G_TYPE_NONE, 1,
+		  GTK_TYPE_SOCKET);
+
+  manager_signals[TRAY_ICON_REMOVED] =
+    g_signal_new ("tray_icon_removed",
+		  G_OBJECT_CLASS_TYPE (klass),
+		  G_SIGNAL_RUN_LAST,
+		  G_STRUCT_OFFSET (NaTrayManagerClass, tray_icon_removed),
+		  NULL, NULL,
+		  g_cclosure_marshal_VOID__OBJECT,
+		  G_TYPE_NONE, 1,
+		  GTK_TYPE_SOCKET);
+  manager_signals[MESSAGE_SENT] =
+    g_signal_new ("message_sent",
+		  G_OBJECT_CLASS_TYPE (klass),
+		  G_SIGNAL_RUN_LAST,
+		  G_STRUCT_OFFSET (NaTrayManagerClass, message_sent),
+		  NULL, NULL,
+		  _na_marshal_VOID__OBJECT_STRING_LONG_LONG,
+		  G_TYPE_NONE, 4,
+		  GTK_TYPE_SOCKET,
+		  G_TYPE_STRING,
+		  G_TYPE_LONG,
+		  G_TYPE_LONG);
+  manager_signals[MESSAGE_CANCELLED] =
+    g_signal_new ("message_cancelled",
+		  G_OBJECT_CLASS_TYPE (klass),
+		  G_SIGNAL_RUN_LAST,
+		  G_STRUCT_OFFSET (NaTrayManagerClass, message_cancelled),
+		  NULL, NULL,
+		  _na_marshal_VOID__OBJECT_LONG,
+		  G_TYPE_NONE, 2,
+		  GTK_TYPE_SOCKET,
+		  G_TYPE_LONG);
+  manager_signals[LOST_SELECTION] =
+    g_signal_new ("lost_selection",
+		  G_OBJECT_CLASS_TYPE (klass),
+		  G_SIGNAL_RUN_LAST,
+		  G_STRUCT_OFFSET (NaTrayManagerClass, lost_selection),
+		  NULL, NULL,
+		  g_cclosure_marshal_VOID__VOID,
+		  G_TYPE_NONE, 0);
+}
+
+static void
+na_tray_manager_finalize (GObject *object)
+{
+  NaTrayManager *manager;
+
+  manager = NA_TRAY_MANAGER (object);
+
+  na_tray_manager_unmanage (manager);
+
+  g_list_free (manager->messages);
+  g_hash_table_destroy (manager->socket_table);
+
+  G_OBJECT_CLASS (na_tray_manager_parent_class)->finalize (object);
+}
+
+static void
+na_tray_manager_set_property (GObject      *object,
+			      guint         prop_id,
+			      const GValue *value,
+			      GParamSpec   *pspec)
+{
+  NaTrayManager *manager = NA_TRAY_MANAGER (object);
+
+  switch (prop_id)
+    {
+    case PROP_ORIENTATION:
+      na_tray_manager_set_orientation (manager, g_value_get_enum (value));
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+na_tray_manager_get_property (GObject    *object,
+			      guint       prop_id,
+			      GValue     *value,
+			      GParamSpec *pspec)
+{
+  NaTrayManager *manager = NA_TRAY_MANAGER (object);
+
+  switch (prop_id)
+    {
+    case PROP_ORIENTATION:
+      g_value_set_enum (value, manager->orientation);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+NaTrayManager *
+na_tray_manager_new (void)
+{
+  NaTrayManager *manager;
+
+  manager = g_object_new (NA_TYPE_TRAY_MANAGER, NULL);
+
+  return manager;
+}
+
+#ifdef GDK_WINDOWING_X11
+
+static gboolean
+na_tray_manager_plug_removed (GtkSocket       *socket,
+			      NaTrayManager   *manager)
+{
+  NaTrayChild *child = NA_TRAY_CHILD (socket);
+
+  g_hash_table_remove (manager->socket_table,
+                       GINT_TO_POINTER (child->icon_window));
+  g_signal_emit (manager, manager_signals[TRAY_ICON_REMOVED], 0, child);
+
+  /* This destroys the socket. */
+  return FALSE;
+}
+
+static void
+na_tray_manager_handle_dock_request (NaTrayManager       *manager,
+				     XClientMessageEvent *xevent)
+{
+  Window icon_window = xevent->data.l[2];
+  GtkWidget *child;
+
+  if (g_hash_table_lookup (manager->socket_table,
+                           GINT_TO_POINTER (icon_window)))
+    {
+      /* We already got this notification earlier, ignore this one */
+      return;
+    }
+
+  child = na_tray_child_new (manager->screen, icon_window);
+  if (child == NULL) /* already gone or other error */
+    return;
+
+  g_signal_emit (manager, manager_signals[TRAY_ICON_ADDED], 0,
+		 child);
+
+  /* If the child wasn't attached, then destroy it */
+
+  if (!GTK_IS_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (child))))
+    {
+      gtk_widget_destroy (child);
+      return;
+    }
+
+  g_signal_connect (child, "plug_removed",
+		    G_CALLBACK (na_tray_manager_plug_removed), manager);
+
+  gtk_socket_add_id (GTK_SOCKET (child), icon_window);
+
+  if (!gtk_socket_get_plug_window (GTK_SOCKET (child)))
+    {
+      /* Embedding failed, we won't get a plug-removed signal */
+      /* This signal destroys the socket */
+      g_signal_emit (manager, manager_signals[TRAY_ICON_REMOVED], 0, child);
+      return;
+    }
+
+  g_hash_table_insert (manager->socket_table,
+                       GINT_TO_POINTER (icon_window), child);
+  gtk_widget_show (child);
+}
+
+static void
+pending_message_free (PendingMessage *message)
+{
+  g_free (message->str);
+  g_free (message);
+}
+
+static void
+na_tray_manager_handle_message_data (NaTrayManager *manager,
+                                     XClientMessageEvent *xevent)
+{
+  GList               *p;
+  int                  len;
+
+  /* Try to see if we can find the pending message in the list */
+  for (p = manager->messages; p; p = p->next)
+    {
+      PendingMessage *msg = p->data;
+
+      if (xevent->window == msg->window)
+	{
+	  /* Append the message */
+	  len = MIN (msg->remaining_len, 20);
+
+	  memcpy ((msg->str + msg->len - msg->remaining_len),
+		  &xevent->data, len);
+	  msg->remaining_len -= len;
+
+	  if (msg->remaining_len == 0)
+	    {
+	      GtkSocket *socket;
+
+	      socket = g_hash_table_lookup (manager->socket_table,
+                                            GINT_TO_POINTER (msg->window));
+
+	      if (socket)
+		  g_signal_emit (manager, manager_signals[MESSAGE_SENT], 0,
+				 socket, msg->str, msg->id, msg->timeout);
+
+	      pending_message_free (msg);
+	      manager->messages = g_list_remove_link (manager->messages, p);
+              g_list_free_1 (p);
+	    }
+
+          break;
+	}
+    }
+}
+
+static void
+na_tray_manager_handle_begin_message (NaTrayManager       *manager,
+				      XClientMessageEvent *xevent)
+{
+  GtkSocket      *socket;
+  GList          *p;
+  PendingMessage *msg;
+  long            timeout;
+  long            len;
+  long            id;
+
+  socket = g_hash_table_lookup (manager->socket_table,
+                                GINT_TO_POINTER (xevent->window));
+  /* we don't know about this tray icon, so ignore the message */
+  if (!socket)
+    return;
+
+  timeout = xevent->data.l[2];
+  len     = xevent->data.l[3];
+  id      = xevent->data.l[4];
+
+  /* Check if the same message is already in the queue and remove it if so */
+  for (p = manager->messages; p; p = p->next)
+    {
+      PendingMessage *pmsg = p->data;
+
+      if (xevent->window == pmsg->window &&
+	  id == pmsg->id)
+	{
+	  /* Hmm, we found it, now remove it */
+	  pending_message_free (pmsg);
+	  manager->messages = g_list_remove_link (manager->messages, p);
+          g_list_free_1 (p);
+	  break;
+	}
+    }
+
+  if (len == 0)
+    {
+      g_signal_emit (manager, manager_signals[MESSAGE_SENT], 0,
+                     socket, "", id, timeout);
+    }
+  else
+    {
+      /* Now add the new message to the queue */
+      msg = g_new0 (PendingMessage, 1);
+      msg->window = xevent->window;
+      msg->timeout = timeout;
+      msg->len = len;
+      msg->id = id;
+      msg->remaining_len = msg->len;
+      msg->str = g_malloc (msg->len + 1);
+      msg->str[msg->len] = '\0';
+      manager->messages = g_list_prepend (manager->messages, msg);
+    }
+}
+
+static void
+na_tray_manager_handle_cancel_message (NaTrayManager       *manager,
+				       XClientMessageEvent *xevent)
+{
+  GList     *p;
+  GtkSocket *socket;
+  long       id;
+
+  id = xevent->data.l[2];
+
+  /* Check if the message is in the queue and remove it if so */
+  for (p = manager->messages; p; p = p->next)
+    {
+      PendingMessage *msg = p->data;
+
+      if (xevent->window == msg->window &&
+	  id == msg->id)
+	{
+	  pending_message_free (msg);
+	  manager->messages = g_list_remove_link (manager->messages, p);
+          g_list_free_1 (p);
+	  break;
+	}
+    }
+
+  socket = g_hash_table_lookup (manager->socket_table,
+                                GINT_TO_POINTER (xevent->window));
+
+  if (socket)
+    {
+      g_signal_emit (manager, manager_signals[MESSAGE_CANCELLED], 0,
+		     socket, xevent->data.l[2]);
+    }
+}
+
+static GdkFilterReturn
+na_tray_manager_window_filter (GdkXEvent *xev,
+                               GdkEvent  *event,
+                               gpointer   data)
+{
+  XEvent        *xevent = (GdkXEvent *)xev;
+  NaTrayManager *manager = data;
+
+  if (xevent->type == ClientMessage)
+    {
+      /* We handle this client message here. See comment in
+       * na_tray_manager_handle_client_message_opcode() for details */
+      if (xevent->xclient.message_type == manager->opcode_atom &&
+          xevent->xclient.data.l[1]    == SYSTEM_TRAY_REQUEST_DOCK)
+	{
+          na_tray_manager_handle_dock_request (manager,
+                                               (XClientMessageEvent *) xevent);
+          return GDK_FILTER_REMOVE;
+	}
+      /* _NET_SYSTEM_TRAY_OPCODE: SYSTEM_TRAY_BEGIN_MESSAGE */
+      else if (xevent->xclient.message_type == manager->opcode_atom &&
+               xevent->xclient.data.l[1] == SYSTEM_TRAY_BEGIN_MESSAGE)
+        {
+          na_tray_manager_handle_begin_message (manager,
+                                                (XClientMessageEvent *) event);
+          return GDK_FILTER_REMOVE;
+        }
+      /* _NET_SYSTEM_TRAY_OPCODE: SYSTEM_TRAY_CANCEL_MESSAGE */
+      else if (xevent->xclient.message_type == manager->opcode_atom &&
+               xevent->xclient.data.l[1] == SYSTEM_TRAY_CANCEL_MESSAGE)
+        {
+          na_tray_manager_handle_cancel_message (manager,
+                                                 (XClientMessageEvent *) event);
+          return GDK_FILTER_REMOVE;
+        }
+      /* _NET_SYSTEM_TRAY_MESSAGE_DATA */
+      else if (xevent->xclient.message_type == manager->message_data_atom)
+        {
+          na_tray_manager_handle_message_data (manager,
+                                               (XClientMessageEvent *) event);
+          return GDK_FILTER_REMOVE;
+        }
+    }
+  else if (xevent->type == SelectionClear)
+    {
+      g_signal_emit (manager, manager_signals[LOST_SELECTION], 0);
+      na_tray_manager_unmanage (manager);
+    }
+
+  return GDK_FILTER_CONTINUE;
+}
+
+#if 0
+//FIXME investigate why this doesn't work
+static gboolean
+na_tray_manager_selection_clear_event (GtkWidget         *widget,
+                                       GdkEventSelection *event,
+                                       NaTrayManager     *manager)
+{
+  g_signal_emit (manager, manager_signals[LOST_SELECTION], 0);
+  na_tray_manager_unmanage (manager);
+
+  return FALSE;
+}
+#endif
+#endif
+
+static void
+na_tray_manager_unmanage (NaTrayManager *manager)
+{
+#ifdef GDK_WINDOWING_X11
+  GdkDisplay *display;
+  guint32     timestamp;
+  GtkWidget  *invisible;
+  GdkWindow  *window;
+
+  if (manager->invisible == NULL)
+    return;
+
+  invisible = manager->invisible;
+  window = gtk_widget_get_window (invisible);
+
+  g_assert (GTK_IS_INVISIBLE (invisible));
+  g_assert (gtk_widget_get_realized (invisible));
+  g_assert (GDK_IS_WINDOW (window));
+
+  display = gtk_widget_get_display (invisible);
+
+  if (gdk_selection_owner_get_for_display (display, manager->selection_atom) ==
+      window)
+    {
+      timestamp = gdk_x11_get_server_time (window);
+      gdk_selection_owner_set_for_display (display,
+                                           NULL,
+                                           manager->selection_atom,
+                                           timestamp,
+                                           TRUE);
+    }
+
+  gdk_window_remove_filter (window,
+                            na_tray_manager_window_filter, manager);
+
+  manager->invisible = NULL; /* prior to destroy for reentrancy paranoia */
+  gtk_widget_destroy (invisible);
+  g_object_unref (G_OBJECT (invisible));
+#endif
+}
+
+static void
+na_tray_manager_set_orientation_property (NaTrayManager *manager)
+{
+#ifdef GDK_WINDOWING_X11
+  GdkWindow  *window;
+  GdkDisplay *display;
+  Atom        orientation_atom;
+  gulong      data[1];
+
+  g_return_if_fail (manager->invisible != NULL);
+  window = gtk_widget_get_window (manager->invisible);
+  g_return_if_fail (window != NULL);
+
+  display = gtk_widget_get_display (manager->invisible);
+  orientation_atom = gdk_x11_get_xatom_by_name_for_display (display,
+                                                            "_NET_SYSTEM_TRAY_ORIENTATION");
+
+  data[0] = manager->orientation == GTK_ORIENTATION_HORIZONTAL ?
+		SYSTEM_TRAY_ORIENTATION_HORZ :
+		SYSTEM_TRAY_ORIENTATION_VERT;
+
+  XChangeProperty (GDK_DISPLAY_XDISPLAY (display),
+		   GDK_WINDOW_XID (window),
+                   orientation_atom,
+		   XA_CARDINAL, 32,
+		   PropModeReplace,
+		   (guchar *) &data, 1);
+#endif
+}
+
+static void
+na_tray_manager_set_visual_property (NaTrayManager *manager)
+{
+#ifdef GDK_WINDOWING_X11
+  GdkWindow  *window;
+  GdkDisplay *display;
+  Visual     *xvisual;
+  Atom        visual_atom;
+  gulong      data[1];
+
+  g_return_if_fail (manager->invisible != NULL);
+  window = gtk_widget_get_window (manager->invisible);
+  g_return_if_fail (window != NULL);
+
+  /* The visual property is a hint to the tray icons as to what visual they
+   * should use for their windows. If the X server has RGBA colormaps, then
+   * we tell the tray icons to use a RGBA colormap and we'll composite the
+   * icon onto its parents with real transparency. Otherwise, we just tell
+   * the icon to use our colormap, and we'll do some hacks with parent
+   * relative backgrounds to simulate transparency.
+   */
+
+  display = gtk_widget_get_display (manager->invisible);
+  visual_atom = gdk_x11_get_xatom_by_name_for_display (display,
+						       "_NET_SYSTEM_TRAY_VISUAL");
+
+  if (gdk_screen_get_rgba_visual (manager->screen) != NULL &&
+      gdk_display_supports_composite (display))
+    {
+      xvisual = GDK_VISUAL_XVISUAL (gdk_screen_get_rgba_visual (manager->screen));
+    }
+  else
+    {
+      /* We actually want the visual of the tray where the icons will
+       * be embedded. In almost all cases, this will be the same as the visual
+       * of the screen.
+       */
+      xvisual = GDK_VISUAL_XVISUAL (gdk_screen_get_system_visual (manager->screen));
+    }
+
+  data[0] = XVisualIDFromVisual (xvisual);
+
+  XChangeProperty (GDK_DISPLAY_XDISPLAY (display),
+                   GDK_WINDOW_XID (window),
+                   visual_atom,
+                   XA_VISUALID, 32,
+                   PropModeReplace,
+                   (guchar *) &data, 1);
+#endif
+}
+
+static void
+na_tray_manager_set_padding_property (NaTrayManager *manager)
+{
+#ifdef GDK_WINDOWING_X11
+  GdkWindow  *window;
+  GdkDisplay *display;
+  Atom        atom;
+  gulong      data[1];
+
+  g_return_if_fail (manager->invisible != NULL);
+  window = gtk_widget_get_window (manager->invisible);
+  g_return_if_fail (window != NULL);
+
+  display = gtk_widget_get_display (manager->invisible);
+  atom = gdk_x11_get_xatom_by_name_for_display (display,
+                                                "_NET_SYSTEM_TRAY_PADDING");
+
+  data[0] = manager->padding;
+
+  XChangeProperty (GDK_DISPLAY_XDISPLAY (display),
+                   GDK_WINDOW_XID (window),
+                   atom,
+                   XA_CARDINAL, 32,
+                   PropModeReplace,
+                   (guchar *) &data, 1);
+#endif
+}
+
+static void
+na_tray_manager_set_icon_size_property (NaTrayManager *manager)
+{
+#ifdef GDK_WINDOWING_X11
+  GdkWindow  *window;
+  GdkDisplay *display;
+  Atom        atom;
+  gulong      data[1];
+
+  g_return_if_fail (manager->invisible != NULL);
+  window = gtk_widget_get_window (manager->invisible);
+  g_return_if_fail (window != NULL);
+
+  display = gtk_widget_get_display (manager->invisible);
+  atom = gdk_x11_get_xatom_by_name_for_display (display,
+                                                "_NET_SYSTEM_TRAY_ICON_SIZE");
+
+  data[0] = manager->icon_size;
+
+  XChangeProperty (GDK_DISPLAY_XDISPLAY (display),
+                   GDK_WINDOW_XID (window),
+                   atom,
+                   XA_CARDINAL, 32,
+                   PropModeReplace,
+                   (guchar *) &data, 1);
+#endif
+}
+
+static void
+na_tray_manager_set_colors_property (NaTrayManager *manager)
+{
+#ifdef GDK_WINDOWING_X11
+  GdkWindow  *window;
+  GdkDisplay *display;
+  Atom        atom;
+  gulong      data[12];
+
+  g_return_if_fail (manager->invisible != NULL);
+  window = gtk_widget_get_window (manager->invisible);
+  g_return_if_fail (window != NULL);
+
+  display = gtk_widget_get_display (manager->invisible);
+  atom = gdk_x11_get_xatom_by_name_for_display (display,
+                                                "_NET_SYSTEM_TRAY_COLORS");
+
+  data[0] = manager->fg.red * 65535;
+  data[1] = manager->fg.green * 65535;
+  data[2] = manager->fg.blue * 65535;
+  data[3] = manager->error.red * 65535;
+  data[4] = manager->error.green * 65535;
+  data[5] = manager->error.blue * 65535;
+  data[6] = manager->warning.red * 65535;
+  data[7] = manager->warning.green * 65535;
+  data[8] = manager->warning.blue * 65535;
+  data[9] = manager->success.red * 65535;
+  data[10] = manager->success.green * 65535;
+  data[11] = manager->success.blue * 65535;
+
+  XChangeProperty (GDK_DISPLAY_XDISPLAY (display),
+                   GDK_WINDOW_XID (window),
+                   atom,
+                   XA_CARDINAL, 32,
+                   PropModeReplace,
+                   (guchar *) &data, 12);
+#endif
+}
+
+#ifdef GDK_WINDOWING_X11
+
+static gboolean
+na_tray_manager_manage_screen_x11 (NaTrayManager *manager,
+				   GdkScreen     *screen)
+{
+  GdkDisplay *display;
+  Screen     *xscreen;
+  GtkWidget  *invisible;
+  GdkWindow  *window;
+  char       *selection_atom_name;
+  guint32     timestamp;
+
+  g_return_val_if_fail (NA_IS_TRAY_MANAGER (manager), FALSE);
+  g_return_val_if_fail (manager->screen == NULL, FALSE);
+
+  /* If there's already a manager running on the screen
+   * we can't create another one.
+   */
+#if 0
+  if (na_tray_manager_check_running_screen_x11 (screen))
+    return FALSE;
+#endif
+
+  manager->screen = screen;
+
+  display = gdk_screen_get_display (screen);
+  xscreen = GDK_SCREEN_XSCREEN (screen);
+
+  invisible = gtk_invisible_new_for_screen (screen);
+  gtk_widget_realize (invisible);
+
+  gtk_widget_add_events (invisible,
+                         GDK_PROPERTY_CHANGE_MASK | GDK_STRUCTURE_MASK);
+
+  selection_atom_name = g_strdup_printf ("_NET_SYSTEM_TRAY_S%d",
+					 gdk_screen_get_number (screen));
+  manager->selection_atom = gdk_atom_intern (selection_atom_name, FALSE);
+  g_free (selection_atom_name);
+
+  manager->invisible = invisible;
+  g_object_ref (G_OBJECT (manager->invisible));
+
+  na_tray_manager_set_orientation_property (manager);
+  na_tray_manager_set_visual_property (manager);
+  na_tray_manager_set_padding_property (manager);
+  na_tray_manager_set_icon_size_property (manager);
+  na_tray_manager_set_colors_property (manager);
+
+  window = gtk_widget_get_window (invisible);
+
+  timestamp = gdk_x11_get_server_time (window);
+
+  /* Check if we could set the selection owner successfully */
+  if (gdk_selection_owner_set_for_display (display,
+                                           window,
+                                           manager->selection_atom,
+                                           timestamp,
+                                           TRUE))
+    {
+      XClientMessageEvent xev;
+      GdkAtom             opcode_atom;
+      GdkAtom             message_data_atom;
+
+      xev.type = ClientMessage;
+      xev.window = RootWindowOfScreen (xscreen);
+      xev.message_type = gdk_x11_get_xatom_by_name_for_display (display,
+                                                                "MANAGER");
+
+      xev.format = 32;
+      xev.data.l[0] = timestamp;
+      xev.data.l[1] = gdk_x11_atom_to_xatom_for_display (display,
+                                                         manager->selection_atom);
+      xev.data.l[2] = GDK_WINDOW_XID (window);
+      xev.data.l[3] = 0;	/* manager specific data */
+      xev.data.l[4] = 0;	/* manager specific data */
+
+      XSendEvent (GDK_DISPLAY_XDISPLAY (display),
+		  RootWindowOfScreen (xscreen),
+		  False, StructureNotifyMask, (XEvent *)&xev);
+
+      opcode_atom = gdk_atom_intern ("_NET_SYSTEM_TRAY_OPCODE", FALSE);
+      manager->opcode_atom = gdk_x11_atom_to_xatom_for_display (display,
+                                                                opcode_atom);
+
+      message_data_atom = gdk_atom_intern ("_NET_SYSTEM_TRAY_MESSAGE_DATA",
+                                           FALSE);
+
+      manager->message_data_atom = gdk_x11_atom_to_xatom_for_display (display,
+                                                                      message_data_atom);
+
+      /* Add a window filter */
+#if 0
+      /* This is for when we lose the selection of _NET_SYSTEM_TRAY_Sx */
+      g_signal_connect (invisible, "selection-clear-event",
+                        G_CALLBACK (na_tray_manager_selection_clear_event),
+                        manager);
+#endif
+      /* This is for SYSTEM_TRAY_REQUEST_DOCK and SelectionClear */
+      gdk_window_add_filter (window,
+                             na_tray_manager_window_filter, manager);
+      return TRUE;
+    }
+  else
+    {
+      gtk_widget_destroy (invisible);
+      g_object_unref (invisible);
+      manager->invisible = NULL;
+
+      manager->screen = NULL;
+
+      return FALSE;
+    }
+}
+
+#endif
+
+gboolean
+na_tray_manager_manage_screen (NaTrayManager *manager,
+			       GdkScreen     *screen)
+{
+  g_return_val_if_fail (GDK_IS_SCREEN (screen), FALSE);
+  g_return_val_if_fail (manager->screen == NULL, FALSE);
+
+#ifdef GDK_WINDOWING_X11
+  return na_tray_manager_manage_screen_x11 (manager, screen);
+#else
+  return FALSE;
+#endif
+}
+
+#ifdef GDK_WINDOWING_X11
+
+static gboolean
+na_tray_manager_check_running_screen_x11 (GdkScreen *screen)
+{
+  GdkDisplay *display;
+  Atom        selection_atom;
+  char       *selection_atom_name;
+
+  display = gdk_screen_get_display (screen);
+  selection_atom_name = g_strdup_printf ("_NET_SYSTEM_TRAY_S%d",
+                                         gdk_screen_get_number (screen));
+  selection_atom = gdk_x11_get_xatom_by_name_for_display (display,
+                                                          selection_atom_name);
+  g_free (selection_atom_name);
+
+  if (XGetSelectionOwner (GDK_DISPLAY_XDISPLAY (display),
+                          selection_atom) != None)
+    return TRUE;
+  else
+    return FALSE;
+}
+
+#endif
+
+gboolean
+na_tray_manager_check_running (GdkScreen *screen)
+{
+  g_return_val_if_fail (GDK_IS_SCREEN (screen), FALSE);
+
+#ifdef GDK_WINDOWING_X11
+  return na_tray_manager_check_running_screen_x11 (screen);
+#else
+  return FALSE;
+#endif
+}
+
+void
+na_tray_manager_set_orientation (NaTrayManager  *manager,
+				 GtkOrientation  orientation)
+{
+  g_return_if_fail (NA_IS_TRAY_MANAGER (manager));
+
+  if (manager->orientation != orientation)
+    {
+      manager->orientation = orientation;
+
+      na_tray_manager_set_orientation_property (manager);
+
+      g_object_notify (G_OBJECT (manager), "orientation");
+    }
+}
+
+void
+na_tray_manager_set_padding (NaTrayManager *manager,
+                             gint           padding)
+{
+  g_return_if_fail (NA_IS_TRAY_MANAGER (manager));
+
+  if (manager->padding != padding)
+    {
+      manager->padding = padding;
+
+      na_tray_manager_set_padding_property (manager);
+    }
+}
+
+void
+na_tray_manager_set_icon_size (NaTrayManager *manager,
+                               gint           icon_size)
+{
+  g_return_if_fail (NA_IS_TRAY_MANAGER (manager));
+
+  if (manager->icon_size != icon_size)
+    {
+      manager->icon_size = icon_size;
+
+      na_tray_manager_set_icon_size_property (manager);
+    }
+}
+
+void
+na_tray_manager_set_colors (NaTrayManager *manager,
+                            GdkRGBA       *fg,
+                            GdkRGBA       *error,
+                            GdkRGBA       *warning,
+                            GdkRGBA       *success)
+{
+  g_return_if_fail (NA_IS_TRAY_MANAGER (manager));
+
+  if (!gdk_rgba_equal (&manager->fg, fg) ||
+      !gdk_rgba_equal (&manager->error, error) ||
+      !gdk_rgba_equal (&manager->warning, warning) ||
+      !gdk_rgba_equal (&manager->success, success))
+    {
+      manager->fg = *fg;
+      manager->error = *error;
+      manager->warning = *warning;
+      manager->success = *success;
+
+      na_tray_manager_set_colors_property (manager);
+    }
+}
+
+GtkOrientation
+na_tray_manager_get_orientation (NaTrayManager *manager)
+{
+  g_return_val_if_fail (NA_IS_TRAY_MANAGER (manager), GTK_ORIENTATION_HORIZONTAL);
+
+  return manager->orientation;
+}
diff --git a/applets/notification_area/system-tray/na-tray-manager.h b/applets/notification_area/system-tray/na-tray-manager.h
new file mode 100644
index 00000000..811791be
--- /dev/null
+++ b/applets/notification_area/system-tray/na-tray-manager.h
@@ -0,0 +1,113 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+/* na-tray-manager.h
+ * Copyright (C) 2002 Anders Carlsson <[email protected]>
+ * Copyright (C) 2003-2006 Vincent Untz
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ *
+ * Used to be: eggtraymanager.h
+ */
+
+#ifndef __NA_TRAY_MANAGER_H__
+#define __NA_TRAY_MANAGER_H__
+
+#ifdef GDK_WINDOWING_X11
+#include <gdk/gdkx.h>
+#endif
+#include <gtk/gtk.h>
+
+#include "na-tray-child.h"
+
+G_BEGIN_DECLS
+
+#define NA_TYPE_TRAY_MANAGER			(na_tray_manager_get_type ())
+#define NA_TRAY_MANAGER(obj)			(G_TYPE_CHECK_INSTANCE_CAST ((obj), NA_TYPE_TRAY_MANAGER, NaTrayManager))
+#define NA_TRAY_MANAGER_CLASS(klass)		(G_TYPE_CHECK_CLASS_CAST ((klass), NA_TYPE_TRAY_MANAGER, NaTrayManagerClass))
+#define NA_IS_TRAY_MANAGER(obj)			(G_TYPE_CHECK_INSTANCE_TYPE ((obj), NA_TYPE_TRAY_MANAGER))
+#define NA_IS_TRAY_MANAGER_CLASS(klass)		(G_TYPE_CHECK_CLASS_TYPE ((klass), NA_TYPE_TRAY_MANAGER))
+#define NA_TRAY_MANAGER_GET_CLASS(obj)		(G_TYPE_INSTANCE_GET_CLASS ((obj), NA_TYPE_TRAY_MANAGER, NaTrayManagerClass))
+
+typedef struct _NaTrayManager	    NaTrayManager;
+typedef struct _NaTrayManagerClass  NaTrayManagerClass;
+
+struct _NaTrayManager
+{
+  GObject parent_instance;
+
+#ifdef GDK_WINDOWING_X11
+  GdkAtom selection_atom;
+  Atom    opcode_atom;
+  Atom message_data_atom;
+#endif
+
+  GtkWidget *invisible;
+  GdkScreen *screen;
+  GtkOrientation orientation;
+  gint padding;
+  gint icon_size;
+  GdkRGBA fg;
+  GdkRGBA error;
+  GdkRGBA warning;
+  GdkRGBA success;
+
+  GList *messages;
+  GHashTable *socket_table;
+};
+
+struct _NaTrayManagerClass
+{
+  GObjectClass parent_class;
+
+  void (* tray_icon_added)   (NaTrayManager      *manager,
+			      NaTrayChild        *child);
+  void (* tray_icon_removed) (NaTrayManager      *manager,
+			      NaTrayChild        *child);
+
+  void (* message_sent)      (NaTrayManager      *manager,
+			      NaTrayChild        *child,
+			      const gchar        *message,
+			      glong               id,
+			      glong               timeout);
+
+  void (* message_cancelled) (NaTrayManager      *manager,
+			      NaTrayChild        *child,
+			      glong               id);
+
+  void (* lost_selection)    (NaTrayManager      *manager);
+};
+
+GType           na_tray_manager_get_type        (void);
+
+gboolean        na_tray_manager_check_running   (GdkScreen          *screen);
+NaTrayManager  *na_tray_manager_new             (void);
+gboolean        na_tray_manager_manage_screen   (NaTrayManager      *manager,
+						 GdkScreen          *screen);
+void            na_tray_manager_set_orientation (NaTrayManager      *manager,
+						 GtkOrientation      orientation);
+GtkOrientation  na_tray_manager_get_orientation (NaTrayManager      *manager);
+void            na_tray_manager_set_padding     (NaTrayManager      *manager,
+						 gint                padding);
+void            na_tray_manager_set_icon_size   (NaTrayManager      *manager,
+						 gint                padding);
+void            na_tray_manager_set_colors      (NaTrayManager      *manager,
+						 GdkRGBA            *fg,
+						 GdkRGBA            *error,
+						 GdkRGBA            *warning,
+						 GdkRGBA            *success);
+
+G_END_DECLS
+
+#endif /* __NA_TRAY_MANAGER_H__ */
diff --git a/applets/notification_area/system-tray/na-tray.c b/applets/notification_area/system-tray/na-tray.c
new file mode 100644
index 00000000..c2488ecf
--- /dev/null
+++ b/applets/notification_area/system-tray/na-tray.c
@@ -0,0 +1,730 @@
+/*
+ * Copyright (C) 2002 Red Hat, Inc.
+ * Copyright (C) 2003-2006 Vincent Untz
+ * Copyright (C) 2007 Christian Persch
+ * Copyright (C) 2017 Colomban Wendling <[email protected]>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301, USA.
+ */
+
+#include <config.h>
+#include <string.h>
+
+#include <gtk/gtk.h>
+
+#include "na-tray-manager.h"
+#include "fixedtip.h"
+
+#include "na-tray.h"
+
+typedef struct
+{
+  NaTrayManager *tray_manager;
+  GSList        *all_trays;
+  GHashTable    *icon_table;
+  GHashTable    *tip_table;
+} TraysScreen;
+
+struct _NaTrayPrivate
+{
+  GdkScreen   *screen;
+  TraysScreen *trays_screen;
+
+  guint idle_redraw_id;
+
+  GtkOrientation orientation;
+  gint           icon_padding;
+  gint           icon_size;
+};
+
+typedef struct
+{
+  char  *text;
+  glong  id;
+  glong  timeout;
+} IconTipBuffer;
+
+typedef struct
+{
+  NaTray *tray;      /* tray containing the tray icon */
+  GtkWidget  *icon;      /* tray icon sending the message */
+  GtkWidget  *fixedtip;
+  guint       source_id;
+  glong       id;        /* id of the current message */
+  GSList     *buffer;    /* buffered messages */
+} IconTip;
+
+enum
+{
+  PROP_0,
+  PROP_ORIENTATION,
+  PROP_ICON_PADDING,
+  PROP_ICON_SIZE,
+  PROP_SCREEN
+};
+
+static gboolean     initialized   = FALSE;
+static TraysScreen *trays_screens = NULL;
+
+static void icon_tip_show_next (IconTip *icontip);
+
+/* NaTray */
+static void na_host_init          (NaHostInterface *iface);
+static void na_tray_style_updated (NaHost          *host,
+                                   GtkStyleContext *context);
+static void na_tray_force_redraw  (NaHost          *host);
+
+G_DEFINE_TYPE_WITH_CODE (NaTray, na_tray, G_TYPE_OBJECT,
+                         G_IMPLEMENT_INTERFACE (GTK_TYPE_ORIENTABLE, NULL)
+                         G_IMPLEMENT_INTERFACE (NA_TYPE_HOST, na_host_init))
+
+static void
+na_host_init (NaHostInterface *iface)
+{
+  iface->force_redraw = na_tray_force_redraw;
+  iface->style_updated = na_tray_style_updated;
+}
+
+static NaTray *
+get_tray (TraysScreen *trays_screen)
+{
+  if (trays_screen->all_trays == NULL)
+    return NULL;
+  
+  return trays_screen->all_trays->data;
+}
+
+static void
+tray_added (NaTrayManager *manager,
+            NaTrayChild   *icon,
+            TraysScreen   *trays_screen)
+{
+  NaTray *tray;
+  NaTrayPrivate *priv;
+
+  tray = get_tray (trays_screen);
+  if (tray == NULL)
+    return;
+
+  priv = tray->priv;
+
+  g_assert (priv->trays_screen == trays_screen);
+
+  g_hash_table_insert (trays_screen->icon_table, icon, tray);
+
+  na_host_emit_item_added (NA_HOST (tray), NA_ITEM (icon));
+
+  gtk_widget_show (GTK_WIDGET (icon));
+}
+
+static void
+tray_removed (NaTrayManager *manager,
+              NaTrayChild   *icon,
+              TraysScreen   *trays_screen)
+{
+  NaTray *tray;
+
+  tray = g_hash_table_lookup (trays_screen->icon_table, icon);
+  if (tray == NULL)
+    return;
+
+  g_assert (tray->priv->trays_screen == trays_screen);
+
+  na_host_emit_item_removed (NA_HOST (tray), NA_ITEM (icon));
+
+  g_hash_table_remove (trays_screen->icon_table, icon);
+  /* this will also destroy the tip associated to this icon */
+  g_hash_table_remove (trays_screen->tip_table, icon);
+}
+
+static void
+icon_tip_buffer_free (gpointer data,
+                      gpointer userdata)
+{
+  IconTipBuffer *buffer;
+
+  buffer = data;
+
+  g_free (buffer->text);
+  buffer->text = NULL;
+
+  g_free (buffer);
+}
+
+static void
+icon_tip_free (gpointer data)
+{
+  IconTip *icontip;
+
+  if (data == NULL)
+    return;
+
+  icontip = data;
+
+  if (icontip->fixedtip != NULL)
+    gtk_widget_destroy (GTK_WIDGET (icontip->fixedtip));
+  icontip->fixedtip = NULL;
+
+  if (icontip->source_id != 0)
+    g_source_remove (icontip->source_id);
+  icontip->source_id = 0;
+
+  if (icontip->buffer != NULL)
+    {
+      g_slist_foreach (icontip->buffer, icon_tip_buffer_free, NULL);
+      g_slist_free (icontip->buffer);
+    }
+  icontip->buffer = NULL;
+
+  g_free (icontip);
+}
+
+static int
+icon_tip_buffer_compare (gconstpointer a,
+                         gconstpointer b)
+{
+  const IconTipBuffer *buffer_a = a;
+  const IconTipBuffer *buffer_b = b;
+
+  if (buffer_a == NULL || buffer_b == NULL)
+    return !(buffer_a == buffer_b);
+
+  return buffer_a->id - buffer_b->id;
+}
+
+static void
+icon_tip_show_next_clicked (GtkWidget *widget,
+                            gpointer   data)
+{
+  icon_tip_show_next ((IconTip *) data);
+}
+
+static gboolean
+icon_tip_show_next_timeout (gpointer data)
+{
+  IconTip *icontip = (IconTip *) data;
+
+  icon_tip_show_next (icontip);
+
+  return FALSE;
+}
+
+static void
+icon_tip_show_next (IconTip *icontip)
+{
+  IconTipBuffer *buffer;
+
+  if (icontip->buffer == NULL)
+    {
+      /* this will also destroy the tip window */
+      g_hash_table_remove (icontip->tray->priv->trays_screen->tip_table,
+                           icontip->icon);
+      return;
+    }
+
+  if (icontip->source_id != 0)
+    g_source_remove (icontip->source_id);
+  icontip->source_id = 0;
+
+  buffer = icontip->buffer->data;
+  icontip->buffer = g_slist_remove (icontip->buffer, buffer);
+
+  if (icontip->fixedtip == NULL)
+    {
+      icontip->fixedtip = na_fixed_tip_new (icontip->icon,
+                                            gtk_orientable_get_orientation (GTK_ORIENTABLE (icontip->tray)));
+
+      g_signal_connect (icontip->fixedtip, "clicked",
+                        G_CALLBACK (icon_tip_show_next_clicked), icontip);
+    }
+
+  na_fixed_tip_set_markup (icontip->fixedtip, buffer->text);
+
+  if (!gtk_widget_get_mapped (icontip->fixedtip))
+    gtk_widget_show (icontip->fixedtip);
+
+  icontip->id = buffer->id;
+
+  if (buffer->timeout > 0)
+    icontip->source_id = g_timeout_add_seconds (buffer->timeout,
+                                                icon_tip_show_next_timeout,
+                                                icontip);
+
+  icon_tip_buffer_free (buffer, NULL);
+}
+
+static void
+message_sent (NaTrayManager *manager,
+              GtkWidget     *icon,
+              const char    *text,
+              glong          id,
+              glong          timeout,
+              TraysScreen   *trays_screen)
+{
+  IconTip       *icontip;
+  IconTipBuffer  find_buffer;
+  IconTipBuffer *buffer;
+  gboolean       show_now;
+
+  icontip = g_hash_table_lookup (trays_screen->tip_table, icon);
+
+  find_buffer.id = id;
+  if (icontip && 
+      (icontip->id == id ||
+       g_slist_find_custom (icontip->buffer, &find_buffer,
+                            icon_tip_buffer_compare) != NULL))
+    /* we already have this message, so ignore it */
+    /* FIXME: in an ideal world, we'd remember all the past ids and ignore them
+     * too */
+    return;
+
+  show_now = FALSE;
+
+  if (icontip == NULL)
+    {
+      NaTray *tray;
+
+      tray = g_hash_table_lookup (trays_screen->icon_table, icon);
+      if (tray == NULL)
+        {
+          /* We don't know about the icon sending the message, so ignore it.
+           * But this should never happen since NaTrayManager shouldn't send
+           * us the message if there's no socket for it. */
+          g_critical ("Ignoring a message sent by a tray icon "
+                      "we don't know: \"%s\".\n", text);
+          return;
+        }
+
+      icontip = g_new0 (IconTip, 1);
+      icontip->tray = tray;
+      icontip->icon = icon;
+
+      g_hash_table_insert (trays_screen->tip_table, icon, icontip);
+
+      show_now = TRUE;
+    }
+
+  buffer = g_new0 (IconTipBuffer, 1);
+
+  buffer->text    = g_strdup (text);
+  buffer->id      = id;
+  buffer->timeout = timeout;
+
+  icontip->buffer = g_slist_append (icontip->buffer, buffer);
+
+  if (show_now)
+    icon_tip_show_next (icontip);
+}
+
+static void
+message_cancelled (NaTrayManager *manager,
+                   GtkWidget     *icon,
+                   glong          id,
+                   TraysScreen   *trays_screen)
+{
+  IconTip       *icontip;
+  IconTipBuffer  find_buffer;
+  GSList        *cancel_buffer_l;
+  IconTipBuffer *cancel_buffer;
+
+  icontip = g_hash_table_lookup (trays_screen->tip_table, icon);
+  if (icontip == NULL)
+    return;
+
+  if (icontip->id == id)
+    {
+      icon_tip_show_next (icontip);
+      return;
+    }
+
+  find_buffer.id = id;
+  cancel_buffer_l = g_slist_find_custom (icontip->buffer, &find_buffer,
+                                         icon_tip_buffer_compare);
+  if (cancel_buffer_l == NULL)
+    return;
+
+  cancel_buffer = cancel_buffer_l->data;
+  icon_tip_buffer_free (cancel_buffer, NULL);
+
+  icontip->buffer = g_slist_remove_link (icontip->buffer, cancel_buffer_l);
+  g_slist_free_1 (cancel_buffer_l);
+}
+
+static void
+update_orientation_for_messages (gpointer key,
+                                 gpointer value,
+                                 gpointer data)
+{
+  NaTray *tray;
+  IconTip    *icontip;
+
+  if (value == NULL)
+    return;
+
+  icontip = value;
+  tray    = data;
+  if (icontip->tray != tray)
+    return;
+
+  if (icontip->fixedtip)
+    na_fixed_tip_set_orientation (icontip->fixedtip, tray->priv->orientation);
+}
+
+static void
+update_size_and_orientation (NaTray *tray)
+{
+  NaTrayPrivate *priv = tray->priv;
+
+  /* This only happens when setting the property during object construction */
+  if (!priv->trays_screen)
+    return;
+
+  g_hash_table_foreach (priv->trays_screen->tip_table,
+                        update_orientation_for_messages, tray);
+
+  if (get_tray (priv->trays_screen) == tray)
+    na_tray_manager_set_orientation (priv->trays_screen->tray_manager,
+                                     priv->orientation);
+}
+
+static void
+na_tray_init (NaTray *tray)
+{
+  NaTrayPrivate *priv;
+
+  priv = tray->priv = G_TYPE_INSTANCE_GET_PRIVATE (tray, NA_TYPE_TRAY, NaTrayPrivate);
+
+  priv->screen = NULL;
+  priv->orientation = GTK_ORIENTATION_HORIZONTAL;
+  priv->icon_padding = 0;
+  priv->icon_size = 0;
+}
+
+static GObject *
+na_tray_constructor (GType type,
+                     guint n_construct_properties,
+                     GObjectConstructParam *construct_params)
+{
+  GObject *object;
+  NaTray *tray;
+  NaTrayPrivate *priv;
+  int screen_number;
+
+  object = G_OBJECT_CLASS (na_tray_parent_class)->constructor (type,
+                                                               n_construct_properties,
+                                                               construct_params);
+  tray = NA_TRAY (object);
+  priv = tray->priv;
+
+  g_assert (priv->screen != NULL);
+
+  if (!initialized)
+    {
+      trays_screens = g_new0 (TraysScreen, 1);
+      initialized = TRUE;
+    }
+
+  screen_number = gdk_screen_get_number (priv->screen);
+
+  if (trays_screens [screen_number].tray_manager == NULL)
+    {
+      NaTrayManager *tray_manager;
+
+      tray_manager = na_tray_manager_new ();
+
+      if (na_tray_manager_manage_screen (tray_manager, priv->screen))
+        {
+          trays_screens [screen_number].tray_manager = tray_manager;
+
+          g_signal_connect (tray_manager, "tray_icon_added",
+                            G_CALLBACK (tray_added),
+                            &trays_screens [screen_number]);
+          g_signal_connect (tray_manager, "tray_icon_removed",
+                            G_CALLBACK (tray_removed),
+                            &trays_screens [screen_number]);
+          g_signal_connect (tray_manager, "message_sent",
+                            G_CALLBACK (message_sent),
+                            &trays_screens [screen_number]);
+          g_signal_connect (tray_manager, "message_cancelled",
+                            G_CALLBACK (message_cancelled),
+                            &trays_screens [screen_number]);
+
+          trays_screens [screen_number].icon_table = g_hash_table_new (NULL,
+                                                                       NULL);
+          trays_screens [screen_number].tip_table = g_hash_table_new_full (
+                                                                NULL,
+                                                                NULL,
+                                                                NULL,
+                                                                icon_tip_free);
+        }
+      else
+        {
+          g_printerr ("System tray didn't get the system tray manager selection for screen %d\n",
+		      screen_number);
+          g_object_unref (tray_manager);
+        }
+    }
+      
+  priv->trays_screen = &trays_screens [screen_number];
+  trays_screens [screen_number].all_trays = g_slist_append (trays_screens [screen_number].all_trays,
+                                                            tray);
+
+  update_size_and_orientation (tray);
+
+  return object;
+}
+
+static void
+na_tray_dispose (GObject *object)
+{
+  NaTray *tray = NA_TRAY (object);
+  NaTrayPrivate *priv = tray->priv;
+  TraysScreen *trays_screen = priv->trays_screen;
+
+  if (trays_screen != NULL)
+    {
+      trays_screen->all_trays = g_slist_remove (trays_screen->all_trays, tray);
+
+      if (trays_screen->all_trays == NULL)
+        {
+          /* Make sure we drop the manager selection */
+          g_object_unref (trays_screen->tray_manager);
+          trays_screen->tray_manager = NULL;
+
+          g_hash_table_destroy (trays_screen->icon_table);
+          trays_screen->icon_table = NULL;
+
+          g_hash_table_destroy (trays_screen->tip_table);
+          trays_screen->tip_table = NULL;
+        }
+      else
+        {
+          NaTray *new_tray;
+
+          new_tray = get_tray (trays_screen);
+          if (new_tray != NULL)
+            na_tray_manager_set_orientation (trays_screen->tray_manager,
+                                             gtk_orientable_get_orientation (GTK_ORIENTABLE (new_tray)));
+        }
+    }
+
+  priv->trays_screen = NULL;
+
+  if (priv->idle_redraw_id != 0)
+    {
+      g_source_remove (priv->idle_redraw_id);
+      priv->idle_redraw_id = 0;
+    }
+
+  G_OBJECT_CLASS (na_tray_parent_class)->dispose (object);
+}
+
+static void
+na_tray_set_orientation (NaTray         *tray,
+			 GtkOrientation  orientation)
+{
+  NaTrayPrivate *priv = tray->priv;
+
+  if (orientation == priv->orientation)
+    return;
+
+  priv->orientation = orientation;
+
+  update_size_and_orientation (tray);
+}
+
+static void
+na_tray_set_property (GObject      *object,
+		      guint         prop_id,
+		      const GValue *value,
+		      GParamSpec   *pspec)
+{
+  NaTray *tray = NA_TRAY (object);
+  NaTrayPrivate *priv = tray->priv;
+
+  switch (prop_id)
+    {
+    case PROP_ORIENTATION:
+      na_tray_set_orientation (tray, g_value_get_enum (value));
+      break;
+    case PROP_ICON_PADDING:
+      na_tray_set_padding (tray, g_value_get_int (value));
+      break;
+    case PROP_ICON_SIZE:
+      na_tray_set_icon_size (tray, g_value_get_int (value));
+      break;
+    case PROP_SCREEN:
+      priv->screen = g_value_get_object (value);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+na_tray_get_property (GObject    *object,
+		      guint       prop_id,
+		      GValue     *value,
+		      GParamSpec *pspec)
+{
+  NaTray *tray = NA_TRAY (object);
+  NaTrayPrivate *priv = tray->priv;
+
+  switch (prop_id)
+    {
+    case PROP_ORIENTATION:
+      g_value_set_enum (value, tray->priv->orientation);
+      break;
+    case PROP_ICON_PADDING:
+      g_value_set_int (value, tray->priv->icon_padding);
+      break;
+    case PROP_ICON_SIZE:
+      g_value_set_int (value, tray->priv->icon_size);
+      break;
+    case PROP_SCREEN:
+      g_value_set_object (value, priv->screen);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+na_tray_class_init (NaTrayClass *klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+  gobject_class->constructor = na_tray_constructor;
+  gobject_class->set_property = na_tray_set_property;
+  gobject_class->get_property = na_tray_get_property;
+  gobject_class->dispose = na_tray_dispose;
+
+  g_object_class_override_property (gobject_class, PROP_ORIENTATION, "orientation");
+
+  g_object_class_override_property (gobject_class, PROP_ICON_PADDING, "icon-padding");
+  g_object_class_override_property (gobject_class, PROP_ICON_SIZE, "icon-size");
+
+  g_object_class_install_property
+    (gobject_class,
+     PROP_SCREEN,
+     g_param_spec_object ("screen", "screen", "screen",
+			  GDK_TYPE_SCREEN,
+			  G_PARAM_WRITABLE |
+			  G_PARAM_CONSTRUCT_ONLY |
+			  G_PARAM_STATIC_NAME |
+			  G_PARAM_STATIC_NICK |
+			  G_PARAM_STATIC_BLURB));
+
+  g_type_class_add_private (gobject_class, sizeof (NaTrayPrivate));
+}
+
+NaHost *
+na_tray_new_for_screen (GdkScreen      *screen,
+		        GtkOrientation  orientation)
+{
+  return g_object_new (NA_TYPE_TRAY,
+		       "screen", screen,
+		       "orientation", orientation,
+		       NULL);
+}
+
+void
+na_tray_set_padding (NaTray *tray,
+                     gint    padding)
+{
+  NaTrayPrivate *priv = tray->priv;
+
+  priv->icon_padding = padding;
+  if (get_tray (priv->trays_screen) == tray)
+    na_tray_manager_set_padding (priv->trays_screen->tray_manager, padding);
+}
+
+void
+na_tray_set_icon_size (NaTray *tray,
+                       gint    size)
+{
+  NaTrayPrivate *priv = tray->priv;
+
+  priv->icon_size = size;
+  if (get_tray (priv->trays_screen) == tray)
+    na_tray_manager_set_icon_size (priv->trays_screen->tray_manager, size);
+}
+
+static void
+na_tray_set_colors (NaTray   *tray,
+                    GdkRGBA  *fg,
+                    GdkRGBA  *error,
+                    GdkRGBA  *warning,
+                    GdkRGBA  *success)
+{
+  NaTrayPrivate *priv = tray->priv;
+
+  if (get_tray (priv->trays_screen) == tray)
+    na_tray_manager_set_colors (priv->trays_screen->tray_manager, fg, error, warning, success);
+}
+
+static void
+na_tray_style_updated (NaHost          *host,
+                       GtkStyleContext *context)
+{
+  GdkRGBA fg;
+  GdkRGBA error;
+  GdkRGBA warning;
+  GdkRGBA success;
+
+  gtk_style_context_save (context);
+  gtk_style_context_set_state (context, GTK_STATE_FLAG_NORMAL);
+
+  gtk_style_context_get_color (context, GTK_STATE_FLAG_NORMAL, &fg);
+
+  if (!gtk_style_context_lookup_color (context, "error_color", &error))
+    error = fg;
+  if (!gtk_style_context_lookup_color (context, "warning_color", &warning))
+    warning = fg;
+  if (!gtk_style_context_lookup_color (context, "success_color", &success))
+    success = fg;
+
+  gtk_style_context_restore (context);
+
+  na_tray_set_colors (NA_TRAY (host), &fg, &error, &warning, &success);
+}
+
+static gboolean
+idle_redraw_cb (NaTray *tray)
+{
+  NaTrayPrivate *priv = tray->priv;
+
+  g_hash_table_foreach (priv->trays_screen->icon_table,
+                        (GHFunc) na_tray_child_force_redraw, NULL);
+  
+  priv->idle_redraw_id = 0;
+
+  return FALSE;
+}
+
+static void
+na_tray_force_redraw (NaHost *host)
+{
+  NaTray *tray = NA_TRAY (host);
+  NaTrayPrivate *priv = tray->priv;
+
+  /* Force the icons to redraw their backgrounds.
+   */
+  if (priv->idle_redraw_id == 0)
+    priv->idle_redraw_id = g_idle_add ((GSourceFunc) idle_redraw_cb, tray);
+}
diff --git a/applets/notification_area/system-tray/na-tray.h b/applets/notification_area/system-tray/na-tray.h
new file mode 100644
index 00000000..8eaca36e
--- /dev/null
+++ b/applets/notification_area/system-tray/na-tray.h
@@ -0,0 +1,69 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+/* na-tray-tray.h
+ * Copyright (C) 2002 Anders Carlsson <[email protected]>
+ * Copyright (C) 2003-2006 Vincent Untz
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ *
+ * Used to be: eggtraytray.h
+ */
+
+#ifndef __NA_TRAY_H__
+#define __NA_TRAY_H__
+
+#ifdef GDK_WINDOWING_X11
+#include <gdk/gdkx.h>
+#endif
+#include <gtk/gtk.h>
+
+#include "na-host.h"
+
+G_BEGIN_DECLS
+
+#define NA_TYPE_TRAY			(na_tray_get_type ())
+#define NA_TRAY(obj)			(G_TYPE_CHECK_INSTANCE_CAST ((obj), NA_TYPE_TRAY, NaTray))
+#define NA_TRAY_CLASS(klass)		(G_TYPE_CHECK_CLASS_CAST ((klass), NA_TYPE_TRAY, NaTrayClass))
+#define NA_IS_TRAY(obj)			(G_TYPE_CHECK_INSTANCE_TYPE ((obj), NA_TYPE_TRAY))
+#define NA_IS_TRAY_CLASS(klass)		(G_TYPE_CHECK_CLASS_TYPE ((klass), NA_TYPE_TRAY))
+#define NA_TRAY_GET_CLASS(obj)		(G_TYPE_INSTANCE_GET_CLASS ((obj), NA_TYPE_TRAY, NaTrayClass))
+
+typedef struct _NaTray		NaTray;
+typedef struct _NaTrayPrivate	NaTrayPrivate;
+typedef struct _NaTrayClass	NaTrayClass;
+
+struct _NaTray
+{
+  GObject parent_instance;
+
+  NaTrayPrivate *priv;
+};
+
+struct _NaTrayClass
+{
+  GObjectClass parent_class;
+};
+
+GType           na_tray_get_type        (void);
+NaHost         *na_tray_new_for_screen  (GdkScreen     *screen,
+					 GtkOrientation orientation);
+void            na_tray_set_padding     (NaTray        *tray,
+					 gint           padding);
+void            na_tray_set_icon_size   (NaTray        *tray,
+					 gint           icon_size);
+
+G_END_DECLS
+
+#endif /* __NA_TRAY_H__ */