/* GTK - The GIMP Toolkit
 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
 *
 * 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., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

/*
 * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
 * file for a list of people on the GTK+ Team.  See the ChangeLog
 * files for a list of changes.  These files are distributed with
 * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 
 */

#include "config.h"

#include <locale.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#include <sys/stat.h>
#ifdef HAVE_SYS_PARAM_H
#include <sys/param.h>
#endif
#include <fcntl.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>


#include <glib.h>
#include <glib/gstdio.h>
#include "gdk/gdk.h"

#include "gtkversion.h"
#include "gtkrc.h"
#include "gtkbindings.h"
#include "gtkintl.h"
#include "gtkiconfactory.h"
#include "gtkmain.h"
#include "gtkmodules.h"
#include "gtkprivate.h"
#include "gtksettingsprivate.h"
#include "gtkwindow.h"

#ifdef G_OS_WIN32
#include <io.h>
#endif


/**
 * SECTION:gtkrc
 * @Short_description: Deprecated routines for handling resource files
 * @Title: Resource Files
 *
 * GTK+ provides resource file mechanism for configuring
 * various aspects of the operation of a GTK+ program
 * at runtime.
 *
 * <warning>
 * In GTK+ 3.0, resource files have been deprecated and replaced
 * by CSS-like style sheets, which are understood by #GtkCssProvider.
 * </warning>
 *
 * <refsect2>
 * <title>Default files</title>
 * <para>
 * An application can cause GTK+ to parse a specific RC
 * file by calling gtk_rc_parse(). In addition to this,
 * certain files will be read at the end of gtk_init().
 * Unless modified, the files looked for will be
 * <filename>&lt;SYSCONFDIR&gt;/gtk-2.0/gtkrc</filename>
 * and <filename>.gtkrc-3.0</filename> in the users home directory.
 * (<filename>&lt;SYSCONFDIR&gt;</filename> defaults to
 * <filename>/usr/local/etc</filename>. It can be changed with the
 * <option>--prefix</option> or <option>--sysconfdir</option> options when
 * configuring GTK+.)
 *
 * The set of these <firstterm>default</firstterm> files
 * can be retrieved with gtk_rc_get_default_files()
 * and modified with gtk_rc_add_default_file() and
 * gtk_rc_set_default_files().
 * Additionally, the <envar>GTK2_RC_FILES</envar> environment variable
 * can be set to a #G_SEARCHPATH_SEPARATOR_S-separated list of files
 * in order to overwrite the set of default files at runtime.
 * <para><anchor id="locale-specific-rc"/>
 * For each RC file, in addition to the file itself, GTK+ will look for
 * a locale-specific file that will be parsed after the main file.
 * For instance, if <envar>LANG</envar> is set to <literal>ja_JP.ujis</literal>,
 * when loading the default file <filename>~/.gtkrc</filename> then GTK+ looks
 * for <filename>~/.gtkrc.ja_JP</filename> and <filename>~/.gtkrc.ja</filename>,
 * and parses the first of those that exists.</para>
 * </para>
 * </refsect2>
 * <refsect2>
 * <title>Pathnames and patterns</title>
 * <anchor id="gtkrc-pathnames-and-patterns"/>
 * <para>
 * A resource file defines a number of styles and key bindings and
 * attaches them to particular widgets. The attachment is done
 * by the <literal>widget</literal>, <literal>widget_class</literal>,
 * and <literal>class</literal> declarations. As an example
 * of such a statement:
 *
 * <informalexample><programlisting>
 * widget "mywindow.*.GtkEntry" style "my-entry-class"
 * </programlisting></informalexample>
 *
 * attaches the style <literal>"my-entry-class"</literal> to all
 * widgets  whose <firstterm>widget path</firstterm> matches the
 * <firstterm>pattern</firstterm> <literal>"mywindow.*.GtkEntry"</literal>.
 * That is, all #GtkEntry widgets which are part of a #GtkWindow named
 * <literal>"mywindow"</literal>.
 *
 * The patterns here are given in the standard shell glob syntax.
 * The <literal>"?"</literal> wildcard matches any character, while
 * <literal>"*"</literal> matches zero or more of any character.
 * The three types of matching are against the widget path, the
 * <firstterm>class path</firstterm> and the class hierarchy. Both the
 * widget path and the class path consist of a <literal>"."</literal>
 * separated list of all the parents of the widget and the widget itself
 * from outermost to innermost. The difference is that in the widget path,
 * the name assigned by gtk_widget_set_name() is used if present, otherwise
 * the class name of the widget, while for the class path, the class name is
 * always used.
 *
 * Since GTK+ 2.10, <literal>widget_class</literal> paths can also contain
 * <literal>&lt;classname&gt;</literal> substrings, which are matching
 * the class with the given name and any derived classes. For instance,
 * <informalexample><programlisting>
 * widget_class "*&lt;GtkMenuItem&gt;.GtkLabel" style "my-style"
 * </programlisting></informalexample>
 * will match #GtkLabel widgets which are contained in any kind of menu item.
 *
 * So, if you have a #GtkEntry named <literal>"myentry"</literal>, inside of a
 * horizontal box in a window named <literal>"mywindow"</literal>, then the
 * widget path is: <literal>"mywindow.GtkHBox.myentry"</literal>
 * while the class path is: <literal>"GtkWindow.GtkHBox.GtkEntry"</literal>.
 *
 * Matching against class is a little different. The pattern match is done
 * against all class names in the widgets class hierarchy (not the layout
 * hierarchy) in sequence, so the pattern:
 * <informalexample><programlisting>
 * class "GtkButton" style "my-style"
 * </programlisting></informalexample>
 * will match not just #GtkButton widgets, but also #GtkToggleButton and
 * #GtkCheckButton widgets, since those classes derive from #GtkButton.
 *
 * Additionally, a priority can be specified for each pattern, and styles
 * override other styles first by priority, then by pattern type and then
 * by order of specification (later overrides earlier). The priorities
 * that can be specified are (highest to lowest):
 * <simplelist>
 * <member><literal>highest</literal></member>
 * <member><literal>rc</literal></member>
 * <member><literal>theme</literal></member>
 * <member><literal>application</literal></member>
 * <member><literal>gtk</literal></member>
 * <member><literal>lowest</literal></member>
 * </simplelist>
 * <literal>rc</literal> is the default for styles
 * read from an RC file, <literal>theme</literal>
 * is the default for styles read from theme RC files,
 * <literal>application</literal>
 * should be used for styles an application sets
 * up, and <literal>gtk</literal> is used for styles
 * that GTK+ creates internally.
 * </para>
 * </refsect2>
 * <refsect2>
 * <title>Theme gtkrc files</title>
 * <anchor id="theme-gtkrc-files"/>
 * <para>
 * Theme RC files are loaded first from under the <filename>~/.themes/</filename>,
 * then from the directory from gtk_rc_get_theme_dir(). The files looked at will
 * be <filename>gtk-3.0/gtkrc</filename>.
 *
 * When the application prefers dark themes
 * (see the #GtkSettings:gtk-application-prefer-dark-theme property for details),
 * <filename>gtk-3.0/gtkrc-dark</filename> will be loaded first, and if not present
 * <filename>gtk-3.0/gtkrc</filename> will be loaded.
 * </para>
 * </refsect2>
 * <refsect2>
 * <title>Optimizing RC Style Matches</title>
 * <anchor id="optimizing-rc-style-matches"/>
 * <para>
 * Everytime a widget is created and added to the layout hierarchy of a #GtkWindow
 * ("anchored" to be exact), a list of matching RC styles out of all RC styles read
 * in so far is composed.
 * For this, every RC style is matched against the widgets class path,
 * the widgets name path and widgets inheritance hierarchy.
 * As a consequence, significant slowdown can be caused by utilization of many
 * RC styles and by using RC style patterns that are slow or complicated to match
 * against a given widget.
 * The following ordered list provides a number of advices (prioritized by
 * effectiveness) to reduce the performance overhead associated with RC style
 * matches:
 *
 * <orderedlist>
 *   <listitem><para>
 *   Move RC styles for specific applications into RC files dedicated to those
 *   applications and parse application specific RC files only from
 *   applications that are affected by them.
 *   This reduces the overall amount of RC styles that have to be considered
 *   for a match across a group of applications.
 *   </para></listitem>
 *   <listitem><para>
 *   Merge multiple styles which use the same matching rule, for instance:
 *   <informalexample><programlisting>
 *      style "Foo" { foo_content }
 *      class "X" style "Foo"
 *      style "Bar" { bar_content }
 *      class "X" style "Bar"
 *   </programlisting></informalexample>
 *   is faster to match as:
 *   <informalexample><programlisting>
 *      style "FooBar" { foo_content bar_content }
 *      class "X" style "FooBar"
 *   </programlisting></informalexample>
 *   </para></listitem>
 *   <listitem><para>
 *   Use of wildcards should be avoided, this can reduce the individual RC style
 *   match to a single integer comparison in most cases.
 *   </para></listitem>
 *   <listitem><para>
 *   To avoid complex recursive matching, specification of full class names
 *   (for <literal>class</literal> matches) or full path names (for
 *   <literal>widget</literal> and <literal>widget_class</literal> matches)
 *   is to be preferred over shortened names
 *   containing <literal>"*"</literal> or <literal>"?"</literal>.
 *   </para></listitem>
 *   <listitem><para>
 *   If at all necessary, wildcards should only be used at the tail or head
 *   of a pattern. This reduces the match complexity to a string comparison
 *   per RC style.
 *   </para></listitem>
 *   <listitem><para>
 *   When using wildcards, use of <literal>"?"</literal> should be preferred
 *   over <literal>"*"</literal>. This can reduce the matching complexity from
 *   O(n^2) to O(n). For example <literal>"Gtk*Box"</literal> can be turned into
 *   <literal>"Gtk?Box"</literal> and will still match #GtkHBox and #GtkVBox.
 *   </para></listitem>
 *  <listitem><para>
 *   The use of <literal>"*"</literal> wildcards should be restricted as much
 *   as possible, because matching <literal>"A*B*C*RestString"</literal> can
 *   result in matching complexities of O(n^2) worst case.
 *   </para></listitem>
 * </orderedlist>
 * </para>
 * </refsect2>
 * <refsect2>
 * <title>Toplevel declarations</title>
 * <para>
 * An RC file is a text file which is composed of a sequence
 * of declarations. <literal>'#'</literal> characters delimit comments and
 * the portion of a line after a <literal>'#'</literal> is ignored when parsing
 * an RC file.
 *
 * The possible toplevel declarations are:
 *
 * <variablelist>
 *   <varlistentry>
 *     <term><literal>binding <replaceable>name</replaceable>
 *      { ... }</literal></term>
 *     <listitem>
 *       <para>Declares a binding set.</para>
 *     </listitem>
 *   </varlistentry>
 *   <varlistentry>
 *     <term><literal>class <replaceable>pattern</replaceable>
 *           [ style | binding ][ : <replaceable>priority</replaceable> ]
 *           <replaceable>name</replaceable></literal></term>
 *     <listitem>
 *      <para>Specifies a style or binding set for a particular
 *      branch of the inheritance hierarchy.</para>
 *     </listitem>
 *   </varlistentry>
 *   <varlistentry>
 *     <term><literal>include <replaceable>filename</replaceable></literal></term>
 *     <listitem>
 *       <para>Parses another file at this point. If
 *         <replaceable>filename</replaceable> is not an absolute filename,
 *         it is searched in the directories of the currently open RC files.</para>
 *       <para>GTK+ also tries to load a
 *         <link linkend="locale-specific-rc">locale-specific variant</link> of
 *         the included file.</para>
 *     </listitem>
 *   </varlistentry>
 *   <varlistentry>
 *     <term><literal>module_path <replaceable>path</replaceable></literal></term>
 *     <listitem>
 *       <para>Sets a path (a list of directories separated
 *       by colons) that will be searched for theme engines referenced in
 *       RC files.</para>
 *     </listitem>
 *   </varlistentry>
 *   <varlistentry>
 *     <term><literal>pixmap_path <replaceable>path</replaceable></literal></term>
 *     <listitem>
 *       <para>Sets a path (a list of directories separated
 *       by colons) that will be searched for pixmaps referenced in
 *       RC files.</para>
 *     </listitem>
 *   </varlistentry>
 *   <varlistentry>
 *     <term><literal>im_module_file <replaceable>pathname</replaceable></literal></term>
 *     <listitem>
 *       <para>Sets the pathname for the IM modules file. Setting this from RC files
 *       is deprecated; you should use the environment variable <envar>GTK_IM_MODULE_FILE</envar>
 *       instead.</para>
 *     </listitem>
 *   </varlistentry>
 *   <varlistentry>
 *     <term><literal>style <replaceable>name</replaceable> [ =
 *     <replaceable>parent</replaceable> ] { ... }</literal></term>
 *     <listitem>
 *       <para>Declares a style.</para>
 *     </listitem>
 *   </varlistentry>
 *   <varlistentry>
 *     <term><literal>widget <replaceable>pattern</replaceable>
 *           [ style | binding ][ : <replaceable>priority</replaceable> ]
 *           <replaceable>name</replaceable></literal></term>
 *     <listitem>
 *      <para>Specifies a style or binding set for a particular
 *      group of widgets by matching on the widget pathname.</para>
 *     </listitem>
 *   </varlistentry>
 *   <varlistentry>
 *     <term><literal>widget_class <replaceable>pattern</replaceable>
 *           [ style | binding ][ : <replaceable>priority</replaceable> ]
 *           <replaceable>name</replaceable></literal></term>
 *     <listitem>
 *      <para>Specifies a style or binding set for a particular
 *      group of widgets by matching on the class pathname.</para>
 *     </listitem>
 *   </varlistentry>
 *   <varlistentry>
 *     <term><replaceable>setting</replaceable> = <replaceable>value</replaceable></term>
 *     <listitem>
 *       <para>Specifies a value for a <link linkend="GtkSettings">setting</link>.
 *         Note that settings in RC files are overwritten by system-wide settings
 *         (which are managed by an XSettings manager on X11).</para>
 *     </listitem>
 *   </varlistentry>
 * </variablelist>
 * </para>
 * </refsect2>
 * <refsect2>
 * <title>Styles</title>
 * <para>
 * A RC style is specified by a <literal>style</literal>
 * declaration in a RC file, and then bound to widgets
 * with a <literal>widget</literal>, <literal>widget_class</literal>,
 * or <literal>class</literal> declaration. All styles
 * applying to a particular widget are composited together
 * with <literal>widget</literal> declarations overriding
 * <literal>widget_class</literal> declarations which, in
 * turn, override <literal>class</literal> declarations.
 * Within each type of declaration, later declarations override
 * earlier ones.
 *
 * Within a <literal>style</literal> declaration, the possible
 * elements are:
 *
 * <variablelist>
 *   <varlistentry>
 *     <term><literal>bg[<replaceable>state</replaceable>] =
 *       <replaceable>color</replaceable></literal></term>
 *      <listitem>
 *          Sets the color used for the background of most widgets.
 *      </listitem>
 *   </varlistentry>
 *   <varlistentry>
 *     <term><literal>fg[<replaceable>state</replaceable>] =
 *       <replaceable>color</replaceable></literal></term>
 *      <listitem>
 *          Sets the color used for the foreground of most widgets.
 *      </listitem>
 *   </varlistentry>
 *   <varlistentry>
 *     <term><literal>base[<replaceable>state</replaceable>] =
 *       <replaceable>color</replaceable></literal></term>
 *      <listitem>
 *          Sets the color used for the background of widgets displaying
 *          editable text. This color is used for the background
 *          of, among others, #GtkText, #GtkEntry, #GtkList, and #GtkCList.
 *      </listitem>
 *   </varlistentry>
 *   <varlistentry>
 *     <term><literal>text[<replaceable>state</replaceable>] =
 *       <replaceable>color</replaceable></literal></term>
 *      <listitem>
 *          Sets the color used for foreground of widgets using
 *          <literal>base</literal> for the background color.
 *      </listitem>
 *   </varlistentry>
 *   <varlistentry>
 *     <term><literal>xthickness =
 *       <replaceable>number</replaceable></literal></term>
 *      <listitem>
 *          Sets the xthickness, which is used for various horizontal padding
 *          values in GTK+.
 *      </listitem>
 *   </varlistentry>
 *   <varlistentry>
 *     <term><literal>ythickness =
 *       <replaceable>number</replaceable></literal></term>
 *      <listitem>
 *          Sets the ythickness, which is used for various vertical padding
 *          values in GTK+.
 *      </listitem>
 *   </varlistentry>
 *   <varlistentry>
 *     <term><literal>bg_pixmap[<replaceable>state</replaceable>] =
 *       <replaceable>pixmap</replaceable></literal></term>
 *      <listitem>
 *          Sets a background pixmap to be used in place of
 *          the <literal>bg</literal> color (or for #GtkText,
 *          in place of the <literal>base</literal> color. The special
 *          value <literal>"&lt;parent&gt;"</literal> may be used to indicate that the widget should
 *          use the same background pixmap as its parent. The special value
 *          <literal>"&lt;none&gt;"</literal> may be used to indicate no background pixmap.
 *      </listitem>
 *   </varlistentry>
 *   <varlistentry>
 *     <term><literal>font = <replaceable>font</replaceable></literal></term>
 *      <listitem>
 *          Starting with GTK+ 2.0, the "font" and "fontset"
 *          declarations are ignored; use "font_name" declarations instead.
 *      </listitem>
 *   </varlistentry>
 *   <varlistentry>
 *     <term><literal>fontset = <replaceable>font</replaceable></literal></term>
 *      <listitem>
 *          Starting with GTK+ 2.0, the "font" and "fontset"
 *          declarations are ignored; use "font_name" declarations instead.
 *      </listitem>
 *   </varlistentry>
 *   <varlistentry>
 *     <term><literal>font_name = <replaceable>font</replaceable></literal></term>
 *      <listitem>
 *          Sets the font for a widget. <replaceable>font</replaceable> must be
 *          a Pango font name, e.g. <literal>"Sans Italic 10"</literal>.
 *          For details about Pango font names, see
 *          pango_font_description_from_string().
 *      </listitem>
 *   </varlistentry>
 *   <varlistentry>
 *     <term><literal>stock[<replaceable>"stock-id"</replaceable>] = { <replaceable>icon source specifications</replaceable> }</literal></term>
 *      <listitem>
 *         Defines the icon for a stock item.
 *      </listitem>
 *   </varlistentry>
 *   <varlistentry>
 *     <term><literal>color[<replaceable>"color-name"</replaceable>] = <replaceable>color specification</replaceable></literal></term>
 *      <listitem>
 *         Since 2.10, this element can be used to defines symbolic colors. See below for
 *         the syntax of color specifications.
 *      </listitem>
 *   </varlistentry>
 *   <varlistentry>
 *     <term><literal>engine <replaceable>"engine"</replaceable> { <replaceable>engine-specific
 * settings</replaceable> }</literal></term>
 *      <listitem>
 *         Defines the engine to be used when drawing with this style.
 *      </listitem>
 *   </varlistentry>
 *   <varlistentry>
 *     <term><literal><replaceable>class</replaceable>::<replaceable>property</replaceable> = <replaceable>value</replaceable></literal></term>
 *      <listitem>
 *         Sets a <link linkend="style-properties">style property</link> for a widget class.
 *      </listitem>
 *   </varlistentry>
 * </variablelist>
 *
 * The colors and background pixmaps are specified as a function of the
 * state of the widget. The states are:
 *
 * <variablelist>
 *   <varlistentry>
 *     <term><literal>NORMAL</literal></term>
 *     <listitem>
 *         A color used for a widget in its normal state.
 *     </listitem>
 *   </varlistentry>
 *   <varlistentry>
 *     <term><literal>ACTIVE</literal></term>
 *     <listitem>
 *         A variant of the <literal>NORMAL</literal> color used when the
 *         widget is in the %GTK_STATE_ACTIVE state, and also for
 *         the trough of a ScrollBar, tabs of a NoteBook
 *         other than the current tab and similar areas.
 *         Frequently, this should be a darker variant
 *         of the <literal>NORMAL</literal> color.
 *     </listitem>
 *   </varlistentry>
 *   <varlistentry>
 *     <term><literal>PRELIGHT</literal></term>
 *     <listitem>
 *         A color used for widgets in the %GTK_STATE_PRELIGHT state. This
 *         state is the used for Buttons and MenuItems
 *         that have the mouse cursor over them, and for
 *         their children.
 *     </listitem>
 *   </varlistentry>
 *   <varlistentry>
 *     <term><literal>SELECTED</literal></term>
 *     <listitem>
 *         A color used to highlight data selected by the user.
 *         for instance, the selected items in a list widget, and the
 *         selection in an editable widget.
 *     </listitem>
 *   </varlistentry>
 *   <varlistentry>
 *     <term><literal>INSENSITIVE</literal></term>
 *     <listitem>
 *         A color used for the background of widgets that have
 *         been set insensitive with gtk_widget_set_sensitive().
 *     </listitem>
 *   </varlistentry>
 * </variablelist>
 *
 * <anchor id="color-format"/>
 * Colors can be specified as a string containing a color name (GTK+ knows
 * all names from the X color database <filename>/usr/lib/X11/rgb.txt</filename>),
 * in one of the hexadecimal forms <literal>#rrrrggggbbbb</literal>,
 * <literal>#rrrgggbbb</literal>, <literal>#rrggbb</literal>,
 * or <literal>#rgb</literal>, where <literal>r</literal>,
 * <literal>g</literal> and <literal>b</literal> are
 * hex digits, or they can be specified as a triplet
 * <literal>{ <replaceable>r</replaceable>, <replaceable>g</replaceable>,
 * <replaceable>b</replaceable>}</literal>, where <literal>r</literal>,
 * <literal>g</literal> and <literal>b</literal> are either integers in
 * the range 0-65535 or floats in the range 0.0-1.0.
 *
 * Since 2.10, colors can also be specified by refering to a symbolic color, as
 * follows: <literal>@<!-- -->color-name</literal>, or by using expressions to combine
 * colors. The following expressions are currently supported:
 *   <variablelist>
 *     <varlistentry>
 *       <term>mix (<replaceable>factor</replaceable>, <replaceable>color1</replaceable>, <replaceable>color2</replaceable>)</term>
 *       <listitem><para>
 *         Computes a new color by mixing <replaceable>color1</replaceable> and
 *         <replaceable>color2</replaceable>. The <replaceable>factor</replaceable>
 *         determines how close the new color is to <replaceable>color1</replaceable>.
 *         A factor of 1.0 gives pure <replaceable>color1</replaceable>, a factor of
 *         0.0 gives pure <replaceable>color2</replaceable>.
 *       </para></listitem>
 *     </varlistentry>
 *     <varlistentry>
 *       <term>shade (<replaceable>factor</replaceable>, <replaceable>color</replaceable>)</term>
 *       <listitem><para>
 *         Computes a lighter or darker variant of <replaceable>color</replaceable>.
 *         A <replaceable>factor</replaceable> of 1.0 leaves the color unchanged, smaller
 *         factors yield darker colors, larger factors yield lighter colors.
 *       </para></listitem>
 *     </varlistentry>
 *     <varlistentry>
 *       <term>lighter (<replaceable>color</replaceable>)</term>
 *       <listitem><para>
 *         This is an abbreviation for
 *         <literal>shade (1.3, <replaceable>color</replaceable>)</literal>.
 *       </para></listitem>
 *     </varlistentry>
 *     <varlistentry>
 *       <term>darker (<replaceable>color</replaceable>)</term>
 *       <listitem><para>
 *         This is an abbreviation for
 *         <literal>shade (0.7, <replaceable>color</replaceable>)</literal>.
 *       </para></listitem>
 *     </varlistentry>
 *   </variablelist>
 *
 * Here are some examples of color expressions:
 *
 * <informalexample><programlisting>
 *  mix (0.5, "red", "blue")
 *  shade (1.5, mix (0.3, "#0abbc0", { 0.3, 0.5, 0.9 }))
 *  lighter (@<!-- -->foreground)
 * </programlisting></informalexample>
 *
 * In a <literal>stock</literal> definition, icon sources are specified as a
 * 4-tuple of image filename or icon name, text direction, widget state, and size, in that
 * order.  Each icon source specifies an image filename or icon name to use with a given
 * direction, state, and size. Filenames are specified as a string such
 * as <literal>"itemltr.png"</literal>, while icon names (looked up
 * in the current icon theme), are specified with a leading
 * <literal>@</literal>, such as <literal>@"item-ltr"</literal>.
 * The <literal>*</literal> character can be used as a
 * wildcard, and if direction/state/size are omitted they default to
 * <literal>*</literal>. So for example, the following specifies different icons to
 * use for left-to-right and right-to-left languages:
 *
 * <informalexample><programlisting>
 * stock["my-stock-item"] =
 * {
 *   { "itemltr.png", LTR, *, * },
 *   { "itemrtl.png", RTL, *, * }
 * }
 * </programlisting></informalexample>
 *
 * This could be abbreviated as follows:
 *
 * <informalexample><programlisting>
 * stock["my-stock-item"] =
 * {
 *   { "itemltr.png", LTR },
 *   { "itemrtl.png", RTL }
 * }
 * </programlisting></informalexample>
 *
 * You can specify custom icons for specific sizes, as follows:
 *
 * <informalexample><programlisting>
 * stock["my-stock-item"] =
 * {
 *   { "itemmenusize.png", *, *, "gtk-menu" },
 *   { "itemtoolbarsize.png", *, *, "gtk-large-toolbar" }
 *   { "itemgeneric.png" } // implicit *, *, * as a fallback
 * }
 * </programlisting></informalexample>
 *
 * The sizes that come with GTK+ itself are <literal>"gtk-menu"</literal>,
 * <literal>"gtk-small-toolbar"</literal>, <literal>"gtk-large-toolbar"</literal>,
 * <literal>"gtk-button"</literal>, <literal>"gtk-dialog"</literal>. Applications
 * can define other sizes.
 *
 * It's also possible to use custom icons for a given state, for example:
 *
 * <informalexample><programlisting>
 * stock["my-stock-item"] =
 * {
 *   { "itemprelight.png", *, PRELIGHT },
 *   { "iteminsensitive.png", *, INSENSITIVE },
 *   { "itemgeneric.png" } // implicit *, *, * as a fallback
 * }
 * </programlisting></informalexample>
 *
 * When selecting an icon source to use, GTK+ will consider text direction most
 * important, state second, and size third. It will select the best match based on
 * those criteria. If an attribute matches exactly (e.g. you specified
 * <literal>PRELIGHT</literal> or specified the size), GTK+ won't modify the image;
 * if the attribute matches with a wildcard, GTK+ will scale or modify the image to
 * match the state and size the user requested.
 * </para>
 * </refsect2>
 * <refsect2>
 * <title>Key bindings</title>
 * <para>
 * Key bindings allow the user to specify actions to be
 * taken on particular key presses. The form of a binding
 * set declaration is:
 *
 * <informalexample><programlisting>
 * binding <replaceable>name</replaceable> {
 *   bind <replaceable>key</replaceable> {
 *     <replaceable>signalname</replaceable> (<replaceable>param</replaceable>, ...)
 *     ...
 *   }
 *   ...
 * }
 * </programlisting></informalexample>
 *
 * <replaceable>key</replaceable> is a string consisting of a
 * series of modifiers followed by the name of a key. The
 * modifiers can be:
 * <simplelist>
 * <member><literal>&lt;alt&gt;</literal></member>
 * <member><literal>&lt;ctl&gt;</literal></member>
 * <member><literal>&lt;control&gt;</literal></member>
 * <member><literal>&lt;meta&gt;</literal></member>
 * <member><literal>&lt;hyper&gt;</literal></member>
 * <member><literal>&lt;super&gt;</literal></member>
 * <member><literal>&lt;mod1&gt;</literal></member>
 * <member><literal>&lt;mod2&gt;</literal></member>
 * <member><literal>&lt;mod3&gt;</literal></member>
 * <member><literal>&lt;mod4&gt;</literal></member>
 * <member><literal>&lt;mod5&gt;</literal></member>
 * <member><literal>&lt;release&gt;</literal></member>
 * <member><literal>&lt;shft&gt;</literal></member>
 * <member><literal>&lt;shift&gt;</literal></member>
 * </simplelist>
 * <literal>&lt;shft&gt;</literal> is an alias for
 * <literal>&lt;shift&gt;</literal>,
 * <literal>&lt;ctl&gt;</literal> is an alias for
 * <literal>&lt;control&gt;</literal>,
 *  and
 * <literal>&lt;alt&gt;</literal> is an alias for
 * <literal>&lt;mod1&gt;</literal>.
 *
 * The action that is bound to the key is a sequence
 * of signal names (strings) followed by parameters for
 * each signal. The signals must be action signals.
 * (See g_signal_new()). Each parameter can be
 * a float, integer, string, or unquoted string
 * representing an enumeration value. The types of
 * the parameters specified must match the types of the
 * parameters of the signal.
 *
 * Binding sets are connected to widgets in the same manner as styles,
 * with one difference: Binding sets override other binding sets first
 * by pattern type, then by priority and then by order of specification.
 * The priorities that can be specified and their default values are the
 * same as for styles.
 * </para>
 * </refsect2>
 */


