Pileus Git - ~andy/gtk/blob - gtk/gtktrayicon-x11.c

   1 /* gtktrayicon.c
   2  * Copyright (C) 2002 Anders Carlsson <andersca@gnu.org>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 /*
  21  * This is an implementation of the freedesktop.org "system tray" spec,
  22  * http://www.freedesktop.org/wiki/Standards/systemtray-spec
  23  */
  24
  25 #include "config.h"
  26 #include <string.h>
  27
  28 #include "gtkintl.h"
  29 #include "gtkprivate.h"
  30 #include "gtktrayicon.h"
  31
  32 #include "x11/gdkx.h"
  33 #include <X11/Xatom.h>
  34
  35 #define SYSTEM_TRAY_REQUEST_DOCK    0
  36 #define SYSTEM_TRAY_BEGIN_MESSAGE   1
  37 #define SYSTEM_TRAY_CANCEL_MESSAGE  2
  38
  39 #define SYSTEM_TRAY_ORIENTATION_HORZ 0
  40 #define SYSTEM_TRAY_ORIENTATION_VERT 1
  41
  42 enum {
  43   PROP_0,
  44   PROP_ORIENTATION,
  45   PROP_FG_COLOR,
  46   PROP_ERROR_COLOR,
  47   PROP_WARNING_COLOR,
  48   PROP_SUCCESS_COLOR,
  49   PROP_PADDING
  50 };
  51
  52 struct _GtkTrayIconPrivate
  53 {
  54   guint stamp;
  55
  56   Atom selection_atom;
  57   Atom manager_atom;
  58   Atom system_tray_opcode_atom;
  59   Atom orientation_atom;
  60   Atom visual_atom;
  61   Atom colors_atom;
  62   Atom padding_atom;
  63   Window manager_window;
  64   GdkVisual *manager_visual;
  65   gboolean manager_visual_rgba;
  66
  67   GtkOrientation orientation;
  68   GdkColor fg_color;
  69   GdkColor error_color;
  70   GdkColor warning_color;
  71   GdkColor success_color;
  72   gint padding;
  73 };
  74
  75 static void gtk_tray_icon_constructed   (GObject     *object);
  76 static void gtk_tray_icon_dispose       (GObject     *object);
  77
  78 static void gtk_tray_icon_get_property  (GObject     *object,
  79                                          guint        prop_id,
  80                                          GValue      *value,
  81                                          GParamSpec  *pspec);
  82
  83 static void     gtk_tray_icon_realize   (GtkWidget   *widget);
  84 static void     gtk_tray_icon_style_set (GtkWidget   *widget,
  85                                          GtkStyle    *previous_style);
  86 static gboolean gtk_tray_icon_delete    (GtkWidget   *widget,
  87                                          GdkEventAny *event);
  88 static gboolean gtk_tray_icon_expose    (GtkWidget      *widget,
  89                                          GdkEventExpose *event);
  90
  91 static void gtk_tray_icon_clear_manager_window     (GtkTrayIcon *icon);
  92 static void gtk_tray_icon_update_manager_window    (GtkTrayIcon *icon);
  93 static void gtk_tray_icon_manager_window_destroyed (GtkTrayIcon *icon);
  94
  95 static GdkFilterReturn gtk_tray_icon_manager_filter (GdkXEvent *xevent,
  96                                                      GdkEvent  *event,
  97                                                      gpointer   user_data);
  98
  99
 100 G_DEFINE_TYPE (GtkTrayIcon, gtk_tray_icon, GTK_TYPE_PLUG)
 101
 102 static void
 103 gtk_tray_icon_class_init (GtkTrayIconClass *class)
 104 {
 105   GObjectClass *gobject_class = (GObjectClass *)class;
 106   GtkWidgetClass *widget_class = (GtkWidgetClass *)class;
 107
 108   gobject_class->get_property = gtk_tray_icon_get_property;
 109   gobject_class->constructed = gtk_tray_icon_constructed;
 110   gobject_class->dispose = gtk_tray_icon_dispose;
 111
 112   widget_class->realize = gtk_tray_icon_realize;
 113   widget_class->style_set = gtk_tray_icon_style_set;
 114   widget_class->delete_event = gtk_tray_icon_delete;
 115   widget_class->expose_event = gtk_tray_icon_expose;
 116
 117   g_object_class_install_property (gobject_class,
 118                                    PROP_ORIENTATION,
 119                                    g_param_spec_enum ("orientation",
 120                                                       P_("Orientation"),
 121                                                       P_("The orientation of the tray"),
 122                                                       GTK_TYPE_ORIENTATION,
 123                                                       GTK_ORIENTATION_HORIZONTAL,
 124                                                       GTK_PARAM_READABLE));
 125
 126   g_object_class_install_property (gobject_class,
 127                                    PROP_FG_COLOR,
 128                                    g_param_spec_boxed ("fg-color",
 129                                                        P_("Foreground color"),
 130                                                        P_("Foreground color for symbolic icons"),
 131                                                        GDK_TYPE_COLOR,
 132                                                        GTK_PARAM_READABLE));
 133
 134   g_object_class_install_property (gobject_class,
 135                                    PROP_ERROR_COLOR,
 136                                    g_param_spec_boxed ("error-color",
 137                                                        P_("Error color"),
 138                                                        P_("Error color for symbolic icons"),
 139                                                        GDK_TYPE_COLOR,
 140                                                        GTK_PARAM_READABLE));
 141
 142   g_object_class_install_property (gobject_class,
 143                                    PROP_WARNING_COLOR,
 144                                    g_param_spec_boxed ("warning-color",
 145                                                        P_("Warning color"),
 146                                                        P_("Warning color for symbolic icons"),
 147                                                        GDK_TYPE_COLOR,
 148                                                        GTK_PARAM_READABLE));
 149
 150   g_object_class_install_property (gobject_class,
 151                                    PROP_SUCCESS_COLOR,
 152                                    g_param_spec_boxed ("success-color",
 153                                                        P_("Success color"),
 154                                                        P_("Success color for symbolic icons"),
 155                                                        GDK_TYPE_COLOR,
 156                                                        GTK_PARAM_READABLE));
 157
 158   g_object_class_install_property (gobject_class,
 159                                    PROP_PADDING,
 160                                    g_param_spec_int ("padding",
 161                                                      P_("Padding"),
 162                                                      P_("Padding that should be put around icons in the tray"),
 163                                                      0,
 164                                                      G_MAXINT,
 165                                                      0,
 166                                                      GTK_PARAM_READABLE));
 167
 168   g_type_class_add_private (class, sizeof (GtkTrayIconPrivate));
 169 }
 170
 171 static void
 172 gtk_tray_icon_init (GtkTrayIcon *icon)
 173 {
 174   icon->priv = G_TYPE_INSTANCE_GET_PRIVATE (icon, GTK_TYPE_TRAY_ICON,
 175                                             GtkTrayIconPrivate);
 176
 177   icon->priv->stamp = 1;
 178   icon->priv->orientation = GTK_ORIENTATION_HORIZONTAL;
 179   icon->priv->fg_color.red        = 0x0000;
 180   icon->priv->fg_color.green      = 0x0000;
 181   icon->priv->fg_color.blue       = 0x0000;
 182   icon->priv->error_color.red     = 0xcc00;
 183   icon->priv->error_color.green   = 0x0000;
 184   icon->priv->error_color.blue    = 0x0000;
 185   icon->priv->warning_color.red   = 0xf500;
 186   icon->priv->warning_color.green = 0x7900;
 187   icon->priv->warning_color.blue  = 0x3e00;
 188   icon->priv->success_color.red   = 0x4e00;
 189   icon->priv->success_color.green = 0x9a00;
 190   icon->priv->success_color.blue  = 0x0600;
 191   icon->priv->padding = 0;
 192
 193   gtk_widget_set_app_paintable (GTK_WIDGET (icon), TRUE);
 194   gtk_widget_add_events (GTK_WIDGET (icon), GDK_PROPERTY_CHANGE_MASK);
 195 }
 196
 197 static void
 198 gtk_tray_icon_constructed (GObject *object)
 199 {
 200   /* Do setup that depends on the screen; screen has been set at this point */
 201
 202   GtkTrayIcon *icon = GTK_TRAY_ICON (object);
 203   GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (object));
 204   GdkWindow *root_window = gdk_screen_get_root_window (screen);
 205   GdkDisplay *display = gtk_widget_get_display (GTK_WIDGET (object));
 206   Display *xdisplay = gdk_x11_display_get_xdisplay (display);
 207   char buffer[256];
 208
 209   g_snprintf (buffer, sizeof (buffer),
 210               "_NET_SYSTEM_TRAY_S%d",
 211               gdk_screen_get_number (screen));
 212
 213   icon->priv->selection_atom = XInternAtom (xdisplay, buffer, False);
 214
 215   icon->priv->manager_atom = XInternAtom (xdisplay, "MANAGER", False);
 216
 217   icon->priv->system_tray_opcode_atom = XInternAtom (xdisplay,
 218                                                      "_NET_SYSTEM_TRAY_OPCODE",
 219                                                      False);
 220
 221   icon->priv->orientation_atom = XInternAtom (xdisplay,
 222                                               "_NET_SYSTEM_TRAY_ORIENTATION",
 223                                               False);
 224
 225   icon->priv->visual_atom = XInternAtom (xdisplay,
 226                                          "_NET_SYSTEM_TRAY_VISUAL",
 227                                          False);
 228
 229   icon->priv->colors_atom = XInternAtom (xdisplay,
 230                                          "_NET_SYSTEM_TRAY_COLORS",
 231                                          False);
 232
 233   icon->priv->padding_atom = XInternAtom (xdisplay,
 234                                          "_NET_SYSTEM_TRAY_PADDING",
 235                                          False);
 236
 237   /* Add a root window filter so that we get changes on MANAGER */
 238   gdk_window_add_filter (root_window,
 239                          gtk_tray_icon_manager_filter, icon);
 240
 241   gtk_tray_icon_update_manager_window (icon);
 242 }
 243
 244 static void
 245 gtk_tray_icon_clear_manager_window (GtkTrayIcon *icon)
 246 {
 247   GdkDisplay *display = gtk_widget_get_display (GTK_WIDGET (icon));
 248
 249   if (icon->priv->manager_window != None)
 250     {
 251       GdkWindow *gdkwin;
 252
 253       gdkwin = gdk_window_lookup_for_display (display,
 254                                               icon->priv->manager_window);
 255
 256       gdk_window_remove_filter (gdkwin, gtk_tray_icon_manager_filter, icon);
 257
 258       icon->priv->manager_window = None;
 259       icon->priv->manager_visual = NULL;
 260     }
 261 }
 262
 263 static void
 264 gtk_tray_icon_dispose (GObject *object)
 265 {
 266   GtkTrayIcon *icon = GTK_TRAY_ICON (object);
 267   GtkWidget *widget = GTK_WIDGET (object);
 268   GdkWindow *root_window = gdk_screen_get_root_window (gtk_widget_get_screen (widget));
 269
 270   gtk_tray_icon_clear_manager_window (icon);
 271
 272   gdk_window_remove_filter (root_window, gtk_tray_icon_manager_filter, icon);
 273 }
 274
 275 static void
 276 gtk_tray_icon_get_property (GObject    *object,
 277                             guint       prop_id,
 278                             GValue     *value,
 279                             GParamSpec *pspec)
 280 {
 281   GtkTrayIcon *icon = GTK_TRAY_ICON (object);
 282
 283   switch (prop_id)
 284     {
 285     case PROP_ORIENTATION:
 286       g_value_set_enum (value, icon->priv->orientation);
 287       break;
 288     case PROP_FG_COLOR:
 289       g_value_set_boxed (value, &icon->priv->fg_color);
 290       break;
 291     case PROP_ERROR_COLOR:
 292       g_value_set_boxed (value, &icon->priv->error_color);
 293       break;
 294     case PROP_WARNING_COLOR:
 295       g_value_set_boxed (value, &icon->priv->warning_color);
 296       break;
 297     case PROP_SUCCESS_COLOR:
 298       g_value_set_boxed (value, &icon->priv->success_color);
 299       break;
 300     case PROP_PADDING:
 301       g_value_set_int (value, icon->priv->padding);
 302       break;
 303     default:
 304       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 305       break;
 306     }
 307 }
 308
 309 static gboolean
 310 gtk_tray_icon_expose (GtkWidget      *widget,
 311                       GdkEventExpose *event)
 312 {
 313   GtkTrayIcon *icon = GTK_TRAY_ICON (widget);
 314   GtkWidget *focus_child;
 315   gint border_width, x, y, width, height;
 316   gboolean retval = FALSE;
 317
 318   if (icon->priv->manager_visual_rgba)
 319     {
 320       /* Clear to transparent */
 321       cairo_t *cr = gdk_cairo_create (widget->window);
 322       cairo_set_source_rgba (cr, 0, 0, 0, 0);
 323       cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
 324       gdk_cairo_region (cr, event->region);
 325       cairo_fill (cr);
 326       cairo_destroy (cr);
 327     }
 328   else
 329     {
 330       /* Clear to parent-relative pixmap */
 331       gdk_window_clear_area (widget->window, event->area.x, event->area.y,
 332                              event->area.width, event->area.height);
 333     }
 334
 335   if (GTK_WIDGET_CLASS (gtk_tray_icon_parent_class)->expose_event)
 336     retval = GTK_WIDGET_CLASS (gtk_tray_icon_parent_class)->expose_event (widget, event);
 337
 338   focus_child = gtk_container_get_focus_child (GTK_CONTAINER (widget));
 339   if (focus_child && gtk_widget_has_focus (focus_child))
 340     {
 341       border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
 342
 343       x = widget->allocation.x + border_width;
 344       y = widget->allocation.y + border_width;
 345
 346       width  = widget->allocation.width  - 2 * border_width;
 347       height = widget->allocation.height - 2 * border_width;
 348
 349       gtk_paint_focus (widget->style, widget->window,
 350                        gtk_widget_get_state (widget),
 351                        &event->area, widget, "tray_icon",
 352                        x, y, width, height);
 353     }
 354
 355   return retval;
 356 }
 357
 358 static void
 359 gtk_tray_icon_get_orientation_property (GtkTrayIcon *icon)
 360 {
 361   GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (icon));
 362   GdkDisplay *display = gdk_screen_get_display (screen);
 363   Display *xdisplay = GDK_DISPLAY_XDISPLAY (display);
 364
 365   Atom type;
 366   int format;
 367   union {
 368         gulong *prop;
 369         guchar *prop_ch;
 370   } prop = { NULL };
 371   gulong nitems;
 372   gulong bytes_after;
 373   int error, result;
 374
 375   g_assert (icon->priv->manager_window != None);
 376
 377   gdk_error_trap_push ();
 378   type = None;
 379   result = XGetWindowProperty (xdisplay,
 380                                icon->priv->manager_window,
 381                                icon->priv->orientation_atom,
 382                                0, G_MAXLONG, FALSE,
 383                                XA_CARDINAL,
 384                                &type, &format, &nitems,
 385                                &bytes_after, &(prop.prop_ch));
 386   error = gdk_error_trap_pop ();
 387
 388   if (error || result != Success)
 389     return;
 390
 391   if (type == XA_CARDINAL && nitems == 1 && format == 32)
 392     {
 393       GtkOrientation orientation;
 394
 395       orientation = (prop.prop [0] == SYSTEM_TRAY_ORIENTATION_HORZ) ?
 396                                         GTK_ORIENTATION_HORIZONTAL :
 397                                         GTK_ORIENTATION_VERTICAL;
 398
 399       if (icon->priv->orientation != orientation)
 400         {
 401           icon->priv->orientation = orientation;
 402
 403           g_object_notify (G_OBJECT (icon), "orientation");
 404         }
 405     }
 406
 407   if (type != None)
 408     XFree (prop.prop);
 409 }
 410
 411 static void
 412 gtk_tray_icon_get_visual_property (GtkTrayIcon *icon)
 413 {
 414   GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (icon));
 415   GdkDisplay *display = gdk_screen_get_display (screen);
 416   Display *xdisplay = GDK_DISPLAY_XDISPLAY (display);
 417
 418   Atom type;
 419   int format;
 420   union {
 421         gulong *prop;
 422         guchar *prop_ch;
 423   } prop = { NULL };
 424   gulong nitems;
 425   gulong bytes_after;
 426   int error, result;
 427   GdkVisual *visual;
 428
 429   g_assert (icon->priv->manager_window != None);
 430
 431   gdk_error_trap_push ();
 432   type = None;
 433   result = XGetWindowProperty (xdisplay,
 434                                icon->priv->manager_window,
 435                                icon->priv->visual_atom,
 436                                0, G_MAXLONG, FALSE,
 437                                XA_VISUALID,
 438                                &type, &format, &nitems,
 439                                &bytes_after, &(prop.prop_ch));
 440   error = gdk_error_trap_pop ();
 441
 442   visual = NULL;
 443
 444   if (!error && result == Success &&
 445       type == XA_VISUALID && nitems == 1 && format == 32)
 446     {
 447       VisualID visual_id = prop.prop[0];
 448       visual = gdk_x11_screen_lookup_visual (screen, visual_id);
 449     }
 450
 451   icon->priv->manager_visual = visual;
 452   icon->priv->manager_visual_rgba = visual != NULL &&
 453     (visual->red_prec + visual->blue_prec + visual->green_prec < visual->depth);
 454
 455   /* For the background-relative hack we use when we aren't using a real RGBA
 456    * visual, we can't be double-buffered */
 457   gtk_widget_set_double_buffered (GTK_WIDGET (icon), icon->priv->manager_visual_rgba);
 458
 459   if (type != None)
 460     XFree (prop.prop);
 461 }
 462
 463 static void
 464 gtk_tray_icon_get_colors_property (GtkTrayIcon *icon)
 465 {
 466   GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (icon));
 467   GdkDisplay *display = gdk_screen_get_display (screen);
 468   Display *xdisplay = GDK_DISPLAY_XDISPLAY (display);
 469
 470   Atom type;
 471   int format;
 472   union {
 473         gulong *prop;
 474         guchar *prop_ch;
 475   } prop = { NULL };
 476   gulong nitems;
 477   gulong bytes_after;
 478   int error, result;
 479
 480   g_assert (icon->priv->manager_window != None);
 481
 482   gdk_error_trap_push ();
 483   type = None;
 484   result = XGetWindowProperty (xdisplay,
 485                                icon->priv->manager_window,
 486                                icon->priv->colors_atom,
 487                                0, G_MAXLONG, FALSE,
 488                                XA_CARDINAL,
 489                                &type, &format, &nitems,
 490                                &bytes_after, &(prop.prop_ch));
 491   error = gdk_error_trap_pop ();
 492
 493   if (error || result != Success)
 494     return;
 495
 496   if (type == XA_CARDINAL && nitems == 12 && format == 32)
 497     {
 498       GdkColor color;
 499
 500       g_object_freeze_notify (G_OBJECT (icon));
 501
 502       color.red = prop.prop[0];
 503       color.green = prop.prop[1];
 504       color.blue = prop.prop[2];
 505
 506       if (!gdk_color_equal (&icon->priv->fg_color, &color))
 507         {
 508           icon->priv->fg_color = color;
 509
 510           g_object_notify (G_OBJECT (icon), "fg-color");
 511         }
 512
 513       color.red = prop.prop[3];
 514       color.green = prop.prop[4];
 515       color.blue = prop.prop[5];
 516
 517       if (!gdk_color_equal (&icon->priv->error_color, &color))
 518         {
 519           icon->priv->error_color = color;
 520
 521           g_object_notify (G_OBJECT (icon), "error-color");
 522         }
 523
 524       g_object_thaw_notify (G_OBJECT (icon));
 525
 526       color.red = prop.prop[6];
 527       color.green = prop.prop[7];
 528       color.blue = prop.prop[8];
 529
 530       if (!gdk_color_equal (&icon->priv->warning_color, &color))
 531         {
 532           icon->priv->warning_color = color;
 533
 534           g_object_notify (G_OBJECT (icon), "warning-color");
 535         }
 536
 537       g_object_thaw_notify (G_OBJECT (icon));
 538
 539       color.red = prop.prop[9];
 540       color.green = prop.prop[10];
 541       color.blue = prop.prop[11];
 542
 543       if (!gdk_color_equal (&icon->priv->success_color, &color))
 544         {
 545           icon->priv->success_color = color;
 546
 547           g_object_notify (G_OBJECT (icon), "success-color");
 548         }
 549
 550       g_object_thaw_notify (G_OBJECT (icon));
 551     }
 552
 553   if (type != None)
 554     XFree (prop.prop);
 555 }
 556
 557 static void
 558 gtk_tray_icon_get_padding_property (GtkTrayIcon *icon)
 559 {
 560   GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (icon));
 561   GdkDisplay *display = gdk_screen_get_display (screen);
 562   Display *xdisplay = GDK_DISPLAY_XDISPLAY (display);
 563
 564   Atom type;
 565   int format;
 566   union {
 567         gulong *prop;
 568         guchar *prop_ch;
 569   } prop = { NULL };
 570   gulong nitems;
 571   gulong bytes_after;
 572   int error, result;
 573
 574   g_assert (icon->priv->manager_window != None);
 575
 576   gdk_error_trap_push ();
 577   type = None;
 578   result = XGetWindowProperty (xdisplay,
 579                                icon->priv->manager_window,
 580                                icon->priv->padding_atom,
 581                                0, G_MAXLONG, FALSE,
 582                                XA_CARDINAL,
 583                                &type, &format, &nitems,
 584                                &bytes_after, &(prop.prop_ch));
 585   error = gdk_error_trap_pop ();
 586
 587   if (!error && result == Success &&
 588       type == XA_CARDINAL && nitems == 1 && format == 32)
 589     {
 590       gint padding;
 591
 592       padding = prop.prop[0];
 593
 594       if (icon->priv->padding != padding)
 595         {
 596           icon->priv->padding = padding;
 597
 598           g_object_notify (G_OBJECT (icon), "padding");
 599         }
 600     }
 601
 602   if (type != None)
 603     XFree (prop.prop);
 604 }
 605
 606 static GdkFilterReturn
 607 gtk_tray_icon_manager_filter (GdkXEvent *xevent,
 608                               GdkEvent  *event,
 609                               gpointer   user_data)
 610 {
 611   GtkTrayIcon *icon = user_data;
 612   XEvent *xev = (XEvent *)xevent;
 613
 614   if (xev->xany.type == ClientMessage &&
 615       xev->xclient.message_type == icon->priv->manager_atom &&
 616       xev->xclient.data.l[1] == icon->priv->selection_atom)
 617     {
 618       GTK_NOTE (PLUGSOCKET,
 619                 g_print ("GtkStatusIcon %p: tray manager appeared\n", icon));
 620
 621       gtk_tray_icon_update_manager_window (icon);
 622     }
 623   else if (xev->xany.window == icon->priv->manager_window)
 624     {
 625       if (xev->xany.type == PropertyNotify &&
 626           xev->xproperty.atom == icon->priv->orientation_atom)
 627         {
 628           GTK_NOTE (PLUGSOCKET,
 629                     g_print ("GtkStatusIcon %p: got PropertyNotify on manager window for orientation atom\n", icon));
 630
 631           gtk_tray_icon_get_orientation_property (icon);
 632         }
 633       else if (xev->xany.type == PropertyNotify &&
 634                xev->xproperty.atom == icon->priv->colors_atom)
 635         {
 636           GTK_NOTE (PLUGSOCKET,
 637                     g_print ("GtkStatusIcon %p: got PropertyNotify on manager window for colors atom\n", icon));
 638
 639           gtk_tray_icon_get_colors_property (icon);
 640         }
 641       else if (xev->xany.type == PropertyNotify &&
 642                xev->xproperty.atom == icon->priv->padding_atom)
 643         {
 644           gtk_tray_icon_get_padding_property (icon);
 645         }
 646       else if (xev->xany.type == DestroyNotify)
 647         {
 648           GTK_NOTE (PLUGSOCKET,
 649                     g_print ("GtkStatusIcon %p: got DestroyNotify for manager window\n", icon));
 650
 651           gtk_tray_icon_manager_window_destroyed (icon);
 652         }
 653       else
 654         GTK_NOTE (PLUGSOCKET,
 655                   g_print ("GtkStatusIcon %p: got other message on manager window\n", icon));
 656     }
 657
 658   return GDK_FILTER_CONTINUE;
 659 }
 660
 661 static void
 662 gtk_tray_icon_send_manager_message (GtkTrayIcon *icon,
 663                                     long         message,
 664                                     Window       window,
 665                                     long         data1,
 666                                     long         data2,
 667                                     long         data3)
 668 {
 669   XClientMessageEvent ev;
 670   Display *display;
 671
 672   memset (&ev, 0, sizeof (ev));
 673   ev.type = ClientMessage;
 674   ev.window = window;
 675   ev.message_type = icon->priv->system_tray_opcode_atom;
 676   ev.format = 32;
 677   ev.data.l[0] = gdk_x11_get_server_time (GTK_WIDGET (icon)->window);
 678   ev.data.l[1] = message;
 679   ev.data.l[2] = data1;
 680   ev.data.l[3] = data2;
 681   ev.data.l[4] = data3;
 682
 683   display = GDK_DISPLAY_XDISPLAY (gtk_widget_get_display (GTK_WIDGET (icon)));
 684
 685   gdk_error_trap_push ();
 686   XSendEvent (display,
 687               icon->priv->manager_window, False, NoEventMask, (XEvent *)&ev);
 688   gdk_display_sync (gtk_widget_get_display (GTK_WIDGET (icon)));
 689   gdk_error_trap_pop ();
 690 }
 691
 692 static void
 693 gtk_tray_icon_send_dock_request (GtkTrayIcon *icon)
 694 {
 695   GTK_NOTE (PLUGSOCKET,
 696             g_print ("GtkStatusIcon %p: sending dock request to manager window %lx\n",
 697                      icon, (gulong) icon->priv->manager_window));
 698
 699   gtk_tray_icon_send_manager_message (icon,
 700                                       SYSTEM_TRAY_REQUEST_DOCK,
 701                                       icon->priv->manager_window,
 702                                       gtk_plug_get_id (GTK_PLUG (icon)),
 703                                       0, 0);
 704 }
 705
 706 static void
 707 gtk_tray_icon_update_manager_window (GtkTrayIcon *icon)
 708 {
 709   GtkWidget *widget = GTK_WIDGET (icon);
 710   GdkScreen *screen = gtk_widget_get_screen (widget);
 711   GdkDisplay *display = gdk_screen_get_display (screen);
 712   Display *xdisplay = GDK_DISPLAY_XDISPLAY (display);
 713
 714   GTK_NOTE (PLUGSOCKET,
 715             g_print ("GtkStatusIcon %p: updating tray icon manager window, current manager window: %lx\n",
 716                      icon, (gulong) icon->priv->manager_window));
 717
 718   if (icon->priv->manager_window != None)
 719     return;
 720
 721   GTK_NOTE (PLUGSOCKET,
 722             g_print ("GtkStatusIcon %p: trying to find manager window\n", icon));
 723
 724   XGrabServer (xdisplay);
 725
 726   icon->priv->manager_window = XGetSelectionOwner (xdisplay,
 727                                                    icon->priv->selection_atom);
 728
 729   if (icon->priv->manager_window != None)
 730     XSelectInput (xdisplay,
 731                   icon->priv->manager_window, StructureNotifyMask|PropertyChangeMask);
 732
 733   XUngrabServer (xdisplay);
 734   XFlush (xdisplay);
 735
 736   if (icon->priv->manager_window != None)
 737     {
 738       GdkWindow *gdkwin;
 739
 740       GTK_NOTE (PLUGSOCKET,
 741                 g_print ("GtkStatusIcon %p: is being managed by window %lx\n",
 742                                 icon, (gulong) icon->priv->manager_window));
 743
 744       gdkwin = gdk_window_lookup_for_display (display,
 745                                               icon->priv->manager_window);
 746
 747       gdk_window_add_filter (gdkwin, gtk_tray_icon_manager_filter, icon);
 748
 749       gtk_tray_icon_get_orientation_property (icon);
 750       gtk_tray_icon_get_visual_property (icon);
 751       gtk_tray_icon_get_colors_property (icon);
 752       gtk_tray_icon_get_padding_property (icon);
 753
 754       if (gtk_widget_get_realized (GTK_WIDGET (icon)))
 755         {
 756           if ((icon->priv->manager_visual == NULL &&
 757                gtk_widget_get_visual (widget) == gdk_screen_get_system_visual (screen)) ||
 758               (icon->priv->manager_visual == gtk_widget_get_visual (widget)))
 759             {
 760               /* Already have the right visual, can just dock
 761                */
 762               gtk_tray_icon_send_dock_request (icon);
 763             }
 764           else
 765             {
 766               /* Need to re-realize the widget to get the right visual
 767                */
 768               gtk_widget_hide (widget);
 769               gtk_widget_unrealize (widget);
 770               gtk_widget_show (widget);
 771             }
 772         }
 773     }
 774   else
 775     GTK_NOTE (PLUGSOCKET,
 776               g_print ("GtkStatusIcon %p: no tray manager found\n", icon));
 777 }
 778
 779 static void
 780 gtk_tray_icon_manager_window_destroyed (GtkTrayIcon *icon)
 781 {
 782   g_return_if_fail (icon->priv->manager_window != None);
 783
 784   GTK_NOTE (PLUGSOCKET,
 785             g_print ("GtkStatusIcon %p: tray manager window destroyed\n", icon));
 786
 787   gtk_tray_icon_clear_manager_window (icon);
 788 }
 789
 790 static gboolean
 791 gtk_tray_icon_delete (GtkWidget   *widget,
 792                       GdkEventAny *event)
 793 {
 794 #ifdef G_ENABLE_DEBUG
 795   GtkTrayIcon *icon = GTK_TRAY_ICON (widget);
 796 #endif
 797
 798   GTK_NOTE (PLUGSOCKET,
 799             g_print ("GtkStatusIcon %p: delete notify, tray manager window %lx\n",
 800                      icon, (gulong) icon->priv->manager_window));
 801
 802   /* A bug in X server versions up to x.org 1.5.0 means that:
 803    * XFixesChangeSaveSet(...., SaveSetRoot, SaveSetUnmap) doesn't work properly
 804    * and we'll left mapped in a separate toplevel window if the tray is destroyed.
 805    * For simplicity just get rid of our X window and start over.
 806    */
 807   gtk_widget_hide (widget);
 808   gtk_widget_unrealize (widget);
 809   gtk_widget_show (widget);
 810
 811   /* Handled it, don't destroy the tray icon */
 812   return TRUE;
 813 }
 814
 815 static void
 816 gtk_tray_icon_set_colormap (GtkTrayIcon *icon)
 817 {
 818   GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (icon));
 819   GdkColormap *colormap;
 820   GdkVisual *visual = icon->priv->manager_visual;
 821   gboolean new_colormap = FALSE;
 822
 823   /* To avoid uncertainty about colormaps, _NET_SYSTEM_TRAY_VISUAL is supposed
 824    * to be either the screen default visual or a TrueColor visual; ignore it
 825    * if it is something else
 826    */
 827   if (visual && visual->type != GDK_VISUAL_TRUE_COLOR)
 828     visual = NULL;
 829
 830   if (visual == NULL || visual == gdk_screen_get_system_visual (screen))
 831     colormap = gdk_screen_get_system_colormap (screen);
 832   else if (visual == gdk_screen_get_rgba_visual (screen))
 833     colormap = gdk_screen_get_rgba_colormap (screen);
 834   else
 835     {
 836       colormap = gdk_colormap_new (visual, FALSE);
 837       new_colormap = TRUE;
 838     }
 839
 840   gtk_widget_set_colormap (GTK_WIDGET (icon), colormap);
 841
 842   if (new_colormap)
 843     g_object_unref (colormap);
 844 }
 845
 846 static void
 847 gtk_tray_icon_realize (GtkWidget *widget)
 848 {
 849   GtkTrayIcon *icon = GTK_TRAY_ICON (widget);
 850
 851   /* Set our colormap before realizing */
 852   gtk_tray_icon_set_colormap (icon);
 853
 854   GTK_WIDGET_CLASS (gtk_tray_icon_parent_class)->realize (widget);
 855   if (icon->priv->manager_visual_rgba)
 856     {
 857       /* Set a transparent background */
 858       GdkColor transparent = { 0, 0, 0, 0 }; /* Only pixel=0 matters */
 859       gdk_window_set_background (widget->window, &transparent);
 860     }
 861   else
 862     {
 863       /* Set a parent-relative background pixmap */
 864       gdk_window_set_back_pixmap (widget->window, NULL, TRUE);
 865     }
 866
 867   GTK_NOTE (PLUGSOCKET,
 868             g_print ("GtkStatusIcon %p: realized, window: %lx, socket window: %lx\n",
 869                      widget,
 870                      (gulong) GDK_WINDOW_XWINDOW (widget->window),
 871                      GTK_PLUG (icon)->socket_window ?
 872                              (gulong) GDK_WINDOW_XWINDOW (GTK_PLUG (icon)->socket_window) : 0UL));
 873
 874   if (icon->priv->manager_window != None)
 875     gtk_tray_icon_send_dock_request (icon);
 876 }
 877
 878 static void
 879 gtk_tray_icon_style_set (GtkWidget   *widget,
 880                          GtkStyle    *previous_style)
 881 {
 882   /* The default handler resets the background according to the style. We either
 883    * use a transparent background or a parent-relative background and ignore the
 884    * style background. So, just don't chain up.
 885    */
 886 }
 887
 888 guint
 889 _gtk_tray_icon_send_message (GtkTrayIcon *icon,
 890                              gint         timeout,
 891                              const gchar *message,
 892                              gint         len)
 893 {
 894   guint stamp;
 895   Display *xdisplay;
 896
 897   g_return_val_if_fail (GTK_IS_TRAY_ICON (icon), 0);
 898   g_return_val_if_fail (timeout >= 0, 0);
 899   g_return_val_if_fail (message != NULL, 0);
 900
 901   if (icon->priv->manager_window == None)
 902     return 0;
 903
 904   if (len < 0)
 905     len = strlen (message);
 906
 907   stamp = icon->priv->stamp++;
 908
 909   /* Get ready to send the message */
 910   gtk_tray_icon_send_manager_message (icon, SYSTEM_TRAY_BEGIN_MESSAGE,
 911                                       (Window)gtk_plug_get_id (GTK_PLUG (icon)),
 912                                       timeout, len, stamp);
 913
 914   /* Now to send the actual message */
 915   xdisplay = GDK_DISPLAY_XDISPLAY (gtk_widget_get_display (GTK_WIDGET (icon)));
 916   gdk_error_trap_push ();
 917   while (len > 0)
 918     {
 919       XClientMessageEvent ev;
 920
 921       memset (&ev, 0, sizeof (ev));
 922       ev.type = ClientMessage;
 923       ev.window = (Window)gtk_plug_get_id (GTK_PLUG (icon));
 924       ev.format = 8;
 925       ev.message_type = XInternAtom (xdisplay,
 926                                      "_NET_SYSTEM_TRAY_MESSAGE_DATA", False);
 927       if (len > 20)
 928         {
 929           memcpy (&ev.data, message, 20);
 930           len -= 20;
 931           message += 20;
 932         }
 933       else
 934         {
 935           memcpy (&ev.data, message, len);
 936           len = 0;
 937         }
 938
 939       XSendEvent (xdisplay,
 940                   icon->priv->manager_window, False,
 941                   StructureNotifyMask, (XEvent *)&ev);
 942     }
 943   gdk_display_sync (gtk_widget_get_display (GTK_WIDGET (icon)));
 944   gdk_error_trap_pop ();
 945
 946   return stamp;
 947 }
 948
 949 void
 950 _gtk_tray_icon_cancel_message (GtkTrayIcon *icon,
 951                                guint        id)
 952 {
 953   g_return_if_fail (GTK_IS_TRAY_ICON (icon));
 954   g_return_if_fail (id > 0);
 955
 956   gtk_tray_icon_send_manager_message (icon, SYSTEM_TRAY_CANCEL_MESSAGE,
 957                                       (Window)gtk_plug_get_id (GTK_PLUG (icon)),
 958                                       id, 0, 0);
 959 }
 960
 961 GtkTrayIcon *
 962 _gtk_tray_icon_new_for_screen (GdkScreen  *screen,
 963                                const gchar *name)
 964 {
 965   g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
 966
 967   return g_object_new (GTK_TYPE_TRAY_ICON,
 968                        "screen", screen,
 969                        "title", name,
 970                        NULL);
 971 }
 972
 973 GtkTrayIcon*
 974 _gtk_tray_icon_new (const gchar *name)
 975 {
 976   return g_object_new (GTK_TYPE_TRAY_ICON,
 977                        "title", name,
 978                        NULL);
 979 }
 980
 981 GtkOrientation
 982 _gtk_tray_icon_get_orientation (GtkTrayIcon *icon)
 983 {
 984   g_return_val_if_fail (GTK_IS_TRAY_ICON (icon), GTK_ORIENTATION_HORIZONTAL);
 985
 986   return icon->priv->orientation;
 987 }
 988
 989 gint
 990 _gtk_tray_icon_get_padding (GtkTrayIcon *icon)
 991 {
 992   g_return_val_if_fail (GTK_IS_TRAY_ICON (icon), 0);
 993
 994   return icon->priv->padding;
 995 }