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