enum 
{
  PATH_ELT_PSPEC,
  PATH_ELT_UNRESOLVED,
  PATH_ELT_TYPE
};

typedef struct
{
  gint type;
  union 
  {
    GType         class_type;
    gchar        *class_name;
    GPatternSpec *pspec;
  } elt;
} PathElt;

#define GTK_RC_STYLE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GTK_TYPE_RC_STYLE, GtkRcStylePrivate))

typedef struct _GtkRcStylePrivate GtkRcStylePrivate;

struct _GtkRcStylePrivate
{
  GSList *color_hashes;
};

static void        gtk_rc_style_finalize             (GObject         *object);
static void        gtk_rc_style_real_merge           (GtkRcStyle      *dest,
                                                      GtkRcStyle      *src);
static GtkRcStyle* gtk_rc_style_real_create_rc_style (GtkRcStyle      *rc_style);
static GtkStyle*   gtk_rc_style_real_create_style    (GtkRcStyle      *rc_style);
static gint	   gtk_rc_properties_cmp	     (gconstpointer    bsearch_node1,
						      gconstpointer    bsearch_node2);

static void	   insert_rc_property		     (GtkRcStyle      *style,
						      GtkRcProperty   *property,
						      gboolean         replace);


static const GScannerConfig gtk_rc_scanner_config =
{
  (
   " \t\r\n"
   )			/* cset_skip_characters */,
  (
   "_"
   G_CSET_a_2_z
   G_CSET_A_2_Z
   )			/* cset_identifier_first */,
  (
   G_CSET_DIGITS
   "-_"
   G_CSET_a_2_z
   G_CSET_A_2_Z
   )			/* cset_identifier_nth */,
  ( "#\n" )		/* cpair_comment_single */,
  
  TRUE			/* case_sensitive */,
  
  TRUE			/* skip_comment_multi */,
  TRUE			/* skip_comment_single */,
  TRUE			/* scan_comment_multi */,
  TRUE			/* scan_identifier */,
  FALSE			/* scan_identifier_1char */,
  FALSE			/* scan_identifier_NULL */,
  TRUE			/* scan_symbols */,
  TRUE			/* scan_binary */,
  TRUE			/* scan_octal */,
  TRUE			/* scan_float */,
  TRUE			/* scan_hex */,
  TRUE			/* scan_hex_dollar */,
  TRUE			/* scan_string_sq */,
  TRUE			/* scan_string_dq */,
  TRUE			/* numbers_2_int */,
  FALSE			/* int_2_float */,
  FALSE			/* identifier_2_string */,
  TRUE			/* char_2_token */,
  TRUE			/* symbol_2_token */,
  FALSE			/* scope_0_fallback */,
};
 
