/* GTK - The GIMP Toolkit

 * Copyright (C) 2000 Red Hat, Inc.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the Free

 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

 */

#define PANGO_ENABLE_BACKEND /* for pango_fc_font_map_cache_clear() */

#include "config.h"

#include <string.h>

#include "gtkmodules.h"

#include "gtksettings.h"

#include "gtkrc.h"

#include "gtkintl.h"

#include "gtkwidget.h"

#include "gtkprivate.h"

#include "gtkalias.h"

#ifdef GDK_WINDOWING_X11

#include "x11/gdkx.h"

#include <pango/pangofc-fontmap.h>

#endif

#ifdef GDK_WINDOWING_QUARTZ

#define DEFAULT_KEY_THEME "Mac"

#else

#define DEFAULT_KEY_THEME NULL

#endif

#define DEFAULT_TIMEOUT_INITIAL 200

#define DEFAULT_TIMEOUT_REPEAT   20

#define DEFAULT_TIMEOUT_EXPAND  500

typedef struct _GtkSettingsValuePrivate GtkSettingsValuePrivate;

typedef enum

{

  GTK_SETTINGS_SOURCE_DEFAULT,

  GTK_SETTINGS_SOURCE_RC_FILE,

  GTK_SETTINGS_SOURCE_XSETTING,

  GTK_SETTINGS_SOURCE_APPLICATION

} GtkSettingsSource;

struct _GtkSettingsValuePrivate

{

  GtkSettingsValue public;

  GtkSettingsSource source;

};

struct _GtkSettingsPropertyValue

{

  GValue value;

  GtkSettingsSource source;

};

enum {

  PROP_0,

  PROP_DOUBLE_CLICK_TIME,

  PROP_DOUBLE_CLICK_DISTANCE,

  PROP_CURSOR_BLINK,

  PROP_CURSOR_BLINK_TIME,

  PROP_CURSOR_BLINK_TIMEOUT,

  PROP_SPLIT_CURSOR,

  PROP_THEME_NAME,

  PROP_ICON_THEME_NAME,

  PROP_FALLBACK_ICON_THEME,

  PROP_KEY_THEME_NAME,

  PROP_MENU_BAR_ACCEL,

  PROP_DND_DRAG_THRESHOLD,

  PROP_FONT_NAME,

  PROP_ICON_SIZES,

  PROP_MODULES,

#ifdef GDK_WINDOWING_X11

  PROP_XFT_ANTIALIAS,

  PROP_XFT_HINTING,

  PROP_XFT_HINTSTYLE,

  PROP_XFT_RGBA,

  PROP_XFT_DPI,

  PROP_CURSOR_THEME_NAME,

  PROP_CURSOR_THEME_SIZE,

#endif

  PROP_ALTERNATIVE_BUTTON_ORDER,

  PROP_ALTERNATIVE_SORT_ARROWS,

  PROP_SHOW_INPUT_METHOD_MENU,

  PROP_SHOW_UNICODE_MENU,

  PROP_TIMEOUT_INITIAL,

  PROP_TIMEOUT_REPEAT,

  PROP_TIMEOUT_EXPAND,

  PROP_COLOR_SCHEME,

  PROP_ENABLE_ANIMATIONS,

  PROP_TOUCHSCREEN_MODE,

  PROP_TOOLTIP_TIMEOUT,

  PROP_TOOLTIP_BROWSE_TIMEOUT,

  PROP_TOOLTIP_BROWSE_MODE_TIMEOUT,

  PROP_KEYNAV_CURSOR_ONLY,

  PROP_KEYNAV_WRAP_AROUND,

  PROP_ERROR_BELL,

  PROP_COLOR_HASH,

  PROP_FILE_CHOOSER_BACKEND,

  PROP_PRINT_BACKENDS,

  PROP_PRINT_PREVIEW_COMMAND,

  PROP_ENABLE_MNEMONICS,

  PROP_ENABLE_ACCELS,

  PROP_RECENT_FILES_LIMIT,

  PROP_IM_MODULE,

  PROP_RECENT_FILES_MAX_AGE,

  PROP_FONTCONFIG_TIMESTAMP,

  PROP_SOUND_THEME_NAME,

  PROP_ENABLE_INPUT_FEEDBACK_SOUNDS,

