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