static const gchar symbol_names[] = 
  "include\0"
  "NORMAL\0"
  "ACTIVE\0"
  "PRELIGHT\0"
  "SELECTED\0"
  "INSENSITIVE\0"
  "fg\0"
  "bg\0"
  "text\0"
  "base\0"
  "xthickness\0"
  "ythickness\0"
  "font\0"
  "fontset\0"
  "font_name\0"
  "bg_pixmap\0"
  "pixmap_path\0"
  "style\0"
  "binding\0"
  "bind\0"
  "widget\0"
  "widget_class\0"
  "class\0"
  "lowest\0"
  "gtk\0"
  "application\0"
  "theme\0"
  "rc\0"
  "highest\0"
  "engine\0"
  "module_path\0"
  "stock\0"
  "im_module_file\0"
  "LTR\0"
  "RTL\0"
  "color\0"
  "unbind\0";

static const struct
{
  guint name_offset;
  guint token;
} symbols[] = {
  {   0, GTK_RC_TOKEN_INCLUDE },
  {   8, GTK_RC_TOKEN_NORMAL },
  {  15, GTK_RC_TOKEN_ACTIVE },
  {  22, GTK_RC_TOKEN_PRELIGHT },
  {  31, GTK_RC_TOKEN_SELECTED },
  {  40, GTK_RC_TOKEN_INSENSITIVE },
  {  52, GTK_RC_TOKEN_FG },
  {  55, GTK_RC_TOKEN_BG },
  {  58, GTK_RC_TOKEN_TEXT },
  {  63, GTK_RC_TOKEN_BASE },
  {  68, GTK_RC_TOKEN_XTHICKNESS },
  {  79, GTK_RC_TOKEN_YTHICKNESS },
  {  90, GTK_RC_TOKEN_FONT },
  {  95, GTK_RC_TOKEN_FONTSET },
  { 103, GTK_RC_TOKEN_FONT_NAME },
  { 113, GTK_RC_TOKEN_BG_PIXMAP },
  { 123, GTK_RC_TOKEN_PIXMAP_PATH },
  { 135, GTK_RC_TOKEN_STYLE },
  { 141, GTK_RC_TOKEN_BINDING },
  { 149, GTK_RC_TOKEN_BIND },
  { 154, GTK_RC_TOKEN_WIDGET },
  { 161, GTK_RC_TOKEN_WIDGET_CLASS },
  { 174, GTK_RC_TOKEN_CLASS },
  { 180, GTK_RC_TOKEN_LOWEST },
  { 187, GTK_RC_TOKEN_GTK },
  { 191, GTK_RC_TOKEN_APPLICATION },
  { 203, GTK_RC_TOKEN_THEME },
  { 209, GTK_RC_TOKEN_RC },
  { 212, GTK_RC_TOKEN_HIGHEST },
  { 220, GTK_RC_TOKEN_ENGINE },
  { 227, GTK_RC_TOKEN_MODULE_PATH },
  { 239, GTK_RC_TOKEN_STOCK },
  { 245, GTK_RC_TOKEN_IM_MODULE_FILE },
  { 260, GTK_RC_TOKEN_LTR },
  { 264, GTK_RC_TOKEN_RTL },
  { 268, GTK_RC_TOKEN_COLOR },
  { 274, GTK_RC_TOKEN_UNBIND }
};

