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