  PROP_ENABLE_EVENT_SOUNDS,

  PROP_ENABLE_TOOLTIPS,

  PROP_TOOLBAR_STYLE,

  PROP_TOOLBAR_ICON_SIZE,

  PROP_AUTO_MNEMONICS,

  PROP_PRIMARY_BUTTON_WARPS_SLIDER,

  PROP_BUTTON_IMAGES,

  PROP_ENTRY_SELECT_ON_FOCUS,

  PROP_ENTRY_PASSWORD_HINT_TIMEOUT,

  PROP_MENU_IMAGES,

  PROP_MENU_BAR_POPUP_DELAY,

  PROP_SCROLLED_WINDOW_PLACEMENT,

  PROP_CAN_CHANGE_ACCELS,

  PROP_MENU_POPUP_DELAY,

  PROP_MENU_POPDOWN_DELAY,

  PROP_LABEL_SELECT_ON_FOCUS,

  PROP_COLOR_PALETTE,

  PROP_IM_PREEDIT_STYLE,

  PROP_IM_STATUS_STYLE

};

/* --- prototypes --- */

static void	gtk_settings_finalize		 (GObject		*object);

static void	gtk_settings_get_property	 (GObject		*object,

						  guint			 property_id,

						  GValue		*value,

						  GParamSpec		*pspec);

static void	gtk_settings_set_property	 (GObject		*object,

						  guint			 property_id,

						  const GValue		*value,

						  GParamSpec		*pspec);

static void	gtk_settings_notify		 (GObject		*object,

						  GParamSpec		*pspec);

static guint	settings_install_property_parser (GtkSettingsClass      *class,

						  GParamSpec            *pspec,

						  GtkRcPropertyParser    parser);

static void    settings_update_double_click      (GtkSettings           *settings);

static void    settings_update_modules           (GtkSettings           *settings);

#ifdef GDK_WINDOWING_X11

static void    settings_update_cursor_theme      (GtkSettings           *settings);

static void    settings_update_resolution        (GtkSettings           *settings);

static void    settings_update_font_options      (GtkSettings           *settings);

static gboolean settings_update_fontconfig       (GtkSettings           *settings);

#endif

static void    settings_update_color_scheme      (GtkSettings *settings);

static void    merge_color_scheme                (GtkSettings           *settings, 

						  const GValue          *value, 

						  GtkSettingsSource      source);

static gchar  *get_color_scheme                  (GtkSettings           *settings);

static GHashTable *get_color_hash                (GtkSettings           *settings);

/* the default palette for GtkColorSelelection */

static const gchar default_color_palette[] =

  "black:white:gray50:red:purple:blue:light blue:green:yellow:orange:"

  "lavender:brown:goldenrod4:dodger blue:pink:light green:gray10:gray30:gray75:gray90";

/* --- variables --- */

static GQuark		 quark_property_parser = 0;

static GSList           *object_list = NULL;

static guint		 class_n_properties = 0;

G_DEFINE_TYPE (GtkSettings, gtk_settings, G_TYPE_OBJECT)

/* --- functions --- */

static void

gtk_settings_init (GtkSettings *settings)

{

  GParamSpec **pspecs, **p;

  guint i = 0;

  g_datalist_init (&settings->queued_settings);

  object_list = g_slist_prepend (object_list, settings);

  /* build up property array for all yet existing properties and queue

   * notification for them (at least notification for internal properties

   * will instantly be caught)

   */

  pspecs = g_object_class_list_properties (G_OBJECT_GET_CLASS (settings), NULL);

  for (p = pspecs; *p; p++)

    if ((*p)->owner_type == G_OBJECT_TYPE (settings))

      i++;

  settings->property_values = g_new0 (GtkSettingsPropertyValue, i);

  i = 0;

  g_object_freeze_notify (G_OBJECT (settings));

  for (p = pspecs; *p; p++)

    {

      GParamSpec *pspec = *p;

      if (pspec->owner_type != G_OBJECT_TYPE (settings))

	continue;

      g_value_init (&settings->property_values[i].value, G_PARAM_SPEC_VALUE_TYPE (pspec));

      g_param_value_set_default (pspec, &settings->property_values[i].value);

      g_object_notify (G_OBJECT (settings), pspec->name);

      settings->property_values[i].source = GTK_SETTINGS_SOURCE_DEFAULT;

      i++;

    }

  g_object_thaw_notify (G_OBJECT (settings));

  g_free (pspecs);

}