static GHashTable *realized_style_ht = NULL;

static gchar *im_module_file = NULL;

static gchar **gtk_rc_default_files = NULL;

/* RC file handling */

static gchar *
gtk_rc_make_default_dir (const gchar *type)
{
  const gchar *var;
  gchar *path;

  var = g_getenv ("GTK_EXE_PREFIX");

  if (var)
    path = g_build_filename (var, "lib", "gtk-3.0", GTK_BINARY_VERSION, type, NULL);
  else
    path = g_build_filename (GTK_LIBDIR, "gtk-3.0", GTK_BINARY_VERSION, type, NULL);

  return path;
}

/**
 * gtk_rc_get_im_module_path:
 * @returns: (type filename): a newly-allocated string containing the
 *    path in which to look for IM modules.
 *
 * Obtains the path in which to look for IM modules. See the documentation
 * of the <link linkend="im-module-path"><envar>GTK_PATH</envar></link>
 * environment variable for more details about looking up modules. This
 * function is useful solely for utilities supplied with GTK+ and should
 * not be used by applications under normal circumstances.
 *
 * Deprecated: 3.0: Use #GtkCssProvider instead.
 */
gchar *
gtk_rc_get_im_module_path (void)
{
  gchar **paths = _gtk_get_module_path ("immodules");
  gchar *result = g_strjoinv (G_SEARCHPATH_SEPARATOR_S, paths);
  g_strfreev (paths);

  return result;
}

