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 "gtkalias.h"
  33
  34 #include "x11/gdkx.h"
  35 #include <X11/Xatom.h>
  36
  37 #define SYSTEM_TRAY_REQUEST_DOCK    0
  38 #define SYSTEM_TRAY_BEGIN_MESSAGE   1
  39 #define SYSTEM_TRAY_CANCEL_MESSAGE  2
  40
  41 #define SYSTEM_TRAY_ORIENTATION_HORZ 0
  42 #define SYSTEM_TRAY_ORIENTATION_VERT 1
  43
  44 enum {
  45   PROP_0,
  46   PROP_ORIENTATION
  47 };
  48
  49 struct _GtkTrayIconPrivate
  50 {
  51   guint stamp;
  52
  53   Atom selection_atom;
  54   Atom manager_atom;
  55   Atom system_tray_opcode_atom;
  56   Atom orientation_atom;
  57   Atom visual_atom;
  58   Window manager_window;
  59   GdkVisual *manager_visual;
  60   gboolean manager_visual_rgba;
  61
  62   GtkOrientation orientation;
  63 };
  64
  65 static void gtk_tray_icon_constructed   (GObject     *object);
  66 static void gtk_tray_icon_dispose       (GObject     *object);
  67
  68 static void gtk_tray_icon_get_property  (GObject     *object,
  69                                          guint        prop_id,
  70                                          GValue      *value,
  71                                          GParamSpec  *pspec);
  72
  73 static void     gtk_tray_icon_realize   (GtkWidget   *widget);
  74 static void     gtk_tray_icon_style_set (GtkWidget   *widget,
  75                                          GtkStyle    *previous_style);
  76 static gboolean gtk_tray_icon_delete    (GtkWidget   *widget,
  77                                          GdkEventAny *event);
  78 static gboolean gtk_tray_icon_expose    (GtkWidget      *widget,
  79                                          GdkEventExpose *event);
  80
  81 static void gtk_tray_icon_clear_manager_window     (GtkTrayIcon *icon);
  82 static void gtk_tray_icon_update_manager_window    (GtkTrayIcon *icon);
  83 static void gtk_tray_icon_manager_window_destroyed (GtkTrayIcon *icon);
  84
  85 static GdkFilterReturn gtk_tray_icon_manager_filter (GdkXEvent *xevent,
  86                                                      GdkEvent  *event,
  87                                                      gpointer   user_data);
  88
  89
  90 G_DEFINE_TYPE (GtkTrayIcon, gtk_tray_icon, GTK_TYPE_PLUG)
  91
  92 static void
  93 gtk_tray_icon_class_init (GtkTrayIconClass *class)
  94 {
  95   GObjectClass *gobject_class = (GObjectClass *)class;
  96   GtkWidgetClass *widget_class = (GtkWidgetClass *)class;
  97
  98   gobject_class->get_property = gtk_tray_icon_get_property;
  99   gobject_class->constructed = gtk_tray_icon_constructed;
 100   gobject_class->dispose = gtk_tray_icon_dispose;
 101
 102   widget_class->realize = gtk_tray_icon_realize;
 103   widget_class->style_set = gtk_tray_icon_style_set;
 104   widget_class->delete_event = gtk_tray_icon_delete;
 105   widget_class->expose_event = gtk_tray_icon_expose;
 106
 107   g_object_class_install_property (gobject_class,
 108                                    PROP_ORIENTATION,
 109                                    g_param_spec_enum ("orientation",
 110                                                       P_("Orientation"),
 111                                                       P_("The orientation of the tray"),
 112                                                       GTK_TYPE_ORIENTATION,
 113                                                       GTK_ORIENTATION_HORIZONTAL,
 114                                                       GTK_PARAM_READABLE));
 115
 116   g_type_class_add_private (class, sizeof (GtkTrayIconPrivate));
 117 }
 118
 119 static void
 120 gtk_tray_icon_init (GtkTrayIcon *icon)
 121 {
 122   icon->priv = G_TYPE_INSTANCE_GET_PRIVATE (icon, GTK_TYPE_TRAY_ICON,
 123                                             GtkTrayIconPrivate);
 124
 125   icon->priv->stamp = 1;
 126   icon->priv->orientation = GTK_ORIENTATION_HORIZONTAL;
 127
 128   gtk_widget_set_app_paintable (GTK_WIDGET (icon), TRUE);
 129   gtk_widget_add_events (GTK_WIDGET (icon), GDK_PROPERTY_CHANGE_MASK);
 130 }
 131
 132 static void
 133 gtk_tray_icon_constructed (GObject *object)
 134 {
 135   /* Do setup that depends on the screen; screen has been set at this point */
 136
 137   GtkTrayIcon *icon = GTK_TRAY_ICON (object);
 138   GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (object));
 139   GdkWindow *root_window = gdk_screen_get_root_window (screen);
 140   GdkDisplay *display = gtk_widget_get_display (GTK_WIDGET (object));
 141   Display *xdisplay = gdk_x11_display_get_xdisplay (display);
 142   char buffer[256];
 143
 144   g_snprintf (buffer, sizeof (buffer),
 145               "_NET_SYSTEM_TRAY_S%d",
 146               gdk_screen_get_number (screen));
 147
 148   icon->priv->selection_atom = XInternAtom (xdisplay, buffer, False);
 149
 150   icon->priv->manager_atom = XInternAtom (xdisplay, "MANAGER", False);
 151
 152   icon->priv->system_tray_opcode_atom = XInternAtom (xdisplay,
 153                                                      "_NET_SYSTEM_TRAY_OPCODE",
 154                                                      False);
 155
 156   icon->priv->orientation_atom = XInternAtom (xdisplay,
 157                                               "_NET_SYSTEM_TRAY_ORIENTATION",
 158                                               False);
 159
 160   icon->priv->visual_atom = XInternAtom (xdisplay,
 161                                          "_NET_SYSTEM_TRAY_VISUAL",
 162                                          False);
 163
 164   /* Add a root window filter so that we get changes on MANAGER */
 165   gdk_window_add_filter (root_window,
 166                          gtk_tray_icon_manager_filter, icon);
 167
 168   gtk_tray_icon_update_manager_window (icon);
 169 }
 170
 171 static void
 172 gtk_tray_icon_clear_manager_window (GtkTrayIcon *icon)
 173 {
 174   GdkDisplay *display = gtk_widget_get_display (GTK_WIDGET (icon));
 175
 176   if (icon->priv->manager_window != None)
 177     {
 178       GdkWindow *gdkwin;
 179
 180       gdkwin = gdk_window_lookup_for_display (display,
 181                                               icon->priv->manager_window);
 182
 183       gdk_window_remove_filter (gdkwin, gtk_tray_icon_manager_filter, icon);
 184
 185       icon->priv->manager_window = None;
 186       icon->priv->manager_visual = NULL;
 187     }
 188 }
 189
 190 static void
 191 gtk_tray_icon_dispose (GObject *object)
 192 {
 193   GtkTrayIcon *icon = GTK_TRAY_ICON (object);
 194   GtkWidget *widget = GTK_WIDGET (object);
 195   GdkWindow *root_window = gdk_screen_get_root_window (gtk_widget_get_screen (widget));
 196
 197   gtk_tray_icon_clear_manager_window (icon);
 198
 199   gdk_window_remove_filter (root_window, gtk_tray_icon_manager_filter, icon);
 200 }
 201
 202 static void
 203 gtk_tray_icon_get_property (GObject    *object,
 204                             guint       prop_id,
 205                             GValue     *value,
 206                             GParamSpec *pspec)
 207 {
 208   GtkTrayIcon *icon = GTK_TRAY_ICON (object);
 209
 210   switch (prop_id)
 211     {
 212     case PROP_ORIENTATION:
 213       g_value_set_enum (value, icon->priv->orientation);
 214       break;
 215     default:
 216       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 217       break;
 218     }
 219 }
 220
 221 static gboolean
 222 gtk_tray_icon_expose (GtkWidget      *widget,
 223                       GdkEventExpose *event)
 224 {
 225   GtkTrayIcon *icon = GTK_TRAY_ICON (widget);
 226   GtkWidget *focus_child;
 227   gint border_width, x, y, width, height;
 228   gboolean retval = FALSE;
 229
 230   if (icon->priv->manager_visual_rgba)
 231     {
 232       /* Clear to transparent */
 233       cairo_t *cr = gdk_cairo_create (widget->window);
 234       cairo_set_source_rgba (cr, 0, 0, 0, 0);
 235       cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
 236       gdk_cairo_region (cr, event->region);
 237       cairo_fill (cr);
 238       cairo_destroy (cr);
 239     }
 240   else
 241     {
 242       /* Clear to parent-relative pixmap */
 243       gdk_window_clear_area (widget->window, event->area.x, event->area.y,
 244                              event->area.width, event->area.height);
 245     }
 246
 247   if (GTK_WIDGET_CLASS (gtk_tray_icon_parent_class)->expose_event)
 248     retval = GTK_WIDGET_CLASS (gtk_tray_icon_parent_class)->expose_event (widget, event);
 249
 250   focus_child = GTK_CONTAINER (widget)->focus_child;
 251   if (focus_child && gtk_widget_has_focus (focus_child))
 252     {
 253       border_width = GTK_CONTAINER (widget)->border_width;
 254
 255       x = widget->allocation.x + border_width;
 256       y = widget->allocation.y + border_width;
 257
 258       width  = widget->allocation.width  - 2 * border_width;
 259       height = widget->allocation.height - 2 * border_width;
 260
 261       gtk_paint_focus (widget->style, widget->window,
 262                        gtk_widget_get_state (widget),
 263                        &event->area, widget, "tray_icon",
 264                        x, y, width, height);
 265     }
 266
 267   return retval;
 268 }
 269
 270 static void
 271 gtk_tray_icon_get_orientation_property (GtkTrayIcon *icon)
 272 {
 273   GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (icon));
 274   GdkDisplay *display = gdk_screen_get_display (screen);
 275   Display *xdisplay = GDK_DISPLAY_XDISPLAY (display);
 276
 277   Atom type;
 278   int format;
 279   union {
 280         gulong *prop;
 281         guchar *prop_ch;
 282   } prop = { NULL };
 283   gulong nitems;
 284   gulong bytes_after;
 285   int error, result;
 286
 287   g_assert (icon->priv->manager_window != None);
 288
 289   gdk_error_trap_push ();
 290   type = None;
 291   result = XGetWindowProperty (xdisplay,
 292                                icon->priv->manager_window,
 293                                icon->priv->orientation_atom,
 294                                0, G_MAXLONG, FALSE,
 295                                XA_CARDINAL,
 296                                &type, &format, &nitems,
 297                                &bytes_after, &(prop.prop_ch));
 298   error = gdk_error_trap_pop ();
 299
 300   if (error || result != Success)
 301     return;
 302
 303   if (type == XA_CARDINAL && nitems == 1 && format == 32)
 304     {
 305       GtkOrientation orientation;
 306
 307       orientation = (prop.prop [0] == SYSTEM_TRAY_ORIENTATION_HORZ) ?
 308                                         GTK_ORIENTATION_HORIZONTAL :
 309                                         GTK_ORIENTATION_VERTICAL;
 310
 311       if (icon->priv->orientation != orientation)
 312         {
 313           icon->priv->orientation = orientation;
 314
 315           g_object_notify (G_OBJECT (icon), "orientation");
 316         }
 317     }
 318
 319   if (type != None)
 320     XFree (prop.prop);
 321 }
 322
 323 static void
 324 gtk_tray_icon_get_visual_property (GtkTrayIcon *icon)
 325 {
 326   GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (icon));
 327   GdkDisplay *display = gdk_screen_get_display (screen);
 328   Display *xdisplay = GDK_DISPLAY_XDISPLAY (display);
 329
 330   Atom type;
 331   int format;
 332   union {
 333         gulong *prop;
 334         guchar *prop_ch;
 335   } prop = { NULL };
 336   gulong nitems;
 337   gulong bytes_after;
 338   int error, result;
 339   GdkVisual *visual;
 340
 341   g_assert (icon->priv->manager_window != None);
 342
 343   gdk_error_trap_push ();
 344   type = None;
 345   result = XGetWindowProperty (xdisplay,
 346                                icon->priv->manager_window,
 347                                icon->priv->visual_atom,
 348                                0, G_MAXLONG, FALSE,
 349                                XA_VISUALID,
 350                                &type, &format, &nitems,
 351                                &bytes_after, &(prop.prop_ch));
 352   error = gdk_error_trap_pop ();
 353
 354   visual = NULL;
 355
 356   if (!error && result == Success &&
 357       type == XA_VISUALID && nitems == 1 && format == 32)
 358     {
 359       VisualID visual_id = prop.prop[0];
 360       visual = gdk_x11_screen_lookup_visual (screen, visual_id);
 361     }
 362
 363   icon->priv->manager_visual = visual;
 364   icon->priv->manager_visual_rgba = visual != NULL &&
 365     (visual->red_prec + visual->blue_prec + visual->green_prec < visual->depth);
 366
 367   /* For the background-relative hack we use when we aren't using a real RGBA
 368    * visual, we can't be double-buffered */
 369   gtk_widget_set_double_buffered (GTK_WIDGET (icon), icon->priv->manager_visual_rgba);
 370
 371   if (type != None)
 372     XFree (prop.prop);
 373 }
 374
 375 static GdkFilterReturn
 376 gtk_tray_icon_manager_filter (GdkXEvent *xevent,
 377                               GdkEvent  *event,
 378                               gpointer   user_data)
 379 {
 380   GtkTrayIcon *icon = user_data;
 381   XEvent *xev = (XEvent *)xevent;
 382
 383   if (xev->xany.type == ClientMessage &&
 384       xev->xclient.message_type == icon->priv->manager_atom &&
 385       xev->xclient.data.l[1] == icon->priv->selection_atom)
 386     {
 387       GTK_NOTE (PLUGSOCKET,
 388                 g_print ("GtkStatusIcon %p: tray manager appeared\n", icon));
 389
 390       gtk_tray_icon_update_manager_window (icon);
 391     }
 392   else if (xev->xany.window == icon->priv->manager_window)
 393     {
 394       if (xev->xany.type == PropertyNotify &&
 395           xev->xproperty.atom == icon->priv->orientation_atom)
 396         {
 397           GTK_NOTE (PLUGSOCKET,
 398                     g_print ("GtkStatusIcon %p: got PropertyNotify on manager window for orientation atom\n", icon));
 399
 400           gtk_tray_icon_get_orientation_property (icon);
 401         }
 402       else if (xev->xany.type == DestroyNotify)
 403         {
 404           GTK_NOTE (PLUGSOCKET,
 405                     g_print ("GtkStatusIcon %p: got DestroyNotify for manager window\n", icon));
 406
 407           gtk_tray_icon_manager_window_destroyed (icon);
 408         }
 409       else
 410         GTK_NOTE (PLUGSOCKET,
 411                   g_print ("GtkStatusIcon %p: got other message on manager window\n", icon));
 412     }
 413
 414   return GDK_FILTER_CONTINUE;
 415 }
 416
 417 static void
 418 gtk_tray_icon_send_manager_message (GtkTrayIcon *icon,
 419                                     long         message,
 420                                     Window       window,
 421                                     long         data1,
 422                                     long         data2,
 423                                     long         data3)
 424 {
 425   XClientMessageEvent ev;
 426   Display *display;
 427
 428   memset (&ev, 0, sizeof (ev));
 429   ev.type = ClientMessage;
 430   ev.window = window;
 431   ev.message_type = icon->priv->system_tray_opcode_atom;
 432   ev.format = 32;
 433   ev.data.l[0] = gdk_x11_get_server_time (GTK_WIDGET (icon)->window);
 434   ev.data.l[1] = message;
 435   ev.data.l[2] = data1;
 436   ev.data.l[3] = data2;
 437   ev.data.l[4] = data3;
 438
 439   display = GDK_DISPLAY_XDISPLAY (gtk_widget_get_display (GTK_WIDGET (icon)));
 440
 441   gdk_error_trap_push ();
 442   XSendEvent (display,
 443               icon->priv->manager_window, False, NoEventMask, (XEvent *)&ev);
 444   gdk_display_sync (gtk_widget_get_display (GTK_WIDGET (icon)));
 445   gdk_error_trap_pop ();
 446 }
 447
 448 static void
 449 gtk_tray_icon_send_dock_request (GtkTrayIcon *icon)
 450 {
 451   GTK_NOTE (PLUGSOCKET,
 452             g_print ("GtkStatusIcon %p: sending dock request to manager window %lx\n",
 453                      icon, (gulong) icon->priv->manager_window));
 454
 455   gtk_tray_icon_send_manager_message (icon,
 456                                       SYSTEM_TRAY_REQUEST_DOCK,
 457                                       icon->priv->manager_window,
 458                                       gtk_plug_get_id (GTK_PLUG (icon)),
 459                                       0, 0);
 460 }
 461
 462 static void
 463 gtk_tray_icon_update_manager_window (GtkTrayIcon *icon)
 464 {
 465   GtkWidget *widget = GTK_WIDGET (icon);
 466   GdkScreen *screen = gtk_widget_get_screen (widget);
 467   GdkDisplay *display = gdk_screen_get_display (screen);
 468   Display *xdisplay = GDK_DISPLAY_XDISPLAY (display);
 469
 470   GTK_NOTE (PLUGSOCKET,
 471             g_print ("GtkStatusIcon %p: updating tray icon manager window, current manager window: %lx\n",
 472                      icon, (gulong) icon->priv->manager_window));
 473
 474   if (icon->priv->manager_window != None)
 475     return;
 476
 477   GTK_NOTE (PLUGSOCKET,
 478             g_print ("GtkStatusIcon %p: trying to find manager window\n", icon));
 479
 480   XGrabServer (xdisplay);
 481
 482   icon->priv->manager_window = XGetSelectionOwner (xdisplay,
 483                                                    icon->priv->selection_atom);
 484
 485   if (icon->priv->manager_window != None)
 486     XSelectInput (xdisplay,
 487                   icon->priv->manager_window, StructureNotifyMask|PropertyChangeMask);
 488
 489   XUngrabServer (xdisplay);
 490   XFlush (xdisplay);
 491
 492   if (icon->priv->manager_window != None)
 493     {
 494       GdkWindow *gdkwin;
 495
 496       GTK_NOTE (PLUGSOCKET,
 497                 g_print ("GtkStatusIcon %p: is being managed by window %lx\n",
 498                                 icon, (gulong) icon->priv->manager_window));
 499
 500       gdkwin = gdk_window_lookup_for_display (display,
 501                                               icon->priv->manager_window);
 502
 503       gdk_window_add_filter (gdkwin, gtk_tray_icon_manager_filter, icon);
 504
 505       gtk_tray_icon_get_orientation_property (icon);
 506       gtk_tray_icon_get_visual_property (icon);
 507
 508       if (gtk_widget_get_realized (GTK_WIDGET (icon)))
 509         {
 510           if ((icon->priv->manager_visual == NULL &&
 511                gtk_widget_get_visual (widget) == gdk_screen_get_system_visual (screen)) ||
 512               (icon->priv->manager_visual == gtk_widget_get_visual (widget)))
 513             {
 514               /* Already have the right visual, can just dock
 515                */
 516               gtk_tray_icon_send_dock_request (icon);
 517             }
 518           else
 519             {
 520               /* Need to re-realize the widget to get the right visual
 521                */
 522               gtk_widget_hide (widget);
 523               gtk_widget_unrealize (widget);
 524               gtk_widget_show (widget);
 525             }
 526         }
 527     }
 528   else
 529     GTK_NOTE (PLUGSOCKET,
 530               g_print ("GtkStatusIcon %p: no tray manager found\n", icon));
 531 }
 532
 533 static void
 534 gtk_tray_icon_manager_window_destroyed (GtkTrayIcon *icon)
 535 {
 536   g_return_if_fail (icon->priv->manager_window != None);
 537
 538   GTK_NOTE (PLUGSOCKET,
 539             g_print ("GtkStatusIcon %p: tray manager window destroyed\n", icon));
 540
 541   gtk_tray_icon_clear_manager_window (icon);
 542 }
 543
 544 static gboolean
 545 gtk_tray_icon_delete (GtkWidget   *widget,
 546                       GdkEventAny *event)
 547 {
 548 #ifdef G_ENABLE_DEBUG
 549   GtkTrayIcon *icon = GTK_TRAY_ICON (widget);
 550 #endif
 551
 552   GTK_NOTE (PLUGSOCKET,
 553             g_print ("GtkStatusIcon %p: delete notify, tray manager window %lx\n",
 554                      icon, (gulong) icon->priv->manager_window));
 555
 556   /* A bug in X server versions up to x.org 1.5.0 means that:
 557    * XFixesChangeSaveSet(...., SaveSetRoot, SaveSetUnmap) doesn't work properly
 558    * and we'll left mapped in a separate toplevel window if the tray is destroyed.
 559    * For simplicity just get rid of our X window and start over.
 560    */
 561   gtk_widget_hide (widget);
 562   gtk_widget_unrealize (widget);
 563   gtk_widget_show (widget);
 564
 565   /* Handled it, don't destroy the tray icon */
 566   return TRUE;
 567 }
 568
 569 static void
 570 gtk_tray_icon_set_colormap (GtkTrayIcon *icon)
 571 {
 572   GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (icon));
 573   GdkColormap *colormap;
 574   GdkVisual *visual = icon->priv->manager_visual;
 575   gboolean new_colormap = FALSE;
 576
 577   /* To avoid uncertainty about colormaps, _NET_SYSTEM_TRAY_VISUAL is supposed
 578    * to be either the screen default visual or a TrueColor visual; ignore it
 579    * if it is something else
 580    */
 581   if (visual && visual->type != GDK_VISUAL_TRUE_COLOR)
 582     visual = NULL;
 583
 584   if (visual == NULL || visual == gdk_screen_get_system_visual (screen))
 585     colormap = gdk_screen_get_system_colormap (screen);
 586   else if (visual == gdk_screen_get_rgb_visual (screen))
 587     colormap = gdk_screen_get_rgb_colormap (screen);
 588   else if (visual == gdk_screen_get_rgba_visual (screen))
 589     colormap = gdk_screen_get_rgba_colormap (screen);
 590   else
 591     {
 592       colormap = gdk_colormap_new (visual, FALSE);
 593       new_colormap = TRUE;
 594     }
 595
 596   gtk_widget_set_colormap (GTK_WIDGET (icon), colormap);
 597
 598   if (new_colormap)
 599     g_object_unref (colormap);
 600 }
 601
 602 static void
 603 gtk_tray_icon_realize (GtkWidget *widget)
 604 {
 605   GtkTrayIcon *icon = GTK_TRAY_ICON (widget);
 606
 607   /* Set our colormap before realizing */
 608   gtk_tray_icon_set_colormap (icon);
 609
 610   GTK_WIDGET_CLASS (gtk_tray_icon_parent_class)->realize (widget);
 611   if (icon->priv->manager_visual_rgba)
 612     {
 613       /* Set a transparent background */
 614       GdkColor transparent = { 0, 0, 0, 0 }; /* Only pixel=0 matters */
 615       gdk_window_set_background (widget->window, &transparent);
 616     }
 617   else
 618     {
 619       /* Set a parent-relative background pixmap */
 620       gdk_window_set_back_pixmap (widget->window, NULL, TRUE);
 621     }
 622
 623   GTK_NOTE (PLUGSOCKET,
 624             g_print ("GtkStatusIcon %p: realized, window: %lx, socket window: %lx\n",
 625                      widget,
 626                      (gulong) GDK_WINDOW_XWINDOW (widget->window),
 627                      GTK_PLUG (icon)->socket_window ?
 628                              (gulong) GDK_WINDOW_XWINDOW (GTK_PLUG (icon)->socket_window) : 0UL));
 629
 630   if (icon->priv->manager_window != None)
 631     gtk_tray_icon_send_dock_request (icon);
 632 }
 633
 634 static void
 635 gtk_tray_icon_style_set (GtkWidget   *widget,
 636                          GtkStyle    *previous_style)
 637 {
 638   /* The default handler resets the background according to the style. We either
 639    * use a transparent background or a parent-relative background and ignore the
 640    * style background. So, just don't chain up.
 641    */
 642 }
 643
 644 guint
 645 _gtk_tray_icon_send_message (GtkTrayIcon *icon,
 646                              gint         timeout,
 647                              const gchar *message,
 648                              gint         len)
 649 {
 650   guint stamp;
 651   Display *xdisplay;
 652
 653   g_return_val_if_fail (GTK_IS_TRAY_ICON (icon), 0);
 654   g_return_val_if_fail (timeout >= 0, 0);
 655   g_return_val_if_fail (message != NULL, 0);
 656
 657   if (icon->priv->manager_window == None)
 658     return 0;
 659
 660   if (len < 0)
 661     len = strlen (message);
 662
 663   stamp = icon->priv->stamp++;
 664
 665   /* Get ready to send the message */
 666   gtk_tray_icon_send_manager_message (icon, SYSTEM_TRAY_BEGIN_MESSAGE,
 667                                       (Window)gtk_plug_get_id (GTK_PLUG (icon)),
 668                                       timeout, len, stamp);
 669
 670   /* Now to send the actual message */
 671   xdisplay = GDK_DISPLAY_XDISPLAY (gtk_widget_get_display (GTK_WIDGET (icon)));
 672   gdk_error_trap_push ();
 673   while (len > 0)
 674     {
 675       XClientMessageEvent ev;
 676
 677       memset (&ev, 0, sizeof (ev));
 678       ev.type = ClientMessage;
 679       ev.window = (Window)gtk_plug_get_id (GTK_PLUG (icon));
 680       ev.format = 8;
 681       ev.message_type = XInternAtom (xdisplay,
 682                                      "_NET_SYSTEM_TRAY_MESSAGE_DATA", False);
 683       if (len > 20)
 684         {
 685           memcpy (&ev.data, message, 20);
 686           len -= 20;
 687           message += 20;
 688         }
 689       else
 690         {
 691           memcpy (&ev.data, message, len);
 692           len = 0;
 693         }
 694
 695       XSendEvent (xdisplay,
 696                   icon->priv->manager_window, False,
 697                   StructureNotifyMask, (XEvent *)&ev);
 698     }
 699   gdk_display_sync (gtk_widget_get_display (GTK_WIDGET (icon)));
 700   gdk_error_trap_pop ();
 701
 702   return stamp;
 703 }
 704
 705 void
 706 _gtk_tray_icon_cancel_message (GtkTrayIcon *icon,
 707                                guint        id)
 708 {
 709   g_return_if_fail (GTK_IS_TRAY_ICON (icon));
 710   g_return_if_fail (id > 0);
 711
 712   gtk_tray_icon_send_manager_message (icon, SYSTEM_TRAY_CANCEL_MESSAGE,
 713                                       (Window)gtk_plug_get_id (GTK_PLUG (icon)),
 714                                       id, 0, 0);
 715 }
 716
 717 GtkTrayIcon *
 718 _gtk_tray_icon_new_for_screen (GdkScreen  *screen,
 719                                const gchar *name)
 720 {
 721   g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
 722
 723   return g_object_new (GTK_TYPE_TRAY_ICON,
 724                        "screen", screen,
 725                        "title", name,
 726                        NULL);
 727 }
 728
 729 GtkTrayIcon*
 730 _gtk_tray_icon_new (const gchar *name)
 731 {
 732   return g_object_new (GTK_TYPE_TRAY_ICON,
 733                        "title", name,
 734                        NULL);
 735 }
 736
 737 GtkOrientation
 738 _gtk_tray_icon_get_orientation (GtkTrayIcon *icon)
 739 {
 740   g_return_val_if_fail (GTK_IS_TRAY_ICON (icon), GTK_ORIENTATION_HORIZONTAL);
 741
 742   return icon->priv->orientation;
 743 }
 744
 745
 746 #define __GTK_TRAY_ICON_X11_C__
 747 #include "gtkaliasdef.c"
 748