Pileus Git - ~andy/gtk/blob - gtk/gtksettings.c

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 2000 Red Hat, Inc.
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free
  16  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17  */
  18
  19 #include "gtksettings.h"
  20 #include "gtkrc.h"
  21 #include "gtkintl.h"
  22 #include "gtkwidget.h"
  23
  24 enum {
  25   PROP_0,
  26   PROP_DOUBLE_CLICK_TIME,
  27   PROP_CURSOR_BLINK,
  28   PROP_CURSOR_BLINK_TIME,
  29   PROP_SPLIT_CURSOR,
  30   PROP_THEME_NAME,
  31   PROP_KEY_THEME_NAME,
  32   PROP_MENU_BAR_ACCEL,
  33   PROP_DND_DRAG_THRESHOLD,
  34   PROP_FONT_NAME
  35 };
  36
  37
  38 /* --- prototypes --- */
  39 static void     gtk_settings_init                (GtkSettings           *settings);
  40 static void     gtk_settings_class_init          (GtkSettingsClass      *class);
  41 static void     gtk_settings_finalize            (GObject               *object);
  42 static GObject* gtk_settings_constructor         (GType                  type,
  43                                                   guint                  n_construct_properties,
  44                                                   GObjectConstructParam *construct_properties);
  45 static void     gtk_settings_get_property        (GObject               *object,
  46                                                   guint                  property_id,
  47                                                   GValue                *value,
  48                                                   GParamSpec            *pspec);
  49 static void     gtk_settings_set_property        (GObject               *object,
  50                                                   guint                  property_id,
  51                                                   const GValue          *value,
  52                                                   GParamSpec            *pspec);
  53 static void     gtk_settings_notify              (GObject               *object,
  54                                                   GParamSpec            *pspec);
  55 static guint    settings_install_property_parser (GtkSettingsClass      *class,
  56                                                   GParamSpec            *pspec,
  57                                                   GtkRcPropertyParser    parser);
  58
  59
  60 /* --- variables --- */
  61 static gpointer          parent_class = NULL;
  62 static GtkSettings      *the_singleton = NULL;
  63 static GQuark            quark_property_parser = 0;
  64 static GSList           *object_list = NULL;
  65 static guint             class_n_properties = 0;
  66
  67
  68 /* --- functions --- */
  69 GType
  70 gtk_settings_get_type (void)
  71 {
  72   static GType settings_type = 0;
  73
  74   if (!settings_type)
  75     {
  76       static const GTypeInfo settings_info =
  77       {
  78         sizeof (GtkSettingsClass),
  79         NULL,           /* base_init */
  80         NULL,           /* base_finalize */
  81         (GClassInitFunc) gtk_settings_class_init,
  82         NULL,           /* class_finalize */
  83         NULL,           /* class_data */
  84         sizeof (GtkSettings),
  85         0,              /* n_preallocs */
  86         (GInstanceInitFunc) gtk_settings_init,
  87       };
  88
  89       settings_type = g_type_register_static (G_TYPE_OBJECT, "GtkSettings", &settings_info, 0);
  90     }
  91
  92   return settings_type;
  93 }
  94
  95 static void
  96 gtk_settings_init (GtkSettings *settings)
  97 {
  98   GParamSpec **pspecs, **p;
  99   guint i = 0;
 100
 101   g_datalist_init (&settings->queued_settings);
 102   object_list = g_slist_prepend (object_list, settings);
 103
 104   /* build up property array for all yet existing properties and queue
 105    * notification for them (at least notification for internal properties
 106    * will instantly be caught)
 107    */
 108   pspecs = g_object_class_list_properties (G_OBJECT_GET_CLASS (settings), NULL);
 109   for (p = pspecs; *p; p++)
 110     if ((*p)->owner_type == G_OBJECT_TYPE (settings))
 111       i++;
 112   settings->property_values = g_new0 (GValue, i);
 113   i = 0;
 114   g_object_freeze_notify (G_OBJECT (settings));
 115   for (p = pspecs; *p; p++)
 116     {
 117       GParamSpec *pspec = *p;
 118
 119       if (pspec->owner_type != G_OBJECT_TYPE (settings))
 120         continue;
 121       g_value_init (settings->property_values + i, G_PARAM_SPEC_VALUE_TYPE (pspec));
 122       g_param_value_set_default (pspec, settings->property_values + i);
 123       g_object_notify (G_OBJECT (settings), pspec->name);
 124       i++;
 125     }
 126   g_object_thaw_notify (G_OBJECT (settings));
 127   g_free (pspecs);
 128 }
 129
 130 static void
 131 gtk_settings_class_init (GtkSettingsClass *class)
 132 {
 133   GObjectClass *gobject_class = G_OBJECT_CLASS (class);
 134   guint result;
 135
 136   parent_class = g_type_class_peek_parent (class);
 137
 138   gobject_class->constructor = gtk_settings_constructor;
 139   gobject_class->finalize = gtk_settings_finalize;
 140   gobject_class->get_property = gtk_settings_get_property;
 141   gobject_class->set_property = gtk_settings_set_property;
 142   gobject_class->notify = gtk_settings_notify;
 143
 144   quark_property_parser = g_quark_from_static_string ("gtk-rc-property-parser");
 145
 146   result = settings_install_property_parser (class,
 147                                              g_param_spec_int ("gtk-double-click-time",
 148                                                                _("Double Click Time"),
 149                                                                _("Maximum time allowed between two clicks for them to be considered a double click (in milliseconds)"),
 150                                                                0, G_MAXINT, 250,
 151                                                                G_PARAM_READWRITE),
 152                                              NULL);
 153   g_assert (result == PROP_DOUBLE_CLICK_TIME);
 154   result = settings_install_property_parser (class,
 155                                              g_param_spec_boolean ("gtk-cursor-blink",
 156                                                                    _("Cursor Blink"),
 157                                                                    _("Whether the cursor should blink"),
 158                                                                    TRUE,
 159                                                                    G_PARAM_READWRITE),
 160                                              NULL);
 161   g_assert (result == PROP_CURSOR_BLINK);
 162   result = settings_install_property_parser (class,
 163                                              g_param_spec_int ("gtk-cursor-blink-time",
 164                                                                _("Cursor Blink Time"),
 165                                                                _("Length of the cursor blink cycle, in milleseconds"),
 166                                                                100, G_MAXINT, 1200,
 167                                                                G_PARAM_READWRITE),
 168                                              NULL);
 169   g_assert (result == PROP_CURSOR_BLINK_TIME);
 170   result = settings_install_property_parser (class,
 171                                              g_param_spec_boolean ("gtk-split-cursor",
 172                                                                    _("Split Cursor"),
 173                                                                    _("Whether two cursors should be displayed for mixed left-to-right and right-to-left text"),
 174                                                                    TRUE,
 175                                                                    G_PARAM_READWRITE),
 176                                              NULL);
 177   g_assert (result == PROP_SPLIT_CURSOR);
 178   result = settings_install_property_parser (class,
 179                                              g_param_spec_string ("gtk-theme-name",
 180                                                                    _("Theme Name"),
 181                                                                    _("Name of theme RC file to load"),
 182                                                                   "Default",
 183                                                                   G_PARAM_READWRITE),
 184                                              NULL);
 185   g_assert (result == PROP_THEME_NAME);
 186   result = settings_install_property_parser (class,
 187                                              g_param_spec_string ("gtk-key-theme-name",
 188                                                                   _("Key Theme Name"),
 189                                                                   _("Name of key theme RC file to load"),
 190                                                                   NULL,
 191                                                                   G_PARAM_READWRITE),
 192                                              NULL);
 193   g_assert (result == PROP_KEY_THEME_NAME);
 194
 195   result = settings_install_property_parser (class,
 196                                              g_param_spec_string ("gtk-menu-bar-accel",
 197                                                                   _("Menu bar accelerator"),
 198                                                                   _("Keybinding to activate the menu bar"),
 199                                                                   "F10",
 200                                                                   G_PARAM_READWRITE),
 201                                              NULL);
 202   g_assert (result == PROP_MENU_BAR_ACCEL);
 203
 204   result = settings_install_property_parser (class,
 205                                              g_param_spec_int ("gtk-dnd-drag-threshold",
 206                                                                _("Drag threshold"),
 207                                                                _("Number of pixels the cursor can move before dragging"),
 208                                                                1, G_MAXINT, 8,
 209                                                                G_PARAM_READWRITE),
 210                                              NULL);
 211   g_assert (result == PROP_DND_DRAG_THRESHOLD);
 212
 213   result = settings_install_property_parser (class,
 214                                              g_param_spec_string ("gtk-font-name",
 215                                                                    _("Font Name"),
 216                                                                    _("Name of default font to use"),
 217                                                                   "Sans 10",
 218                                                                   G_PARAM_READWRITE),
 219                                              NULL);
 220   g_assert (result == PROP_FONT_NAME);
 221
 222 }
 223
 224 static void
 225 gtk_settings_finalize (GObject *object)
 226 {
 227   GtkSettings *settings = GTK_SETTINGS (object);
 228   guint i;
 229
 230   object_list = g_slist_remove (object_list, settings);
 231
 232   for (i = 0; i < class_n_properties; i++)
 233     g_value_unset (settings->property_values + i);
 234   g_free (settings->property_values);
 235
 236   g_datalist_clear (&settings->queued_settings);
 237
 238   G_OBJECT_CLASS (parent_class)->finalize (object);
 239 }
 240
 241 static GObject*
 242 gtk_settings_constructor (GType                  type,
 243                           guint                  n_construct_properties,
 244                           GObjectConstructParam *construct_properties)
 245 {
 246   GObject *object;
 247
 248   /* currently we're a singleton, that might change with multiple display support though */
 249   if (!the_singleton)
 250     {
 251       object = G_OBJECT_CLASS (parent_class)->constructor (type,
 252                                                            n_construct_properties,
 253                                                            construct_properties);
 254       the_singleton = GTK_SETTINGS (g_object_ref (object));
 255     }
 256   else
 257     object = g_object_ref (G_OBJECT (the_singleton));
 258
 259   return object;
 260 }
 261
 262 GtkSettings*
 263 gtk_settings_get_default (void)
 264 {
 265   if (!the_singleton)
 266     g_object_new (GTK_TYPE_SETTINGS, NULL);
 267
 268   return the_singleton; /* we don't add a reference count here, we'd be settings_ref_global() if we did */
 269 }
 270
 271 static void
 272 gtk_settings_set_property (GObject      *object,
 273                            guint         property_id,
 274                            const GValue *value,
 275                            GParamSpec   *pspec)
 276 {
 277   GtkSettings *settings = GTK_SETTINGS (object);
 278
 279   g_value_copy (value, settings->property_values + property_id - 1);
 280 }
 281
 282 static void
 283 gtk_settings_get_property (GObject     *object,
 284                            guint        property_id,
 285                            GValue      *value,
 286                            GParamSpec  *pspec)
 287 {
 288   GtkSettings *settings = GTK_SETTINGS (object);
 289   GType value_type = G_VALUE_TYPE (value);
 290   GType fundamental_type = G_TYPE_FUNDAMENTAL (value_type);
 291
 292   /* For enums and strings, we need to get the value as a string,
 293    * not as an int, since we support using names/nicks as the setting
 294    * value.
 295    */
 296   if ((g_value_type_transformable (G_TYPE_INT, value_type) &&
 297        !(fundamental_type == G_TYPE_ENUM || fundamental_type == G_TYPE_FLAGS)) ||
 298       g_value_type_transformable (G_TYPE_STRING, G_VALUE_TYPE (value)) ||
 299       g_value_type_transformable (GDK_TYPE_COLOR, G_VALUE_TYPE (value)))
 300     {
 301       if (gdk_setting_get (pspec->name, value))
 302         g_param_value_validate (pspec, value);
 303       else
 304         g_value_copy (settings->property_values + property_id - 1, value);
 305     }
 306   else
 307     {
 308       GValue val = { 0, };
 309
 310       /* Try to get xsetting as a string and parse it. */
 311
 312       g_value_init (&val, G_TYPE_STRING);
 313
 314       if (!gdk_setting_get (pspec->name, &val))
 315         {
 316           g_value_copy (settings->property_values + property_id - 1, value);
 317         }
 318       else
 319         {
 320           GValue tmp_value = { 0, };
 321           GValue gstring_value = { 0, };
 322           GtkRcPropertyParser parser = g_param_spec_get_qdata (pspec,
 323                                                                quark_property_parser);
 324
 325           g_value_init (&gstring_value, G_TYPE_GSTRING);
 326
 327           g_value_set_boxed (&gstring_value,
 328                              g_string_new (g_value_get_string (&val)));
 329
 330           g_value_init (&tmp_value, G_PARAM_SPEC_VALUE_TYPE (pspec));
 331
 332           if (parser && _gtk_settings_parse_convert (parser, &gstring_value,
 333                                                      pspec, &tmp_value))
 334             {
 335               g_value_copy (&tmp_value, value);
 336               g_param_value_validate (pspec, value);
 337             }
 338           else
 339             {
 340               g_value_copy (settings->property_values + property_id - 1, value);
 341             }
 342
 343           g_value_unset (&gstring_value);
 344           g_value_unset (&tmp_value);
 345         }
 346
 347       g_value_unset (&val);
 348     }
 349 }
 350
 351 static void
 352 gtk_settings_notify (GObject    *object,
 353                      GParamSpec *pspec)
 354 {
 355   guint property_id = pspec->param_id;
 356   gint double_click_time;
 357
 358 #if 1
 359   GValue tmp_value = { 0, };
 360   gchar *contents;
 361   g_value_init (&tmp_value, G_PARAM_SPEC_VALUE_TYPE (pspec));
 362   g_object_get_property (object, pspec->name, &tmp_value);
 363   contents = g_strdup_value_contents (&tmp_value);
 364
 365   switch (property_id)
 366     {
 367     case PROP_DOUBLE_CLICK_TIME:
 368       g_object_get (object, pspec->name, &double_click_time, NULL);
 369       gdk_set_double_click_time (double_click_time);
 370       break;
 371     }
 372
 373   g_free (contents);
 374   g_value_unset (&tmp_value);
 375 #endif
 376 }
 377
 378 gboolean
 379 _gtk_settings_parse_convert (GtkRcPropertyParser parser,
 380                              const GValue       *src_value,
 381                              GParamSpec         *pspec,
 382                              GValue             *dest_value)
 383 {
 384   gboolean success = FALSE;
 385
 386   g_return_val_if_fail (G_VALUE_HOLDS (dest_value, G_PARAM_SPEC_VALUE_TYPE (pspec)), FALSE);
 387
 388   if (parser)
 389     {
 390       GString *gstring;
 391       gboolean free_gstring = TRUE;
 392
 393       if (G_VALUE_HOLDS (src_value, G_TYPE_GSTRING))
 394         {
 395           gstring = g_value_get_boxed (src_value);
 396           free_gstring = FALSE;
 397         }
 398       else if (G_VALUE_HOLDS_LONG (src_value))
 399         {
 400           gstring = g_string_new ("");
 401           g_string_append_printf (gstring, "%ld", g_value_get_long (src_value));
 402         }
 403       else if (G_VALUE_HOLDS_DOUBLE (src_value))
 404         {
 405           gstring = g_string_new ("");
 406           g_string_append_printf (gstring, "%f", g_value_get_double (src_value));
 407         }
 408       else if (G_VALUE_HOLDS_STRING (src_value))
 409         {
 410           gchar *tstr = g_strescape (g_value_get_string (src_value), NULL);
 411
 412           gstring = g_string_new ("\"");
 413           g_string_append (gstring, tstr);
 414           g_string_append_c (gstring, '\"');
 415           g_free (tstr);
 416         }
 417       else
 418         {
 419           g_return_val_if_fail (G_VALUE_HOLDS (src_value, G_TYPE_GSTRING), FALSE);
 420           gstring = NULL; /* silence compiler */
 421         }
 422
 423       success = (parser (pspec, gstring, dest_value) &&
 424                  !g_param_value_validate (pspec, dest_value));
 425
 426       if (free_gstring)
 427         g_string_free (gstring, TRUE);
 428     }
 429   else if (G_VALUE_HOLDS (src_value, G_TYPE_GSTRING))
 430     {
 431       if (G_VALUE_HOLDS (dest_value, G_TYPE_STRING))
 432         {
 433           GString *gstring = g_value_get_boxed (src_value);
 434
 435           g_value_set_string (dest_value, gstring ? gstring->str : NULL);
 436           success = !g_param_value_validate (pspec, dest_value);
 437         }
 438     }
 439   else if (g_value_type_transformable (G_VALUE_TYPE (src_value), G_VALUE_TYPE (dest_value)))
 440     success = g_param_value_convert (pspec, src_value, dest_value, TRUE);
 441
 442   return success;
 443 }
 444
 445 static void
 446 apply_queued_setting (GtkSettings      *data,
 447                       GParamSpec       *pspec,
 448                       GtkSettingsValue *qvalue)
 449 {
 450   GValue tmp_value = { 0, };
 451   GtkRcPropertyParser parser = g_param_spec_get_qdata (pspec, quark_property_parser);
 452
 453   g_value_init (&tmp_value, G_PARAM_SPEC_VALUE_TYPE (pspec));
 454   if (_gtk_settings_parse_convert (parser, &qvalue->value,
 455                                    pspec, &tmp_value))
 456     g_object_set_property (G_OBJECT (data), pspec->name, &tmp_value);
 457   else
 458     {
 459       gchar *debug = g_strdup_value_contents (&qvalue->value);
 460
 461       g_message ("%s: failed to retrieve property `%s' of type `%s' from rc file value \"%s\" of type `%s'",
 462                  qvalue->origin,
 463                  pspec->name,
 464                  g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec)),
 465                  debug,
 466                  G_VALUE_TYPE_NAME (&tmp_value));
 467       g_free (debug);
 468     }
 469   g_value_unset (&tmp_value);
 470 }
 471
 472 static guint
 473 settings_install_property_parser (GtkSettingsClass   *class,
 474                                   GParamSpec         *pspec,
 475                                   GtkRcPropertyParser parser)
 476 {
 477   GSList *node, *next;
 478
 479   switch (G_TYPE_FUNDAMENTAL (G_PARAM_SPEC_VALUE_TYPE (pspec)))
 480     {
 481     case G_TYPE_BOOLEAN:
 482     case G_TYPE_UCHAR:
 483     case G_TYPE_CHAR:
 484     case G_TYPE_UINT:
 485     case G_TYPE_INT:
 486     case G_TYPE_ULONG:
 487     case G_TYPE_LONG:
 488     case G_TYPE_FLOAT:
 489     case G_TYPE_DOUBLE:
 490     case G_TYPE_STRING:
 491       break;
 492     default:
 493       if (!parser)
 494         {
 495           g_warning (G_STRLOC ": parser needs to be specified for property \"%s\" of type `%s'",
 496                      pspec->name, g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec)));
 497           return 0;
 498         }
 499     }
 500   if (g_object_class_find_property (G_OBJECT_CLASS (class), pspec->name))
 501     {
 502       g_warning (G_STRLOC ": an rc-data property \"%s\" already exists",
 503                  pspec->name);
 504       return 0;
 505     }
 506
 507   for (node = object_list; node; node = node->next)
 508     g_object_freeze_notify (node->data);
 509
 510   g_object_class_install_property (G_OBJECT_CLASS (class), ++class_n_properties, pspec);
 511   g_param_spec_set_qdata (pspec, quark_property_parser, parser);
 512
 513   for (node = object_list; node; node = node->next)
 514     {
 515       GtkSettings *settings = node->data;
 516       GtkSettingsValue *qvalue;
 517
 518       settings->property_values = g_renew (GValue, settings->property_values, class_n_properties);
 519       settings->property_values[class_n_properties - 1].g_type = 0;
 520       g_value_init (settings->property_values + class_n_properties - 1, G_PARAM_SPEC_VALUE_TYPE (pspec));
 521       g_param_value_set_default (pspec, settings->property_values + class_n_properties - 1);
 522       g_object_notify (G_OBJECT (settings), pspec->name);
 523
 524       qvalue = g_datalist_get_data (&settings->queued_settings, pspec->name);
 525       if (qvalue)
 526         apply_queued_setting (settings, pspec, qvalue);
 527     }
 528
 529   for (node = object_list; node; node = next)
 530     {
 531       next = node->next;
 532       g_object_thaw_notify (node->data);
 533     }
 534
 535   return class_n_properties;
 536 }
 537
 538 GtkRcPropertyParser
 539 _gtk_rc_property_parser_from_type (GType type)
 540 {
 541   if (type == GDK_TYPE_COLOR)
 542     return gtk_rc_property_parse_color;
 543   else if (type == GTK_TYPE_REQUISITION)
 544     return gtk_rc_property_parse_requisition;
 545   else if (type == GTK_TYPE_BORDER)
 546     return gtk_rc_property_parse_border;
 547   else if (G_TYPE_FUNDAMENTAL (type) == G_TYPE_ENUM && G_TYPE_IS_DERIVED (type))
 548     return gtk_rc_property_parse_enum;
 549   else if (G_TYPE_FUNDAMENTAL (type) == G_TYPE_FLAGS && G_TYPE_IS_DERIVED (type))
 550     return gtk_rc_property_parse_flags;
 551   else
 552     return NULL;
 553 }
 554
 555 void
 556 gtk_settings_install_property (GParamSpec  *pspec)
 557 {
 558   GtkRcPropertyParser parser;
 559
 560   g_return_if_fail (G_IS_PARAM_SPEC (pspec));
 561
 562   parser = _gtk_rc_property_parser_from_type (G_PARAM_SPEC_VALUE_TYPE (pspec));
 563
 564   settings_install_property_parser (gtk_type_class (GTK_TYPE_SETTINGS), pspec, parser);
 565 }
 566
 567 void
 568 gtk_settings_install_property_parser (GParamSpec         *pspec,
 569                                       GtkRcPropertyParser parser)
 570 {
 571   g_return_if_fail (G_IS_PARAM_SPEC (pspec));
 572   g_return_if_fail (parser != NULL);
 573
 574   settings_install_property_parser (gtk_type_class (GTK_TYPE_SETTINGS), pspec, parser);
 575 }
 576
 577 static void
 578 free_value (gpointer data)
 579 {
 580   GtkSettingsValue *qvalue = data;
 581
 582   g_value_unset (&qvalue->value);
 583   g_free (qvalue->origin);
 584   g_free (qvalue);
 585 }
 586
 587 void
 588 gtk_settings_set_property_value (GtkSettings            *settings,
 589                                  const gchar            *prop_name,
 590                                  const GtkSettingsValue *new_value)
 591 {
 592   GtkSettingsValue *qvalue;
 593   GParamSpec *pspec;
 594   gchar *name;
 595   GQuark name_quark;
 596
 597   g_return_if_fail (GTK_SETTINGS (settings));
 598   g_return_if_fail (prop_name != NULL);
 599   g_return_if_fail (new_value != NULL);
 600   g_return_if_fail (new_value->origin != NULL);
 601
 602   if (!G_VALUE_HOLDS_LONG (&new_value->value) &&
 603       !G_VALUE_HOLDS_DOUBLE (&new_value->value) &&
 604       !G_VALUE_HOLDS_STRING (&new_value->value) &&
 605       !G_VALUE_HOLDS (&new_value->value, G_TYPE_GSTRING))
 606     {
 607       g_warning (G_STRLOC ": value type invalid");
 608       return;
 609     }
 610
 611   name = g_strdup (prop_name);
 612   g_strcanon (name, G_CSET_A_2_Z G_CSET_a_2_z G_CSET_DIGITS "-", '-');
 613   name_quark = g_quark_from_string (name);
 614   g_free (name);
 615
 616   qvalue = g_datalist_id_get_data (&settings->queued_settings, name_quark);
 617   if (!qvalue)
 618     {
 619       qvalue = g_new0 (GtkSettingsValue, 1);
 620       g_datalist_id_set_data_full (&settings->queued_settings, name_quark, qvalue, free_value);
 621     }
 622   else
 623     {
 624       g_free (qvalue->origin);
 625       g_value_unset (&qvalue->value);
 626     }
 627   qvalue->origin = g_strdup (new_value->origin);
 628   g_value_init (&qvalue->value, G_VALUE_TYPE (&new_value->value));
 629   g_value_copy (&new_value->value, &qvalue->value);
 630   pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (settings), g_quark_to_string (name_quark));
 631   if (pspec)
 632     apply_queued_setting (settings, pspec, qvalue);
 633 }
 634
 635 void
 636 gtk_settings_set_string_property (GtkSettings *settings,
 637                                   const gchar *name,
 638                                   const gchar *v_string,
 639                                   const gchar *origin)
 640 {
 641   GtkSettingsValue svalue = { NULL, { 0, }, };
 642
 643   g_return_if_fail (GTK_SETTINGS (settings));
 644   g_return_if_fail (name != NULL);
 645   g_return_if_fail (v_string != NULL);
 646   g_return_if_fail (origin != NULL);
 647
 648   svalue.origin = (gchar*) origin;
 649   g_value_init (&svalue.value, G_TYPE_STRING);
 650   g_value_set_static_string (&svalue.value, v_string);
 651   gtk_settings_set_property_value (settings, name, &svalue);
 652   g_value_unset (&svalue.value);
 653 }
 654
 655 void
 656 gtk_settings_set_long_property (GtkSettings *settings,
 657                                 const gchar *name,
 658                                 glong        v_long,
 659                                 const gchar *origin)
 660 {
 661   GtkSettingsValue svalue = { NULL, { 0, }, };
 662
 663   g_return_if_fail (GTK_SETTINGS (settings));
 664   g_return_if_fail (name != NULL);
 665   g_return_if_fail (origin != NULL);
 666
 667   svalue.origin = (gchar*) origin;
 668   g_value_init (&svalue.value, G_TYPE_LONG);
 669   g_value_set_long (&svalue.value, v_long);
 670   gtk_settings_set_property_value (settings, name, &svalue);
 671   g_value_unset (&svalue.value);
 672 }
 673
 674 void
 675 gtk_settings_set_double_property (GtkSettings *settings,
 676                                   const gchar *name,
 677                                   gdouble      v_double,
 678                                   const gchar *origin)
 679 {
 680   GtkSettingsValue svalue = { NULL, { 0, }, };
 681
 682   g_return_if_fail (GTK_SETTINGS (settings));
 683   g_return_if_fail (name != NULL);
 684   g_return_if_fail (origin != NULL);
 685
 686   svalue.origin = (gchar*) origin;
 687   g_value_init (&svalue.value, G_TYPE_DOUBLE);
 688   g_value_set_double (&svalue.value, v_double);
 689   gtk_settings_set_property_value (settings, name, &svalue);
 690   g_value_unset (&svalue.value);
 691 }
 692
 693 gboolean
 694 gtk_rc_property_parse_color (const GParamSpec *pspec,
 695                              const GString    *gstring,
 696                              GValue           *property_value)
 697 {
 698   GdkColor color = { 0, 0, 0, 0, };
 699   GScanner *scanner;
 700   gboolean success;
 701
 702   g_return_val_if_fail (G_IS_PARAM_SPEC (pspec), FALSE);
 703   g_return_val_if_fail (G_VALUE_HOLDS (property_value, GDK_TYPE_COLOR), FALSE);
 704
 705   scanner = gtk_rc_scanner_new ();
 706   g_scanner_input_text (scanner, gstring->str, gstring->len);
 707   if (gtk_rc_parse_color (scanner, &color) == G_TOKEN_NONE &&
 708       g_scanner_get_next_token (scanner) == G_TOKEN_EOF)
 709     {
 710       g_value_set_boxed (property_value, &color);
 711       success = TRUE;
 712     }
 713   else
 714     success = FALSE;
 715   g_scanner_destroy (scanner);
 716
 717   return success;
 718 }
 719
 720 gboolean
 721 gtk_rc_property_parse_enum (const GParamSpec *pspec,
 722                             const GString    *gstring,
 723                             GValue           *property_value)
 724 {
 725   gboolean need_closing_brace = FALSE, success = FALSE;
 726   GScanner *scanner;
 727   GEnumValue *enum_value = NULL;
 728
 729   g_return_val_if_fail (G_IS_PARAM_SPEC (pspec), FALSE);
 730   g_return_val_if_fail (G_VALUE_HOLDS_ENUM (property_value), FALSE);
 731
 732   scanner = gtk_rc_scanner_new ();
 733   g_scanner_input_text (scanner, gstring->str, gstring->len);
 734
 735   /* we just want to parse _one_ value, but for consistency with flags parsing
 736    * we support optional paranthesis
 737    */
 738   g_scanner_get_next_token (scanner);
 739   if (scanner->token == '(')
 740     {
 741       need_closing_brace = TRUE;
 742       g_scanner_get_next_token (scanner);
 743     }
 744   if (scanner->token == G_TOKEN_IDENTIFIER)
 745     {
 746       GEnumClass *class = G_PARAM_SPEC_ENUM (pspec)->enum_class;
 747
 748       enum_value = g_enum_get_value_by_name (class, scanner->value.v_identifier);
 749       if (!enum_value)
 750         enum_value = g_enum_get_value_by_nick (class, scanner->value.v_identifier);
 751       if (enum_value)
 752         {
 753           g_value_set_enum (property_value, enum_value->value);
 754           success = TRUE;
 755         }
 756     }
 757   else if (scanner->token == G_TOKEN_INT)
 758     {
 759       g_value_set_enum (property_value, scanner->value.v_int);
 760       success = TRUE;
 761     }
 762   if (need_closing_brace && g_scanner_get_next_token (scanner) != ')')
 763     success = FALSE;
 764   if (g_scanner_get_next_token (scanner) != G_TOKEN_EOF)
 765     success = FALSE;
 766
 767   g_scanner_destroy (scanner);
 768
 769   return success;
 770 }
 771
 772 static guint
 773 parse_flags_value (GScanner    *scanner,
 774                    GFlagsClass *class,
 775                    guint       *number)
 776 {
 777   g_scanner_get_next_token (scanner);
 778   if (scanner->token == G_TOKEN_IDENTIFIER)
 779     {
 780       GFlagsValue *flags_value;
 781
 782       flags_value = g_flags_get_value_by_name (class, scanner->value.v_identifier);
 783       if (!flags_value)
 784         flags_value = g_flags_get_value_by_nick (class, scanner->value.v_identifier);
 785       if (flags_value)
 786         {
 787           *number |= flags_value->value;
 788           return G_TOKEN_NONE;
 789         }
 790     }
 791   else if (scanner->token == G_TOKEN_INT)
 792     {
 793       *number |= scanner->value.v_int;
 794       return G_TOKEN_NONE;
 795     }
 796   return G_TOKEN_IDENTIFIER;
 797 }
 798
 799 gboolean
 800 gtk_rc_property_parse_flags (const GParamSpec *pspec,
 801                              const GString    *gstring,
 802                              GValue           *property_value)
 803 {
 804   GFlagsClass *class;
 805   gboolean success = FALSE;
 806   GScanner *scanner;
 807
 808   g_return_val_if_fail (G_IS_PARAM_SPEC (pspec), FALSE);
 809   g_return_val_if_fail (G_VALUE_HOLDS_FLAGS (property_value), FALSE);
 810
 811   class = G_PARAM_SPEC_FLAGS (pspec)->flags_class;
 812   scanner = gtk_rc_scanner_new ();
 813   g_scanner_input_text (scanner, gstring->str, gstring->len);
 814
 815   /* parse either a single flags value or a "\( ... [ \| ... ] \)" compound */
 816   if (g_scanner_peek_next_token (scanner) == G_TOKEN_IDENTIFIER ||
 817       scanner->next_token == G_TOKEN_INT)
 818     {
 819       guint token, flags_value = 0;
 820
 821       token = parse_flags_value (scanner, class, &flags_value);
 822
 823       if (token == G_TOKEN_NONE && g_scanner_peek_next_token (scanner) == G_TOKEN_EOF)
 824         {
 825           success = TRUE;
 826           g_value_set_flags (property_value, flags_value);
 827         }
 828
 829     }
 830   else if (g_scanner_get_next_token (scanner) == '(')
 831     {
 832       guint token, flags_value = 0;
 833
 834       /* parse first value */
 835       token = parse_flags_value (scanner, class, &flags_value);
 836
 837       /* parse nth values, preceeded by '|' */
 838       while (token == G_TOKEN_NONE && g_scanner_get_next_token (scanner) == '|')
 839         token = parse_flags_value (scanner, class, &flags_value);
 840
 841       /* done, last token must have closed expression */
 842       if (token == G_TOKEN_NONE && scanner->token == ')' &&
 843           g_scanner_peek_next_token (scanner) == G_TOKEN_EOF)
 844         {
 845           g_value_set_flags (property_value, flags_value);
 846           success = TRUE;
 847         }
 848     }
 849   g_scanner_destroy (scanner);
 850
 851   return success;
 852 }
 853
 854 static gboolean
 855 get_braced_int (GScanner *scanner,
 856                 gboolean  first,
 857                 gboolean  last,
 858                 gint     *value)
 859 {
 860   if (first)
 861     {
 862       g_scanner_get_next_token (scanner);
 863       if (scanner->token != '{')
 864         return FALSE;
 865     }
 866
 867   g_scanner_get_next_token (scanner);
 868   if (scanner->token != G_TOKEN_INT)
 869     return FALSE;
 870
 871   *value = scanner->value.v_int;
 872
 873   if (last)
 874     {
 875       g_scanner_get_next_token (scanner);
 876       if (scanner->token != '}')
 877         return FALSE;
 878     }
 879   else
 880     {
 881       g_scanner_get_next_token (scanner);
 882       if (scanner->token != ',')
 883         return FALSE;
 884     }
 885
 886   return TRUE;
 887 }
 888
 889 gboolean
 890 gtk_rc_property_parse_requisition  (const GParamSpec *pspec,
 891                                     const GString    *gstring,
 892                                     GValue           *property_value)
 893 {
 894   GtkRequisition requisition;
 895   GScanner *scanner;
 896   gboolean success = FALSE;
 897
 898   g_return_val_if_fail (G_IS_PARAM_SPEC (pspec), FALSE);
 899   g_return_val_if_fail (G_VALUE_HOLDS_BOXED (property_value), FALSE);
 900
 901   scanner = gtk_rc_scanner_new ();
 902   g_scanner_input_text (scanner, gstring->str, gstring->len);
 903
 904   if (get_braced_int (scanner, TRUE, FALSE, &requisition.width) &&
 905       get_braced_int (scanner, FALSE, TRUE, &requisition.height))
 906     {
 907       g_value_set_boxed (property_value, &requisition);
 908       success = TRUE;
 909     }
 910
 911   g_scanner_destroy (scanner);
 912
 913   return success;
 914 }
 915
 916 gboolean
 917 gtk_rc_property_parse_border (const GParamSpec *pspec,
 918                               const GString    *gstring,
 919                               GValue           *property_value)
 920 {
 921   GtkBorder border;
 922   GScanner *scanner;
 923   gboolean success = FALSE;
 924
 925   g_return_val_if_fail (G_IS_PARAM_SPEC (pspec), FALSE);
 926   g_return_val_if_fail (G_VALUE_HOLDS_BOXED (property_value), FALSE);
 927
 928   scanner = gtk_rc_scanner_new ();
 929   g_scanner_input_text (scanner, gstring->str, gstring->len);
 930
 931   if (get_braced_int (scanner, TRUE, FALSE, &border.left) &&
 932       get_braced_int (scanner, FALSE, FALSE, &border.right) &&
 933       get_braced_int (scanner, FALSE, FALSE, &border.top) &&
 934       get_braced_int (scanner, FALSE, TRUE, &border.bottom))
 935     {
 936       g_value_set_boxed (property_value, &border);
 937       success = TRUE;
 938     }
 939
 940   g_scanner_destroy (scanner);
 941
 942   return success;
 943 }
 944
 945 void
 946 _gtk_settings_handle_event (GdkEventSetting *event)
 947 {
 948   GtkSettings *settings = gtk_settings_get_default ();
 949
 950   if (g_object_class_find_property (G_OBJECT_GET_CLASS (settings), event->name))
 951     g_object_notify (G_OBJECT (settings), event->name);
 952 }