/**
 * gtk_rc_get_im_module_file:
 * @returns: (type filename): a newly-allocated string containing the
 *    name of the file listing the IM modules available for loading
 *
 * Obtains the path to the IM modules file. See the documentation
 * of the <link linkend="im-module-file"><envar>GTK_IM_MODULE_FILE</envar></link>
 * environment variable for more details.
 *
 * Deprecated: 3.0: Use #GtkCssProvider instead.
 */
gchar *
gtk_rc_get_im_module_file (void)
{
  const gchar *var = g_getenv ("GTK_IM_MODULE_FILE");
  gchar *result = NULL;

  if (var)
    result = g_strdup (var);

  if (!result)
    {
      if (im_module_file)
        result = g_strdup (im_module_file);
      else
        result = gtk_rc_make_default_dir ("immodules.cache");
    }

  return result;
}

/**
 * gtk_rc_get_theme_dir:
 *
 * Returns the standard directory in which themes should
 * be installed. (GTK+ does not actually use this directory
 * itself.)
 *
 * Returns: The directory (must be freed with g_free()).
 *
 * Deprecated: 3.0: Use #GtkCssProvider instead.
 */
gchar *
gtk_rc_get_theme_dir (void)
{
  const gchar *var;
  gchar *path;

  var = g_getenv ("GTK_DATA_PREFIX");

  if (var)
    path = g_build_filename (var, "share", "themes", NULL);
  else
    path = g_build_filename (GTK_DATA_PREFIX, "share", "themes", NULL);

  return path;
}

/**
 * gtk_rc_get_module_dir:
 *
 * Returns a directory in which GTK+ looks for theme engines.
 * For full information about the search for theme engines,
 * see the docs for <envar>GTK_PATH</envar> in
 * <xref linkend="gtk-running"/>.
 *
 * return value: (type filename): the directory. (Must be freed with g_free())
 *
 * Deprecated: 3.0: Use #GtkCssProvider instead.
 **/
gchar *
gtk_rc_get_module_dir (void)
{
  return gtk_rc_make_default_dir ("engines");
}

/**
 * gtk_rc_add_default_file:
 * @filename: (type filename): the pathname to the file. If @filename
 *    is not absolute, it is searched in the current directory.
 *
 * Adds a file to the list of files to be parsed at the
 * end of gtk_init().
 *
 * Deprecated:3.0: Use #GtkStyleContext with a custom #GtkStyleProvider instead
 **/
void
gtk_rc_add_default_file (const gchar *filename)
{
}

/**
 * gtk_rc_set_default_files:
 * @filenames: (array zero-terminated=1) (element-type filename): A
 *     %NULL-terminated list of filenames.
 *
 * Sets the list of files that GTK+ will read at the
 * end of gtk_init().
 *
 * Deprecated:3.0: Use #GtkStyleContext with a custom #GtkStyleProvider instead
 **/
void
gtk_rc_set_default_files (gchar **filenames)
{
}

/**
 * gtk_rc_get_default_files:
 *
 * Retrieves the current list of RC files that will be parsed
 * at the end of gtk_init().
 *
 * Return value: (transfer none) (array zero-terminated=1) (element-type filename):
 *      A %NULL-terminated array of filenames.  This memory is owned
 *     by GTK+ and must not be freed by the application.  If you want
 *     to store this information, you should make a copy.
 *
 * Deprecated:3.0: Use #GtkStyleContext instead
 **/
gchar **
gtk_rc_get_default_files (void)
{
  return gtk_rc_default_files;
}

/**
 * gtk_rc_parse_string:
 * @rc_string: a string to parse.
 *
 * Parses resource information directly from a string.
 *
 * Deprecated: 3.0: Use #GtkCssProvider instead.
 */
void
gtk_rc_parse_string (const gchar *rc_string)
{
  g_return_if_fail (rc_string != NULL);
}

/**
 * gtk_rc_parse:
 * @filename: the filename of a file to parse. If @filename is not absolute, it
 *  is searched in the current directory.
 *
 * Parses a given resource file.
 *
 * Deprecated: 3.0: Use #GtkCssProvider instead.
 */
void
gtk_rc_parse (const gchar *filename)
{
  g_return_if_fail (filename != NULL);
}

/* Handling of RC styles */

G_DEFINE_TYPE (GtkRcStyle, gtk_rc_style, G_TYPE_OBJECT)

static void
gtk_rc_style_init (GtkRcStyle *style)
{
  GtkRcStylePrivate *priv = GTK_RC_STYLE_GET_PRIVATE (style);
  guint i;

  style->name = NULL;
  style->font_desc = NULL;

  for (i = 0; i < 5; i++)
    {
      static const GdkColor init_color = { 0, 0, 0, 0, };

      style->bg_pixmap_name[i] = NULL;
      style->color_flags[i] = 0;
      style->fg[i] = init_color;
      style->bg[i] = init_color;
      style->text[i] = init_color;
      style->base[i] = init_color;
    }
  style->xthickness = -1;
  style->ythickness = -1;
  style->rc_properties = NULL;

  style->rc_style_lists = NULL;
  style->icon_factories = NULL;

  priv->color_hashes = NULL;
}

static void
gtk_rc_style_class_init (GtkRcStyleClass *klass)
{
  GObjectClass *object_class = G_OBJECT_CLASS (klass);

  object_class->finalize = gtk_rc_style_finalize;

  klass->parse = NULL;
  klass->create_rc_style = gtk_rc_style_real_create_rc_style;
  klass->merge = gtk_rc_style_real_merge;
  klass->create_style = gtk_rc_style_real_create_style;

  g_type_class_add_private (object_class, sizeof (GtkRcStylePrivate));
}

static void
gtk_rc_style_finalize (GObject *object)
{
  GSList *tmp_list1, *tmp_list2;
  GtkRcStyle *rc_style;
  GtkRcStylePrivate *rc_priv;
  gint i;

  rc_style = GTK_RC_STYLE (object);
  rc_priv = GTK_RC_STYLE_GET_PRIVATE (rc_style);

  g_free (rc_style->name);
  if (rc_style->font_desc)
    pango_font_description_free (rc_style->font_desc);

  for (i = 0; i < 5; i++)
    g_free (rc_style->bg_pixmap_name[i]);

  /* Now remove all references to this rc_style from
   * realized_style_ht
   */
  tmp_list1 = rc_style->rc_style_lists;
  while (tmp_list1)
    {
      GSList *rc_styles = tmp_list1->data;
      GtkStyle *style = g_hash_table_lookup (realized_style_ht, rc_styles);
      g_object_unref (style);

      /* Remove the list of styles from the other rc_styles
       * in the list
       */
      tmp_list2 = rc_styles;
      while (tmp_list2)
        {
          GtkRcStyle *other_style = tmp_list2->data;

          if (other_style != rc_style)
            other_style->rc_style_lists = g_slist_remove_all (other_style->rc_style_lists,
							      rc_styles);
          tmp_list2 = tmp_list2->next;
        }

      /* And from the hash table itself
       */
      g_hash_table_remove (realized_style_ht, rc_styles);
      g_slist_free (rc_styles);

      tmp_list1 = tmp_list1->next;
    }
  g_slist_free (rc_style->rc_style_lists);

  if (rc_style->rc_properties)
    {
      guint i;

      for (i = 0; i < rc_style->rc_properties->len; i++)
	{
	  GtkRcProperty *node = &g_array_index (rc_style->rc_properties, GtkRcProperty, i);

	  g_free (node->origin);
	  g_value_unset (&node->value);
	}
      g_array_free (rc_style->rc_properties, TRUE);
      rc_style->rc_properties = NULL;
    }

  g_slist_foreach (rc_style->icon_factories, (GFunc) g_object_unref, NULL);
  g_slist_free (rc_style->icon_factories);

  g_slist_foreach (rc_priv->color_hashes, (GFunc) g_hash_table_unref, NULL);
  g_slist_free (rc_priv->color_hashes);

  G_OBJECT_CLASS (gtk_rc_style_parent_class)->finalize (object);
}

