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 /**
 764  * gtk_rc_property_parse_color:
 765  * @pspec: a #GParamSpec
 766  * @gstring: the #GString to be parsed
 767  * @property_value: a #GValue which must hold #GdkColor values.
 768  *
 769  * A #GtkRcPropertyParser for use with gtk_settings_install_property_parser()
 770  * or gtk_widget_class_install_style_property_parser() which parses a
 771  * color given either by its name or in the form
 772  * <literal>{ red, green, blue }</literal> where %red, %green and
 773  * %blue are integers between 0 and 65535 or floating-point numbers
 774  * between 0 and 1.
 775  *
 776  * Return value: %TRUE if @gstring could be parsed and @property_value
 777  * has been set to the resulting #GdkColor.
 778  **/
 779 gboolean
 780 gtk_rc_property_parse_color (const GParamSpec *pspec,
 781                              const GString    *gstring,
 782                              GValue           *property_value)
 783 {
 784   GdkColor color = { 0, 0, 0, 0, };
 785   GScanner *scanner;
 786   gboolean success;
 787
 788   g_return_val_if_fail (G_IS_PARAM_SPEC (pspec), FALSE);
 789   g_return_val_if_fail (G_VALUE_HOLDS (property_value, GDK_TYPE_COLOR), FALSE);
 790
 791   scanner = gtk_rc_scanner_new ();
 792   g_scanner_input_text (scanner, gstring->str, gstring->len);
 793   if (gtk_rc_parse_color (scanner, &color) == G_TOKEN_NONE &&
 794       g_scanner_get_next_token (scanner) == G_TOKEN_EOF)
 795     {
 796       g_value_set_boxed (property_value, &color);
 797       success = TRUE;
 798     }
 799   else
 800     success = FALSE;
 801   g_scanner_destroy (scanner);
 802
 803   return success;
 804 }
 805
 806 /**
 807  * gtk_rc_property_parse_enum:
 808  * @pspec: a #GParamSpec
 809  * @gstring: the #GString to be parsed
 810  * @property_value: a #GValue which must hold enum values.
 811  *
 812  * A #GtkRcPropertyParser for use with gtk_settings_install_property_parser()
 813  * or gtk_widget_class_install_style_property_parser() which parses a single
 814  * enumeration value.
 815  *
 816  * The enumeration value can be specified by its name, its nickname or
 817  * its numeric value. For consistency with flags parsing, the value
 818  * may be surrounded by parentheses.
 819  *
 820  * Return value: %TRUE if @gstring could be parsed and @property_value
 821  * has been set to the resulting #GEnumValue.
 822  **/
 823 gboolean
 824 gtk_rc_property_parse_enum (const GParamSpec *pspec,
 825                             const GString    *gstring,
 826                             GValue           *property_value)
 827 {
 828   gboolean need_closing_brace = FALSE, success = FALSE;
 829   GScanner *scanner;
 830   GEnumValue *enum_value = NULL;
 831
 832   g_return_val_if_fail (G_IS_PARAM_SPEC (pspec), FALSE);
 833   g_return_val_if_fail (G_VALUE_HOLDS_ENUM (property_value), FALSE);
 834
 835   scanner = gtk_rc_scanner_new ();
 836   g_scanner_input_text (scanner, gstring->str, gstring->len);
 837
 838   /* we just want to parse _one_ value, but for consistency with flags parsing
 839    * we support optional parenthesis
 840    */
 841   g_scanner_get_next_token (scanner);
 842   if (scanner->token == '(')
 843     {
 844       need_closing_brace = TRUE;
 845       g_scanner_get_next_token (scanner);
 846     }
 847   if (scanner->token == G_TOKEN_IDENTIFIER)
 848     {
 849       GEnumClass *class = G_PARAM_SPEC_ENUM (pspec)->enum_class;
 850
 851       enum_value = g_enum_get_value_by_name (class, scanner->value.v_identifier);
 852       if (!enum_value)
 853         enum_value = g_enum_get_value_by_nick (class, scanner->value.v_identifier);
 854       if (enum_value)
 855         {
 856           g_value_set_enum (property_value, enum_value->value);
 857           success = TRUE;
 858         }
 859     }
 860   else if (scanner->token == G_TOKEN_INT)
 861     {
 862       g_value_set_enum (property_value, scanner->value.v_int);
 863       success = TRUE;
 864     }
 865   if (need_closing_brace && g_scanner_get_next_token (scanner) != ')')
 866     success = FALSE;
 867   if (g_scanner_get_next_token (scanner) != G_TOKEN_EOF)
 868     success = FALSE;
 869
 870   g_scanner_destroy (scanner);
 871
 872   return success;
 873 }
 874
 875 static guint
 876 parse_flags_value (GScanner    *scanner,
 877                    GFlagsClass *class,
 878                    guint       *number)
 879 {
 880   g_scanner_get_next_token (scanner);
 881   if (scanner->token == G_TOKEN_IDENTIFIER)
 882     {
 883       GFlagsValue *flags_value;
 884
 885       flags_value = g_flags_get_value_by_name (class, scanner->value.v_identifier);
 886       if (!flags_value)
 887         flags_value = g_flags_get_value_by_nick (class, scanner->value.v_identifier);
 888       if (flags_value)
 889         {
 890           *number |= flags_value->value;
 891           return G_TOKEN_NONE;
 892         }
 893     }
 894   else if (scanner->token == G_TOKEN_INT)
 895     {
 896       *number |= scanner->value.v_int;
 897       return G_TOKEN_NONE;
 898     }
 899   return G_TOKEN_IDENTIFIER;
 900 }
 901
 902 /**
 903  * gtk_rc_property_parse_flags:
 904  * @pspec: a #GParamSpec
 905  * @gstring: the #GString to be parsed
 906  * @property_value: a #GValue which must hold flags values.
 907  *
 908  * A #GtkRcPropertyParser for use with gtk_settings_install_property_parser()
 909  * or gtk_widget_class_install_style_property_parser() which parses flags.
 910  *
 911  * Flags can be specified by their name, their nickname or
 912  * numerically. Multiple flags can be specified in the form
 913  * <literal>"( flag1 | flag2 | ... )"</literal>.
 914  *
 915  * Return value: %TRUE if @gstring could be parsed and @property_value
 916  * has been set to the resulting flags value.
 917  **/
 918 gboolean
 919 gtk_rc_property_parse_flags (const GParamSpec *pspec,
 920                              const GString    *gstring,
 921                              GValue           *property_value)
 922 {
 923   GFlagsClass *class;
 924    gboolean success = FALSE;
 925   GScanner *scanner;
 926
 927   g_return_val_if_fail (G_IS_PARAM_SPEC (pspec), FALSE);
 928   g_return_val_if_fail (G_VALUE_HOLDS_FLAGS (property_value), FALSE);
 929
 930   class = G_PARAM_SPEC_FLAGS (pspec)->flags_class;
 931   scanner = gtk_rc_scanner_new ();
 932   g_scanner_input_text (scanner, gstring->str, gstring->len);
 933
 934   /* parse either a single flags value or a "\( ... [ \| ... ] \)" compound */
 935   if (g_scanner_peek_next_token (scanner) == G_TOKEN_IDENTIFIER ||
 936       scanner->next_token == G_TOKEN_INT)
 937     {
 938       guint token, flags_value = 0;
 939
 940       token = parse_flags_value (scanner, class, &flags_value);
 941
 942       if (token == G_TOKEN_NONE && g_scanner_peek_next_token (scanner) == G_TOKEN_EOF)
 943         {
 944           success = TRUE;
 945           g_value_set_flags (property_value, flags_value);
 946         }
 947
 948     }
 949   else if (g_scanner_get_next_token (scanner) == '(')
 950     {
 951       guint token, flags_value = 0;
 952
 953       /* parse first value */
 954       token = parse_flags_value (scanner, class, &flags_value);
 955
 956       /* parse nth values, preceeded by '|' */
 957       while (token == G_TOKEN_NONE && g_scanner_get_next_token (scanner) == '|')
 958         token = parse_flags_value (scanner, class, &flags_value);
 959
 960       /* done, last token must have closed expression */
 961       if (token == G_TOKEN_NONE && scanner->token == ')' &&
 962           g_scanner_peek_next_token (scanner) == G_TOKEN_EOF)
 963         {
 964           g_value_set_flags (property_value, flags_value);
 965           success = TRUE;
 966         }
 967     }
 968   g_scanner_destroy (scanner);
 969
 970   return success;
 971 }
 972
 973 static gboolean
 974 get_braced_int (GScanner *scanner,
 975                 gboolean  first,
 976                 gboolean  last,
 977                 gint     *value)
 978 {
 979   if (first)
 980     {
 981       g_scanner_get_next_token (scanner);
 982       if (scanner->token != '{')
 983         return FALSE;
 984     }
 985
 986   g_scanner_get_next_token (scanner);
 987   if (scanner->token != G_TOKEN_INT)
 988     return FALSE;
 989
 990   *value = scanner->value.v_int;
 991
 992   if (last)
 993     {
 994       g_scanner_get_next_token (scanner);
 995       if (scanner->token != '}')
 996         return FALSE;
 997     }
 998   else
 999     {
1000       g_scanner_get_next_token (scanner);
1001       if (scanner->token != ',')
1002         return FALSE;
1003     }
1004
1005   return TRUE;
1006 }
1007
1008 /**
1009  * gtk_rc_property_parse_requisition:
1010  * @pspec: a #GParamSpec
1011  * @gstring: the #GString to be parsed
1012  * @property_value: a #GValue which must hold boxed values.
1013  *
1014  * A #GtkRcPropertyParser for use with gtk_settings_install_property_parser()
1015  * or gtk_widget_class_install_style_property_parser() which parses a
1016  * requisition in the form
1017  * <literal>"{ width, height }"</literal> for integers %width and %height.
1018  *
1019  * Return value: %TRUE if @gstring could be parsed and @property_value
1020  * has been set to the resulting #GtkRequisition.
1021  **/
1022 gboolean
1023 gtk_rc_property_parse_requisition  (const GParamSpec *pspec,
1024                                     const GString    *gstring,
1025                                     GValue           *property_value)
1026 {
1027   GtkRequisition requisition;
1028   GScanner *scanner;
1029   gboolean success = FALSE;
1030
1031   g_return_val_if_fail (G_IS_PARAM_SPEC (pspec), FALSE);
1032   g_return_val_if_fail (G_VALUE_HOLDS_BOXED (property_value), FALSE);
1033
1034   scanner = gtk_rc_scanner_new ();
1035   g_scanner_input_text (scanner, gstring->str, gstring->len);
1036
1037   if (get_braced_int (scanner, TRUE, FALSE, &requisition.width) &&
1038       get_braced_int (scanner, FALSE, TRUE, &requisition.height))
1039     {
1040       g_value_set_boxed (property_value, &requisition);
1041       success = TRUE;
1042     }
1043
1044   g_scanner_destroy (scanner);
1045
1046   return success;
1047 }
1048
1049 /**
1050  * gtk_rc_property_parse_border:
1051  * @pspec: a #GParamSpec
1052  * @gstring: the #GString to be parsed
1053  * @property_value: a #GValue which must hold boxed values.
1054  *
1055  * A #GtkRcPropertyParser for use with gtk_settings_install_property_parser()
1056  * or gtk_widget_class_install_style_property_parser() which parses
1057  * borders in the form
1058  * <literal>"{ left, right, top, bottom }"</literal> for integers
1059  * %left, %right, %top and %bottom.
1060  *
1061  * Return value: %TRUE if @gstring could be parsed and @property_value
1062  * has been set to the resulting #GtkBorder.
1063  **/
1064 gboolean
1065 gtk_rc_property_parse_border (const GParamSpec *pspec,
1066                               const GString    *gstring,
1067                               GValue           *property_value)
1068 {
1069   GtkBorder border;
1070   GScanner *scanner;
1071   gboolean success = FALSE;
1072
1073   g_return_val_if_fail (G_IS_PARAM_SPEC (pspec), FALSE);
1074   g_return_val_if_fail (G_VALUE_HOLDS_BOXED (property_value), FALSE);
1075
1076   scanner = gtk_rc_scanner_new ();
1077   g_scanner_input_text (scanner, gstring->str, gstring->len);
1078
1079   if (get_braced_int (scanner, TRUE, FALSE, &border.left) &&
1080       get_braced_int (scanner, FALSE, FALSE, &border.right) &&
1081       get_braced_int (scanner, FALSE, FALSE, &border.top) &&
1082       get_braced_int (scanner, FALSE, TRUE, &border.bottom))
1083     {
1084       g_value_set_boxed (property_value, &border);
1085       success = TRUE;
1086     }
1087
1088   g_scanner_destroy (scanner);
1089
1090   return success;
1091 }
1092
1093 void
1094 _gtk_settings_handle_event (GdkEventSetting *event)
1095 {
1096   GtkSettings *settings = gtk_settings_get_for_screen (gdk_drawable_get_screen (event->window));
1097
1098   if (g_object_class_find_property (G_OBJECT_GET_CLASS (settings), event->name))
1099     g_object_notify (G_OBJECT (settings), event->name);
1100 }
1101
1102 static void
1103 reset_rc_values_foreach (GQuark    key_id,
1104                          gpointer  data,
1105                          gpointer  user_data)
1106 {
1107   GtkSettingsValuePrivate *qvalue = data;
1108   GSList **to_reset = user_data;
1109
1110   if (qvalue->source == GTK_SETTINGS_SOURCE_RC_FILE)
1111     *to_reset = g_slist_prepend (*to_reset, GUINT_TO_POINTER (key_id));
1112 }
1113
1114 void
1115 _gtk_settings_reset_rc_values (GtkSettings *settings)
1116 {
1117   GSList *to_reset = NULL;
1118   GSList *tmp_list;
1119   GParamSpec **pspecs, **p;
1120   gint i;
1121
1122   /* Remove any queued settings
1123    */
1124   g_datalist_foreach (&settings->queued_settings,
1125                       reset_rc_values_foreach,
1126                       &to_reset);
1127
1128   for (tmp_list = to_reset; tmp_list; tmp_list = tmp_list->next)
1129     {
1130       GQuark key_id = GPOINTER_TO_UINT (tmp_list->data);
1131       g_datalist_id_remove_data (&settings->queued_settings, key_id);
1132     }
1133
1134   /* Now reset the active settings
1135    */
1136   pspecs = g_object_class_list_properties (G_OBJECT_GET_CLASS (settings), NULL);
1137   i = 0;
1138
1139   g_object_freeze_notify (G_OBJECT (settings));
1140   for (p = pspecs; *p; p++)
1141     {
1142       if (settings->property_values[i].source == GTK_SETTINGS_SOURCE_RC_FILE)
1143         {
1144           GParamSpec *pspec = *p;
1145
1146           g_param_value_set_default (pspec, &settings->property_values[i].value);
1147           g_object_notify (G_OBJECT (settings), pspec->name);
1148         }
1149       i++;
1150     }
1151   g_object_thaw_notify (G_OBJECT (settings));
1152   g_free (pspecs);
1153 }
1154
1155 static void
1156 settings_update_double_click_time (GtkSettings *settings)
1157 {
1158   if (gdk_screen_get_number (settings->screen) == 0)
1159     {
1160       GdkDisplay *display = gdk_screen_get_display (settings->screen);
1161       gint double_click_time;
1162
1163       g_object_get (settings, "gtk-double-click-time",
1164                     &double_click_time, NULL);
1165
1166       gdk_display_set_double_click_time (display, double_click_time);
1167     }
1168 }