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