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   GtkAllocation allocation;
 315   GtkWidget *focus_child;
 316   GdkWindow *window;
 317   gint border_width, x, y, width, height;
 318   gboolean retval = FALSE;
 319
 320   window = gtk_widget_get_window (widget);
 321
 322   if (icon->priv->manager_visual_rgba)
 323     {
 324       /* Clear to transparent */
 325       cairo_t *cr = gdk_cairo_create (window);
 326       cairo_set_source_rgba (cr, 0, 0, 0, 0);
 327       cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
 328       gdk_cairo_region (cr, event->region);
 329       cairo_fill (cr);
 330       cairo_destroy (cr);
 331     }
 332   else
 333     {
 334       /* Clear to parent-relative pixmap
 335        * We need to use direct X access here because GDK doesn't know about
 336        * the parent realtive pixmap. */
 337       XClearArea (GDK_WINDOW_XDISPLAY (window),
 338                   GDK_WINDOW_XID (window),
 339                   event->area.x, event->area.y,
 340                   event->area.width, event->area.height,
 341                   False);
 342     }
 343
 344   if (GTK_WIDGET_CLASS (gtk_tray_icon_parent_class)->expose_event)
 345     retval = GTK_WIDGET_CLASS (gtk_tray_icon_parent_class)->expose_event (widget, event);
 346
 347   focus_child = gtk_container_get_focus_child (GTK_CONTAINER (widget));
 348   if (focus_child && gtk_widget_has_focus (focus_child))
 349     {
 350       gtk_widget_get_allocation (widget, &allocation);
 351       border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
 352
 353       x = allocation.x + border_width;
 354       y = allocation.y + border_width;
 355
 356       width  = allocation.width  - 2 * border_width;
 357       height = allocation.height - 2 * border_width;
 358
 359       gtk_paint_focus (gtk_widget_get_style (widget),
 360                        window,
 361                        gtk_widget_get_state (widget),
 362                        &event->area, widget, "tray_icon",
 363                        x, y, width, height);
 364     }
 365
 366   return retval;
 367 }
 368
 369 static void
 370 gtk_tray_icon_get_orientation_property (GtkTrayIcon *icon)
 371 {
 372   GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (icon));
 373   GdkDisplay *display = gdk_screen_get_display (screen);
 374   Display *xdisplay = GDK_DISPLAY_XDISPLAY (display);
 375
 376   Atom type;
 377   int format;
 378   union {
 379         gulong *prop;
 380         guchar *prop_ch;
 381   } prop = { NULL };
 382   gulong nitems;
 383   gulong bytes_after;
 384   int error, result;
 385
 386   g_assert (icon->priv->manager_window != None);
 387
 388   gdk_error_trap_push ();
 389   type = None;
 390   result = XGetWindowProperty (xdisplay,
 391                                icon->priv->manager_window,
 392                                icon->priv->orientation_atom,
 393                                0, G_MAXLONG, FALSE,
 394                                XA_CARDINAL,
 395                                &type, &format, &nitems,
 396                                &bytes_after, &(prop.prop_ch));
 397   error = gdk_error_trap_pop ();
 398
 399   if (error || result != Success)
 400     return;
 401
 402   if (type == XA_CARDINAL && nitems == 1 && format == 32)
 403     {
 404       GtkOrientation orientation;
 405
 406       orientation = (prop.prop [0] == SYSTEM_TRAY_ORIENTATION_HORZ) ?
 407                                         GTK_ORIENTATION_HORIZONTAL :
 408                                         GTK_ORIENTATION_VERTICAL;
 409
 410       if (icon->priv->orientation != orientation)
 411         {
 412           icon->priv->orientation = orientation;
 413
 414           g_object_notify (G_OBJECT (icon), "orientation");
 415         }
 416     }
 417
 418   if (type != None)
 419     XFree (prop.prop);
 420 }
 421
 422 static void
 423 gtk_tray_icon_get_visual_property (GtkTrayIcon *icon)
 424 {
 425   GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (icon));
 426   GdkDisplay *display = gdk_screen_get_display (screen);
 427   Display *xdisplay = GDK_DISPLAY_XDISPLAY (display);
 428
 429   Atom type;
 430   int format;
 431   union {
 432         gulong *prop;
 433         guchar *prop_ch;
 434   } prop = { NULL };
 435   gulong nitems;
 436   gulong bytes_after;
 437   int error, result;
 438   GdkVisual *visual;
 439
 440   g_assert (icon->priv->manager_window != None);
 441
 442   gdk_error_trap_push ();
 443   type = None;
 444   result = XGetWindowProperty (xdisplay,
 445                                icon->priv->manager_window,
 446                                icon->priv->visual_atom,
 447                                0, G_MAXLONG, FALSE,
 448                                XA_VISUALID,
 449                                &type, &format, &nitems,
 450                                &bytes_after, &(prop.prop_ch));
 451   error = gdk_error_trap_pop ();
 452
 453   visual = NULL;
 454
 455   if (!error && result == Success &&
 456       type == XA_VISUALID && nitems == 1 && format == 32)
 457     {
 458       VisualID visual_id = prop.prop[0];
 459       visual = gdk_x11_screen_lookup_visual (screen, visual_id);
 460     }
 461
 462   icon->priv->manager_visual = visual;
 463   icon->priv->manager_visual_rgba = visual != NULL &&
 464     (visual->red_prec + visual->blue_prec + visual->green_prec < visual->depth);
 465
 466   /* For the background-relative hack we use when we aren't using a real RGBA
 467    * visual, we can't be double-buffered */
 468   gtk_widget_set_double_buffered (GTK_WIDGET (icon), icon->priv->manager_visual_rgba);
 469
 470   if (type != None)
 471     XFree (prop.prop);
 472 }
 473
 474 static void
 475 gtk_tray_icon_get_colors_property (GtkTrayIcon *icon)
 476 {
 477   GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (icon));
 478   GdkDisplay *display = gdk_screen_get_display (screen);
 479   Display *xdisplay = GDK_DISPLAY_XDISPLAY (display);
 480
 481   Atom type;
 482   int format;
 483   union {
 484         gulong *prop;
 485         guchar *prop_ch;
 486   } prop = { NULL };
 487   gulong nitems;
 488   gulong bytes_after;
 489   int error, result;
 490
 491   g_assert (icon->priv->manager_window != None);
 492
 493   gdk_error_trap_push ();
 494   type = None;
 495   result = XGetWindowProperty (xdisplay,
 496                                icon->priv->manager_window,
 497                                icon->priv->colors_atom,
 498                                0, G_MAXLONG, FALSE,
 499                                XA_CARDINAL,
 500                                &type, &format, &nitems,
 501                                &bytes_after, &(prop.prop_ch));
 502   error = gdk_error_trap_pop ();
 503
 504   if (error || result != Success)
 505     return;
 506
 507   if (type == XA_CARDINAL && nitems == 12 && format == 32)
 508     {
 509       GdkColor color;
 510
 511       g_object_freeze_notify (G_OBJECT (icon));
 512
 513       color.red = prop.prop[0];
 514       color.green = prop.prop[1];
 515       color.blue = prop.prop[2];
 516
 517       if (!gdk_color_equal (&icon->priv->fg_color, &color))
 518         {
 519           icon->priv->fg_color = color;
 520
 521           g_object_notify (G_OBJECT (icon), "fg-color");
 522         }
 523
 524       color.red = prop.prop[3];
 525       color.green = prop.prop[4];
 526       color.blue = prop.prop[5];
 527
 528       if (!gdk_color_equal (&icon->priv->error_color, &color))
 529         {
 530           icon->priv->error_color = color;
 531
 532           g_object_notify (G_OBJECT (icon), "error-color");
 533         }
 534
 535       g_object_thaw_notify (G_OBJECT (icon));
 536
 537       color.red = prop.prop[6];
 538       color.green = prop.prop[7];
 539       color.blue = prop.prop[8];
 540
 541       if (!gdk_color_equal (&icon->priv->warning_color, &color))
 542         {
 543           icon->priv->warning_color = color;
 544
 545           g_object_notify (G_OBJECT (icon), "warning-color");
 546         }
 547
 548       g_object_thaw_notify (G_OBJECT (icon));
 549
 550       color.red = prop.prop[9];
 551       color.green = prop.prop[10];
 552       color.blue = prop.prop[11];
 553
 554       if (!gdk_color_equal (&icon->priv->success_color, &color))
 555         {
 556           icon->priv->success_color = color;
 557
 558           g_object_notify (G_OBJECT (icon), "success-color");
 559         }
 560
 561       g_object_thaw_notify (G_OBJECT (icon));
 562     }
 563
 564   if (type != None)
 565     XFree (prop.prop);
 566 }
 567
 568 static void
 569 gtk_tray_icon_get_padding_property (GtkTrayIcon *icon)
 570 {
 571   GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (icon));
 572   GdkDisplay *display = gdk_screen_get_display (screen);
 573   Display *xdisplay = GDK_DISPLAY_XDISPLAY (display);
 574
 575   Atom type;
 576   int format;
 577   union {
 578         gulong *prop;
 579         guchar *prop_ch;
 580   } prop = { NULL };
 581   gulong nitems;
 582   gulong bytes_after;
 583   int error, result;
 584
 585   g_assert (icon->priv->manager_window != None);
 586
 587   gdk_error_trap_push ();
 588   type = None;
 589   result = XGetWindowProperty (xdisplay,
 590                                icon->priv->manager_window,
 591                                icon->priv->padding_atom,
 592                                0, G_MAXLONG, FALSE,
 593                                XA_CARDINAL,
 594                                &type, &format, &nitems,
 595                                &bytes_after, &(prop.prop_ch));
 596   error = gdk_error_trap_pop ();
 597
 598   if (!error && result == Success &&
 599       type == XA_CARDINAL && nitems == 1 && format == 32)
 600     {
 601       gint padding;
 602
 603       padding = prop.prop[0];
 604
 605       if (icon->priv->padding != padding)
 606         {
 607           icon->priv->padding = padding;
 608
 609           g_object_notify (G_OBJECT (icon), "padding");
 610         }
 611     }
 612
 613   if (type != None)
 614     XFree (prop.prop);
 615 }
 616
 617 static GdkFilterReturn
 618 gtk_tray_icon_manager_filter (GdkXEvent *xevent,
 619                               GdkEvent  *event,
 620                               gpointer   user_data)
 621 {
 622   GtkTrayIcon *icon = user_data;
 623   XEvent *xev = (XEvent *)xevent;
 624
 625   if (xev->xany.type == ClientMessage &&
 626       xev->xclient.message_type == icon->priv->manager_atom &&
 627       xev->xclient.data.l[1] == icon->priv->selection_atom)
 628     {
 629       GTK_NOTE (PLUGSOCKET,
 630                 g_print ("GtkStatusIcon %p: tray manager appeared\n", icon));
 631
 632       gtk_tray_icon_update_manager_window (icon);
 633     }
 634   else if (xev->xany.window == icon->priv->manager_window)
 635     {
 636       if (xev->xany.type == PropertyNotify &&
 637           xev->xproperty.atom == icon->priv->orientation_atom)
 638         {
 639           GTK_NOTE (PLUGSOCKET,
 640                     g_print ("GtkStatusIcon %p: got PropertyNotify on manager window for orientation atom\n", icon));
 641
 642           gtk_tray_icon_get_orientation_property (icon);
 643         }
 644       else if (xev->xany.type == PropertyNotify &&
 645                xev->xproperty.atom == icon->priv->colors_atom)
 646         {
 647           GTK_NOTE (PLUGSOCKET,
 648                     g_print ("GtkStatusIcon %p: got PropertyNotify on manager window for colors atom\n", icon));
 649
 650           gtk_tray_icon_get_colors_property (icon);
 651         }
 652       else if (xev->xany.type == PropertyNotify &&
 653                xev->xproperty.atom == icon->priv->padding_atom)
 654         {
 655           gtk_tray_icon_get_padding_property (icon);
 656         }
 657       else if (xev->xany.type == DestroyNotify)
 658         {
 659           GTK_NOTE (PLUGSOCKET,
 660                     g_print ("GtkStatusIcon %p: got DestroyNotify for manager window\n", icon));
 661
 662           gtk_tray_icon_manager_window_destroyed (icon);
 663         }
 664       else
 665         GTK_NOTE (PLUGSOCKET,
 666                   g_print ("GtkStatusIcon %p: got other message on manager window\n", icon));
 667     }
 668
 669   return GDK_FILTER_CONTINUE;
 670 }
 671
 672 static void
 673 gtk_tray_icon_send_manager_message (GtkTrayIcon *icon,
 674                                     long         message,
 675                                     Window       window,
 676                                     long         data1,
 677                                     long         data2,
 678                                     long         data3)
 679 {
 680   GtkWidget *widget;
 681   XClientMessageEvent ev;
 682   Display *display;
 683
 684   widget = GTK_WIDGET (icon);
 685
 686   memset (&ev, 0, sizeof (ev));
 687   ev.type = ClientMessage;
 688   ev.window = window;
 689   ev.message_type = icon->priv->system_tray_opcode_atom;
 690   ev.format = 32;
 691   ev.data.l[0] = gdk_x11_get_server_time (gtk_widget_get_window (widget));
 692   ev.data.l[1] = message;
 693   ev.data.l[2] = data1;
 694   ev.data.l[3] = data2;
 695   ev.data.l[4] = data3;
 696
 697   display = GDK_DISPLAY_XDISPLAY (gtk_widget_get_display (widget));
 698
 699   gdk_error_trap_push ();
 700   XSendEvent (display,
 701               icon->priv->manager_window, False, NoEventMask, (XEvent *)&ev);
 702   gdk_error_trap_pop_ignored ();
 703 }
 704
 705 static void
 706 gtk_tray_icon_send_dock_request (GtkTrayIcon *icon)
 707 {
 708   GTK_NOTE (PLUGSOCKET,
 709             g_print ("GtkStatusIcon %p: sending dock request to manager window %lx\n",
 710                      icon, (gulong) icon->priv->manager_window));
 711
 712   gtk_tray_icon_send_manager_message (icon,
 713                                       SYSTEM_TRAY_REQUEST_DOCK,
 714                                       icon->priv->manager_window,
 715                                       gtk_plug_get_id (GTK_PLUG (icon)),
 716                                       0, 0);
 717 }
 718
 719 static void
 720 gtk_tray_icon_update_manager_window (GtkTrayIcon *icon)
 721 {
 722   GtkWidget *widget = GTK_WIDGET (icon);
 723   GdkScreen *screen = gtk_widget_get_screen (widget);
 724   GdkDisplay *display = gdk_screen_get_display (screen);
 725   Display *xdisplay = GDK_DISPLAY_XDISPLAY (display);
 726
 727   GTK_NOTE (PLUGSOCKET,
 728             g_print ("GtkStatusIcon %p: updating tray icon manager window, current manager window: %lx\n",
 729                      icon, (gulong) icon->priv->manager_window));
 730
 731   if (icon->priv->manager_window != None)
 732     return;
 733
 734   GTK_NOTE (PLUGSOCKET,
 735             g_print ("GtkStatusIcon %p: trying to find manager window\n", icon));
 736
 737   XGrabServer (xdisplay);
 738
 739   icon->priv->manager_window = XGetSelectionOwner (xdisplay,
 740                                                    icon->priv->selection_atom);
 741
 742   if (icon->priv->manager_window != None)
 743     XSelectInput (xdisplay,
 744                   icon->priv->manager_window, StructureNotifyMask|PropertyChangeMask);
 745
 746   XUngrabServer (xdisplay);
 747   XFlush (xdisplay);
 748
 749   if (icon->priv->manager_window != None)
 750     {
 751       GdkWindow *gdkwin;
 752
 753       GTK_NOTE (PLUGSOCKET,
 754                 g_print ("GtkStatusIcon %p: is being managed by window %lx\n",
 755                                 icon, (gulong) icon->priv->manager_window));
 756
 757       gdkwin = gdk_window_lookup_for_display (display,
 758                                               icon->priv->manager_window);
 759
 760       gdk_window_add_filter (gdkwin, gtk_tray_icon_manager_filter, icon);
 761
 762       gtk_tray_icon_get_orientation_property (icon);
 763       gtk_tray_icon_get_visual_property (icon);
 764       gtk_tray_icon_get_colors_property (icon);
 765       gtk_tray_icon_get_padding_property (icon);
 766
 767       if (gtk_widget_get_realized (GTK_WIDGET (icon)))
 768         {
 769           if ((icon->priv->manager_visual == NULL &&
 770                gtk_widget_get_visual (widget) == gdk_screen_get_system_visual (screen)) ||
 771               (icon->priv->manager_visual == gtk_widget_get_visual (widget)))
 772             {
 773               /* Already have the right visual, can just dock
 774                */
 775               gtk_tray_icon_send_dock_request (icon);
 776             }
 777           else
 778             {
 779               /* Need to re-realize the widget to get the right visual
 780                */
 781               gtk_widget_hide (widget);
 782               gtk_widget_unrealize (widget);
 783               gtk_widget_show (widget);
 784             }
 785         }
 786     }
 787   else
 788     GTK_NOTE (PLUGSOCKET,
 789               g_print ("GtkStatusIcon %p: no tray manager found\n", icon));
 790 }
 791
 792 static void
 793 gtk_tray_icon_manager_window_destroyed (GtkTrayIcon *icon)
 794 {
 795   g_return_if_fail (icon->priv->manager_window != None);
 796
 797   GTK_NOTE (PLUGSOCKET,
 798             g_print ("GtkStatusIcon %p: tray manager window destroyed\n", icon));
 799
 800   gtk_tray_icon_clear_manager_window (icon);
 801 }
 802
 803 static gboolean
 804 gtk_tray_icon_delete (GtkWidget   *widget,
 805                       GdkEventAny *event)
 806 {
 807 #ifdef G_ENABLE_DEBUG
 808   GtkTrayIcon *icon = GTK_TRAY_ICON (widget);
 809 #endif
 810
 811   GTK_NOTE (PLUGSOCKET,
 812             g_print ("GtkStatusIcon %p: delete notify, tray manager window %lx\n",
 813                      icon, (gulong) icon->priv->manager_window));
 814
 815   /* A bug in X server versions up to x.org 1.5.0 means that:
 816    * XFixesChangeSaveSet(...., SaveSetRoot, SaveSetUnmap) doesn't work properly
 817    * and we'll left mapped in a separate toplevel window if the tray is destroyed.
 818    * For simplicity just get rid of our X window and start over.
 819    */
 820   gtk_widget_hide (widget);
 821   gtk_widget_unrealize (widget);
 822   gtk_widget_show (widget);
 823
 824   /* Handled it, don't destroy the tray icon */
 825   return TRUE;
 826 }
 827
 828 static void
 829 gtk_tray_icon_set_visual (GtkTrayIcon *icon)
 830 {
 831   GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (icon));
 832   GdkVisual *visual = icon->priv->manager_visual;
 833
 834   /* To avoid uncertainty about colormaps, _NET_SYSTEM_TRAY_VISUAL is supposed
 835    * to be either the screen default visual or a TrueColor visual; ignore it
 836    * if it is something else
 837    */
 838   if (visual && visual->type != GDK_VISUAL_TRUE_COLOR)
 839     visual = NULL;
 840
 841   if (visual == NULL)
 842     visual = gdk_screen_get_system_visual (screen);
 843
 844   gtk_window_set_visual (GTK_WINDOW (icon), visual);
 845 }
 846
 847 static void
 848 gtk_tray_icon_realize (GtkWidget *widget)
 849 {
 850   GtkTrayIcon *icon = GTK_TRAY_ICON (widget);
 851   GdkWindow *window;
 852
 853   /* Set our visual before realizing */
 854   gtk_tray_icon_set_visual (icon);
 855
 856   GTK_WIDGET_CLASS (gtk_tray_icon_parent_class)->realize (widget);
 857   window = gtk_widget_get_window (widget);
 858   if (icon->priv->manager_visual_rgba)
 859     {
 860       /* Set a transparent background */
 861       GdkColor transparent = { 0, 0, 0, 0 }; /* Only pixel=0 matters */
 862       gdk_window_set_background (window, &transparent);
 863     }
 864   else
 865     {
 866       /* Set a parent-relative background pixmap */
 867       gdk_window_set_background_pattern (window, NULL);
 868     }
 869
 870   GTK_NOTE (PLUGSOCKET,
 871             g_print ("GtkStatusIcon %p: realized, window: %lx, socket window: %lx\n",
 872                      widget,
 873                      (gulong) GDK_WINDOW_XWINDOW (window),
 874                      gtk_plug_get_socket_window (GTK_PLUG (icon)) ?
 875                      (gulong) GDK_WINDOW_XWINDOW (gtk_plug_get_socket_window (GTK_PLUG (icon))) : 0UL));
 876
 877   if (icon->priv->manager_window != None)
 878     gtk_tray_icon_send_dock_request (icon);
 879 }
 880
 881 static void
 882 gtk_tray_icon_style_set (GtkWidget   *widget,
 883                          GtkStyle    *previous_style)
 884 {
 885   /* The default handler resets the background according to the style. We either
 886    * use a transparent background or a parent-relative background and ignore the
 887    * style background. So, just don't chain up.
 888    */
 889 }
 890
 891 guint
 892 _gtk_tray_icon_send_message (GtkTrayIcon *icon,
 893                              gint         timeout,
 894                              const gchar *message,
 895                              gint         len)
 896 {
 897   guint stamp;
 898   Display *xdisplay;
 899
 900   g_return_val_if_fail (GTK_IS_TRAY_ICON (icon), 0);
 901   g_return_val_if_fail (timeout >= 0, 0);
 902   g_return_val_if_fail (message != NULL, 0);
 903
 904   if (icon->priv->manager_window == None)
 905     return 0;
 906
 907   if (len < 0)
 908     len = strlen (message);
 909
 910   stamp = icon->priv->stamp++;
 911
 912   /* Get ready to send the message */
 913   gtk_tray_icon_send_manager_message (icon, SYSTEM_TRAY_BEGIN_MESSAGE,
 914                                       (Window)gtk_plug_get_id (GTK_PLUG (icon)),
 915                                       timeout, len, stamp);
 916
 917   /* Now to send the actual message */
 918   xdisplay = GDK_DISPLAY_XDISPLAY (gtk_widget_get_display (GTK_WIDGET (icon)));
 919   gdk_error_trap_push ();
 920   while (len > 0)
 921     {
 922       XClientMessageEvent ev;
 923
 924       memset (&ev, 0, sizeof (ev));
 925       ev.type = ClientMessage;
 926       ev.window = (Window)gtk_plug_get_id (GTK_PLUG (icon));
 927       ev.format = 8;
 928       ev.message_type = XInternAtom (xdisplay,
 929                                      "_NET_SYSTEM_TRAY_MESSAGE_DATA", False);
 930       if (len > 20)
 931         {
 932           memcpy (&ev.data, message, 20);
 933           len -= 20;
 934           message += 20;
 935         }
 936       else
 937         {
 938           memcpy (&ev.data, message, len);
 939           len = 0;
 940         }
 941
 942       XSendEvent (xdisplay,
 943                   icon->priv->manager_window, False,
 944                   StructureNotifyMask, (XEvent *)&ev);
 945     }
 946   gdk_error_trap_pop_ignored ();
 947
 948   return stamp;
 949 }
 950
 951 void
 952 _gtk_tray_icon_cancel_message (GtkTrayIcon *icon,
 953                                guint        id)
 954 {
 955   g_return_if_fail (GTK_IS_TRAY_ICON (icon));
 956   g_return_if_fail (id > 0);
 957
 958   gtk_tray_icon_send_manager_message (icon, SYSTEM_TRAY_CANCEL_MESSAGE,
 959                                       (Window)gtk_plug_get_id (GTK_PLUG (icon)),
 960                                       id, 0, 0);
 961 }
 962
 963 GtkTrayIcon *
 964 _gtk_tray_icon_new_for_screen (GdkScreen  *screen,
 965                                const gchar *name)
 966 {
 967   g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
 968
 969   return g_object_new (GTK_TYPE_TRAY_ICON,
 970                        "screen", screen,
 971                        "title", name,
 972                        NULL);
 973 }
 974
 975 GtkTrayIcon*
 976 _gtk_tray_icon_new (const gchar *name)
 977 {
 978   return g_object_new (GTK_TYPE_TRAY_ICON,
 979                        "title", name,
 980                        NULL);
 981 }
 982
 983 GtkOrientation
 984 _gtk_tray_icon_get_orientation (GtkTrayIcon *icon)
 985 {
 986   g_return_val_if_fail (GTK_IS_TRAY_ICON (icon), GTK_ORIENTATION_HORIZONTAL);
 987
 988   return icon->priv->orientation;
 989 }
 990
 991 gint
 992 _gtk_tray_icon_get_padding (GtkTrayIcon *icon)
 993 {
 994   g_return_val_if_fail (GTK_IS_TRAY_ICON (icon), 0);
 995
 996   return icon->priv->padding;
 997 }