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

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