src/gtk/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 <string.h>
  22 #include <gdk/gdkx.h>
  23 #include "eggtrayicon.h"
  24
  25 #define SYSTEM_TRAY_REQUEST_DOCK    0
  26 #define SYSTEM_TRAY_BEGIN_MESSAGE   1
  27 #define SYSTEM_TRAY_CANCEL_MESSAGE  2
  28
  29 static GtkPlugClass *parent_class = NULL;
  30
  31 static void egg_tray_icon_init (EggTrayIcon *icon);
  32 static void egg_tray_icon_class_init (EggTrayIconClass *klass);
  33
  34 static void egg_tray_icon_unrealize (GtkWidget *widget);
  35
  36 static void egg_tray_icon_update_manager_window (EggTrayIcon *icon);
  37
  38 GType
  39 egg_tray_icon_get_type (void)
  40 {
  41   static GType our_type = 0;
  42
  43   if (our_type == 0)
  44     {
  45       static const GTypeInfo our_info =
  46       {
  47         sizeof (EggTrayIconClass),
  48         (GBaseInitFunc) NULL,
  49         (GBaseFinalizeFunc) NULL,
  50         (GClassInitFunc) egg_tray_icon_class_init,
  51         NULL, /* class_finalize */
  52         NULL, /* class_data */
  53         sizeof (EggTrayIcon),
  54         0,    /* n_preallocs */
  55         (GInstanceInitFunc) egg_tray_icon_init
  56       };
  57
  58       our_type = g_type_register_static (GTK_TYPE_PLUG, "EggTrayIcon", &our_info, 0);
  59     }
  60
  61   return our_type;
  62 }
  63
  64 static void
  65 egg_tray_icon_init (EggTrayIcon *icon)
  66 {
  67   icon->stamp = 1;
  68
  69   gtk_widget_add_events (GTK_WIDGET (icon), GDK_PROPERTY_CHANGE_MASK);
  70 }
  71
  72 static void
  73 egg_tray_icon_class_init (EggTrayIconClass *klass)
  74 {
  75   GtkWidgetClass *widget_class = (GtkWidgetClass *)klass;
  76
  77   parent_class = g_type_class_peek_parent (klass);
  78
  79   widget_class->unrealize = egg_tray_icon_unrealize;
  80 }
  81
  82 static GdkFilterReturn
  83 egg_tray_icon_manager_filter (GdkXEvent *xevent, GdkEvent *event, gpointer user_data)
  84 {
  85   EggTrayIcon *icon = user_data;
  86   XEvent *xev = (XEvent *)xevent;
  87
  88   if (xev->xany.type == ClientMessage &&
  89       xev->xclient.message_type == icon->manager_atom &&
  90       xev->xclient.data.l[1] == icon->selection_atom)
  91     {
  92       egg_tray_icon_update_manager_window (icon);
  93     }
  94   else if (xev->xany.window == icon->manager_window)
  95     {
  96       if (xev->xany.type == DestroyNotify)
  97         {
  98           egg_tray_icon_update_manager_window (icon);
  99         }
 100     }
 101
 102   return GDK_FILTER_CONTINUE;
 103 }
 104
 105 static void
 106 egg_tray_icon_unrealize (GtkWidget *widget)
 107 {
 108   EggTrayIcon *icon = EGG_TRAY_ICON (widget);
 109   GdkWindow *root_window;
 110
 111   if (icon->manager_window != None)
 112     {
 113       GdkWindow *gdkwin;
 114
 115       gdkwin = gdk_window_lookup_for_display (gtk_widget_get_display (widget),
 116                                               icon->manager_window);
 117
 118       gdk_window_remove_filter (gdkwin, egg_tray_icon_manager_filter, icon);
 119     }
 120
 121   root_window = gdk_screen_get_root_window (gtk_widget_get_screen (widget));
 122
 123   gdk_window_remove_filter (root_window, egg_tray_icon_manager_filter, icon);
 124
 125   if (GTK_WIDGET_CLASS (parent_class)->unrealize)
 126     (* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
 127 }
 128
 129 static void
 130 egg_tray_icon_send_manager_message (EggTrayIcon *icon,
 131                                     long         message,
 132                                     Window       window,
 133                                     long         data1,
 134                                     long         data2,
 135                                     long         data3)
 136 {
 137   XClientMessageEvent ev;
 138   Display *display;
 139
 140   ev.type = ClientMessage;
 141   ev.window = window;
 142   ev.message_type = icon->system_tray_opcode_atom;
 143   ev.format = 32;
 144   ev.data.l[0] = gdk_x11_get_server_time (GTK_WIDGET (icon)->window);
 145   ev.data.l[1] = message;
 146   ev.data.l[2] = data1;
 147   ev.data.l[3] = data2;
 148   ev.data.l[4] = data3;
 149
 150   display = GDK_DISPLAY_XDISPLAY (gtk_widget_get_display (GTK_WIDGET (icon)));
 151
 152   gdk_error_trap_push ();
 153   XSendEvent (display,
 154               icon->manager_window, False, NoEventMask, (XEvent *)&ev);
 155   XSync (display, False);
 156   gdk_error_trap_pop ();
 157 }
 158
 159 static void
 160 egg_tray_icon_send_dock_request (EggTrayIcon *icon)
 161 {
 162   egg_tray_icon_send_manager_message (icon,
 163                                       SYSTEM_TRAY_REQUEST_DOCK,
 164                                       icon->manager_window,
 165                                       gtk_plug_get_id (GTK_PLUG (icon)),
 166                                       0, 0);
 167 }
 168
 169 static void
 170 egg_tray_icon_update_manager_window (EggTrayIcon *icon)
 171 {
 172   Display *xdisplay;
 173
 174   xdisplay = GDK_DISPLAY_XDISPLAY (gtk_widget_get_display (GTK_WIDGET (icon)));
 175
 176   if (icon->manager_window != None)
 177     {
 178       GdkWindow *gdkwin;
 179
 180       gdkwin = gdk_window_lookup_for_display (gtk_widget_get_display (GTK_WIDGET (icon)),
 181                                               icon->manager_window);
 182
 183       gdk_window_remove_filter (gdkwin, egg_tray_icon_manager_filter, icon);
 184     }
 185
 186   XGrabServer (xdisplay);
 187
 188   icon->manager_window = XGetSelectionOwner (xdisplay,
 189                                              icon->selection_atom);
 190
 191   if (icon->manager_window != None)
 192     XSelectInput (xdisplay,
 193                   icon->manager_window, StructureNotifyMask);
 194
 195   XUngrabServer (xdisplay);
 196   XFlush (xdisplay);
 197
 198   if (icon->manager_window != None)
 199     {
 200       GdkWindow *gdkwin;
 201
 202       gdkwin = gdk_window_lookup_for_display (gtk_widget_get_display (GTK_WIDGET (icon)),
 203                                               icon->manager_window);
 204
 205       gdk_window_add_filter (gdkwin, egg_tray_icon_manager_filter, icon);
 206
 207       /* Send a request that we'd like to dock */
 208       egg_tray_icon_send_dock_request (icon);
 209     }
 210 }
 211
 212 EggTrayIcon *
 213 egg_tray_icon_new_for_xscreen (Screen *xscreen, const char *name)
 214 {
 215   EggTrayIcon *icon;
 216   char buffer[256];
 217   GdkWindow *root_window;
 218   GdkDisplay *display;
 219   GdkScreen *screen;
 220
 221   g_return_val_if_fail (xscreen != NULL, NULL);
 222
 223   icon = g_object_new (EGG_TYPE_TRAY_ICON, NULL);
 224   gtk_window_set_title (GTK_WINDOW (icon), name);
 225
 226   display = gdk_x11_lookup_xdisplay (DisplayOfScreen (xscreen));
 227   screen = gdk_display_get_screen (display, XScreenNumberOfScreen (xscreen));
 228
 229   gtk_plug_construct_for_display (GTK_PLUG (icon),
 230                                   display, 0);
 231
 232   gtk_window_set_screen (GTK_WINDOW (icon), screen);
 233
 234   gtk_widget_realize (GTK_WIDGET (icon));
 235
 236   /* Now see if there's a manager window around */
 237   g_snprintf (buffer, sizeof (buffer),
 238               "_NET_SYSTEM_TRAY_S%d",
 239               XScreenNumberOfScreen (xscreen));
 240
 241   icon->selection_atom = XInternAtom (DisplayOfScreen (xscreen),
 242                                       buffer, False);
 243
 244   icon->manager_atom = XInternAtom (DisplayOfScreen (xscreen),
 245                                     "MANAGER", False);
 246
 247   icon->system_tray_opcode_atom = XInternAtom (DisplayOfScreen (xscreen),
 248                                                "_NET_SYSTEM_TRAY_OPCODE", False);
 249
 250   egg_tray_icon_update_manager_window (icon);
 251
 252   root_window = gdk_screen_get_root_window (gtk_widget_get_screen (GTK_WIDGET (icon)));
 253
 254   /* Add a root window filter so that we get changes on MANAGER */
 255   gdk_window_add_filter (root_window,
 256                          egg_tray_icon_manager_filter, icon);
 257
 258   return icon;
 259 }
 260
 261 EggTrayIcon *
 262 egg_tray_icon_new_for_screen (GdkScreen *screen, const char *name)
 263 {
 264   g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
 265
 266   return egg_tray_icon_new_for_xscreen (GDK_SCREEN_XSCREEN (screen), name);
 267 }
 268
 269 EggTrayIcon*
 270 egg_tray_icon_new (const gchar *name)
 271 {
 272   return egg_tray_icon_new_for_xscreen (DefaultScreenOfDisplay (gdk_display), name);
 273 }
 274
 275 guint
 276 egg_tray_icon_send_message (EggTrayIcon *icon,
 277                             gint         timeout,
 278                             const gchar *message,
 279                             gint         len)
 280 {
 281   guint stamp;
 282
 283   g_return_val_if_fail (EGG_IS_TRAY_ICON (icon), 0);
 284   g_return_val_if_fail (timeout >= 0, 0);
 285   g_return_val_if_fail (message != NULL, 0);
 286
 287   if (icon->manager_window == None)
 288     return 0;
 289
 290   if (len < 0)
 291     len = strlen (message);
 292
 293   stamp = icon->stamp++;
 294
 295   /* Get ready to send the message */
 296   egg_tray_icon_send_manager_message (icon, SYSTEM_TRAY_BEGIN_MESSAGE,
 297                                       (Window)gtk_plug_get_id (GTK_PLUG (icon)),
 298                                       timeout, len, stamp);
 299
 300   /* Now to send the actual message */
 301   gdk_error_trap_push ();
 302   while (len > 0)
 303     {
 304       XClientMessageEvent ev;
 305       Display *xdisplay;
 306
 307       xdisplay = GDK_DISPLAY_XDISPLAY (gtk_widget_get_display (GTK_WIDGET (icon)));
 308
 309       ev.type = ClientMessage;
 310       ev.window = (Window)gtk_plug_get_id (GTK_PLUG (icon));
 311       ev.format = 8;
 312       ev.message_type = XInternAtom (xdisplay,
 313                                      "_NET_SYSTEM_TRAY_MESSAGE_DATA", False);
 314       if (len > 20)
 315         {
 316           memcpy (&ev.data, message, 20);
 317           len -= 20;
 318           message += 20;
 319         }
 320       else
 321         {
 322           memcpy (&ev.data, message, len);
 323           len = 0;
 324         }
 325
 326       XSendEvent (xdisplay,
 327                   icon->manager_window, False, StructureNotifyMask, (XEvent *)&ev);
 328       XSync (xdisplay, False);
 329     }
 330   gdk_error_trap_pop ();
 331
 332   return stamp;
 333 }
 334
 335 void
 336 egg_tray_icon_cancel_message (EggTrayIcon *icon,
 337                               guint        id)
 338 {
 339   g_return_if_fail (EGG_IS_TRAY_ICON (icon));
 340   g_return_if_fail (id > 0);
 341
 342   egg_tray_icon_send_manager_message (icon, SYSTEM_TRAY_CANCEL_MESSAGE,
 343                                       (Window)gtk_plug_get_id (GTK_PLUG (icon)),
 344                                       id, 0, 0);
 345 }