← Back to branch summary

~ubuntu-branches/ubuntu/trusty/brightside/trusty

« back to all changes in this revision

Viewing changes to src/eggtrayicon.c

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Holbach
  • Date: 2005-03-14 12:55:57 UTC
  • Revision ID: james.westby@ubuntu.com-20050314125557-s7vle73vmcspbi8x
Tags: upstream-1.3.2
Import upstream version 1.3.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/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 <gdk/gdkx.h>
 
28
#include <X11/Xatom.h>
 
29
 
 
30
#ifndef EGG_COMPILATION
 
31
#ifndef _
 
32
#define _(x) dgettext (GETTEXT_PACKAGE, x)
 
33
#define N_(x) x
 
34
#endif
 
35
#else
 
36
#define _(x) x
 
37
#define N_(x) x
 
38
#endif
 
39
 
 
40
#define SYSTEM_TRAY_REQUEST_DOCK    0
 
41
#define SYSTEM_TRAY_BEGIN_MESSAGE   1
 
42
#define SYSTEM_TRAY_CANCEL_MESSAGE  2
 
43
 
 
44
#define SYSTEM_TRAY_ORIENTATION_HORZ 0
 
45
#define SYSTEM_TRAY_ORIENTATION_VERT 1
 
46
 
 
47
enum {
 
48
  PROP_0,
 
49
  PROP_ORIENTATION
 
50
};
 
51
         
 
52
static GtkPlugClass *parent_class = NULL;
 
53
 
 
54
static void egg_tray_icon_init (EggTrayIcon *icon);
 
55
static void egg_tray_icon_class_init (EggTrayIconClass *klass);
 
56
 
 
57
static void egg_tray_icon_get_property (GObject    *object,
 
58
                                        guint       prop_id,
 
59
                                        GValue     *value,
 
60
                                        GParamSpec *pspec);
 
61
 
 
62
static void egg_tray_icon_realize   (GtkWidget *widget);
 
63
static void egg_tray_icon_unrealize (GtkWidget *widget);
 
64
 
 
65
static void egg_tray_icon_update_manager_window (EggTrayIcon *icon);
 
66
 
 
67
GType
 
68
egg_tray_icon_get_type (void)
 
69
{
 
70
  static GType our_type = 0;
 
71
 
 
72
  if (our_type == 0)
 
73
    {
 
74
      static const GTypeInfo our_info =
 
75
      {
 
76
        sizeof (EggTrayIconClass),
 
77
        (GBaseInitFunc) NULL,
 
78
        (GBaseFinalizeFunc) NULL,
 
79
        (GClassInitFunc) egg_tray_icon_class_init,
 
80
        NULL, /* class_finalize */
 
81
        NULL, /* class_data */
 
82
        sizeof (EggTrayIcon),
 
83
        0,    /* n_preallocs */
 
84
        (GInstanceInitFunc) egg_tray_icon_init
 
85
      };
 
86
 
 
87
      our_type = g_type_register_static (GTK_TYPE_PLUG, "EggTrayIcon", &our_info, 0);
 
88
    }
 
89
 
 
90
  return our_type;
 
91
}
 
92
 
 
93
static void
 
94
egg_tray_icon_init (EggTrayIcon *icon)
 
95
{
 
96
  icon->stamp = 1;
 
97
  icon->orientation = GTK_ORIENTATION_HORIZONTAL;
 
98
  
 
99
  gtk_widget_add_events (GTK_WIDGET (icon), GDK_PROPERTY_CHANGE_MASK);
 
100
}
 
101
 
 
102
static void
 
103
egg_tray_icon_class_init (EggTrayIconClass *klass)
 