/**
 * gtk_rc_style_new:
 *
 * Creates a new #GtkRcStyle with no fields set and
 * a reference count of 1.
 *
 * Returns: the newly-created #GtkRcStyle
 *
 * Deprecated: 3.0: Use #GtkCssProvider instead.
 */
GtkRcStyle *
gtk_rc_style_new (void)
{
  GtkRcStyle *style;

  style = g_object_new (GTK_TYPE_RC_STYLE, NULL);

  return style;
}

/**
 * gtk_rc_style_copy:
 * @orig: the style to copy
 *
 * Makes a copy of the specified #GtkRcStyle. This function
 * will correctly copy an RC style that is a member of a class
 * derived from #GtkRcStyle.
 *
 * Return value: (transfer full): the resulting #GtkRcStyle
 *
 * Deprecated: 3.0: Use #GtkCssProvider instead.
 **/
GtkRcStyle *
gtk_rc_style_copy (GtkRcStyle *orig)
{
  GtkRcStyle *style;

  g_return_val_if_fail (GTK_IS_RC_STYLE (orig), NULL);
  
  style = GTK_RC_STYLE_GET_CLASS (orig)->create_rc_style (orig);
  GTK_RC_STYLE_GET_CLASS (style)->merge (style, orig);

  return style;
}

static GtkRcStyle *
gtk_rc_style_real_create_rc_style (GtkRcStyle *style)
{
  return g_object_new (G_OBJECT_TYPE (style), NULL);
}

static gint
gtk_rc_properties_cmp (gconstpointer bsearch_node1,
		       gconstpointer bsearch_node2)
{
  const GtkRcProperty *prop1 = bsearch_node1;
  const GtkRcProperty *prop2 = bsearch_node2;

  if (prop1->type_name == prop2->type_name)
    return prop1->property_name < prop2->property_name ? -1 : prop1->property_name == prop2->property_name ? 0 : 1;
  else
    return prop1->type_name < prop2->type_name ? -1 : 1;
}

static void
insert_rc_property (GtkRcStyle    *style,
		    GtkRcProperty *property,
		    gboolean       replace)
{
  guint i;
  GtkRcProperty *new_property = NULL;
  GtkRcProperty key = { 0, 0, NULL, { 0, }, };

  key.type_name = property->type_name;
  key.property_name = property->property_name;

  if (!style->rc_properties)
    style->rc_properties = g_array_new (FALSE, FALSE, sizeof (GtkRcProperty));

  i = 0;
  while (i < style->rc_properties->len)
    {
      gint cmp = gtk_rc_properties_cmp (&key, &g_array_index (style->rc_properties, GtkRcProperty, i));

      if (cmp == 0)
	{
	  if (replace)
	    {
	      new_property = &g_array_index (style->rc_properties, GtkRcProperty, i);
	      
	      g_free (new_property->origin);
	      g_value_unset (&new_property->value);
	      
	      *new_property = key;
	      break;
	    }
	  else
	    return;
	}
      else if (cmp < 0)
	break;

      i++;
    }

  if (!new_property)
    {
      g_array_insert_val (style->rc_properties, i, key);
      new_property = &g_array_index (style->rc_properties, GtkRcProperty, i);
    }

  new_property->origin = g_strdup (property->origin);
  g_value_init (&new_property->value, G_VALUE_TYPE (&property->value));
  g_value_copy (&property->value, &new_property->value);
}

static void
gtk_rc_style_real_merge (GtkRcStyle *dest,
			 GtkRcStyle *src)
{
  gint i;

  for (i = 0; i < 5; i++)
    {
      if (!dest->bg_pixmap_name[i] && src->bg_pixmap_name[i])
	dest->bg_pixmap_name[i] = g_strdup (src->bg_pixmap_name[i]);
      
      if (!(dest->color_flags[i] & GTK_RC_FG) && 
	  src->color_flags[i] & GTK_RC_FG)
	{
	  dest->fg[i] = src->fg[i];
	  dest->color_flags[i] |= GTK_RC_FG;
	}
      if (!(dest->color_flags[i] & GTK_RC_BG) && 
	  src->color_flags[i] & GTK_RC_BG)
	{
	  dest->bg[i] = src->bg[i];
	  dest->color_flags[i] |= GTK_RC_BG;
	}
      if (!(dest->color_flags[i] & GTK_RC_TEXT) && 
	  src->color_flags[i] & GTK_RC_TEXT)
	{
	  dest->text[i] = src->text[i];
	  dest->color_flags[i] |= GTK_RC_TEXT;
	}
      if (!(dest->color_flags[i] & GTK_RC_BASE) && 
	  src->color_flags[i] & GTK_RC_BASE)
	{
	  dest->base[i] = src->base[i];
	  dest->color_flags[i] |= GTK_RC_BASE;
	}
    }

  if (dest->xthickness < 0 && src->xthickness >= 0)
    dest->xthickness = src->xthickness;
  if (dest->ythickness < 0 && src->ythickness >= 0)
    dest->ythickness = src->ythickness;

  if (src->font_desc)
    {
      if (!dest->font_desc)
	dest->font_desc = pango_font_description_copy (src->font_desc);
      else
	pango_font_description_merge (dest->font_desc, src->font_desc, FALSE);
    }

  if (src->rc_properties)
    {
      guint i;

      for (i = 0; i < src->rc_properties->len; i++)
	insert_rc_property (dest,
			    &g_array_index (src->rc_properties, GtkRcProperty, i),
			    FALSE);
    }
}

static GtkStyle *
gtk_rc_style_real_create_style (GtkRcStyle *rc_style)
{
  return gtk_style_new ();
}

/**
 * gtk_rc_reset_styles:
 * @settings: a #GtkSettings
 *
 * This function recomputes the styles for all widgets that use a
 * particular #GtkSettings object. (There is one #GtkSettings object
 * per #GdkScreen, see gtk_settings_get_for_screen()); It is useful
 * when some global parameter has changed that affects the appearance
 * of all widgets, because when a widget gets a new style, it will
 * both redraw and recompute any cached information about its
 * appearance. As an example, it is used when the default font size
 * set by the operating system changes. Note that this function
 * doesn't affect widgets that have a style set explicitely on them
 * with gtk_widget_set_style().
 *
 * Since: 2.4
 *
 * Deprecated: 3.0: Use #GtkCssProvider instead.
 **/
void
gtk_rc_reset_styles (GtkSettings *settings)
{
  gtk_style_context_reset_widgets (_gtk_settings_get_screen (settings));
}

/**
 * gtk_rc_reparse_all_for_settings:
 * @settings: a #GtkSettings
 * @force_load: load whether or not anything changed
 *
 * If the modification time on any previously read file
 * for the given #GtkSettings has changed, discard all style information
 * and then reread all previously read RC files.
 *
 * Return value: %TRUE if the files were reread.
 *
 * Deprecated: 3.0: Use #GtkCssProvider instead.
 **/
gboolean
gtk_rc_reparse_all_for_settings (GtkSettings *settings,
				 gboolean     force_load)
{
  return FALSE;
}

/**
 * gtk_rc_reparse_all:
 *
 * If the modification time on any previously read file for the
 * default #GtkSettings has changed, discard all style information
 * and then reread all previously read RC files.
 *
 * Return value:  %TRUE if the files were reread.
 *
 * Deprecated: 3.0: Use #GtkCssProvider instead.
 **/
gboolean
gtk_rc_reparse_all (void)
{
  return FALSE;
}

/**
 * gtk_rc_get_style:
 * @widget: a #GtkWidget
 *
 * Finds all matching RC styles for a given widget,
 * composites them together, and then creates a
 * #GtkStyle representing the composite appearance.
 * (GTK+ actually keeps a cache of previously
 * created styles, so a new style may not be
 * created.)
 *
 * Returns: (transfer none): the resulting style. No refcount is added
 *   to the returned style, so if you want to save this style around,
 *   you should add a reference yourself.
 *
 * Deprecated:3.0: Use #GtkStyleContext instead
 **/
GtkStyle *
gtk_rc_get_style (GtkWidget *widget)
{
  g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);

  gtk_widget_ensure_style (widget);

  return gtk_widget_get_style (widget);
}

