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