104
{
 
105
  GObjectClass *gobject_class = (GObjectClass *)klass;
 
106
  GtkWidgetClass *widget_class = (GtkWidgetClass *)klass;
 
107
 
 
108
  parent_class = g_type_class_peek_parent (klass);
 
109
 
 
110
  gobject_class->get_property = egg_tray_icon_get_property;
 
111
 
 
112
  widget_class->realize   = egg_tray_icon_realize;
 
113
  widget_class->unrealize = egg_tray_icon_unrealize;
 
114
 
 
115
  g_object_class_install_property (gobject_class,
 
116
                                   PROP_ORIENTATION,
 
117
                                   g_param_spec_enum ("orientation",
 
118
                                                      _("Orientation"),
 
119
                                                      _("The orientation of the tray."),
 
120
                                                      GTK_TYPE_ORIENTATION,
 
121
                                                      GTK_ORIENTATION_HORIZONTAL,
 
122
                                                      G_PARAM_READABLE));
 
123
}
 
124
 
 
125
static void
 
126
egg_tray_icon_get_property (GObject    *object,
 
127
                            guint       prop_id,
 
128
                            GValue     *value,
 
129
                            GParamSpec *pspec)
 
130
{
 
131
  EggTrayIcon *icon = EGG_TRAY_ICON (object);
 
132
 
 
133
  switch (prop_id)
 
134
    {
 
135
    case PROP_ORIENTATION:
 
136
      g_value_set_enum (value, icon->orientation);
 
137
      break;
 
138
    default:
 
139
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 
140
      break;
 
141
    }
 
142
}
 
143
 
 
144
static void
 
145
egg_tray_icon_get_orientation_property (EggTrayIcon *icon)
 
146
{
 
147
  Display *xdisplay;
 
148
  Atom type;
 
149
  int format;
 
150
  union {
 
151
        gulong *prop;
 
152
        guchar *prop_ch;
 
153
  } prop = { NULL };
 
154
  gulong nitems;
 
155
  gulong bytes_after;
 
156
  int error, result;
 
157
 
 
158
  g_assert (icon->manager_window != None);
 
159
  
 
160
  xdisplay = GDK_DISPLAY_XDISPLAY (gtk_widget_get_display (GTK_WIDGET (icon)));
 
161
 
 
162
  gdk_error_trap_push ();
 
163
  type = None;
 
164
  result = XGetWindowProperty (xdisplay,
 
165
                               icon->manager_window,
 
166
                               icon->orientation_atom,
 
167
                               0, G_MAXLONG, FALSE,
 
168
                               XA_CARDINAL,
 
169
                               &type, &format, &nitems,
 
170
                               &bytes_after, &(prop.prop_ch));
 
171
  error = gdk_error_trap_pop ();
 
172
 
 
173
  if (error || result != Success)
 
174
    return;
 
175
 
 
176
  if (type == XA_CARDINAL)
 
177
    {
 
178
      GtkOrientation orientation;
 
179
 
 
180
      orientation = (prop.prop [0] == SYSTEM_TRAY_ORIENTATION_HORZ) ?
 
181
                                        GTK_ORIENTATION_HORIZONTAL :
 
182
                                        GTK_ORIENTATION_VERTICAL;
 
183
 
 
184
      if (icon->orientation != orientation)
 
185
        {
 
186
          icon->orientation = orientation;
 
187
 
 
188
          g_object_notify (G_OBJECT (icon), "orientation");
 
189
        }
 
190
    }
 
191
 
 
192
  if (prop.prop)
 
193
    XFree (prop.prop);
 
194
}
 
195
 
 
196
static GdkFilterReturn
 
197
egg_tray_icon_manager_filter (GdkXEvent *xevent, GdkEvent *event, gpointer user_data)
 