/**
 * gtk_rc_get_style_by_paths:
 * @settings: a #GtkSettings object
 * @widget_path: (allow-none): the widget path to use when looking up the
 *     style, or %NULL if no matching against the widget path should be done
 * @class_path: (allow-none): the class path to use when looking up the style,
 *     or %NULL if no matching against the class path should be done.
 * @type: a type that will be used along with parent types of this type
 *     when matching against class styles, or #G_TYPE_NONE
 *
 * Creates up a #GtkStyle from styles defined in a RC file by providing
 * the raw components used in matching. This function may be useful
 * when creating pseudo-widgets that should be themed like widgets but
 * don't actually have corresponding GTK+ widgets. An example of this
 * would be items inside a GNOME canvas widget.
 *
 * The action of gtk_rc_get_style() is similar to:
 * |[
 *  gtk_widget_path (widget, NULL, &path, NULL);
 *  gtk_widget_class_path (widget, NULL, &class_path, NULL);
 *  gtk_rc_get_style_by_paths (gtk_widget_get_settings (widget),
 *                             path, class_path,
 *                             G_OBJECT_TYPE (widget));
 * ]|
 *
 * Return value: (transfer none): A style created by matching with the
 *     supplied paths, or %NULL if nothing matching was specified and the
 *     default style should be used. The returned value is owned by GTK+
 *     as part of an internal cache, so you must call g_object_ref() on
 *     the returned value if you want to keep a reference to it.
 *
 * Deprecated:3.0: Use #GtkStyleContext instead
 **/
GtkStyle *
gtk_rc_get_style_by_paths (GtkSettings *settings,
			   const char  *widget_path,
			   const char  *class_path,
			   GType        type)
{
  GtkWidgetPath *path;
  GtkStyle *style;

  path = gtk_widget_path_new ();

  /* For compatibility, we return a GtkStyle based on a GtkStyleContext
   * with a GtkWidgetPath appropriate for the supplied information.
   *
   * GtkWidgetPath is composed of a list of GTypes with optional names;
   * In GTK+-2.0, widget_path consisted of the widget names, or
   * the class names for unnamed widgets, while class_path had the
   * class names always. So, use class_path to determine the GTypes
   * and extract widget names from widget_path as applicable.
   */
  if (class_path == NULL)
    {
      gtk_widget_path_append_type (path, type == G_TYPE_NONE ? GTK_TYPE_WIDGET : type);
    }
  else
    {
      const gchar *widget_p, *widget_next;
      const gchar *class_p, *class_next;

      widget_next = widget_path;
      class_next = class_path;

      while (*class_next)
	{
	  GType component_type;
	  gchar *component_class;
	  gchar *component_name;
	  gint pos;

	  class_p = class_next;
	  if (*class_p == '.')
	    class_p++;

	  widget_p = widget_next; /* Might be NULL */
	  if (widget_p && *widget_p == '.')
	    widget_p++;

	  class_next = strchr (class_p, '.');
	  if (class_next == NULL)
	    class_next = class_p + strlen (class_p);

	  if (widget_p)
	    {
	      widget_next = strchr (widget_p, '.');
	      if (widget_next == NULL)
		widget_next = widget_p + strlen (widget_p);
	    }

	  component_class = g_strndup (class_p, class_next - class_p);
	  if (widget_p && *widget_p)
	    component_name = g_strndup (widget_p, widget_next - widget_p);
	  else
	    component_name = NULL;

	  component_type = g_type_from_name (component_class);
	  if (component_type == G_TYPE_INVALID)
	    component_type = GTK_TYPE_WIDGET;

	  pos = gtk_widget_path_append_type (path, component_type);
	  if (component_name != NULL && strcmp (component_name, component_name) != 0)
	    gtk_widget_path_iter_set_name (path, pos, component_name);

	  g_free (component_class);
	  g_free (component_name);
	}
    }

  style = _gtk_style_new_for_path (_gtk_settings_get_screen (settings),
				   path);

  gtk_widget_path_free (path);

  return style;
}

/**
 * gtk_rc_scanner_new: (skip)
 *
 * Deprecated:3.0: Use #GtkCssProvider instead
 */
GScanner*
gtk_rc_scanner_new (void)
{
  return g_scanner_new (&gtk_rc_scanner_config);
}

/*********************
 * Parsing functions *
 *********************/

static gboolean
lookup_color (GtkRcStyle *style,
              const char *color_name,
              GdkColor   *color)
{
  GtkRcStylePrivate *priv = GTK_RC_STYLE_GET_PRIVATE (style);
  GSList *iter;

  for (iter = priv->color_hashes; iter != NULL; iter = iter->next)
    {
      GHashTable *hash  = iter->data;
      GdkColor   *match = g_hash_table_lookup (hash, color_name);

      if (match)
        {
          color->red = match->red;
          color->green = match->green;
          color->blue = match->blue;
          return TRUE;
        }
    }

  return FALSE;
}

/**
 * gtk_rc_find_pixmap_in_path:
 * @settings: a #GtkSettings
 * @scanner: Scanner used to get line number information for the
 *   warning message, or %NULL
 * @pixmap_file: name of the pixmap file to locate.
 *
 * Looks up a file in pixmap path for the specified #GtkSettings.
 * If the file is not found, it outputs a warning message using
 * g_warning() and returns %NULL.
 *
 * Return value: (type filename): the filename.
 *
 * Deprecated: 3.0: Use #GtkCssProvider instead.
 **/
gchar*
gtk_rc_find_pixmap_in_path (GtkSettings  *settings,
			    GScanner     *scanner,
			    const gchar  *pixmap_file)
{
  g_warning ("Unable to locate image file in pixmap_path: \"%s\"",
             pixmap_file);
  return NULL;
}

/**
 * gtk_rc_find_module_in_path:
 * @module_file: name of a theme engine
 *
 * Searches for a theme engine in the GTK+ search path. This function
 * is not useful for applications and should not be used.
 *
 * Return value: (type filename): The filename, if found (must be
 *   freed with g_free()), otherwise %NULL.
 *
 * Deprecated: 3.0: Use #GtkCssProvider instead.
 **/
gchar*
gtk_rc_find_module_in_path (const gchar *module_file)
{
  return _gtk_find_module (module_file, "engines");
}

/**
 * gtk_rc_parse_state:
 * @scanner: a #GtkScanner (must be initialized for parsing an RC file)
 * @state: (out): A pointer to a #GtkStateType variable in which to
 *  store the result.
 *
 * Parses a #GtkStateType variable from the format expected
 * in a RC file.
 *
 * Returns: %G_TOKEN_NONE if parsing succeeded, otherwise the token
 *   that was expected but not found.
 *
 * Deprecated: 3.0: Use #GtkCssProvider instead
 */
guint
gtk_rc_parse_state (GScanner	 *scanner,
		    GtkStateType *state)
{
  guint old_scope;
  guint token;

  g_return_val_if_fail (scanner != NULL, G_TOKEN_ERROR);
  g_return_val_if_fail (state != NULL, G_TOKEN_ERROR);
  
  /* we don't know where we got called from, so we reset the scope here.
   * if we bail out due to errors, we *don't* reset the scope, so the
   * error messaging code can make sense of our tokens.
   */
  old_scope = g_scanner_set_scope (scanner, 0);
  
  token = g_scanner_get_next_token (scanner);
  if (token != G_TOKEN_LEFT_BRACE)
    return G_TOKEN_LEFT_BRACE;
  
  token = g_scanner_get_next_token (scanner);
  switch (token)
    {
    case GTK_RC_TOKEN_ACTIVE:
      *state = GTK_STATE_ACTIVE;
      break;
    case GTK_RC_TOKEN_INSENSITIVE:
      *state = GTK_STATE_INSENSITIVE;
      break;
    case GTK_RC_TOKEN_NORMAL:
      *state = GTK_STATE_NORMAL;
      break;
    case GTK_RC_TOKEN_PRELIGHT:
      *state = GTK_STATE_PRELIGHT;
      break;
    case GTK_RC_TOKEN_SELECTED:
      *state = GTK_STATE_SELECTED;
      break;
    default:
      return /* G_TOKEN_SYMBOL */ GTK_RC_TOKEN_NORMAL;
    }
  
  token = g_scanner_get_next_token (scanner);
  if (token != G_TOKEN_RIGHT_BRACE)
    return G_TOKEN_RIGHT_BRACE;
  
  g_scanner_set_scope (scanner, old_scope);

  return G_TOKEN_NONE;
}

/**
 * gtk_rc_parse_priority:
 * @scanner: a #GtkScanner (must be initialized for parsing an RC file)
 * @priority: A pointer to #GtkPathPriorityType variable in which
 *  to store the result.
 *
 * Parses a #GtkPathPriorityType variable from the format expected
 * in a RC file.
 *
 * Returns: %G_TOKEN_NONE if parsing succeeded, otherwise the token
 *   that was expected but not found.
 *
 * Deprecated:3.0: Use #GtkCssProvider instead
 */
