Pileus Git - ~andy/gtk/blob - gdk/x11/xsettings-client.c

   1 /*
   2  * Copyright © 2001, 2007 Red Hat, Inc.
   3  *
   4  * Permission to use, copy, modify, distribute, and sell this software and its
   5  * documentation for any purpose is hereby granted without fee, provided that
   6  * the above copyright notice appear in all copies and that both that
   7  * copyright notice and this permission notice appear in supporting
   8  * documentation, and that the name of Red Hat not be used in advertising or
   9  * publicity pertaining to distribution of the software without specific,
  10  * written prior permission.  Red Hat makes no representations about the
  11  * suitability of this software for any purpose.  It is provided "as is"
  12  * without express or implied warranty.
  13  *
  14  * RED HAT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL RED HAT
  16  * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  17  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  18  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  19  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  20  *
  21  * Author:  Owen Taylor, Red Hat, Inc.
  22  */
  23
  24 #include "config.h"
  25
  26 #include "xsettings-client.h"
  27
  28 #include <gdk/x11/gdkx11display.h>
  29 #include <gdk/x11/gdkx11property.h>
  30 #include <gdk/x11/gdkx11screen.h>
  31 #include <gdk/x11/gdkx11window.h>
  32 #include <gdk/x11/gdkscreen-x11.h>
  33
  34 #include <gdkinternals.h>
  35
  36 #include <string.h>
  37
  38 #include <X11/Xlib.h>
  39 #include <X11/Xmd.h>            /* For CARD16 */
  40
  41 #include "gdksettings.c"
  42
  43 /* Types of settings possible. Enum values correspond to
  44  * protocol values.
  45  */
  46 typedef enum
  47 {
  48   XSETTINGS_TYPE_INT     = 0,
  49   XSETTINGS_TYPE_STRING  = 1,
  50   XSETTINGS_TYPE_COLOR   = 2
  51 } XSettingsType;
  52
  53 typedef struct _XSettingsBuffer  XSettingsBuffer;
  54
  55 struct _XSettingsBuffer
  56 {
  57   char byte_order;
  58   size_t len;
  59   unsigned char *data;
  60   unsigned char *pos;
  61 };
  62
  63 struct _XSettingsClient
  64 {
  65   GdkScreen *screen;
  66
  67   GdkWindow *manager_window;
  68   Atom selection_atom;
  69
  70   GHashTable *settings; /* string of GDK settings name => XSettingsSetting */
  71 };
  72
  73 static void
  74 gdk_xsettings_notify (const char       *name,
  75                       GdkSettingAction  action,
  76                       GdkScreen        *screen)
  77 {
  78   GdkEvent new_event;
  79   GdkX11Screen *x11_screen = GDK_X11_SCREEN (screen);
  80
  81   if (x11_screen->xsettings_in_init)
  82     return;
  83
  84   new_event.type = GDK_SETTING;
  85   new_event.setting.window = gdk_screen_get_root_window (screen);
  86   new_event.setting.send_event = FALSE;
  87   new_event.setting.action = action;
  88   new_event.setting.name = (char*) name;
  89
  90   gdk_event_put (&new_event);
  91 }
  92
  93 static gboolean
  94 value_equal (const GValue *value_a,
  95              const GValue *value_b)
  96 {
  97   if (G_VALUE_TYPE (value_a) != G_VALUE_TYPE (value_b))
  98     return FALSE;
  99
 100   switch (G_VALUE_TYPE (value_a))
 101     {
 102     case G_TYPE_INT:
 103       return g_value_get_int (value_a) == g_value_get_int (value_b);
 104     case XSETTINGS_TYPE_COLOR:
 105       return gdk_rgba_equal (g_value_get_boxed (value_a), g_value_get_boxed (value_b));
 106     case G_TYPE_STRING:
 107       return g_str_equal (g_value_get_string (value_a), g_value_get_string (value_b));
 108     default:
 109       g_warning ("unable to compare values of type %s", g_type_name (G_VALUE_TYPE (value_a)));
 110       return FALSE;
 111     }
 112 }
 113
 114 static void
 115 notify_changes (XSettingsClient *client,
 116                 GHashTable      *old_list)
 117 {
 118   GHashTableIter iter;
 119   GValue *setting, *old_setting;
 120   const char *name;
 121
 122   if (client->settings != NULL)
 123     {
 124       g_hash_table_iter_init (&iter, client->settings);
 125       while (g_hash_table_iter_next (&iter, (gpointer *) &name, (gpointer*) &setting))
 126         {
 127           old_setting = old_list ? g_hash_table_lookup (old_list, name) : NULL;
 128
 129           if (old_setting == NULL)
 130             gdk_xsettings_notify (name, GDK_SETTING_ACTION_NEW, client->screen);
 131           else if (!value_equal (setting, old_setting))
 132             gdk_xsettings_notify (name, GDK_SETTING_ACTION_CHANGED, client->screen);
 133
 134           /* remove setting from old_list */
 135           if (old_setting != NULL)
 136             g_hash_table_remove (old_list, name);
 137         }
 138     }
 139
 140   if (old_list != NULL)
 141     {
 142       /* old_list now contains only deleted settings */
 143       g_hash_table_iter_init (&iter, old_list);
 144       while (g_hash_table_iter_next (&iter, (gpointer *) &name, (gpointer*) &old_setting))
 145         gdk_xsettings_notify (name, GDK_SETTING_ACTION_DELETED, client->screen);
 146     }
 147 }
 148
 149 #define BYTES_LEFT(buffer) ((buffer)->data + (buffer)->len - (buffer)->pos)
 150
 151 #define return_if_fail_bytes(buffer, n_bytes) G_STMT_START{ \
 152   if (BYTES_LEFT (buffer) < (n_bytes)) \
 153     { \
 154       g_warning ("Invalid XSETTINGS property (read off end: Expected %u bytes, only %ld left", \
 155                  (n_bytes), BYTES_LEFT (buffer)); \
 156       return FALSE; \
 157     } \
 158 }G_STMT_END
 159
 160 static gboolean
 161 fetch_card16 (XSettingsBuffer *buffer,
 162               CARD16          *result)
 163 {
 164   CARD16 x;
 165
 166   return_if_fail_bytes (buffer, 2);
 167
 168   x = *(CARD16 *)buffer->pos;
 169   buffer->pos += 2;
 170
 171   if (buffer->byte_order == MSBFirst)
 172     *result = GUINT16_FROM_BE (x);
 173   else
 174     *result = GUINT16_FROM_LE (x);
 175
 176   return TRUE;
 177 }
 178
 179 static gboolean
 180 fetch_ushort (XSettingsBuffer *buffer,
 181               unsigned short  *result)
 182 {
 183   CARD16 x;
 184   gboolean r;
 185
 186   r = fetch_card16 (buffer, &x);
 187   if (r)
 188     *result = x;
 189
 190   return r;
 191 }
 192
 193 static gboolean
 194 fetch_card32 (XSettingsBuffer *buffer,
 195               CARD32          *result)
 196 {
 197   CARD32 x;
 198
 199   return_if_fail_bytes (buffer, 4);
 200
 201   x = *(CARD32 *)buffer->pos;
 202   buffer->pos += 4;
 203
 204   if (buffer->byte_order == MSBFirst)
 205     *result = GUINT32_FROM_BE (x);
 206   else
 207     *result = GUINT32_FROM_LE (x);
 208
 209   return TRUE;
 210 }
 211
 212 static gboolean
 213 fetch_card8 (XSettingsBuffer *buffer,
 214              CARD8           *result)
 215 {
 216   return_if_fail_bytes (buffer, 1);
 217
 218   *result = *(CARD8 *)buffer->pos;
 219   buffer->pos += 1;
 220
 221   return TRUE;
 222 }
 223
 224 #define XSETTINGS_PAD(n,m) ((n + m - 1) & (~(m-1)))
 225
 226 static gboolean
 227 fetch_string (XSettingsBuffer  *buffer,
 228               guint             length,
 229               char            **result)
 230 {
 231   guint pad_len;
 232
 233   pad_len = XSETTINGS_PAD (length, 4);
 234   if (pad_len < length) /* guard against overflow */
 235     {
 236       g_warning ("Invalid XSETTINGS property (overflow in string length)");
 237       return FALSE;
 238     }
 239
 240   return_if_fail_bytes (buffer, pad_len);
 241
 242   *result = g_strndup ((char *) buffer->pos, length);
 243   buffer->pos += pad_len;
 244
 245   return TRUE;
 246 }
 247
 248 static void
 249 free_value (gpointer data)
 250 {
 251   GValue *value = data;
 252
 253   g_value_unset (value);
 254   g_free (value);
 255 }
 256
 257 static GHashTable *
 258 parse_settings (unsigned char *data,
 259                 size_t         len)
 260 {
 261   XSettingsBuffer buffer;
 262   GHashTable *settings = NULL;
 263   CARD32 serial;
 264   CARD32 n_entries;
 265   CARD32 i;
 266   GValue *value = NULL;
 267   char *x_name = NULL;
 268   const char *gdk_name;
 269
 270   buffer.pos = buffer.data = data;
 271   buffer.len = len;
 272
 273   if (!fetch_card8 (&buffer, (unsigned char *)&buffer.byte_order))
 274     goto out;
 275
 276   if (buffer.byte_order != MSBFirst &&
 277       buffer.byte_order != LSBFirst)
 278     {
 279       g_warning ("Invalid XSETTINGS property (unknown byte order %u)", buffer.byte_order);
 280       goto out;
 281     }
 282
 283   buffer.pos += 3;
 284
 285   if (!fetch_card32 (&buffer, &serial) ||
 286       !fetch_card32 (&buffer, &n_entries))
 287     goto out;
 288
 289   GDK_NOTE(SETTINGS, g_print("reading %u settings (serial %u byte order %u)\n", n_entries, serial, buffer.byte_order));
 290
 291   for (i = 0; i < n_entries; i++)
 292     {
 293       CARD8 type;
 294       CARD16 name_len;
 295       CARD32 v_int;
 296
 297       if (!fetch_card8 (&buffer, &type))
 298         goto out;
 299
 300       buffer.pos += 1;
 301
 302       if (!fetch_card16 (&buffer, &name_len))
 303         goto out;
 304
 305       if (!fetch_string (&buffer, name_len, &x_name) ||
 306           /* last change serial (we ignore it) */
 307           !fetch_card32 (&buffer, &v_int))
 308         goto out;
 309
 310       switch (type)
 311         {
 312         case XSETTINGS_TYPE_INT:
 313           if (!fetch_card32 (&buffer, &v_int))
 314             goto out;
 315
 316           value = g_new0 (GValue, 1);
 317           g_value_init (value, G_TYPE_INT);
 318           g_value_set_int (value, (gint32) v_int);
 319
 320           GDK_NOTE(SETTINGS, g_print("  %s = %d\n", x_name, (gint32) v_int));
 321           break;
 322         case XSETTINGS_TYPE_STRING:
 323           {
 324             char *s;
 325
 326             if (!fetch_card32 (&buffer, &v_int) ||
 327                 !fetch_string (&buffer, v_int, &s))
 328               goto out;
 329
 330             value = g_new0 (GValue, 1);
 331             g_value_init (value, G_TYPE_STRING);
 332             g_value_take_string (value, s);
 333
 334             GDK_NOTE(SETTINGS, g_print("  %s = \"%s\"\n", x_name, s));
 335           }
 336           break;
 337         case XSETTINGS_TYPE_COLOR:
 338           {
 339             unsigned short red, green, blue, alpha;
 340             GdkRGBA rgba;
 341
 342             if (!fetch_ushort (&buffer, &red) ||
 343                 !fetch_ushort (&buffer, &green) ||
 344                 !fetch_ushort (&buffer, &blue) ||
 345                 !fetch_ushort (&buffer, &alpha))
 346               goto out;
 347
 348             rgba.red = red / 65535.0;
 349             rgba.green = green / 65535.0;
 350             rgba.blue = blue / 65535.0;
 351             rgba.alpha = alpha / 65535.0;
 352
 353             value = g_new0 (GValue, 1);
 354             g_value_init (value, G_TYPE_STRING);
 355             g_value_set_boxed (value, &rgba);
 356
 357             GDK_NOTE(SETTINGS, g_print("  %s = #%02X%02X%02X%02X\n", x_name, alpha,red, green, blue));
 358           }
 359           break;
 360         default:
 361           /* Quietly ignore unknown types */
 362           GDK_NOTE(SETTINGS, g_print("  %s = ignored (unknown type %u)\n", x_name, type));
 363           break;
 364         }
 365
 366       gdk_name = gdk_from_xsettings_name (x_name);
 367       g_free (x_name);
 368       x_name = NULL;
 369
 370       if (gdk_name == NULL)
 371         {
 372           GDK_NOTE(SETTINGS, g_print("    ==> unknown to GTK\n"));
 373         }
 374       else
 375         {
 376           GDK_NOTE(SETTINGS, g_print("    ==> storing as '%s'\n", gdk_name));
 377
 378           if (settings == NULL)
 379             settings = g_hash_table_new_full (g_str_hash, g_str_equal,
 380                                               NULL,
 381                                               free_value);
 382
 383           if (g_hash_table_lookup (settings, gdk_name) != NULL)
 384             {
 385               g_warning ("Invalid XSETTINGS property (Duplicate entry for '%s')", gdk_name);
 386               goto out;
 387             }
 388
 389           g_hash_table_insert (settings, (gpointer) gdk_name, value);
 390         }
 391
 392       value = NULL;
 393     }
 394
 395   return settings;
 396
 397  out:
 398
 399   if (value)
 400     free_value (value);
 401
 402   if (settings)
 403     g_hash_table_unref (settings);
 404
 405   g_free (x_name);
 406
 407   return NULL;
 408 }
 409
 410 static void
 411 read_settings (XSettingsClient *client)
 412 {
 413   Atom type;
 414   int format;
 415   unsigned long n_items;
 416   unsigned long bytes_after;
 417   unsigned char *data;
 418   int result;
 419
 420   GHashTable *old_list = client->settings;
 421
 422   client->settings = NULL;
 423
 424   if (client->manager_window)
 425     {
 426       GdkDisplay *display = gdk_screen_get_display (client->screen);
 427       Atom xsettings_atom = gdk_x11_get_xatom_by_name_for_display (display, "_XSETTINGS_SETTINGS");
 428
 429       gdk_x11_display_error_trap_push (display);
 430       result = XGetWindowProperty (gdk_x11_display_get_xdisplay (display),
 431                                    gdk_x11_window_get_xid (client->manager_window),
 432                                    xsettings_atom, 0, LONG_MAX,
 433                                    False, xsettings_atom,
 434                                    &type, &format, &n_items, &bytes_after, &data);
 435       gdk_x11_display_error_trap_pop_ignored (display);
 436
 437       if (result == Success && type != None)
 438         {
 439           if (type != xsettings_atom)
 440             {
 441               g_warning ("Invalid type for XSETTINGS property: %s", gdk_x11_get_xatom_name_for_display (display, type));
 442             }
 443           else if (format != 8)
 444             {
 445               g_warning ("Invalid format for XSETTINGS property: %d", format);
 446             }
 447           else
 448             client->settings = parse_settings (data, n_items);
 449
 450           XFree (data);
 451         }
 452     }
 453
 454   notify_changes (client, old_list);
 455   if (old_list)
 456     g_hash_table_unref (old_list);
 457 }
 458
 459 static GdkFilterReturn
 460 gdk_xsettings_manager_window_filter (GdkXEvent *xevent,
 461                                      GdkEvent  *event,
 462                                      gpointer   data);
 463
 464 static void
 465 check_manager_window (XSettingsClient *client)
 466 {
 467   GdkDisplay *display;
 468   Display *xdisplay;
 469   Window manager_window_xid;
 470
 471   display = gdk_screen_get_display (client->screen);
 472   xdisplay = gdk_x11_display_get_xdisplay (display);
 473
 474   if (client->manager_window)
 475     {
 476       gdk_window_remove_filter (client->manager_window, gdk_xsettings_manager_window_filter, client->screen);
 477       g_object_unref (client->manager_window);
 478     }
 479
 480   gdk_x11_display_grab (display);
 481
 482   manager_window_xid = XGetSelectionOwner (xdisplay,
 483                                            client->selection_atom);
 484   client->manager_window = gdk_x11_window_foreign_new_for_display (display,
 485                                                                    manager_window_xid);
 486   /* XXX: Can't use gdk_window_set_events() here because the first call to this
 487    * function happens too early in gdk_init() */
 488   if (client->manager_window)
 489     XSelectInput (xdisplay,
 490                   gdk_x11_window_get_xid (client->manager_window),
 491                   PropertyChangeMask | StructureNotifyMask);
 492
 493   gdk_x11_display_ungrab (display);
 494
 495   gdk_display_flush (display);
 496
 497   if (client->manager_window)
 498     {
 499       gdk_window_add_filter (client->manager_window, gdk_xsettings_manager_window_filter, client->screen);
 500     }
 501
 502   read_settings (client);
 503 }
 504
 505 static GdkFilterReturn
 506 gdk_xsettings_root_window_filter (GdkXEvent *xevent,
 507                                   GdkEvent  *event,
 508                                   gpointer   data)
 509 {
 510   GdkScreen *screen = data;
 511   XSettingsClient *client = GDK_X11_SCREEN (screen)->xsettings_client;
 512   GdkDisplay *display = gdk_screen_get_display (screen);
 513   XEvent *xev = xevent;
 514
 515   /* The checks here will not unlikely cause us to reread
 516    * the properties from the manager window a number of
 517    * times when the manager changes from A->B. But manager changes
 518    * are going to be pretty rare.
 519    */
 520   if (xev->xany.type == ClientMessage &&
 521       xev->xclient.message_type == gdk_x11_get_xatom_by_name_for_display (display, "MANAGER") &&
 522       xev->xclient.data.l[1] == client->selection_atom)
 523     {
 524       check_manager_window (client);
 525       return GDK_FILTER_REMOVE;
 526     }
 527
 528   return GDK_FILTER_CONTINUE;
 529 }
 530
 531 static GdkFilterReturn
 532 gdk_xsettings_manager_window_filter (GdkXEvent *xevent,
 533                                      GdkEvent  *event,
 534                                      gpointer   data)
 535 {
 536   GdkScreen *screen = data;
 537   XSettingsClient *client = GDK_X11_SCREEN (screen)->xsettings_client;
 538   XEvent *xev = xevent;
 539
 540   if (xev->xany.type == DestroyNotify)
 541     {
 542       check_manager_window (client);
 543       /* let GDK do its cleanup */
 544       return GDK_FILTER_CONTINUE;
 545     }
 546   else if (xev->xany.type == PropertyNotify)
 547     {
 548       read_settings (client);
 549       return GDK_FILTER_REMOVE;
 550     }
 551
 552   return GDK_FILTER_CONTINUE;;
 553 }
 554
 555 XSettingsClient *
 556 _gdk_x11_xsettings_client_new (GdkScreen *screen)
 557 {
 558   XSettingsClient *client;
 559   char *selection_atom_name;
 560
 561   client = g_new (XSettingsClient, 1);
 562   if (!client)
 563     return NULL;
 564
 565   client->screen = screen;
 566   client->manager_window = None;
 567   client->settings = NULL;
 568
 569   selection_atom_name = g_strdup_printf ("_XSETTINGS_S%d", gdk_x11_screen_get_screen_number (screen));
 570   client->selection_atom = gdk_x11_get_xatom_by_name_for_display (gdk_screen_get_display (screen), selection_atom_name);
 571   g_free (selection_atom_name);
 572
 573   gdk_window_add_filter (gdk_screen_get_root_window (screen), gdk_xsettings_root_window_filter, screen);
 574
 575   check_manager_window (client);
 576
 577   return client;
 578 }
 579
 580 void
 581 _gdk_x11_xsettings_client_destroy (XSettingsClient *client)
 582 {
 583   gdk_window_remove_filter (gdk_screen_get_root_window (client->screen), gdk_xsettings_root_window_filter, client->screen);
 584   if (client->manager_window)
 585     {
 586       gdk_window_remove_filter (client->manager_window, gdk_xsettings_manager_window_filter, client->screen);
 587       g_object_unref (client->manager_window);
 588     }
 589
 590   if (client->settings)
 591     g_hash_table_unref (client->settings);
 592   g_free (client);
 593 }
 594
 595 const GValue *
 596 _gdk_x11_xsettings_client_get_setting (XSettingsClient   *client,
 597                                        const char        *name)
 598 {
 599   return g_hash_table_lookup (client->settings, name);
 600 }
 601