static void

gtk_settings_class_init (GtkSettingsClass *class)

{

  GObjectClass *gobject_class = G_OBJECT_CLASS (class);

  guint result;

  gobject_class->finalize = gtk_settings_finalize;

  gobject_class->get_property = gtk_settings_get_property;

  gobject_class->set_property = gtk_settings_set_property;

  gobject_class->notify = gtk_settings_notify;

  quark_property_parser = g_quark_from_static_string ("gtk-rc-property-parser");

  result = settings_install_property_parser (class,

                                             g_param_spec_int ("gtk-double-click-time",

                                                               P_("Double Click Time"),

                                                               P_("Maximum time allowed between two clicks for them to be considered a double click (in milliseconds)"),

                                                               0, G_MAXINT, 250,

                                                               GTK_PARAM_READWRITE),

                                             NULL);

  g_assert (result == PROP_DOUBLE_CLICK_TIME);

  result = settings_install_property_parser (class,

                                             g_param_spec_int ("gtk-double-click-distance",

                                                               P_("Double Click Distance"),

                                                               P_("Maximum distance allowed between two clicks for them to be considered a double click (in pixels)"),

                                                               0, G_MAXINT, 5,

                                                               GTK_PARAM_READWRITE),

                                             NULL);

  g_assert (result == PROP_DOUBLE_CLICK_DISTANCE);

  /**

   * GtkSettings:gtk-cursor-blink:

   *

   * Whether the cursor should blink. 

   *

   * Also see the #GtkSettings:gtk-cursor-blink-timeout setting, 

   * which allows more flexible control over cursor blinking.

   */

  result = settings_install_property_parser (class,

                                             g_param_spec_boolean ("gtk-cursor-blink",

								   P_("Cursor Blink"),

								   P_("Whether the cursor should blink"),

								   TRUE,

								   GTK_PARAM_READWRITE),

					     NULL);

  g_assert (result == PROP_CURSOR_BLINK);

  result = settings_install_property_parser (class,

                                             g_param_spec_int ("gtk-cursor-blink-time",

                                                               P_("Cursor Blink Time"),

                                                               P_("Length of the cursor blink cycle, in milliseconds"),

                                                               100, G_MAXINT, 1200,

                                                               GTK_PARAM_READWRITE),

                                             NULL);

  g_assert (result == PROP_CURSOR_BLINK_TIME);

  /**

   * GtkSettings:gtk-cursor-blink-timeout:

   *

   * Time after which the cursor stops blinking, in seconds.

   * The timer is reset after each user interaction.

   *

   * Setting this to zero has the same effect as setting

   * #GtkSettings:gtk-cursor-blink to %FALSE. 

   *

   * Since: 2.12

   */

  result = settings_install_property_parser (class,

                                             g_param_spec_int ("gtk-cursor-blink-timeout",

                                                               P_("Cursor Blink Timeout"),

                                                               P_("Time after which the cursor stops blinking, in seconds"),

                                                               1, G_MAXINT, G_MAXINT,

                                                               GTK_PARAM_READWRITE),

                                             NULL);

  g_assert (result == PROP_CURSOR_BLINK_TIMEOUT);

  result = settings_install_property_parser (class,

                                             g_param_spec_boolean ("gtk-split-cursor",

								   P_("Split Cursor"),

								   P_("Whether two cursors should be displayed for mixed left-to-right and right-to-left text"),

								   TRUE,

								   GTK_PARAM_READWRITE),

                                             NULL);

  g_assert (result == PROP_SPLIT_CURSOR);

  result = settings_install_property_parser (class,

                                             g_param_spec_string ("gtk-theme-name",

								   P_("Theme Name"),

								   P_("Name of theme RC file to load"),

#ifdef G_OS_WIN32

								  "MS-Windows",

#else

								  "Raleigh",

#endif

								  GTK_PARAM_READWRITE),

                                             NULL);

  g_assert (result == PROP_THEME_NAME);

  result = settings_install_property_parser (class,

                                             g_param_spec_string ("gtk-icon-theme-name",

								  P_("Icon Theme Name"),

								  P_("Name of icon theme to use"),

								  "hicolor",

								  GTK_PARAM_READWRITE),

                                             NULL);

  g_assert (result == PROP_ICON_THEME_NAME);

  result = settings_install_property_parser (class,

                                             g_param_spec_string ("gtk-fallback-icon-theme",

								  P_("Fallback Icon Theme Name"),

								  P_("Name of a icon theme to fall back to"),

								  NULL,

								  GTK_PARAM_READWRITE),

                                             NULL);

  g_assert (result == PROP_FALLBACK_ICON_THEME);

  result = settings_install_property_parser (class,

                                             g_param_spec_string ("gtk-key-theme-name",

								  P_("Key Theme Name"),

								  P_("Name of key theme RC file to load"),

								  DEFAULT_KEY_THEME,

								  GTK_PARAM_READWRITE),

                                             NULL);

  g_assert (result == PROP_KEY_THEME_NAME);    

  result = settings_install_property_parser (class,

                                             g_param_spec_string ("gtk-menu-bar-accel",

                                                                  P_("Menu bar accelerator"),

                                                                  P_("Keybinding to activate the menu bar"),

                                                                  "F10",

                                                                  GTK_PARAM_READWRITE),

                                             NULL);

  g_assert (result == PROP_MENU_BAR_ACCEL);

  result = settings_install_property_parser (class,

					     g_param_spec_int ("gtk-dnd-drag-threshold",

							       P_("Drag threshold"),

							       P_("Number of pixels the cursor can move before dragging"),

							       1, G_MAXINT, 8,

                                                               GTK_PARAM_READWRITE),

					     NULL);

  g_assert (result == PROP_DND_DRAG_THRESHOLD);

  result = settings_install_property_parser (class,

                                             g_param_spec_string ("gtk-font-name",

								   P_("Font Name"),

								   P_("Name of default font to use"),

								  "Sans 10",

								  GTK_PARAM_READWRITE),

                                             NULL);

  g_assert (result == PROP_FONT_NAME);

  /**

   * GtkSettings:gtk-icon-sizes:

   *

   * A list of icon sizes. The list is separated by colons, and

   * item has the form:

   *

   * <replaceable>size-name</replaceable> = <replaceable>width</replaceable> , <replaceable>height</replaceable>

   *

   * E.g. "gtk-menu=16,16:gtk-button=20,20:gtk-dialog=48,48". 

   * GTK+ itself use the following named icon sizes: gtk-menu, 

   * gtk-button, gtk-small-toolbar, gtk-large-toolbar, gtk-dnd, 

   * gtk-dialog. Applications can register their own named icon 

   * sizes with gtk_icon_size_register().

   */

  result = settings_install_property_parser (class,

                                             g_param_spec_string ("gtk-icon-sizes",

								   P_("Icon Sizes"),

								   P_("List of icon sizes (gtk-menu=16,16:gtk-button=20,20..."),

								  NULL,

								  GTK_PARAM_READWRITE),

                                             NULL);

  g_assert (result == PROP_ICON_SIZES);

  result = settings_install_property_parser (class,

                                             g_param_spec_string ("gtk-modules",

								  P_("GTK Modules"),

								  P_("List of currently active GTK modules"),

								  NULL,

								  GTK_PARAM_READWRITE),

                                             NULL);

  g_assert (result == PROP_MODULES);

#ifdef GDK_WINDOWING_X11

  result = settings_install_property_parser (class,

					     g_param_spec_int ("gtk-xft-antialias",

 							       P_("Xft Antialias"),

 							       P_("Whether to antialias Xft fonts; 0=no, 1=yes, -1=default"),

 							       -1, 1, -1,

 							       GTK_PARAM_READWRITE),

					     NULL);

  g_assert (result == PROP_XFT_ANTIALIAS);

  result = settings_install_property_parser (class,

					     g_param_spec_int ("gtk-xft-hinting",

 							       P_("Xft Hinting"),

 							       P_("Whether to hint Xft fonts; 0=no, 1=yes, -1=default"),

 							       -1, 1, -1,

 							       GTK_PARAM_READWRITE),

					     NULL);

  g_assert (result == PROP_XFT_HINTING);

  result = settings_install_property_parser (class,

					     g_param_spec_string ("gtk-xft-hintstyle",

 								  P_("Xft Hint Style"),

 								  P_("What degree of hinting to use; hintnone, hintslight, hintmedium, or hintfull"),

 								  NULL,

 								  GTK_PARAM_READWRITE),

                                              NULL);

  g_assert (result == PROP_XFT_HINTSTYLE);

  result = settings_install_property_parser (class,

					     g_param_spec_string ("gtk-xft-rgba",

 								  P_("Xft RGBA"),

 								  P_("Type of subpixel antialiasing; none, rgb, bgr, vrgb, vbgr"),

 								  NULL,

 								  GTK_PARAM_READWRITE),

					     NULL);

  g_assert (result == PROP_XFT_RGBA);

  result = settings_install_property_parser (class,

					     g_param_spec_int ("gtk-xft-dpi",

 							       P_("Xft DPI"),

 							       P_("Resolution for Xft, in 1024 * dots/inch. -1 to use default value"),

 							       -1, 1024*1024, -1,

 							       GTK_PARAM_READWRITE),

					     NULL);

  g_assert (result == PROP_XFT_DPI);

  result = settings_install_property_parser (class,

                                             g_param_spec_string ("gtk-cursor-theme-name",

								  P_("Cursor theme name"),

								  P_("Name of the cursor theme to use, or NULL to use the default theme"),

								  NULL,

								  GTK_PARAM_READWRITE),

                                             NULL);

  g_assert (result == PROP_CURSOR_THEME_NAME);

  result = settings_install_property_parser (class,

					     g_param_spec_int ("gtk-cursor-theme-size",

 							       P_("Cursor theme size"),

 							       P_("Size to use for cursors, or 0 to use the default size"),

 							       0, 128, 0,

 							       GTK_PARAM_READWRITE),

					     NULL);

  g_assert (result == PROP_CURSOR_THEME_SIZE);

#endif  /* GDK_WINDOWING_X11 */

  result = settings_install_property_parser (class,

                                             g_param_spec_boolean ("gtk-alternative-button-order",

								   P_("Alternative button order"),

								   P_("Whether buttons in dialogs should use the alternative button order"),

								   FALSE,

								   GTK_PARAM_READWRITE),

                                             NULL);

  g_assert (result == PROP_ALTERNATIVE_BUTTON_ORDER);

  /**

   * GtkSettings:gtk-alternative-sort-arrows:

   *

   * Controls the direction of the sort indicators in sorted list and tree

   * views. By default an arrow pointing down means the column is sorted

   * in ascending order. When set to %TRUE, this order will be inverted.

   *

   * Since: 2.12

   */

  result = settings_install_property_parser (class,

                                             g_param_spec_boolean ("gtk-alternative-sort-arrows",

								   P_("Alternative sort indicator direction"),

								   P_("Whether the direction of the sort indicators in list and tree views is inverted compared to the default (where down means ascending)"),

								   FALSE,

								   GTK_PARAM_READWRITE),

                                             NULL);

  g_assert (result == PROP_ALTERNATIVE_SORT_ARROWS);

  result = settings_install_property_parser (class,

					     g_param_spec_boolean ("gtk-show-input-method-menu",

								   P_("Show the 'Input Methods' menu"),

								   P_("Whether the context menus of entries and text views should offer to change the input method"),

								   TRUE,

								   GTK_PARAM_READWRITE),

					     NULL);

  g_assert (result == PROP_SHOW_INPUT_METHOD_MENU);

  result = settings_install_property_parser (class,

					     g_param_spec_boolean ("gtk-show-unicode-menu",

								   P_("Show the 'Insert Unicode Control Character' menu"),

								   P_("Whether the context menus of entries and text views should offer to insert control characters"),

								   TRUE,

								   GTK_PARAM_READWRITE),

					     NULL);

  g_assert (result == PROP_SHOW_UNICODE_MENU);

  result = settings_install_property_parser (class,

					     g_param_spec_int ("gtk-timeout-initial",

 							       P_("Start timeout"),

 							       P_("Starting value for timeouts, when button is pressed"),

 							       0, G_MAXINT, DEFAULT_TIMEOUT_INITIAL,

 							       GTK_PARAM_READWRITE),

					     NULL);

  g_assert (result == PROP_TIMEOUT_INITIAL);

  result = settings_install_property_parser (class,

					     g_param_spec_int ("gtk-timeout-repeat",

 							       P_("Repeat timeout"),

 							       P_("Repeat value for timeouts, when button is pressed"),

 							       0, G_MAXINT, DEFAULT_TIMEOUT_REPEAT,

 							       GTK_PARAM_READWRITE),

					     NULL);

  g_assert (result == PROP_TIMEOUT_REPEAT);

  result = settings_install_property_parser (class,

					     g_param_spec_int ("gtk-timeout-expand",

 							       P_("Expand timeout"),

 							       P_("Expand value for timeouts, when a widget is expanding a new region"),

 							       0, G_MAXINT, DEFAULT_TIMEOUT_EXPAND,

 							       GTK_PARAM_READWRITE),

					     NULL);

  g_assert (result == PROP_TIMEOUT_EXPAND);

  /**

   * GtkSettings:gtk-color-scheme:

   *

   * A palette of named colors for use in themes. The format of the string is

   * <programlisting>

   * name1: color1

   * name2: color2

   * ...

   * </programlisting>

   * Color names must be acceptable as identifiers in the 

   * <link linkend="gtk-Resource-Files">gtkrc</link> syntax, and

   * color specifications must be in the format accepted by

   * gdk_color_parse().

   * 

   * Note that due to the way the color tables from different sources are

   * merged, color specifications will be converted to hexadecimal form

   * when getting this property.

   *

   * Starting with GTK+ 2.12, the entries can alternatively be separated

   * by ';' instead of newlines:

   * <programlisting>

   * name1: color1; name2: color2; ...

   * </programlisting>

   *

   * Since: 2.10

   */

  result = settings_install_property_parser (class,

					     g_param_spec_string ("gtk-color-scheme",

 								  P_("Color scheme"),

 								  P_("A palette of named colors for use in themes"),

 								  "",

 								  GTK_PARAM_READWRITE),

					     NULL);

  g_assert (result == PROP_COLOR_SCHEME);

  result = settings_install_property_parser (class,

                                             g_param_spec_boolean ("gtk-enable-animations",

                                                                   P_("Enable Animations"),

                                                                   P_("Whether to enable toolkit-wide animations."),

                                                                   TRUE,

                                                                   GTK_PARAM_READWRITE),

                                             NULL);

  g_assert (result == PROP_ENABLE_ANIMATIONS);

  /**

   * GtkSettings:gtk-touchscreen-mode:

   *

   * When %TRUE, there are no motion notify events delivered on this screen,

   * and widgets can't use the pointer hovering them for any essential

   * functionality.

   *

   * Since: 2.10

   */

  result = settings_install_property_parser (class,

                                             g_param_spec_boolean ("gtk-touchscreen-mode",

                                                                   P_("Enable Touchscreen Mode"),

                                                                   P_("When TRUE, there are no motion notify events delivered on this screen"),

                                                                   FALSE,

                                                                   GTK_PARAM_READWRITE),

                                             NULL);

  g_assert (result == PROP_TOUCHSCREEN_MODE);

  /**

   * GtkSettings:gtk-tooltip-timeout:

   *

   * Time, in milliseconds, after which a tooltip could appear if the

   * cursor is hovering on top of a widget.

   *

   * Since: 2.12

   */

  result = settings_install_property_parser (class,

					     g_param_spec_int ("gtk-tooltip-timeout",

							       P_("Tooltip timeout"),

							       P_("Timeout before tooltip is shown"),

							       0, G_MAXINT,

							       500,

							       GTK_PARAM_READWRITE),

					     NULL);

  g_assert (result == PROP_TOOLTIP_TIMEOUT);

  /**

   * GtkSettings:gtk-tooltip-browse-timeout:

   *

   * Controls the time after which tooltips will appear when

   * browse mode is enabled, in milliseconds.

   *

   * Browse mode is enabled when the mouse pointer moves off an object

   * where a tooltip was currently being displayed. If the mouse pointer

   * hits another object before the browse mode timeout expires (see

   * #GtkSettings:gtk-tooltip-browse-mode-timeout), it will take the 

   * amount of milliseconds specified by this setting to popup the tooltip

   * for the new object.

   *

   * Since: 2.12

   */

  result = settings_install_property_parser (class,

					     g_param_spec_int ("gtk-tooltip-browse-timeout",

							       P_("Tooltip browse timeout"),

							       P_("Timeout before tooltip is shown when browse mode is enabled"),

							       0, G_MAXINT,

							       60,

							       GTK_PARAM_READWRITE),

					     NULL);

  g_assert (result == PROP_TOOLTIP_BROWSE_TIMEOUT);

  /**

   * GtkSettings:gtk-tooltip-browse-mode-timeout:

   *

   * Amount of time, in milliseconds, after which the browse mode

   * will be disabled.

   *

   * See #GtkSettings:gtk-tooltip-browse-timeout for more information

   * about browse mode.

   *

   * Since: 2.12

   */

  result = settings_install_property_parser (class,

					     g_param_spec_int ("gtk-tooltip-browse-mode-timeout",

 							       P_("Tooltip browse mode timeout"),

 							       P_("Timeout after which browse mode is disabled"),

 							       0, G_MAXINT,

							       500,

 							       GTK_PARAM_READWRITE),

					     NULL);

  g_assert (result == PROP_TOOLTIP_BROWSE_MODE_TIMEOUT);

  /**

   * GtkSettings:gtk-keynav-cursor-only:

   *

   * When %TRUE, keyboard navigation should be able to reach all widgets

   * by using the cursor keys only. Tab, Shift etc. keys can't be expected

   * to be present on the used input device.

   *

   * Since: 2.12

   */

  result = settings_install_property_parser (class,

                                             g_param_spec_boolean ("gtk-keynav-cursor-only",

                                                                   P_("Keynav Cursor Only"),

                                                                   P_("When TRUE, there are only cursor keys available to navigate widgets"),

                                                                   FALSE,

                                                                   GTK_PARAM_READWRITE),

                                             NULL);

  g_assert (result == PROP_KEYNAV_CURSOR_ONLY);

  /**

   * GtkSettings:gtk-keynav-wrap-around:

   *

   * When %TRUE, some widgets will wrap around when doing keyboard

   * navigation, such as menus, menubars and notebooks.

   *

   * Since: 2.12

   */

  result = settings_install_property_parser (class,

                                             g_param_spec_boolean ("gtk-keynav-wrap-around",

                                                                   P_("Keynav Wrap Around"),

                                                                   P_("Whether to wrap around when keyboard-navigating widgets"),

                                                                   TRUE,

                                                                   GTK_PARAM_READWRITE),

                                             NULL);

  g_assert (result == PROP_KEYNAV_WRAP_AROUND);

  /**

   * GtkSettings:gtk-error-bell:

   *

   * When %TRUE, keyboard navigation and other input-related errors

   * will cause a beep. Since the error bell is implemented using

   * gdk_window_beep(), the windowing system may offer ways to

   * configure the error bell in many ways, such as flashing the

   * window or similar visual effects.

   *

   * Since: 2.12

   */

  result = settings_install_property_parser (class,

                                             g_param_spec_boolean ("gtk-error-bell",

                                                                   P_("Error Bell"),

                                                                   P_("When TRUE, keyboard navigation and other errors will cause a beep"),

                                                                   TRUE,

                                                                   GTK_PARAM_READWRITE),

                                             NULL);

  g_assert (result == PROP_ERROR_BELL);

  /**

   * GtkSettings:color-hash:

   *

   * Holds a hash table representation of the #GtkSettings:gtk-color-scheme 

   * setting, mapping color names to #GdkColors. 

   *

   * Since: 2.10

   */

  result = settings_install_property_parser (class, 

                                             g_param_spec_boxed ("color-hash",

                                                                 P_("Color Hash"),

                                                                 P_("A hash table representation of the color scheme."),

                                                                 G_TYPE_HASH_TABLE,

                                                                 GTK_PARAM_READABLE),

                                             NULL);

  g_assert (result == PROP_COLOR_HASH);

  result = settings_install_property_parser (class, 

                                             g_param_spec_string ("gtk-file-chooser-backend",

                                                                  P_("Default file chooser backend"),

                                                                  P_("Name of the GtkFileChooser backend to use by default"),

                                                                  NULL,

                                                                  GTK_PARAM_READWRITE),

                                             NULL);

  g_assert (result == PROP_FILE_CHOOSER_BACKEND);

  /**

   * GtkSettings:gtk-print-backends:

   *

   * A comma-separated list of print backends to use in the print

   * dialog. Available print backends depend on the GTK+ installation,

   * and may include "file", "cups", "lpr" or "papi".

   *

   * Since: 2.10

   */

  result = settings_install_property_parser (class,

                                             g_param_spec_string ("gtk-print-backends",

                                                                  P_("Default print backend"),

                                                                  P_("List of the GtkPrintBackend backends to use by default"),

                                                                  GTK_PRINT_BACKENDS,

                                                                  GTK_PARAM_READWRITE),

                                             NULL);

  g_assert (result == PROP_PRINT_BACKENDS);

  /**

   * GtkSettings:gtk-print-preview-command:

   *

   * A command to run for displaying the print preview. The command

   * should contain a %f placeholder, which will get replaced by

   * the path to the pdf file. The command may also contain a %s

   * placeholder, which will get replaced by the path to a file

   * containing the print settings in the format produced by 

   * gtk_print_settings_to_file().

   *

   * The preview application is responsible for removing the pdf file

   * and the print settings file when it is done.

   *

   * Since: 2.10

   */

  result = settings_install_property_parser (class,

                                             g_param_spec_string ("gtk-print-preview-command",

                                                                  P_("Default command to run when displaying a print preview"),

                                                                  P_("Command to run when displaying a print preview"),

                                                                  GTK_PRINT_PREVIEW_COMMAND,

                                                                  GTK_PARAM_READWRITE),

                                             NULL); 

  g_assert (result == PROP_PRINT_PREVIEW_COMMAND);

  /**

   * GtkSettings:gtk-enable-mnemonics:

   *

   * Whether labels and menu items should have visible mnemonics which

   * can be activated.

   *

   * Since: 2.12

   */

  result = settings_install_property_parser (class,

                                             g_param_spec_boolean ("gtk-enable-mnemonics",

                                                                   P_("Enable Mnemonics"),

                                                                   P_("Whether labels should have mnemonics"),

                                                                   TRUE,

                                                                   GTK_PARAM_READWRITE),

                                             NULL);

  g_assert (result == PROP_ENABLE_MNEMONICS);

  /**

   * GtkSettings:gtk-enable-accels:

   *

   * Whether menu items should have visible accelerators which can be

   * activated.

   *

   * Since: 2.12

   */

  result = settings_install_property_parser (class,

                                             g_param_spec_boolean ("gtk-enable-accels",

                                                                   P_("Enable Accelerators"),

                                                                   P_("Whether menu items should have accelerators"),

                                                                   TRUE,

                                                                   GTK_PARAM_READWRITE),

                                             NULL);

  g_assert (result == PROP_ENABLE_ACCELS);

  /**

   * GtkSettings:gtk-recent-files-limit:

   *

   * The number of recently used files that should be displayed by default by

   * #GtkRecentChooser implementations and by the #GtkFileChooser. A value of

   * -1 means every recently used file stored.

   *

   * Since: 2.12

   */

  result = settings_install_property_parser (class,

					     g_param_spec_int ("gtk-recent-files-limit",

 							       P_("Recent Files Limit"),

 							       P_("Number of recently used files"),

 							       -1, G_MAXINT,

							       50,

 							       GTK_PARAM_READWRITE),

					     NULL);

  g_assert (result == PROP_RECENT_FILES_LIMIT);

  /**

   * GtkSettings:gtk-im-module:

   *

   * Which IM (input method) module should be used by default. This is the 

   * input method that will be used if the user has not explicitly chosen 

   * another input method from the IM context menu.  

   * This also can be a colon-separated list of input methods, which GTK+

   * will try in turn until it finds one available on the system.

   *

   * See #GtkIMContext and see the #GtkSettings:gtk-show-input-method-menu property.

   */

  result = settings_install_property_parser (class,

					     g_param_spec_string ("gtk-im-module",

								  P_("Default IM module"),

								  P_("Which IM module should be used by default"),

								  NULL,

								  GTK_PARAM_READWRITE),