guint
gtk_rc_parse_priority (GScanner	           *scanner,
		       GtkPathPriorityType *priority)
{
  guint old_scope;
  guint token;

  g_return_val_if_fail (scanner != NULL, G_TOKEN_ERROR);
  g_return_val_if_fail (priority != NULL, G_TOKEN_ERROR);

  /* we don't know where we got called from, so we reset the scope here.
   * if we bail out due to errors, we *don't* reset the scope, so the
   * error messaging code can make sense of our tokens.
   */
  old_scope = g_scanner_set_scope (scanner, 0);
  
  token = g_scanner_get_next_token (scanner);
  if (token != ':')
    return ':';
  
  token = g_scanner_get_next_token (scanner);
  switch (token)
    {
    case GTK_RC_TOKEN_LOWEST:
      *priority = GTK_PATH_PRIO_LOWEST;
      break;
    case GTK_RC_TOKEN_GTK:
      *priority = GTK_PATH_PRIO_GTK;
      break;
    case GTK_RC_TOKEN_APPLICATION:
      *priority = GTK_PATH_PRIO_APPLICATION;
      break;
    case GTK_RC_TOKEN_THEME:
      *priority = GTK_PATH_PRIO_THEME;
      break;
    case GTK_RC_TOKEN_RC:
      *priority = GTK_PATH_PRIO_RC;
      break;
    case GTK_RC_TOKEN_HIGHEST:
      *priority = GTK_PATH_PRIO_HIGHEST;
      break;
    default:
      return /* G_TOKEN_SYMBOL */ GTK_RC_TOKEN_APPLICATION;
    }
  
  g_scanner_set_scope (scanner, old_scope);

  return G_TOKEN_NONE;
}

/**
 * gtk_rc_parse_color:
 * @scanner: a #GScanner
 * @color: (out): a pointer to a #GdkColor structure in which to store
 *     the result
 *
 * Parses a color in the <link linkend="color=format">format</link> expected
 * in a RC file.
 *
 * Note that theme engines should use gtk_rc_parse_color_full() in
 * order to support symbolic colors.
 *
 * Returns: %G_TOKEN_NONE if parsing succeeded, otherwise the token
 *     that was expected but not found
 *
 * Deprecated:3.0: Use #GtkCssProvider instead
 */
guint
gtk_rc_parse_color (GScanner *scanner,
		    GdkColor *color)
{
  return gtk_rc_parse_color_full (scanner, NULL, color);
}

/**
 * gtk_rc_parse_color_full:
 * @scanner: a #GScanner
 * @style: (allow-none): a #GtkRcStyle, or %NULL
 * @color: (out): a pointer to a #GdkColor structure in which to store
 *     the result
 *
 * Parses a color in the <link linkend="color=format">format</link> expected
 * in a RC file. If @style is not %NULL, it will be consulted to resolve
 * references to symbolic colors.
 *
 * Returns: %G_TOKEN_NONE if parsing succeeded, otherwise the token
 *     that was expected but not found
 *
 * Since: 2.12
 *
 * Deprecated:3.0: Use #GtkCssProvider instead
 */
guint
gtk_rc_parse_color_full (GScanner   *scanner,
                         GtkRcStyle *style,
                         GdkColor   *color)
{
  guint token;

  g_return_val_if_fail (scanner != NULL, G_TOKEN_ERROR);

  /* we don't need to set our own scope here, because
   * we don't need own symbols
   */
  
  token = g_scanner_get_next_token (scanner);
  switch (token)
    {
      gint token_int;
      GdkColor c1, c2;
      gboolean negate;
      gdouble l;

    case G_TOKEN_LEFT_CURLY:
      token = g_scanner_get_next_token (scanner);
      if (token == G_TOKEN_INT)
	token_int = scanner->value.v_int;
      else if (token == G_TOKEN_FLOAT)
	token_int = scanner->value.v_float * 65535.0;
      else
	return G_TOKEN_FLOAT;
      color->red = CLAMP (token_int, 0, 65535);
      
      token = g_scanner_get_next_token (scanner);
      if (token != G_TOKEN_COMMA)
	return G_TOKEN_COMMA;
      
      token = g_scanner_get_next_token (scanner);
      if (token == G_TOKEN_INT)
	token_int = scanner->value.v_int;
      else if (token == G_TOKEN_FLOAT)
	token_int = scanner->value.v_float * 65535.0;
      else
	return G_TOKEN_FLOAT;
      color->green = CLAMP (token_int, 0, 65535);
      
      token = g_scanner_get_next_token (scanner);
      if (token != G_TOKEN_COMMA)
	return G_TOKEN_COMMA;
      
      token = g_scanner_get_next_token (scanner);
      if (token == G_TOKEN_INT)
	token_int = scanner->value.v_int;
      else if (token == G_TOKEN_FLOAT)
	token_int = scanner->value.v_float * 65535.0;
      else
	return G_TOKEN_FLOAT;
      color->blue = CLAMP (token_int, 0, 65535);
      
      token = g_scanner_get_next_token (scanner);
      if (token != G_TOKEN_RIGHT_CURLY)
	return G_TOKEN_RIGHT_CURLY;
      return G_TOKEN_NONE;
      
    case G_TOKEN_STRING:
      if (!gdk_color_parse (scanner->value.v_string, color))
	{
          g_scanner_warn (scanner, "Invalid color constant '%s'",
                          scanner->value.v_string);
          return G_TOKEN_STRING;
	}
      return G_TOKEN_NONE;

    case '@':
      token = g_scanner_get_next_token (scanner);
      if (token != G_TOKEN_IDENTIFIER)
	return G_TOKEN_IDENTIFIER;

      if (!style || !lookup_color (style, scanner->value.v_identifier, color))
        {
          g_scanner_warn (scanner, "Invalid symbolic color '%s'",
                          scanner->value.v_identifier);
          return G_TOKEN_IDENTIFIER;
        }

      return G_TOKEN_NONE;

    case G_TOKEN_IDENTIFIER:
      if (strcmp (scanner->value.v_identifier, "mix") == 0)
        {
          token = g_scanner_get_next_token (scanner);
          if (token != G_TOKEN_LEFT_PAREN)
            return G_TOKEN_LEFT_PAREN;

          negate = FALSE;
          if (g_scanner_peek_next_token (scanner) == '-')
            {
              g_scanner_get_next_token (scanner); /* eat sign */
              negate = TRUE;
            }

          token = g_scanner_get_next_token (scanner);
          if (token != G_TOKEN_FLOAT)
            return G_TOKEN_FLOAT;

          l = negate ? -scanner->value.v_float : scanner->value.v_float;

          token = g_scanner_get_next_token (scanner);
          if (token != G_TOKEN_COMMA)
            return G_TOKEN_COMMA;

          token = gtk_rc_parse_color_full (scanner, style, &c1);
          if (token != G_TOKEN_NONE)
            return token;

	  token = g_scanner_get_next_token (scanner);
	  if (token != G_TOKEN_COMMA)
            return G_TOKEN_COMMA;

	  token = gtk_rc_parse_color_full (scanner, style, &c2);
	  if (token != G_TOKEN_NONE)
            return token;

	  token = g_scanner_get_next_token (scanner);
	  if (token != G_TOKEN_RIGHT_PAREN)
            return G_TOKEN_RIGHT_PAREN;

	  color->red   = l * c1.red   + (1.0 - l) * c2.red;
	  color->green = l * c1.green + (1.0 - l) * c2.green;
	  color->blue  = l * c1.blue  + (1.0 - l) * c2.blue;

	  return G_TOKEN_NONE;
	}
      else if (strcmp (scanner->value.v_identifier, "shade") == 0)
        {
	  token = g_scanner_get_next_token (scanner);
          if (token != G_TOKEN_LEFT_PAREN)
            return G_TOKEN_LEFT_PAREN;

          negate = FALSE;
          if (g_scanner_peek_next_token (scanner) == '-')
            {
              g_scanner_get_next_token (scanner); /* eat sign */
              negate = TRUE;
            }

          token = g_scanner_get_next_token (scanner);
          if (token != G_TOKEN_FLOAT)
            return G_TOKEN_FLOAT;

          l = negate ? -scanner->value.v_float : scanner->value.v_float;

          token = g_scanner_get_next_token (scanner);
          if (token != G_TOKEN_COMMA)
            return G_TOKEN_COMMA;

          token = gtk_rc_parse_color_full (scanner, style, &c1);
          if (token != G_TOKEN_NONE)
            return token;

          token = g_scanner_get_next_token (scanner);
          if (token != G_TOKEN_RIGHT_PAREN)
            return G_TOKEN_RIGHT_PAREN;

          _gtk_style_shade (&c1, color, l);

          return G_TOKEN_NONE;
        }
      else if (strcmp (scanner->value.v_identifier, "lighter") == 0 ||
               strcmp (scanner->value.v_identifier, "darker") == 0)
        {
          if (scanner->value.v_identifier[0] == 'l')
            l = 1.3;
          else
	    l = 0.7;

	  token = g_scanner_get_next_token (scanner);
          if (token != G_TOKEN_LEFT_PAREN)
            return G_TOKEN_LEFT_PAREN;

          token = gtk_rc_parse_color_full (scanner, style, &c1);
          if (token != G_TOKEN_NONE)
            return token;

          token = g_scanner_get_next_token (scanner);
          if (token != G_TOKEN_RIGHT_PAREN)
            return G_TOKEN_RIGHT_PAREN;

          _gtk_style_shade (&c1, color, l);

          return G_TOKEN_NONE;
        }
      else
        return G_TOKEN_IDENTIFIER;

    default:
      return G_TOKEN_STRING;
    }
}
