glue/eggtrayicon.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /* eggtrayicon.c
   3  * Copyright (C) 2002 Anders Carlsson <andersca@gnu.org>
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20
  21 #include <config.h>
  22 #include <string.h>
  23 #include <libintl.h>
  24
  25 #include "eggtrayicon.h"
  26
  27 #include <gdkconfig.h>
  28 #if defined (GDK_WINDOWING_X11)
  29 #include <gdk/gdkx.h>
  30 #include <X11/Xatom.h>
  31 #elif defined (GDK_WINDOWING_WIN32)
  32 #include <gdk/gdkwin32.h>
  33 #endif
  34
  35 #ifndef EGG_COMPILATION
  36 #ifndef _
  37 #define _(x) dgettext (GETTEXT_PACKAGE, x)
  38 #define N_(x) x
  39 #endif
  40 #else
  41 #define _(x) x
  42 #define N_(x) x
  43 #endif
  44
  45 #define SYSTEM_TRAY_REQUEST_DOCK    0
  46 #define SYSTEM_TRAY_BEGIN_MESSAGE   1
  47 #define SYSTEM_TRAY_CANCEL_MESSAGE  2
  48
  49 #define SYSTEM_TRAY_ORIENTATION_HORZ 0
  50 #define SYSTEM_TRAY_ORIENTATION_VERT 1
  51
  52 enum {
  53   PROP_0,
  54   PROP_ORIENTATION
  55 };
  56
  57 static GtkPlugClass *parent_class = NULL;
  58
  59 static void egg_tray_icon_init (EggTrayIcon *icon);
  60 static void egg_tray_icon_class_init (EggTrayIconClass *klass);
  61
  62 static void egg_tray_icon_get_property (GObject    *object,
  63                                         guint       prop_id,
  64                                         GValue     *value,
  65                                         GParamSpec *pspec);
  66
  67 static void egg_tray_icon_realize   (GtkWidget *widget);
  68 static void egg_tray_icon_unrealize (GtkWidget *widget);
  69
  70 #ifdef GDK_WINDOWING_X11
  71 static void egg_tray_icon_update_manager_window    (EggTrayIcon *icon,
  72                                                     gboolean     dock_if_realized);
  73 static void egg_tray_icon_manager_window_destroyed (EggTrayIcon *icon);
  74 #endif
  75
  76 GType
  77 egg_tray_icon_get_type (void)
  78 {
  79   static GType our_type = 0;
  80
  81   if (our_type == 0)
  82     {
  83       static const GTypeInfo our_info =
  84       {
  85         sizeof (EggTrayIconClass),
  86         (GBaseInitFunc) NULL,
  87         (GBaseFinalizeFunc) NULL,
  88         (GClassInitFunc) egg_tray_icon_class_init,
  89         NULL, /* class_finalize */
  90         NULL, /* class_data */
  91         sizeof (EggTrayIcon),
  92         0,    /* n_preallocs */
  93         (GInstanceInitFunc) egg_tray_icon_init
  94       };
  95
  96       our_type = g_type_register_static (GTK_TYPE_PLUG, "EggTrayIcon", &our_info, 0);
  97     }
  98
  99   return our_type;
 100 }
 101
 102 static void
 103 egg_tray_icon_init (EggTrayIcon *icon)
 104 {
 105   icon->stamp = 1;
 106   icon->orientation = GTK_ORIENTATION_HORIZONTAL;
 107
 108   gtk_widget_add_events (GTK_WIDGET (icon), GDK_PROPERTY_CHANGE_MASK);
 109 }
 110
 111 static void
 112 egg_tray_icon_class_init (EggTrayIconClass *klass)
 113 {
 114   GObjectClass *gobject_class = (GObjectClass *)klass;
 115   GtkWidgetClass *widget_class = (GtkWidgetClass *)klass;
 116
 117   parent_class = g_type_class_peek_parent (klass);
 118
 119   gobject_class->get_property = egg_tray_icon_get_property;
 120
 121   widget_class->realize   = egg_tray_icon_realize;
 122   widget_class->unrealize = egg_tray_icon_unrealize;
 123
 124   g_object_class_install_property (gobject_class,
 125                                    PROP_ORIENTATION,
 126                                    g_param_spec_enum ("orientation",
 127                                                       _("Orientation"),
 128                                                       _("The orientation of the tray."),
 129                                                       GTK_TYPE_ORIENTATION,
 130                                                       GTK_ORIENTATION_HORIZONTAL,
 131                                                       G_PARAM_READABLE));
 132
 133 #if defined (GDK_WINDOWING_X11)
 134   /* Nothing */
 135 #elif defined (GDK_WINDOWING_WIN32)
 136   g_warning ("Port eggtrayicon to Win32");
 137 #else
 138   g_warning ("Port eggtrayicon to this GTK+ backend");
 139 #endif
 140 }
 141
 142 static void
 143 egg_tray_icon_get_property (GObject    *object,
 144                             guint       prop_id,
 145                             GValue     *value,
 146                             GParamSpec *pspec)
 147 {
 148   EggTrayIcon *icon = EGG_TRAY_ICON (object);
 149
 150   switch (prop_id)
 151     {
 152     case PROP_ORIENTATION:
 153       g_value_set_enum (value, icon->orientation);
 154       break;
 155     default:
 156       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 157       break;
 158     }
 159 }
 160
 161 #ifdef GDK_WINDOWING_X11
 162
 163 static void
 164 egg_tray_icon_get_orientation_property (EggTrayIcon *icon)
 165 {
 166   Display *xdisplay;
 167   Atom type;
 168   int format;
 169   union {
 170         gulong *prop;
 171         guchar *prop_ch;
 172   } prop = { NULL };
 173   gulong nitems;
 174   gulong bytes_after;
 175   int error, result;
 176
 177   g_assert (icon->manager_window != None);
 178
 179   xdisplay = GDK_DISPLAY_XDISPLAY (gtk_widget_get_display (GTK_WIDGET (icon)));
 180
 181   gdk_error_trap_push ();
 182   type = None;
 183   result = XGetWindowProperty (xdisplay,
 184                                icon->manager_window,
 185                                icon->orientation_atom,
 186                                0, G_MAXLONG, FALSE,
 187                                XA_CARDINAL,
 188                                &type, &format, &nitems,
 189                                &bytes_after, &(prop.prop_ch));
 190   error = gdk_error_trap_pop ();
 191
 192   if (error || result != Success)
 193     return;
 194
 195   if (type == XA_CARDINAL)
 196     {
 197       GtkOrientation orientation;
 198
 199       orientation = (prop.prop [0] == SYSTEM_TRAY_ORIENTATION_HORZ) ?
 200                                         GTK_ORIENTATION_HORIZONTAL :
 201                                         GTK_ORIENTATION_VERTICAL;
 202
 203       if (icon->orientation != orientation)
 204         {
 205           icon->orientation = orientation;
 206
 207           g_object_notify (G_OBJECT (icon), "orientation");
 208         }
 209     }
 210
 211   if (prop.prop)
 212     XFree (prop.prop);
 213 }
 214
 215 static GdkFilterReturn
 216 egg_tray_icon_manager_filter (GdkXEvent *xevent, GdkEvent *event, gpointer user_data)
 217 {
 218   EggTrayIcon *icon = user_data;
 219   XEvent *xev = (XEvent *)xevent;
 220
 221   if (xev->xany.type == ClientMessage &&
 222       xev->xclient.message_type == icon->manager_atom &&
 223       xev->xclient.data.l[1] == icon->selection_atom)
 224     {
 225       egg_tray_icon_update_manager_window (icon, TRUE);
 226     }
 227   else if (xev->xany.window == icon->manager_window)
 228     {
 229       if (xev->xany.type == PropertyNotify &&
 230           xev->xproperty.atom == icon->orientation_atom)
 231         {
 232           egg_tray_icon_get_orientation_property (icon);
 233         }
 234       if (xev->xany.type == DestroyNotify)
 235         {
 236           egg_tray_icon_manager_window_destroyed (icon);
 237         }
 238     }
 239   return GDK_FILTER_CONTINUE;
 240 }
 241
 242 #endif
 243
 244 static void
 245 egg_tray_icon_unrealize (GtkWidget *widget)
 246 {
 247 #ifdef GDK_WINDOWING_X11
 248   EggTrayIcon *icon = EGG_TRAY_ICON (widget);
 249   GdkWindow *root_window;
 250
 251   if (icon->manager_window != None)
 252     {
 253       GdkWindow *gdkwin;
 254
 255       gdkwin = gdk_window_lookup_for_display (gtk_widget_get_display (widget),
 256                                               icon->manager_window);
 257
 258       gdk_window_remove_filter (gdkwin, egg_tray_icon_manager_filter, icon);
 259     }
 260
 261   root_window = gdk_screen_get_root_window (gtk_widget_get_screen (widget));
 262
 263   gdk_window_remove_filter (root_window, egg_tray_icon_manager_filter, icon);
 264
 265   if (GTK_WIDGET_CLASS (parent_class)->unrealize)
 266     (* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
 267 #endif
 268 }
 269
 270 #ifdef GDK_WINDOWING_X11
 271
 272 static void
 273 egg_tray_icon_send_manager_message (EggTrayIcon *icon,
 274                                     long         message,
 275                                     Window       window,
 276                                     long         data1,
 277                                     long         data2,
 278                                     long         data3)
 279 {
 280   XClientMessageEvent ev;
 281   Display *display;
 282
 283   ev.type = ClientMessage;
 284   ev.window = window;
 285   ev.message_type = icon->system_tray_opcode_atom;
 286   ev.format = 32;
 287   ev.data.l[0] = gdk_x11_get_server_time (GTK_WIDGET (icon)->window);
 288   ev.data.l[1] = message;
 289   ev.data.l[2] = data1;
 290   ev.data.l[3] = data2;
 291   ev.data.l[4] = data3;
 292
 293   display = GDK_DISPLAY_XDISPLAY (gtk_widget_get_display (GTK_WIDGET (icon)));
 294
 295   gdk_error_trap_push ();
 296   XSendEvent (display,
 297               icon->manager_window, False, NoEventMask, (XEvent *)&ev);
 298   XSync (display, False);
 299   gdk_error_trap_pop ();
 300 }
 301
 302 static void
 303 egg_tray_icon_send_dock_request (EggTrayIcon *icon)
 304 {
 305   egg_tray_icon_send_manager_message (icon,
 306                                       SYSTEM_TRAY_REQUEST_DOCK,
 307                                       icon->manager_window,
 308                                       gtk_plug_get_id (GTK_PLUG (icon)),
 309                                       0, 0);
 310 }
 311
 312 static void
 313 egg_tray_icon_update_manager_window (EggTrayIcon *icon,
 314                                      gboolean     dock_if_realized)
 315 {
 316   Display *xdisplay;
 317
 318   if (icon->manager_window != None)
 319     return;
 320
 321   xdisplay = GDK_DISPLAY_XDISPLAY (gtk_widget_get_display (GTK_WIDGET (icon)));
 322
 323   XGrabServer (xdisplay);
 324
 325   icon->manager_window = XGetSelectionOwner (xdisplay,
 326                                              icon->selection_atom);
 327
 328   if (icon->manager_window != None)
 329     XSelectInput (xdisplay,
 330                   icon->manager_window, StructureNotifyMask|PropertyChangeMask);
 331
 332   XUngrabServer (xdisplay);
 333   XFlush (xdisplay);
 334
 335   if (icon->manager_window != None)
 336     {
 337       GdkWindow *gdkwin;
 338
 339       gdkwin = gdk_window_lookup_for_display (gtk_widget_get_display (GTK_WIDGET (icon)),
 340                                               icon->manager_window);
 341
 342       gdk_window_add_filter (gdkwin, egg_tray_icon_manager_filter, icon);
 343
 344       if (dock_if_realized && GTK_WIDGET_REALIZED (icon))
 345         egg_tray_icon_send_dock_request (icon);
 346
 347       egg_tray_icon_get_orientation_property (icon);
 348     }
 349 }
 350
 351 static void
 352 egg_tray_icon_manager_window_destroyed (EggTrayIcon *icon)
 353 {
 354   GdkWindow *gdkwin;
 355
 356   g_return_if_fail (icon->manager_window != None);
 357
 358   gdkwin = gdk_window_lookup_for_display (gtk_widget_get_display (GTK_WIDGET (icon)),
 359                                           icon->manager_window);
 360
 361   gdk_window_remove_filter (gdkwin, egg_tray_icon_manager_filter, icon);
 362
 363   icon->manager_window = None;
 364
 365   egg_tray_icon_update_manager_window (icon, TRUE);
 366 }
 367
 368 #endif
 369
 370 static void
 371 egg_tray_icon_realize (GtkWidget *widget)
 372 {
 373 #ifdef GDK_WINDOWING_X11
 374   EggTrayIcon *icon = EGG_TRAY_ICON (widget);
 375   GdkScreen *screen;
 376   GdkDisplay *display;
 377   Display *xdisplay;
 378   char buffer[256];
 379   GdkWindow *root_window;
 380
 381   if (GTK_WIDGET_CLASS (parent_class)->realize)
 382     GTK_WIDGET_CLASS (parent_class)->realize (widget);
 383
 384   screen = gtk_widget_get_screen (widget);
 385   display = gdk_screen_get_display (screen);
 386   xdisplay = gdk_x11_display_get_xdisplay (display);
 387
 388   /* Now see if there's a manager window around */
 389   g_snprintf (buffer, sizeof (buffer),
 390               "_NET_SYSTEM_TRAY_S%d",
 391               gdk_screen_get_number (screen));
 392
 393   icon->selection_atom = XInternAtom (xdisplay, buffer, False);
 394
 395   icon->manager_atom = XInternAtom (xdisplay, "MANAGER", False);
 396
 397   icon->system_tray_opcode_atom = XInternAtom (xdisplay,
 398                                                    "_NET_SYSTEM_TRAY_OPCODE",
 399                                                    False);
 400
 401   icon->orientation_atom = XInternAtom (xdisplay,
 402                                         "_NET_SYSTEM_TRAY_ORIENTATION",
 403                                         False);
 404
 405   egg_tray_icon_update_manager_window (icon, FALSE);
 406   egg_tray_icon_send_dock_request (icon);
 407
 408   root_window = gdk_screen_get_root_window (screen);
 409
 410   /* Add a root window filter so that we get changes on MANAGER */
 411   gdk_window_add_filter (root_window,
 412                          egg_tray_icon_manager_filter, icon);
 413 #endif
 414 }
 415
 416 EggTrayIcon *
 417 egg_tray_icon_new_for_screen (GdkScreen *screen, const char *name)
 418 {
 419   g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
 420
 421   return g_object_new (EGG_TYPE_TRAY_ICON, "screen", screen, "title", name, NULL);
 422 }
 423
 424 EggTrayIcon*
 425 egg_tray_icon_new (const gchar *name)
 426 {
 427   return g_object_new (EGG_TYPE_TRAY_ICON, "title", name, NULL);
 428 }
 429
 430 guint
 431 egg_tray_icon_send_message (EggTrayIcon *icon,
 432                             gint         timeout,
 433                             const gchar *message,
 434                             gint         len)
 435 {
 436   guint stamp;
 437
 438   g_return_val_if_fail (EGG_IS_TRAY_ICON (icon), 0);
 439   g_return_val_if_fail (timeout >= 0, 0);
 440   g_return_val_if_fail (message != NULL, 0);
 441
 442 #ifdef GDK_WINDOWING_X11
 443   if (icon->manager_window == None)
 444     return 0;
 445 #endif
 446
 447   if (len < 0)
 448     len = strlen (message);
 449
 450   stamp = icon->stamp++;
 451
 452 #ifdef GDK_WINDOWING_X11
 453   /* Get ready to send the message */
 454   egg_tray_icon_send_manager_message (icon, SYSTEM_TRAY_BEGIN_MESSAGE,
 455                                       (Window)gtk_plug_get_id (GTK_PLUG (icon)),
 456                                       timeout, len, stamp);
 457
 458   /* Now to send the actual message */
 459   gdk_error_trap_push ();
 460   while (len > 0)
 461     {
 462       XClientMessageEvent ev;
 463       Display *xdisplay;
 464
 465       xdisplay = GDK_DISPLAY_XDISPLAY (gtk_widget_get_display (GTK_WIDGET (icon)));
 466
 467       ev.type = ClientMessage;
 468       ev.window = (Window)gtk_plug_get_id (GTK_PLUG (icon));
 469       ev.format = 8;
 470       ev.message_type = XInternAtom (xdisplay,
 471                                      "_NET_SYSTEM_TRAY_MESSAGE_DATA", False);
 472       if (len > 20)
 473         {
 474           memcpy (&ev.data, message, 20);
 475           len -= 20;
 476           message += 20;
 477         }
 478       else
 479         {
 480           memcpy (&ev.data, message, len);
 481           len = 0;
 482         }
 483
 484       XSendEvent (xdisplay,
 485                   icon->manager_window, False, StructureNotifyMask, (XEvent *)&ev);
 486       XSync (xdisplay, False);
 487     }
 488   gdk_error_trap_pop ();
 489 #endif
 490
 491   return stamp;
 492 }
 493
 494 void
 495 egg_tray_icon_cancel_message (EggTrayIcon *icon,
 496                               guint        id)
 497 {
 498   g_return_if_fail (EGG_IS_TRAY_ICON (icon));
 499   g_return_if_fail (id > 0);
 500 #ifdef GDK_WINDOWING_X11
 501   egg_tray_icon_send_manager_message (icon, SYSTEM_TRAY_CANCEL_MESSAGE,
 502                                       (Window)gtk_plug_get_id (GTK_PLUG (icon)),
 503                                       id, 0, 0);
 504 #endif
 505 }
 506
 507 GtkOrientation
 508 egg_tray_icon_get_orientation (EggTrayIcon *icon)
 509 {
 510   g_return_val_if_fail (EGG_IS_TRAY_ICON (icon), GTK_ORIENTATION_HORIZONTAL);
 511
 512   return icon->orientation;
 513 }