198
{
 
199
  EggTrayIcon *icon = user_data;
 
200
  XEvent *xev = (XEvent *)xevent;
 
201
 
 
202
  if (xev->xany.type == ClientMessage &&
 
203
      xev->xclient.message_type == icon->manager_atom &&
 
204
      xev->xclient.data.l[1] == icon->selection_atom)
 
205
    {
 
206
      egg_tray_icon_update_manager_window (icon);
 
207
    }
 
208
  else if (xev->xany.window == icon->manager_window)
 
209
    {
 
210
      if (xev->xany.type == PropertyNotify &&
 
211
          xev->xproperty.atom == icon->orientation_atom)
 
212
        {
 
213
          egg_tray_icon_get_orientation_property (icon);
 
214
        }
 
215
      if (xev->xany.type == DestroyNotify)
 
216
        {
 
217
          egg_tray_icon_update_manager_window (icon);
 
218
        }
 
219
    }
 
220
  
 
221
  return GDK_FILTER_CONTINUE;
 
222
}
 
223
 
 
224
static void
 
225
egg_tray_icon_unrealize (GtkWidget *widget)
 
226
{
 
227
  EggTrayIcon *icon = EGG_TRAY_ICON (widget);
 
228
  GdkWindow *root_window;
 
229
 
 
230
  if (icon->manager_window != None)
 
231
    {
 
232
      GdkWindow *gdkwin;
 
233
 
 
234
      gdkwin = gdk_window_lookup_for_display (gtk_widget_get_display (widget),
 
235
                                              icon->manager_window);
 
236
 
 
237
      gdk_window_remove_filter (gdkwin, egg_tray_icon_manager_filter, icon);
 
238
    }
 
239
 
 
240
  root_window = gdk_screen_get_root_window (gtk_widget_get_screen (widget));
 
241
 
 
242
  gdk_window_remove_filter (root_window, egg_tray_icon_manager_filter, icon);
 
243
 
 
244
  if (GTK_WIDGET_CLASS (parent_class)->unrealize)
 
245
    (* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
 
246
}
 
247
 
 
248
static void
 
249
egg_tray_icon_send_manager_message (EggTrayIcon *icon,
 
250
                                    long         message,
 
251
                                    Window       window,
 
252
                                    long         data1,
 
253
                                    long         data2,
 
254
                                    long         data3)
 
255
{
 
256
  XClientMessageEvent ev;
 
257
  Display *display;
 
258
  
 
259
  ev.type = ClientMessage;
 
260
  ev.window = window;
 
261
  ev.message_type = icon->system_tray_opcode_atom;
 
262
  ev.format = 32;
 
263
  ev.data.l[0] = gdk_x11_get_server_time (GTK_WIDGET (icon)->window);
 
264
  ev.data.l[1] = message;
 
265
  ev.data.l[2] = data1;
 
266
  ev.data.l[3] = data2;
 
267
  ev.data.l[4] = data3;
 
268
 
 
269
  display = GDK_DISPLAY_XDISPLAY (gtk_widget_get_display (GTK_WIDGET (icon)));
 
270
  
 
271
  gdk_error_trap_push ();
 
272
  XSendEvent (display,
 
273
              icon->manager_window, False, NoEventMask, (XEvent *)&ev);
 
274
  XSync (display, False);
 
275
  gdk_error_trap_pop ();
 
276
}
 
277
 
 
278
static void
 
279
egg_tray_icon_send_dock_request (EggTrayIcon *icon)
 
280
{
 
281
  egg_tray_icon_send_manager_message (icon,
 
282
                                      SYSTEM_TRAY_REQUEST_DOCK,
 
283
                                      icon->manager_window,
 
284
                                      gtk_plug_get_id (GTK_PLUG (icon)),
 
285
                                      0, 0);
 
286
}
 
287
 
 
288
static void
 
289
egg_tray_icon_update_manager_window (EggTrayIcon *icon)
 
290
{
 
291
  Display *xdisplay;
 
292
  
 
293
  xdisplay = GDK_DISPLAY_XDISPLAY (gtk_widget_get_display (GTK_WIDGET (icon)));
 
294
  
 
295
  if (icon->manager_window != None)
 
296
    {
 
297
      GdkWindow *gdkwin;
 
298
 
 
299
      gdkwin = gdk_window_lookup_for_display (gtk_widget_get_display (GTK_WIDGET (icon)),
 
300
                                              icon->manager_window);
 
301
      
 
302
      gdk_window_remove_filter (gdkwin, egg_tray_icon_manager_filter, icon);
 
303
    }
 
304
  
 
305
  XGrabServer (xdisplay);
 
306
  
 
307
  icon->manager_window = XGetSelectionOwner (xdisplay,
 
308
                                             icon->selection_atom);
 
309
 
 
310
  if (icon->manager_window != None)
 
311
    XSelectInput (xdisplay,
 
312
                  icon->manager_window, StructureNotifyMask|PropertyChangeMask);
 
313
 
 
314
  XUngrabServer (xdisplay);
 
315
  XFlush (xdisplay);
 
316
  
 
317
  if (icon->manager_window != None)
 
318
    {
 
319
      GdkWindow *gdkwin;
 
320
 
 
321
      gdkwin = gdk_window_lookup_for_display (gtk_widget_get_display (GTK_WIDGET (icon)),
 
322
                                              icon->manager_window);
 
323
      
 
324
      gdk_window_add_filter (gdkwin, egg_tray_icon_manager_filter, icon);
 
325
 
 
326
      /* Send a request that we'd like to dock */
 
327
      egg_tray_icon_send_dock_request (icon);
 
328
 
 
329
      egg_tray_icon_get_orientation_property (icon);
 
330
    }
 
331
}
 
332
 
 
333
static void
 
334
egg_tray_icon_realize (GtkWidget *widget)
 
335
{
 
336
  EggTrayIcon *icon = EGG_TRAY_ICON (widget);
 
337
  GdkScreen *screen;
 
338
  GdkDisplay *display;
 
339
  Display *xdisplay;
 
340
  char buffer[256];
 
341
  GdkWindow *root_window;
 
342
 
 
343
  if (GTK_WIDGET_CLASS (parent_class)->realize)
 
344
    GTK_WIDGET_CLASS (parent_class)->realize (widget);
 
345
 
 
346
  screen = gtk_widget_get_screen (widget);
 
347
  display = gdk_screen_get_display (screen);
 
348
  xdisplay = gdk_x11_display_get_xdisplay (display);
 
349
 
 
350
  /* Now see if there's a manager window around */
 
351
  g_snprintf (buffer, sizeof (buffer),
 
352
              "_NET_SYSTEM_TRAY_S%d",
 
353
              gdk_screen_get_number (screen));
 
354
 
 
355
  icon->selection_atom = XInternAtom (xdisplay, buffer, False);
 
356
  
 
357
  icon->manager_atom = XInternAtom (xdisplay, "MANAGER", False);
 
358
  
 
359
  icon->system_tray_opcode_atom = XInternAtom (xdisplay,
 
360
                                                   "_NET_SYSTEM_TRAY_OPCODE",
 
361
                                                   False);
 
362
 
 
363
  icon->orientation_atom = XInternAtom (xdisplay,
 
364
                                        "_NET_SYSTEM_TRAY_ORIENTATION",
 
365
                                        False);
 
366
 
 
367
  egg_tray_icon_update_manager_window (icon);
 
368
 
 
369
  root_window = gdk_screen_get_root_window (screen);
 
370
  
 
371
  /* Add a root window filter so that we get changes on MANAGER */
 
372
  gdk_window_add_filter (root_window,
 
373
                         egg_tray_icon_manager_filter, icon);
 
374
}
 
375
 
 
376
EggTrayIcon *
 
377
egg_tray_icon_new_for_xscreen (Screen *xscreen, const char *name)
 
378
{
 
379
  GdkDisplay *display;
 
380
  GdkScreen *screen;
 
381
 
 
382
  display = gdk_x11_lookup_xdisplay (DisplayOfScreen (xscreen));
 
383
  screen = gdk_display_get_screen (display, XScreenNumberOfScreen (xscreen));
 
384
 
 
385
  return egg_tray_icon_new_for_screen (screen, name);
 
386
}
 
387
 
 
388
EggTrayIcon *
 
389
egg_tray_icon_new_for_screen (GdkScreen *screen, const char *name)
 
390
{
 
391
  g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
 
392
 
 
393
  return g_object_new (EGG_TYPE_TRAY_ICON, "screen", screen, "title", name, NULL);
 
394
}
 
395
 
 
396
EggTrayIcon*
 
397
egg_tray_icon_new (const gchar *name)
 
398
{
 
399
  return g_object_new (EGG_TYPE_TRAY_ICON, "title", name, NULL);
 
400
}
 
401
 
 
402
guint
 
403
egg_tray_icon_send_message (EggTrayIcon *icon,
 
404
                            gint         timeout,
 
405
                            const gchar *message,
 
406
                            gint         len)
 
407
{
 
408
  guint stamp;
 
409
  
 
410
  g_return_val_if_fail (EGG_IS_TRAY_ICON (icon), 0);
 
411
  g_return_val_if_fail (timeout >= 0, 0);
 
412
  g_return_val_if_fail (message != NULL, 0);
 
413
                     
 
414
  if (icon->manager_window == None)
 
415
    return 0;
 
416
 
 
417
  if (len < 0)
 
418
    len = strlen (message);
 
419
 
 
420
  stamp = icon->stamp++;
 
421
  
 
422
  /* Get ready to send the message */
 
423
  egg_tray_icon_send_manager_message (icon, SYSTEM_TRAY_BEGIN_MESSAGE,
 
424
                                      (Window)gtk_plug_get_id (GTK_PLUG (icon)),
 
425
                                      timeout, len, stamp);
 
426
 
 
427
  /* Now to send the actual message */
 
428
  gdk_error_trap_push ();
 
429
  while (len > 0)
 
430
    {
 
431
      XClientMessageEvent ev;
 
432
      Display *xdisplay;
 
433
 
 
434
      xdisplay = GDK_DISPLAY_XDISPLAY (gtk_widget_get_display (GTK_WIDGET (icon)));
 
435
      
 
436
      ev.type = ClientMessage;
 
437
      ev.window = (Window)gtk_plug_get_id (GTK_PLUG (icon));
 
438
      ev.format = 8;
 
439
      ev.message_type = XInternAtom (xdisplay,
 
440
                                     "_NET_SYSTEM_TRAY_MESSAGE_DATA", False);
 
441
      if (len > 20)
 
442
        {
 
443
          memcpy (&ev.data, message, 20);
 
444
          len -= 20;
 
445
          message += 20;
 
446
        }
 
447
      else
 
448
        {
 
449
          memcpy (&ev.data, message, len);
 
450
          len = 0;
 
451
        }
 
452
 
 
453
      XSendEvent (xdisplay,
 
454
                  icon->manager_window, False, StructureNotifyMask, (XEvent *)&ev);
 
455
      XSync (xdisplay, False);
 
456
    }
 
457
  gdk_error_trap_pop ();
 
458
 
 
459
  return stamp;
 
460
}
 
461
 
 
462
void
 
463
egg_tray_icon_cancel_message (EggTrayIcon *icon,
 
464
                              guint        id)
 
465
{
 
466
  g_return_if_fail (EGG_IS_TRAY_ICON (icon));
 
467
  g_return_if_fail (id > 0);
 
468
  
 
469
  egg_tray_icon_send_manager_message (icon, SYSTEM_TRAY_CANCEL_MESSAGE,
 
470
                                      (Window)gtk_plug_get_id (GTK_PLUG (icon)),
 
471
                                      id, 0, 0);
 
472
}
 
473
 
 
474
GtkOrientation
 
475
egg_tray_icon_get_orientation (EggTrayIcon *icon)
 
476
{
 
477
  g_return_val_if_fail (EGG_IS_TRAY_ICON (icon), GTK_ORIENTATION_HORIZONTAL);
 
478
 
 
479
  return icon->orientation;
 
480
}