Move gtkstyle and gtkrc to deprecated/

This required a somewhat more substantial include reshuffling.
Some typedefs have been moved to gtkiconfactory.h and to
gtksettings.h.

4 files changed, 7029 insertions, 0 deletions

diff --git a/gtk/deprecated/gtkrc.c b/gtk/deprecated/gtkrc.c
new file mode 100644
index 0000000000..a36d90d0ce
--- /dev/null
+++ b/gtk/deprecated/gtkrc.c
@@ -0,0 +1,2058 @@
+/* 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 "gtkstyle.h"
+#include "gtkbindings.h"
+#include "gtkintl.h"
+#include "gtkiconfactory.h"
+#include "gtkmain.h"
+#include "gtkmodules.h"
+#include "gtkmodulesprivate.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_get_libdir (), "gtk-3.0", GTK_BINARY_VERSION, type, NULL);
+
+  return path;
+}
+
+/**
+ * gtk_rc_get_im_module_path:
+ *
+ * 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.
+ *
+ * Returns: (type filename): a newly-allocated string containing the
+ *    path in which to look for IM modules.
+ *
+ * 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:
+ *
+ * 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.
+ *
+ * Returns: (type filename): a newly-allocated string containing the
+ *    name of the file listing the IM modules available for loading
+ *
+ * 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_get_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;
+    }
+}
diff --git a/gtk/deprecated/gtkrc.h b/gtk/deprecated/gtkrc.h
new file mode 100644
index 0000000000..6b48f40d00
--- /dev/null
+++ b/gtk/deprecated/gtkrc.h
@@ -0,0 +1,324 @@
+/* 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/.
+ */
+
+#if !defined (__GTK_H_INSIDE__) && !defined (GTK_COMPILATION)
+#error "Only <gtk/gtk.h> can be included directly."
+#endif
+
+#ifndef __GTK_RC_H__
+#define __GTK_RC_H__
+
+#include <gtk/gtkwidget.h>
+
+G_BEGIN_DECLS
+
+/* Forward declarations */
+typedef struct _GtkRcContext    GtkRcContext;
+typedef struct _GtkRcStyleClass GtkRcStyleClass;
+
+#define GTK_TYPE_RC_STYLE              (gtk_rc_style_get_type ())
+#define GTK_RC_STYLE(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GTK_TYPE_RC_STYLE, GtkRcStyle))
+#define GTK_RC_STYLE_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_RC_STYLE, GtkRcStyleClass))
+#define GTK_IS_RC_STYLE(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GTK_TYPE_RC_STYLE))
+#define GTK_IS_RC_STYLE_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_RC_STYLE))
+#define GTK_RC_STYLE_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_RC_STYLE, GtkRcStyleClass))
+
+typedef enum
+{
+  GTK_RC_FG             = 1 << 0,
+  GTK_RC_BG             = 1 << 1,
+  GTK_RC_TEXT           = 1 << 2,
+  GTK_RC_BASE           = 1 << 3
+} GtkRcFlags;
+
+/**
+ * GtkRcStyle:
+ * @name:
+ * @bg_pixmap_name:
+ * @font_desc:
+ * @color_flags:
+ * @fg:
+ * @bg:
+ * @text:
+ * @base:
+ * @xthickness:
+ * @ythickness:
+ *
+ * The #GtkRcStyle structure is used to represent a set
+ * of information about the appearance of a widget.
+ * This can later be composited together with other
+ * #GtkRcStyle structures to form a #GtkStyle.
+ */
+struct _GtkRcStyle
+{
+  GObject parent_instance;
+
+  /*< public >*/
+
+  gchar *name;
+  gchar *bg_pixmap_name[5];
+  PangoFontDescription *font_desc;
+
+  GtkRcFlags color_flags[5];
+  GdkColor   fg[5];
+  GdkColor   bg[5];
+  GdkColor   text[5];
+  GdkColor   base[5];
+
+  gint xthickness;
+  gint ythickness;
+
+  /*< private >*/
+  GArray *rc_properties;
+
+  /* list of RC style lists including this RC style */
+  GSList *rc_style_lists;
+
+  GSList *icon_factories;
+
+  guint engine_specified : 1;   /* The RC file specified the engine */
+};
+
+struct _GtkRcStyleClass
+{
+  GObjectClass parent_class;
+
+  /* Create an empty RC style of the same type as this RC style.
+   * The default implementation, which does
+   * g_object_new (G_OBJECT_TYPE (style), NULL);
+   * should work in most cases.
+   */
+  GtkRcStyle * (*create_rc_style) (GtkRcStyle *rc_style);
+
+  /* Fill in engine specific parts of GtkRcStyle by parsing contents
+   * of brackets. Returns G_TOKEN_NONE if successful, otherwise returns
+   * the token it expected but didn't get.
+   */
+  guint     (*parse)  (GtkRcStyle   *rc_style,
+                       GtkSettings  *settings,
+                       GScanner     *scanner);
+
+  /* Combine RC style data from src into dest. If overridden, this
+   * function should chain to the parent.
+   */
+  void      (*merge)  (GtkRcStyle *dest,
+                       GtkRcStyle *src);
+
+  /* Create an empty style suitable to this RC style
+   */
+  GtkStyle * (*create_style) (GtkRcStyle *rc_style);
+
+  /* Padding for future expansion */
+  void (*_gtk_reserved1) (void);
+  void (*_gtk_reserved2) (void);
+  void (*_gtk_reserved3) (void);
+  void (*_gtk_reserved4) (void);
+};
+
+GSList*   _gtk_rc_parse_widget_class_path (const gchar *pattern);
+void      _gtk_rc_free_widget_class_path (GSList       *list);
+gboolean  _gtk_rc_match_widget_class     (GSList       *list,
+                                          gint          length,
+                                          gchar        *path,
+                                          gchar        *path_reversed);
+
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void      gtk_rc_add_default_file       (const gchar *filename);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void      gtk_rc_set_default_files      (gchar **filenames);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+gchar**   gtk_rc_get_default_files      (void);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+GtkStyle* gtk_rc_get_style              (GtkWidget   *widget);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+GtkStyle* gtk_rc_get_style_by_paths     (GtkSettings *settings,
+                                         const char  *widget_path,
+                                         const char  *class_path,
+                                         GType        type);
+
+GDK_DEPRECATED_FOR(GtkStyleContext)
+gboolean gtk_rc_reparse_all_for_settings (GtkSettings *settings,
+                                          gboolean     force_load);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void     gtk_rc_reset_styles             (GtkSettings *settings);
+
+GDK_DEPRECATED_FOR(GtkStyleContext)
+gchar*   gtk_rc_find_pixmap_in_path (GtkSettings  *settings,
+                                     GScanner     *scanner,
+                                     const gchar  *pixmap_file);
+
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void     gtk_rc_parse                   (const gchar *filename);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void      gtk_rc_parse_string           (const gchar *rc_string);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+gboolean  gtk_rc_reparse_all            (void);
+
+GType       gtk_rc_style_get_type   (void) G_GNUC_CONST;
+GDK_DEPRECATED_FOR(GtkStyleContext)
+GtkRcStyle* gtk_rc_style_new        (void);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+GtkRcStyle* gtk_rc_style_copy       (GtkRcStyle *orig);
+
+GDK_DEPRECATED_FOR(GtkStyleContext)
+gchar*      gtk_rc_find_module_in_path (const gchar *module_file);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+gchar*      gtk_rc_get_theme_dir       (void);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+gchar*      gtk_rc_get_module_dir      (void);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+gchar*      gtk_rc_get_im_module_path  (void);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+gchar*      gtk_rc_get_im_module_file  (void);
+
+/* private functions/definitions */
+
+/**
+ * GtkRcTokenType:
+ * @GTK_RC_TOKEN_INVALID:
+ * @GTK_RC_TOKEN_INCLUDE:
+ * @GTK_RC_TOKEN_NORMAL:
+ * @GTK_RC_TOKEN_ACTIVE:
+ * @GTK_RC_TOKEN_PRELIGHT:
+ * @GTK_RC_TOKEN_SELECTED:
+ * @GTK_RC_TOKEN_INSENSITIVE:
+ * @GTK_RC_TOKEN_FG:
+ * @GTK_RC_TOKEN_BG:
+ * @GTK_RC_TOKEN_TEXT:
+ * @GTK_RC_TOKEN_BASE:
+ * @GTK_RC_TOKEN_XTHICKNESS:
+ * @GTK_RC_TOKEN_YTHICKNESS:
+ * @GTK_RC_TOKEN_FONT:
+ * @GTK_RC_TOKEN_FONTSET:
+ * @GTK_RC_TOKEN_FONT_NAME:
+ * @GTK_RC_TOKEN_BG_PIXMAP:
+ * @GTK_RC_TOKEN_PIXMAP_PATH:
+ * @GTK_RC_TOKEN_STYLE:
+ * @GTK_RC_TOKEN_BINDING:
+ * @GTK_RC_TOKEN_BIND:
+ * @GTK_RC_TOKEN_WIDGET:
+ * @GTK_RC_TOKEN_WIDGET_CLASS:
+ * @GTK_RC_TOKEN_CLASS:
+ * @GTK_RC_TOKEN_LOWEST:
+ * @GTK_RC_TOKEN_GTK:
+ * @GTK_RC_TOKEN_APPLICATION:
+ * @GTK_RC_TOKEN_THEME:
+ * @GTK_RC_TOKEN_RC:
+ * @GTK_RC_TOKEN_HIGHEST:
+ * @GTK_RC_TOKEN_ENGINE:
+ * @GTK_RC_TOKEN_MODULE_PATH:
+ * @GTK_RC_TOKEN_IM_MODULE_PATH:
+ * @GTK_RC_TOKEN_IM_MODULE_FILE:
+ * @GTK_RC_TOKEN_STOCK:
+ * @GTK_RC_TOKEN_LTR:
+ * @GTK_RC_TOKEN_RTL:
+ * @GTK_RC_TOKEN_COLOR:
+ * @GTK_RC_TOKEN_UNBIND:
+ * @GTK_RC_TOKEN_LAST:
+ *
+ * The #GtkRcTokenType enumeration represents the tokens
+ * in the RC file. It is exposed so that theme engines
+ * can reuse these tokens when parsing the theme-engine
+ * specific portions of a RC file.
+ *
+ * Deprecated: 3.0: Use #GtkCssProvider instead.
+ */
+typedef enum {
+  GTK_RC_TOKEN_INVALID = G_TOKEN_LAST,
+  GTK_RC_TOKEN_INCLUDE,
+  GTK_RC_TOKEN_NORMAL,
+  GTK_RC_TOKEN_ACTIVE,
+  GTK_RC_TOKEN_PRELIGHT,
+  GTK_RC_TOKEN_SELECTED,
+  GTK_RC_TOKEN_INSENSITIVE,
+  GTK_RC_TOKEN_FG,
+  GTK_RC_TOKEN_BG,
+  GTK_RC_TOKEN_TEXT,
+  GTK_RC_TOKEN_BASE,
+  GTK_RC_TOKEN_XTHICKNESS,
+  GTK_RC_TOKEN_YTHICKNESS,
+  GTK_RC_TOKEN_FONT,
+  GTK_RC_TOKEN_FONTSET,
+  GTK_RC_TOKEN_FONT_NAME,
+  GTK_RC_TOKEN_BG_PIXMAP,
+  GTK_RC_TOKEN_PIXMAP_PATH,
+  GTK_RC_TOKEN_STYLE,
+  GTK_RC_TOKEN_BINDING,
+  GTK_RC_TOKEN_BIND,
+  GTK_RC_TOKEN_WIDGET,
+  GTK_RC_TOKEN_WIDGET_CLASS,
+  GTK_RC_TOKEN_CLASS,
+  GTK_RC_TOKEN_LOWEST,
+  GTK_RC_TOKEN_GTK,
+  GTK_RC_TOKEN_APPLICATION,
+  GTK_RC_TOKEN_THEME,
+  GTK_RC_TOKEN_RC,
+  GTK_RC_TOKEN_HIGHEST,
+  GTK_RC_TOKEN_ENGINE,
+  GTK_RC_TOKEN_MODULE_PATH,
+  GTK_RC_TOKEN_IM_MODULE_PATH,
+  GTK_RC_TOKEN_IM_MODULE_FILE,
+  GTK_RC_TOKEN_STOCK,
+  GTK_RC_TOKEN_LTR,
+  GTK_RC_TOKEN_RTL,
+  GTK_RC_TOKEN_COLOR,
+  GTK_RC_TOKEN_UNBIND,
+  GTK_RC_TOKEN_LAST
+} GtkRcTokenType;
+
+GDK_DEPRECATED_FOR(GtkStyleContext)
+GScanner* gtk_rc_scanner_new    (void);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+guint     gtk_rc_parse_color    (GScanner            *scanner,
+                                 GdkColor            *color);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+guint     gtk_rc_parse_color_full (GScanner          *scanner,
+                                   GtkRcStyle        *style,
+                                   GdkColor          *color);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+guint     gtk_rc_parse_state    (GScanner            *scanner,
+                                 GtkStateType        *state);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+guint     gtk_rc_parse_priority (GScanner            *scanner,
+                                 GtkPathPriorityType *priority);
+
+/* rc properties
+ * (structure forward declared in gtkstyle.h)
+ */
+struct _GtkRcProperty
+{
+  /* quark-ified property identifier like "GtkScrollbar::spacing" */
+  GQuark type_name;
+  GQuark property_name;
+
+  /* fields similar to GtkSettingsValue */
+  gchar *origin;
+  GValue value;
+};
+
+G_END_DECLS
+
+#endif /* __GTK_RC_H__ */
diff --git a/gtk/deprecated/gtkstyle.c b/gtk/deprecated/gtkstyle.c
new file mode 100644
index 0000000000..dcb222ac1d
--- /dev/null
+++ b/gtk/deprecated/gtkstyle.c
@@ -0,0 +1,3981 @@
+/* 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 <math.h>
+#include <stdlib.h>
+#include <string.h>
+#include <gobject/gvaluecollector.h>
+#include "gtkmarshalers.h"
+#include "gtkpango.h"
+#include "gtkrc.h"
+#include "gtkspinbutton.h"
+#include "gtkstyle.h"
+#include "gtkstylecontextprivate.h"
+#include "gtkwidget.h"
+#include "gtkiconfactory.h"
+#include "gtkintl.h"
+#include "gtkdebug.h"
+#include "gtkspinner.h"
+#include "gtkborder.h"
+
+/**
+ * SECTION:gtkstyle
+ * @Short_description: Deprecated object that holds style information
+ *     for widgets
+ * @Title: GtkStyle
+ *
+ * A #GtkStyle object encapsulates the information that provides the look and
+ * feel for a widget.
+ *
+ * <warning>
+ * In GTK+ 3.0, GtkStyle has been deprecated and replaced by #GtkStyleContext.
+ * </warning>
+ *
+ * Each #GtkWidget has an associated #GtkStyle object that is used when
+ * rendering that widget. Also, a #GtkStyle holds information for the five
+ * possible widget states though not every widget supports all five
+ * states; see #GtkStateType.
+ *
+ * Usually the #GtkStyle for a widget is the same as the default style that
+ * is set by GTK+ and modified the theme engine.
+ *
+ * Usually applications should not need to use or modify the #GtkStyle of
+ * their widgets.
+ */
+
+
+#define LIGHTNESS_MULT  1.3
+#define DARKNESS_MULT   0.7
+
+/* --- typedefs & structures --- */
+typedef struct {
+  GType       widget_type;
+  GParamSpec *pspec;
+  GValue      value;
+} PropertyValue;
+
+#define GTK_STYLE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GTK_TYPE_STYLE, GtkStylePrivate))
+
+typedef struct _GtkStylePrivate GtkStylePrivate;
+
+struct _GtkStylePrivate {
+  GtkStyleContext *context;
+  gulong context_changed_id;
+};
+
+enum {
+  PROP_0,
+  PROP_CONTEXT
+};
+
+/* --- prototypes --- */
+static void	 gtk_style_finalize		(GObject	*object);
+static void	 gtk_style_constructed		(GObject	*object);
+static void      gtk_style_set_property         (GObject        *object,
+                                                 guint           prop_id,
+                                                 const GValue   *value,
+                                                 GParamSpec     *pspec);
+static void      gtk_style_get_property         (GObject        *object,
+                                                 guint           prop_id,
+                                                 GValue         *value,
+                                                 GParamSpec     *pspec);
+
+static void      gtk_style_real_realize        (GtkStyle	*style);
+static void      gtk_style_real_unrealize      (GtkStyle	*style);
+static void      gtk_style_real_copy           (GtkStyle	*style,
+						GtkStyle	*src);
+static void      gtk_style_real_set_background (GtkStyle	*style,
+						GdkWindow	*window,
+						GtkStateType	 state_type);
+static GtkStyle *gtk_style_real_clone          (GtkStyle	*style);
+static void      gtk_style_real_init_from_rc   (GtkStyle	*style,
+                                                GtkRcStyle	*rc_style);
+static GdkPixbuf *gtk_default_render_icon      (GtkStyle            *style,
+                                                const GtkIconSource *source,
+                                                GtkTextDirection     direction,
+                                                GtkStateType         state,
+                                                GtkIconSize          size,
+                                                GtkWidget           *widget,
+                                                const gchar         *detail);
+static void gtk_default_draw_hline      (GtkStyle        *style,
+					 cairo_t         *cr,
+					 GtkStateType     state_type,
+					 GtkWidget       *widget,
+					 const gchar     *detail,
+					 gint             x1,
+					 gint             x2,
+					 gint             y);
+static void gtk_default_draw_vline      (GtkStyle        *style,
+					 cairo_t         *cr,
+					 GtkStateType     state_type,
+					 GtkWidget       *widget,
+					 const gchar     *detail,
+					 gint             y1,
+					 gint             y2,
+					 gint             x);
+static void gtk_default_draw_shadow     (GtkStyle        *style,
+					 cairo_t         *cr,
+					 GtkStateType     state_type,
+					 GtkShadowType    shadow_type,
+					 GtkWidget       *widget,
+					 const gchar     *detail,
+					 gint             x,
+					 gint             y,
+					 gint             width,
+					 gint             height);
+static void gtk_default_draw_arrow      (GtkStyle        *style,
+					 cairo_t         *cr,
+					 GtkStateType     state_type,
+					 GtkShadowType    shadow_type,
+					 GtkWidget       *widget,
+					 const gchar     *detail,
+					 GtkArrowType     arrow_type,
+					 gboolean         fill,
+					 gint             x,
+					 gint             y,
+					 gint             width,
+					 gint             height);
+static void gtk_default_draw_diamond    (GtkStyle        *style,
+					 cairo_t         *cr,
+					 GtkStateType     state_type,
+					 GtkShadowType    shadow_type,
+					 GtkWidget       *widget,
+					 const gchar     *detail,
+					 gint             x,
+					 gint             y,
+					 gint             width,
+					 gint             height);
+static void gtk_default_draw_box        (GtkStyle        *style,
+					 cairo_t         *cr,
+					 GtkStateType     state_type,
+					 GtkShadowType    shadow_type,
+					 GtkWidget       *widget,
+					 const gchar     *detail,
+					 gint             x,
+					 gint             y,
+					 gint             width,
+					 gint             height);
+static void gtk_default_draw_flat_box   (GtkStyle        *style,
+					 cairo_t         *cr,
+					 GtkStateType     state_type,
+					 GtkShadowType    shadow_type,
+					 GtkWidget       *widget,
+					 const gchar     *detail,
+					 gint             x,
+					 gint             y,
+					 gint             width,
+					 gint             height);
+static void gtk_default_draw_check      (GtkStyle        *style,
+					 cairo_t         *cr,
+					 GtkStateType     state_type,
+					 GtkShadowType    shadow_type,
+					 GtkWidget       *widget,
+					 const gchar     *detail,
+					 gint             x,
+					 gint             y,
+					 gint             width,
+					 gint             height);
+static void gtk_default_draw_option     (GtkStyle        *style,
+					 cairo_t         *cr,
+					 GtkStateType     state_type,
+					 GtkShadowType    shadow_type,
+					 GtkWidget       *widget,
+					 const gchar     *detail,
+					 gint             x,
+					 gint             y,
+					 gint             width,
+					 gint             height);
+static void gtk_default_draw_tab        (GtkStyle        *style,
+					 cairo_t         *cr,
+					 GtkStateType     state_type,
+					 GtkShadowType    shadow_type,
+					 GtkWidget       *widget,
+					 const gchar     *detail,
+					 gint             x,
+					 gint             y,
+					 gint             width,
+					 gint             height);
+static void gtk_default_draw_shadow_gap (GtkStyle        *style,
+					 cairo_t         *cr,
+					 GtkStateType     state_type,
+					 GtkShadowType    shadow_type,
+					 GtkWidget       *widget,
+					 const gchar     *detail,
+					 gint             x,
+					 gint             y,
+					 gint             width,
+					 gint             height,
+					 GtkPositionType  gap_side,
+					 gint             gap_x,
+					 gint             gap_width);
+static void gtk_default_draw_box_gap    (GtkStyle        *style,
+					 cairo_t         *cr,
+					 GtkStateType     state_type,
+					 GtkShadowType    shadow_type,
+					 GtkWidget       *widget,
+					 const gchar     *detail,
+					 gint             x,
+					 gint             y,
+					 gint             width,
+					 gint             height,
+					 GtkPositionType  gap_side,
+					 gint             gap_x,
+					 gint             gap_width);
+static void gtk_default_draw_extension  (GtkStyle        *style,
+					 cairo_t         *cr,
+					 GtkStateType     state_type,
+					 GtkShadowType    shadow_type,
+					 GtkWidget       *widget,
+					 const gchar     *detail,
+					 gint             x,
+					 gint             y,
+					 gint             width,
+					 gint             height,
+					 GtkPositionType  gap_side);
+static void gtk_default_draw_focus      (GtkStyle        *style,
+					 cairo_t         *cr,
+					 GtkStateType     state_type,
+					 GtkWidget       *widget,
+					 const gchar     *detail,
+					 gint             x,
+					 gint             y,
+					 gint             width,
+					 gint             height);
+static void gtk_default_draw_slider     (GtkStyle        *style,
+					 cairo_t         *cr,
+					 GtkStateType     state_type,
+					 GtkShadowType    shadow_type,
+					 GtkWidget       *widget,
+					 const gchar     *detail,
+					 gint             x,
+					 gint             y,
+					 gint             width,
+					 gint             height,
+					 GtkOrientation   orientation);
+static void gtk_default_draw_handle     (GtkStyle        *style,
+					 cairo_t         *cr,
+					 GtkStateType     state_type,
+					 GtkShadowType    shadow_type,
+					 GtkWidget       *widget,
+					 const gchar     *detail,
+					 gint             x,
+					 gint             y,
+					 gint             width,
+					 gint             height,
+					 GtkOrientation   orientation);
+static void gtk_default_draw_expander   (GtkStyle        *style,
+                                         cairo_t         *cr,
+                                         GtkStateType     state_type,
+                                         GtkWidget       *widget,
+                                         const gchar     *detail,
+                                         gint             x,
+                                         gint             y,
+					 GtkExpanderStyle expander_style);
+static void gtk_default_draw_layout     (GtkStyle        *style,
+                                         cairo_t         *cr,
+                                         GtkStateType     state_type,
+					 gboolean         use_text,
+                                         GtkWidget       *widget,
+                                         const gchar     *detail,
+                                         gint             x,
+                                         gint             y,
+                                         PangoLayout     *layout);
+static void gtk_default_draw_resize_grip (GtkStyle       *style,
+                                          cairo_t        *cr,
+                                          GtkStateType    state_type,
+                                          GtkWidget      *widget,
+                                          const gchar    *detail,
+                                          GdkWindowEdge   edge,
+                                          gint            x,
+                                          gint            y,
+                                          gint            width,
+                                          gint            height);
+static void gtk_default_draw_spinner     (GtkStyle       *style,
+                                          cairo_t        *cr,
+					  GtkStateType    state_type,
+                                          GtkWidget      *widget,
+                                          const gchar    *detail,
+					  guint           step,
+					  gint            x,
+					  gint            y,
+					  gint            width,
+					  gint            height);
+
+static void rgb_to_hls			(gdouble	 *r,
+					 gdouble	 *g,
+					 gdouble	 *b);
+static void hls_to_rgb			(gdouble	 *h,
+					 gdouble	 *l,
+					 gdouble	 *s);
+
+static void transform_detail_string (const gchar     *detail,
+                                     GtkStyleContext *context);
+
+/*
+ * Data for default check and radio buttons
+ */
+
+static const GtkRequisition default_option_indicator_size = { 7, 13 };
+static const GtkBorder default_option_indicator_spacing = { 7, 5, 2, 2 };
+
+#define GTK_GRAY		0xdcdc, 0xdada, 0xd5d5
+#define GTK_DARK_GRAY		0xc4c4, 0xc2c2, 0xbdbd
+#define GTK_LIGHT_GRAY		0xeeee, 0xebeb, 0xe7e7
+#define GTK_WHITE		0xffff, 0xffff, 0xffff
+#define GTK_BLUE		0x4b4b, 0x6969, 0x8383
+#define GTK_VERY_DARK_GRAY	0x9c9c, 0x9a9a, 0x9494
+#define GTK_BLACK		0x0000, 0x0000, 0x0000
+#define GTK_WEAK_GRAY		0x7530, 0x7530, 0x7530
+
+/* --- variables --- */
+static const GdkColor gtk_default_normal_fg =      { 0, GTK_BLACK };
+static const GdkColor gtk_default_active_fg =      { 0, GTK_BLACK };
+static const GdkColor gtk_default_prelight_fg =    { 0, GTK_BLACK };
+static const GdkColor gtk_default_selected_fg =    { 0, GTK_WHITE };
+static const GdkColor gtk_default_insensitive_fg = { 0, GTK_WEAK_GRAY };
+
+static const GdkColor gtk_default_normal_bg =      { 0, GTK_GRAY };
+static const GdkColor gtk_default_active_bg =      { 0, GTK_DARK_GRAY };
+static const GdkColor gtk_default_prelight_bg =    { 0, GTK_LIGHT_GRAY };
+static const GdkColor gtk_default_selected_bg =    { 0, GTK_BLUE };
+static const GdkColor gtk_default_insensitive_bg = { 0, GTK_GRAY };
+static const GdkColor gtk_default_selected_base =  { 0, GTK_BLUE };
+static const GdkColor gtk_default_active_base =    { 0, GTK_VERY_DARK_GRAY };
+
+/* --- signals --- */
+static guint realize_signal = 0;
+static guint unrealize_signal = 0;
+
+G_DEFINE_TYPE (GtkStyle, gtk_style, G_TYPE_OBJECT)
+
+/* --- functions --- */
+
+static void
+gtk_style_init (GtkStyle *style)
+{
+  gint i;
+
+  style->font_desc = pango_font_description_from_string ("Sans 10");
+
+  style->attach_count = 0;
+  
+  style->black.red = 0;
+  style->black.green = 0;
+  style->black.blue = 0;
+  
+  style->white.red = 65535;
+  style->white.green = 65535;
+  style->white.blue = 65535;
+  
+  style->fg[GTK_STATE_NORMAL] = gtk_default_normal_fg;
+  style->fg[GTK_STATE_ACTIVE] = gtk_default_active_fg;
+  style->fg[GTK_STATE_PRELIGHT] = gtk_default_prelight_fg;
+  style->fg[GTK_STATE_SELECTED] = gtk_default_selected_fg;
+  style->fg[GTK_STATE_INSENSITIVE] = gtk_default_insensitive_fg;
+  
+  style->bg[GTK_STATE_NORMAL] = gtk_default_normal_bg;
+  style->bg[GTK_STATE_ACTIVE] = gtk_default_active_bg;
+  style->bg[GTK_STATE_PRELIGHT] = gtk_default_prelight_bg;
+  style->bg[GTK_STATE_SELECTED] = gtk_default_selected_bg;
+  style->bg[GTK_STATE_INSENSITIVE] = gtk_default_insensitive_bg;
+  
+  for (i = 0; i < 4; i++)
+    {
+      style->text[i] = style->fg[i];
+      style->base[i] = style->white;
+    }
+
+  style->base[GTK_STATE_SELECTED] = gtk_default_selected_base;
+  style->text[GTK_STATE_SELECTED] = style->white;
+  style->base[GTK_STATE_ACTIVE] = gtk_default_active_base;
+  style->text[GTK_STATE_ACTIVE] = style->white;
+  style->base[GTK_STATE_INSENSITIVE] = gtk_default_prelight_bg;
+  style->text[GTK_STATE_INSENSITIVE] = gtk_default_insensitive_fg;
+  
+  style->rc_style = NULL;
+  
+  style->xthickness = 2;
+  style->ythickness = 2;
+
+  style->property_cache = NULL;
+}
+
+static void
+gtk_style_class_init (GtkStyleClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  
+  object_class->finalize = gtk_style_finalize;
+  object_class->set_property = gtk_style_set_property;
+  object_class->get_property = gtk_style_get_property;
+  object_class->constructed = gtk_style_constructed;
+
+  klass->clone = gtk_style_real_clone;
+  klass->copy = gtk_style_real_copy;
+  klass->init_from_rc = gtk_style_real_init_from_rc;
+  klass->realize = gtk_style_real_realize;
+  klass->unrealize = gtk_style_real_unrealize;
+  klass->set_background = gtk_style_real_set_background;
+  klass->render_icon = gtk_default_render_icon;
+
+  klass->draw_hline = gtk_default_draw_hline;
+  klass->draw_vline = gtk_default_draw_vline;
+  klass->draw_shadow = gtk_default_draw_shadow;
+  klass->draw_arrow = gtk_default_draw_arrow;
+  klass->draw_diamond = gtk_default_draw_diamond;
+  klass->draw_box = gtk_default_draw_box;
+  klass->draw_flat_box = gtk_default_draw_flat_box;
+  klass->draw_check = gtk_default_draw_check;
+  klass->draw_option = gtk_default_draw_option;
+  klass->draw_tab = gtk_default_draw_tab;
+  klass->draw_shadow_gap = gtk_default_draw_shadow_gap;
+  klass->draw_box_gap = gtk_default_draw_box_gap;
+  klass->draw_extension = gtk_default_draw_extension;
+  klass->draw_focus = gtk_default_draw_focus;
+  klass->draw_slider = gtk_default_draw_slider;
+  klass->draw_handle = gtk_default_draw_handle;
+  klass->draw_expander = gtk_default_draw_expander;
+  klass->draw_layout = gtk_default_draw_layout;
+  klass->draw_resize_grip = gtk_default_draw_resize_grip;
+  klass->draw_spinner = gtk_default_draw_spinner;
+
+  g_type_class_add_private (object_class, sizeof (GtkStylePrivate));
+
+  g_object_class_install_property (object_class,
+				   PROP_CONTEXT,
+				   g_param_spec_object ("context",
+ 							P_("Style context"),
+							P_("GtkStyleContext to get style from"),
+                                                        GTK_TYPE_STYLE_CONTEXT,
+                                                        G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE));
+
+  /**
+   * GtkStyle::realize:
+   * @style: the object which received the signal
+   *
+   * Emitted when the style has been initialized for a particular
+   * visual. Connecting to this signal is probably seldom
+   * useful since most of the time applications and widgets only
+   * deal with styles that have been already realized.
+   *
+   * Since: 2.4
+   */
+  realize_signal = g_signal_new (I_("realize"),
+				 G_TYPE_FROM_CLASS (object_class),
+				 G_SIGNAL_RUN_FIRST,
+				 G_STRUCT_OFFSET (GtkStyleClass, realize),
+				 NULL, NULL,
+				 _gtk_marshal_VOID__VOID,
+				 G_TYPE_NONE, 0);
+  /**
+   * GtkStyle::unrealize:
+   * @style: the object which received the signal
+   *
+   * Emitted when the aspects of the style specific to a particular visual
+   * is being cleaned up. A connection to this signal can be useful
+   * if a widget wants to cache objects as object data on #GtkStyle.
+   * This signal provides a convenient place to free such cached objects.
+   *
+   * Since: 2.4
+   */
+  unrealize_signal = g_signal_new (I_("unrealize"),
+				   G_TYPE_FROM_CLASS (object_class),
+				   G_SIGNAL_RUN_FIRST,
+				   G_STRUCT_OFFSET (GtkStyleClass, unrealize),
+				   NULL, NULL,
+				   _gtk_marshal_VOID__VOID,
+				   G_TYPE_NONE, 0);
+}
+
+static void
+gtk_style_finalize (GObject *object)
+{
+  GtkStyle *style = GTK_STYLE (object);
+  GtkStylePrivate *priv = GTK_STYLE_GET_PRIVATE (style);
+  gint i;
+
+  g_return_if_fail (style->attach_count == 0);
+
+  /* All the styles in the list have the same 
+   * style->styles pointer. If we delete the 
+   * *first* style from the list, we need to update
+   * the style->styles pointers from all the styles.
+   * Otherwise we simply remove the node from
+   * the list.
+   */
+  if (style->styles)
+    {
+      if (style->styles->data != style)
+        style->styles = g_slist_remove (style->styles, style);
+      else
+        {
+          GSList *tmp_list = style->styles->next;
+	  
+          while (tmp_list)
+            {
+              GTK_STYLE (tmp_list->data)->styles = style->styles->next;
+              tmp_list = tmp_list->next;
+            }
+          g_slist_free_1 (style->styles);
+        }
+    }
+
+  g_slist_foreach (style->icon_factories, (GFunc) g_object_unref, NULL);
+  g_slist_free (style->icon_factories);
+
+  pango_font_description_free (style->font_desc);
+
+  if (style->private_font_desc)
+    pango_font_description_free (style->private_font_desc);
+
+  if (style->rc_style)
+    g_object_unref (style->rc_style);
+
+  if (priv->context)
+    {
+      if (priv->context_changed_id)
+        g_signal_handler_disconnect (priv->context, priv->context_changed_id);
+
+      g_object_unref (priv->context);
+    }
+
+  for (i = 0; i < 5; i++)
+    {
+      if (style->background[i])
+        cairo_pattern_destroy (style->background[i]);
+    }
+
+  G_OBJECT_CLASS (gtk_style_parent_class)->finalize (object);
+}
+
+static void
+gtk_style_set_property (GObject      *object,
+                        guint         prop_id,
+                        const GValue *value,
+                        GParamSpec   *pspec)
+{
+  GtkStylePrivate *priv;
+
+  priv = GTK_STYLE_GET_PRIVATE (object);
+
+  switch (prop_id)
+    {
+    case PROP_CONTEXT:
+      priv->context = g_value_dup_object (value);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+gtk_style_get_property (GObject      *object,
+                        guint         prop_id,
+                        GValue       *value,
+                        GParamSpec   *pspec)
+{
+  GtkStylePrivate *priv;
+
+  priv = GTK_STYLE_GET_PRIVATE (object);
+
+  switch (prop_id)
+    {
+    case PROP_CONTEXT:
+      g_value_set_object (value, priv->context);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+set_color (GtkStyle        *style,
+           GtkStyleContext *context,
+           GtkStateType     state,
+           GtkRcFlags       prop)
+{
+  GtkStateFlags flags;
+  GdkRGBA *color = NULL;
+  GdkColor *dest = { 0 }; /* Shut up gcc */
+
+  switch (state)
+    {
+    case GTK_STATE_ACTIVE:
+      flags = GTK_STATE_FLAG_ACTIVE;
+      break;
+    case GTK_STATE_PRELIGHT:
+      flags = GTK_STATE_FLAG_PRELIGHT;
+      break;
+    case GTK_STATE_SELECTED:
+      flags = GTK_STATE_FLAG_SELECTED;
+      break;
+    case GTK_STATE_INSENSITIVE:
+      flags = GTK_STATE_FLAG_INSENSITIVE;
+      break;
+    default:
+      flags = 0;
+    }
+
+  switch (prop)
+    {
+    case GTK_RC_BG:
+      gtk_style_context_get (context, flags,
+                             "background-color", &color,
+                             NULL);
+      dest = &style->bg[state];
+      break;
+    case GTK_RC_FG:
+      gtk_style_context_get (context, flags,
+                             "color", &color,
+                             NULL);
+      dest = &style->fg[state];
+      break;
+    case GTK_RC_TEXT:
+      gtk_style_context_get (context, flags,
+                             "color", &color,
+                             NULL);
+      dest = &style->text[state];
+      break;
+    case GTK_RC_BASE:
+      gtk_style_context_get (context, flags,
+                             "background-color", &color,
+                             NULL);
+      dest = &style->base[state];
+      break;
+    }
+
+  if (color)
+    {
+      dest->pixel = 0;
+      dest->red = CLAMP ((guint) (color->red * 65535), 0, 65535);
+      dest->green = CLAMP ((guint) (color->green * 65535), 0, 65535);
+      dest->blue = CLAMP ((guint) (color->blue * 65535), 0, 65535);
+      gdk_rgba_free (color);
+    }
+}
+
+static void
+gtk_style_update_from_context (GtkStyle *style)
+{
+  GtkStylePrivate *priv;
+  GtkStateType state;
+  GtkBorder padding;
+  gint i;
+
+  priv = GTK_STYLE_GET_PRIVATE (style);
+
+  for (state = GTK_STATE_NORMAL; state <= GTK_STATE_INSENSITIVE; state++)
+    {
+      if (gtk_style_context_has_class (priv->context, "entry"))
+        {
+          gtk_style_context_save (priv->context);
+          gtk_style_context_remove_class (priv->context, "entry");
+          set_color (style, priv->context, state, GTK_RC_BG);
+          set_color (style, priv->context, state, GTK_RC_FG);
+          gtk_style_context_restore (priv->context);
+
+          set_color (style, priv->context, state, GTK_RC_BASE);
+          set_color (style, priv->context, state, GTK_RC_TEXT);
+        }
+      else
+        {
+          gtk_style_context_save (priv->context);
+          gtk_style_context_add_class (priv->context, "entry");
+          set_color (style, priv->context, state, GTK_RC_BASE);
+          set_color (style, priv->context, state, GTK_RC_TEXT);
+          gtk_style_context_restore (priv->context);
+
+          set_color (style, priv->context, state, GTK_RC_BG);
+          set_color (style, priv->context, state, GTK_RC_FG);
+        }
+    }
+
+  if (style->font_desc)
+    pango_font_description_free (style->font_desc);
+
+  gtk_style_context_get (priv->context, 0,
+                         "font", &style->font_desc,
+                         NULL);
+  gtk_style_context_get_padding (priv->context, 0, &padding);
+
+  style->xthickness = padding.left;
+  style->ythickness = padding.top;
+
+  for (i = 0; i < 5; i++)
+    {
+      _gtk_style_shade (&style->bg[i], &style->light[i], LIGHTNESS_MULT);
+      _gtk_style_shade (&style->bg[i], &style->dark[i], DARKNESS_MULT);
+
+      style->mid[i].red = (style->light[i].red + style->dark[i].red) / 2;
+      style->mid[i].green = (style->light[i].green + style->dark[i].green) / 2;
+      style->mid[i].blue = (style->light[i].blue + style->dark[i].blue) / 2;
+
+      style->text_aa[i].red = (style->text[i].red + style->base[i].red) / 2;
+      style->text_aa[i].green = (style->text[i].green + style->base[i].green) / 2;
+      style->text_aa[i].blue = (style->text[i].blue + style->base[i].blue) / 2;
+    }
+
+  style->black.red = 0x0000;
+  style->black.green = 0x0000;
+  style->black.blue = 0x0000;
+
+  style->white.red = 0xffff;
+  style->white.green = 0xffff;
+  style->white.blue = 0xffff;
+
+  for (i = 0; i < 5; i++)
+    {
+      if (style->background[i])
+        cairo_pattern_destroy (style->background[i]);
+
+      style->background[i] = cairo_pattern_create_rgb (style->bg[i].red / 65535.0,
+                                                       style->bg[i].green / 65535.0,
+                                                       style->bg[i].blue / 65535.0);
+    }
+}
+
+static void
+style_context_changed (GtkStyleContext *context,
+                       gpointer         user_data)
+{
+  gtk_style_update_from_context (GTK_STYLE (user_data));
+}
+
+static void
+gtk_style_constructed (GObject *object)
+{
+  GtkStylePrivate *priv;
+
+  priv = GTK_STYLE_GET_PRIVATE (object);
+
+  if (priv->context)
+    {
+      gtk_style_update_from_context (GTK_STYLE (object));
+
+      priv->context_changed_id = g_signal_connect (priv->context, "changed",
+                                                   G_CALLBACK (style_context_changed), object);
+    }
+}
+
+/**
+ * gtk_style_copy:
+ * @style: a #GtkStyle
+ *
+ * Creates a copy of the passed in #GtkStyle object.
+ *
+ * Returns: (transfer full): a copy of @style
+ *
+ * Deprecated:3.0: Use #GtkStyleContext instead
+ */
+GtkStyle*
+gtk_style_copy (GtkStyle *style)
+{
+  GtkStyle *new_style;
+  
+  g_return_val_if_fail (GTK_IS_STYLE (style), NULL);
+  
+  new_style = GTK_STYLE_GET_CLASS (style)->clone (style);
+  GTK_STYLE_GET_CLASS (style)->copy (new_style, style);
+
+  return new_style;
+}
+
+GtkStyle*
+_gtk_style_new_for_path (GdkScreen     *screen,
+                         GtkWidgetPath *path)
+{
+  GtkStyleContext *context;
+  GtkStyle *style;
+
+  context = gtk_style_context_new ();
+
+  if (screen)
+    gtk_style_context_set_screen (context, screen);
+
+  gtk_style_context_set_path (context, path);
+
+  style = g_object_new (GTK_TYPE_STYLE,
+                        "context", context,
+                        NULL);
+
+  g_object_unref (context);
+
+  return style;
+}
+
+/**
+ * gtk_style_new:
+ *
+ * Creates a new #GtkStyle.
+ *
+ * Returns: a new #GtkStyle.
+ *
+ * Deprecated: 3.0: Use #GtkStyleContext
+ */
+GtkStyle*
+gtk_style_new (void)
+{
+  GtkWidgetPath *path;
+  GtkStyle *style;
+
+  path = gtk_widget_path_new ();
+  gtk_widget_path_append_type (path, GTK_TYPE_WIDGET);
+
+  style = _gtk_style_new_for_path (gdk_screen_get_default (), path);
+
+  gtk_widget_path_free (path);
+
+  return style;
+}
+
+/**
+ * gtk_style_has_context:
+ * @style: a #GtkStyle
+ *
+ * Returns whether @style has an associated #GtkStyleContext.
+ *
+ * Returns: %TRUE if @style has a #GtkStyleContext
+ *
+ * Since: 3.0
+ */
+gboolean
+gtk_style_has_context (GtkStyle *style)
+{
+  GtkStylePrivate *priv;
+
+  priv = GTK_STYLE_GET_PRIVATE (style);
+
+  return priv->context != NULL;
+}
+
+/**
+ * gtk_style_attach: (skip)
+ * @style: a #GtkStyle.
+ * @window: a #GdkWindow.
+ *
+ * Attaches a style to a window; this process allocates the
+ * colors and creates the GC's for the style - it specializes
+ * it to a particular visual. The process may involve the creation
+ * of a new style if the style has already been attached to a
+ * window with a different style and visual.
+ *
+ * Since this function may return a new object, you have to use it
+ * in the following way:
+ * <literal>style = gtk_style_attach (style, window)</literal>
+ *
+ * Returns: Either @style, or a newly-created #GtkStyle.
+ *   If the style is newly created, the style parameter
+ *   will be unref'ed, and the new style will have
+ *   a reference count belonging to the caller.
+ *
+ * Deprecated:3.0: Use gtk_widget_style_attach() instead
+ */
+GtkStyle*
+gtk_style_attach (GtkStyle  *style,
+                  GdkWindow *window)
+{
+  g_return_val_if_fail (GTK_IS_STYLE (style), NULL);
+  g_return_val_if_fail (window != NULL, NULL);
+
+  return style;
+}
+
+/**
+ * gtk_style_detach:
+ * @style: a #GtkStyle
+ *
+ * Detaches a style from a window. If the style is not attached
+ * to any windows anymore, it is unrealized. See gtk_style_attach().
+ *
+ * Deprecated:3.0: Use #GtkStyleContext instead
+ */
+void
+gtk_style_detach (GtkStyle *style)
+{
+  g_return_if_fail (GTK_IS_STYLE (style));
+}
+
+/**
+ * gtk_style_lookup_icon_set:
+ * @style: a #GtkStyle
+ * @stock_id: an icon name
+ *
+ * Looks up @stock_id in the icon factories associated with @style
+ * and the default icon factory, returning an icon set if found,
+ * otherwise %NULL.
+ *
+ * Return value: (transfer none): icon set of @stock_id
+ *
+ * Deprecated:3.0: Use gtk_style_context_lookup_icon_set() instead
+ */
+GtkIconSet*
+gtk_style_lookup_icon_set (GtkStyle   *style,
+                           const char *stock_id)
+{
+  GtkStylePrivate *priv;
+
+  g_return_val_if_fail (GTK_IS_STYLE (style), NULL);
+  g_return_val_if_fail (stock_id != NULL, NULL);
+
+  priv = GTK_STYLE_GET_PRIVATE (style);
+
+  if (priv->context)
+    return gtk_style_context_lookup_icon_set (priv->context, stock_id);
+
+  return gtk_icon_factory_lookup_default (stock_id);
+}
+
+/**
+ * gtk_style_lookup_color:
+ * @style: a #GtkStyle
+ * @color_name: the name of the logical color to look up
+ * @color: (out): the #GdkColor to fill in
+ *
+ * Looks up @color_name in the style's logical color mappings,
+ * filling in @color and returning %TRUE if found, otherwise
+ * returning %FALSE. Do not cache the found mapping, because
+ * it depends on the #GtkStyle and might change when a theme
+ * switch occurs.
+ *
+ * Return value: %TRUE if the mapping was found.
+ *
+ * Since: 2.10
+ *
+ * Deprecated:3.0: Use gtk_style_context_lookup_color() instead
+ **/
+gboolean
+gtk_style_lookup_color (GtkStyle   *style,
+                        const char *color_name,
+                        GdkColor   *color)
+{
+  GtkStylePrivate *priv;
+  gboolean result;
+  GdkRGBA rgba;
+
+  g_return_val_if_fail (GTK_IS_STYLE (style), FALSE);
+  g_return_val_if_fail (color_name != NULL, FALSE);
+  g_return_val_if_fail (color != NULL, FALSE);
+
+  priv = GTK_STYLE_GET_PRIVATE (style);
+
+  if (!priv->context)
+    return FALSE;
+
+  result = gtk_style_context_lookup_color (priv->context, color_name, &rgba);
+
+  if (color)
+    {
+      color->red = (guint16) (rgba.red * 65535);
+      color->green = (guint16) (rgba.green * 65535);
+      color->blue = (guint16) (rgba.blue * 65535);
+      color->pixel = 0;
+    }
+
+  return result;
+}
+
+/**
+ * gtk_style_set_background:
+ * @style: a #GtkStyle
+ * @window: a #GdkWindow
+ * @state_type: a state
+ * 
+ * Sets the background of @window to the background color or pixmap
+ * specified by @style for the given state.
+ *
+ * Deprecated:3.0: Use gtk_style_context_set_background() instead
+ */
+void
+gtk_style_set_background (GtkStyle    *style,
+                          GdkWindow   *window,
+                          GtkStateType state_type)
+{
+  g_return_if_fail (GTK_IS_STYLE (style));
+  g_return_if_fail (window != NULL);
+  
+  GTK_STYLE_GET_CLASS (style)->set_background (style, window, state_type);
+}
+
+/* Default functions */
+static GtkStyle *
+gtk_style_real_clone (GtkStyle *style)
+{
+  GtkStylePrivate *priv;
+
+  priv = GTK_STYLE_GET_PRIVATE (style);
+
+  return g_object_new (G_OBJECT_TYPE (style),
+                       "context", priv->context,
+                       NULL);
+}
+
+static void
+gtk_style_real_copy (GtkStyle *style,
+		     GtkStyle *src)
+{
+  gint i;
+  
+  for (i = 0; i < 5; i++)
+    {
+      style->fg[i] = src->fg[i];
+      style->bg[i] = src->bg[i];
+      style->text[i] = src->text[i];
+      style->base[i] = src->base[i];
+
+      if (style->background[i])
+	cairo_pattern_destroy (style->background[i]),
+      style->background[i] = src->background[i];
+      if (style->background[i])
+	cairo_pattern_reference (style->background[i]);
+    }
+
+  if (style->font_desc)
+    pango_font_description_free (style->font_desc);
+  if (src->font_desc)
+    style->font_desc = pango_font_description_copy (src->font_desc);
+  else
+    style->font_desc = NULL;
+  
+  style->xthickness = src->xthickness;
+  style->ythickness = src->ythickness;
+
+  if (style->rc_style)
+    g_object_unref (style->rc_style);
+  style->rc_style = src->rc_style;
+  if (src->rc_style)
+    g_object_ref (src->rc_style);
+
+  g_slist_foreach (style->icon_factories, (GFunc) g_object_unref, NULL);
+  g_slist_free (style->icon_factories);
+  style->icon_factories = g_slist_copy (src->icon_factories);
+  g_slist_foreach (style->icon_factories, (GFunc) g_object_ref, NULL);
+}
+
+static void
+gtk_style_real_init_from_rc (GtkStyle   *style,
+			     GtkRcStyle *rc_style)
+{
+}
+
+/**
+ * gtk_style_get_style_property:
+ * @style: a #GtkStyle
+ * @widget_type: the #GType of a descendant of #GtkWidget
+ * @property_name: the name of the style property to get
+ * @value: a #GValue where the value of the property being
+ *     queried will be stored
+ *
+ * Queries the value of a style property corresponding to a
+ * widget class is in the given style.
+ *
+ * Since: 2.16
+ */
+void 
+gtk_style_get_style_property (GtkStyle     *style,
+                              GType        widget_type,
+                              const gchar *property_name,
+                              GValue      *value)
+{
+  GtkStylePrivate *priv;
+  GtkWidgetClass *klass;
+  GParamSpec *pspec;
+  const GValue *peek_value;
+
+  klass = g_type_class_ref (widget_type);
+  pspec = gtk_widget_class_find_style_property (klass, property_name);
+  g_type_class_unref (klass);
+
+  if (!pspec)
+    {
+      g_warning ("%s: widget class `%s' has no property named `%s'",
+                 G_STRLOC,
+                 g_type_name (widget_type),
+                 property_name);
+      return;
+    }
+
+  priv = GTK_STYLE_GET_PRIVATE (style);
+  peek_value = _gtk_style_context_peek_style_property (priv->context,
+                                                       widget_type,
+                                                       0, pspec);
+
+  if (G_VALUE_TYPE (value) == G_PARAM_SPEC_VALUE_TYPE (pspec))
+    g_value_copy (peek_value, value);
+  else if (g_value_type_transformable (G_PARAM_SPEC_VALUE_TYPE (pspec), G_VALUE_TYPE (value)))
+    g_value_transform (peek_value, value);
+  else
+    g_warning ("can't retrieve style property `%s' of type `%s' as value of type `%s'",
+               pspec->name,
+               g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec)),
+               G_VALUE_TYPE_NAME (value));
+}
+
+/**
+ * gtk_style_get_valist:
+ * @style: a #GtkStyle
+ * @widget_type: the #GType of a descendant of #GtkWidget
+ * @first_property_name: the name of the first style property to get
+ * @var_args: a <type>va_list</type> of pairs of property names and
+ *     locations to return the property values, starting with the
+ *     location for @first_property_name.
+ *
+ * Non-vararg variant of gtk_style_get().
+ * Used primarily by language bindings.
+ *
+ * Since: 2.16
+ */
+void 
+gtk_style_get_valist (GtkStyle    *style,
+                      GType        widget_type,
+                      const gchar *first_property_name,
+                      va_list      var_args)
+{
+  GtkStylePrivate *priv;
+  const char *property_name;
+  GtkWidgetClass *klass;
+
+  g_return_if_fail (GTK_IS_STYLE (style));
+
+  klass = g_type_class_ref (widget_type);
+
+  priv = GTK_STYLE_GET_PRIVATE (style);
+  property_name = first_property_name;
+  while (property_name)
+    {
+      GParamSpec *pspec;
+      const GValue *peek_value;
+      gchar *error;
+
+      pspec = gtk_widget_class_find_style_property (klass, property_name);
+
+      if (!pspec)
+        {
+          g_warning ("%s: widget class `%s' has no property named `%s'",
+                     G_STRLOC,
+                     g_type_name (widget_type),
+                     property_name);
+          break;
+        }
+
+      peek_value = _gtk_style_context_peek_style_property (priv->context, widget_type,
+                                                           0, pspec);
+      G_VALUE_LCOPY (peek_value, var_args, 0, &error);
+      if (error)
+        {
+          g_warning ("%s: %s", G_STRLOC, error);
+          g_free (error);
+          break;
+        }
+
+      property_name = va_arg (var_args, gchar*);
+    }
+
+  g_type_class_unref (klass);
+}
+
+/**
+ * gtk_style_get:
+ * @style: a #GtkStyle
+ * @widget_type: the #GType of a descendant of #GtkWidget
+ * @first_property_name: the name of the first style property to get
+ * @...: pairs of property names and locations to
+ *   return the property values, starting with the location for
+ *   @first_property_name, terminated by %NULL.
+ *
+ * Gets the values of a multiple style properties for @widget_type
+ * from @style.
+ *
+ * Since: 2.16
+ */
+void
+gtk_style_get (GtkStyle    *style,
+               GType        widget_type,
+               const gchar *first_property_name,
+               ...)
+{
+  va_list var_args;
+
+  va_start (var_args, first_property_name);
+  gtk_style_get_valist (style, widget_type, first_property_name, var_args);
+  va_end (var_args);
+}
+
+static void
+gtk_style_real_realize (GtkStyle *style)
+{
+}
+
+static void
+gtk_style_real_unrealize (GtkStyle *style)
+{
+}
+
+static void
+gtk_style_real_set_background (GtkStyle    *style,
+			       GdkWindow   *window,
+			       GtkStateType state_type)
+{
+  gdk_window_set_background_pattern (window, style->background[state_type]);
+}
+
+/**
+ * gtk_style_render_icon:
+ * @style: a #GtkStyle
+ * @source: the #GtkIconSource specifying the icon to render
+ * @direction: a text direction
+ * @state: a state
+ * @size: (type int): the size to render the icon at. A size of
+ *     (GtkIconSize)-1 means render at the size of the source and
+ *     don't scale.
+ * @widget: (allow-none): the widget
+ * @detail: (allow-none): a style detail
+ *
+ * Renders the icon specified by @source at the given @size
+ * according to the given parameters and returns the result in a
+ * pixbuf.
+ *
+ * Return value: (transfer full): a newly-created #GdkPixbuf
+ *     containing the rendered icon
+ *
+ * Deprecated:3.0: Use gtk_render_icon_pixbuf() instead
+ */
+GdkPixbuf *
+gtk_style_render_icon (GtkStyle            *style,
+                       const GtkIconSource *source,
+                       GtkTextDirection     direction,
+                       GtkStateType         state,
+                       GtkIconSize          size,
+                       GtkWidget           *widget,
+                       const gchar         *detail)
+{
+  GdkPixbuf *pixbuf;
+  
+  g_return_val_if_fail (GTK_IS_STYLE (style), NULL);
+  g_return_val_if_fail (GTK_STYLE_GET_CLASS (style)->render_icon != NULL, NULL);
+  
+  pixbuf = GTK_STYLE_GET_CLASS (style)->render_icon (style, source, direction, state,
+                                                     size, widget, detail);
+
+  g_return_val_if_fail (pixbuf != NULL, NULL);
+
+  return pixbuf;
+}
+
+/* Default functions */
+
+/**
+ * gtk_style_apply_default_background:
+ * @style:
+ * @cr:
+ * @window:
+ * @state_type:
+ * @x:
+ * @y:
+ * @width:
+ * @height:
+ *
+ * Deprecated:3.0: Use #GtkStyleContext instead
+ */
+void
+gtk_style_apply_default_background (GtkStyle          *style,
+                                    cairo_t           *cr,
+                                    GdkWindow         *window,
+                                    GtkStateType       state_type,
+                                    gint               x,
+                                    gint               y,
+                                    gint               width,
+                                    gint               height)
+{
+  cairo_save (cr);
+
+  if (style->background[state_type] == NULL)
+    {
+      GdkWindow *parent = gdk_window_get_parent (window);
+      int x_offset, y_offset;
+
+      if (parent)
+        {
+          gdk_window_get_position (window, &x_offset, &y_offset);
+          cairo_translate (cr, -x_offset, -y_offset);
+          gtk_style_apply_default_background (style, cr,
+                                              parent, state_type,
+                                              x + x_offset, y + y_offset,
+                                              width, height);
+          goto out;
+        }
+      else
+        gdk_cairo_set_source_color (cr, &style->bg[state_type]);
+    }
+  else
+    cairo_set_source (cr, style->background[state_type]);
+
+  cairo_rectangle (cr, x, y, width, height);
+  cairo_fill (cr);
+
+out:
+  cairo_restore (cr);
+}
+
+static GdkPixbuf *
+gtk_default_render_icon (GtkStyle            *style,
+                         const GtkIconSource *source,
+                         GtkTextDirection     direction,
+                         GtkStateType         state,
+                         GtkIconSize          size,
+                         GtkWidget           *widget,
+                         const gchar         *detail)
+{
+  GtkStyleContext *context;
+  GtkStylePrivate *priv;
+  GtkStateFlags flags = 0;
+  GdkPixbuf *pixbuf;
+
+  if (widget)
+    context = gtk_widget_get_style_context (widget);
+  else
+    {
+      priv = GTK_STYLE_GET_PRIVATE (style);
+      context = priv->context;
+    }
+
+  if (!context)
+    return NULL;
+
+  gtk_style_context_save (context);
+
+  if (detail)
+    transform_detail_string (detail, context);
+
+  switch (state)
+    {
+    case GTK_STATE_PRELIGHT:
+      flags |= GTK_STATE_FLAG_PRELIGHT;
+      break;
+    case GTK_STATE_INSENSITIVE:
+      flags |= GTK_STATE_FLAG_INSENSITIVE;
+      break;
+    default:
+      break;
+    }
+
+  gtk_style_context_set_state (context, flags);
+
+  pixbuf = gtk_render_icon_pixbuf (context, source, size);
+
+  gtk_style_context_restore (context);
+
+  return pixbuf;
+}
+
+static void
+_cairo_draw_line (cairo_t  *cr,
+                  GdkColor *color,
+                  gint      x1,
+                  gint      y1,
+                  gint      x2,
+                  gint      y2)
+{
+  cairo_save (cr);
+
+  gdk_cairo_set_source_color (cr, color);
+  cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE);
+
+  cairo_move_to (cr, x1 + 0.5, y1 + 0.5);
+  cairo_line_to (cr, x2 + 0.5, y2 + 0.5);
+  cairo_stroke (cr);
+
+  cairo_restore (cr);
+}
+
+static void
+transform_detail_string (const gchar     *detail,
+			 GtkStyleContext *context)
+{
+  if (!detail)
+    return;
+
+  if (strcmp (detail, "arrow") == 0)
+    gtk_style_context_add_class (context, "arrow");
+  else if (strcmp (detail, "button") == 0)
+    gtk_style_context_add_class (context, "button");
+  else if (strcmp (detail, "buttondefault") == 0)
+    {
+      gtk_style_context_add_class (context, "button");
+      gtk_style_context_add_class (context, "default");
+    }
+  else if (strcmp (detail, "calendar") == 0)
+    gtk_style_context_add_class (context, "calendar");
+  else if (strcmp (detail, "cellcheck") == 0)
+    {
+      gtk_style_context_add_class (context, "cell");
+      gtk_style_context_add_class (context, "check");
+    }
+  else if (strcmp (detail, "cellradio") == 0)
+    {
+      gtk_style_context_add_class (context, "cell");
+      gtk_style_context_add_class (context, "radio");
+    }
+  else if (strcmp (detail, "checkbutton") == 0)
+    gtk_style_context_add_class (context, "check");
+  else if (strcmp (detail, "check") == 0)
+    {
+      gtk_style_context_add_class (context, "check");
+      gtk_style_context_add_class (context, "menu");
+    }
+  else if (strcmp (detail, "radiobutton") == 0)
+    {
+      gtk_style_context_add_class (context, "radio");
+    }
+  else if (strcmp (detail, "option") == 0)
+    {
+      gtk_style_context_add_class (context, "radio");
+      gtk_style_context_add_class (context, "menu");
+    }
+  else if (strcmp (detail, "entry") == 0 ||
+           strcmp (detail, "entry_bg") == 0)
+    gtk_style_context_add_class (context, "entry");
+  else if (strcmp (detail, "expander") == 0)
+    gtk_style_context_add_class (context, "expander");
+  else if (strcmp (detail, "tooltip") == 0)
+    gtk_style_context_add_class (context, "tooltip");
+  else if (strcmp (detail, "frame") == 0)
+    gtk_style_context_add_class (context, "frame");
+  else if (strcmp (detail, "scrolled_window") == 0)
+    gtk_style_context_add_class (context, "scrolled-window");
+  else if (strcmp (detail, "viewport") == 0 ||
+	   strcmp (detail, "viewportbin") == 0)
+    gtk_style_context_add_class (context, "viewport");
+  else if (strncmp (detail, "trough", 6) == 0)
+    gtk_style_context_add_class (context, "trough");
+  else if (strcmp (detail, "spinbutton") == 0)
+    gtk_style_context_add_class (context, "spinbutton");
+  else if (strcmp (detail, "spinbutton_up") == 0)
+    {
+      gtk_style_context_add_class (context, "spinbutton");
+      gtk_style_context_add_class (context, "button");
+      gtk_style_context_set_junction_sides (context, GTK_JUNCTION_BOTTOM);
+    }
+  else if (strcmp (detail, "spinbutton_down") == 0)
+    {
+      gtk_style_context_add_class (context, "spinbutton");
+      gtk_style_context_add_class (context, "button");
+      gtk_style_context_set_junction_sides (context, GTK_JUNCTION_TOP);
+    }
+  else if ((detail[0] == 'h' || detail[0] == 'v') &&
+           strncmp (&detail[1], "scrollbar_", 10) == 0)
+    {
+      gtk_style_context_add_class (context, "button");
+      gtk_style_context_add_class (context, "scrollbar");
+    }
+  else if (strcmp (detail, "slider") == 0)
+    {
+      gtk_style_context_add_class (context, "slider");
+      gtk_style_context_add_class (context, "scrollbar");
+    }
+  else if (strcmp (detail, "vscale") == 0 ||
+           strcmp (detail, "hscale") == 0)
+    {
+      gtk_style_context_add_class (context, "slider");
+      gtk_style_context_add_class (context, "scale");
+    }
+  else if (strcmp (detail, "menuitem") == 0)
+    {
+      gtk_style_context_add_class (context, "menuitem");
+      gtk_style_context_add_class (context, "menu");
+    }
+  else if (strcmp (detail, "menu") == 0)
+    {
+      gtk_style_context_add_class (context, "popup");
+      gtk_style_context_add_class (context, "menu");
+    }
+  else if (strcmp (detail, "accellabel") == 0)
+    gtk_style_context_add_class (context, "accelerator");
+  else if (strcmp (detail, "menubar") == 0)
+    gtk_style_context_add_class (context, "menubar");
+  else if (strcmp (detail, "base") == 0)
+    gtk_style_context_add_class (context, "background");
+  else if (strcmp (detail, "bar") == 0 ||
+           strcmp (detail, "progressbar") == 0)
+    gtk_style_context_add_class (context, "progressbar");
+  else if (strcmp (detail, "toolbar") == 0)
+    gtk_style_context_add_class (context, "toolbar");
+  else if (strcmp (detail, "handlebox_bin") == 0)
+    gtk_style_context_add_class (context, "dock");
+  else if (strcmp (detail, "notebook") == 0)
+    gtk_style_context_add_class (context, "notebook");
+  else if (strcmp (detail, "tab") == 0)
+    {
+      gtk_style_context_add_class (context, "notebook");
+      gtk_style_context_add_region (context, GTK_STYLE_REGION_TAB, 0);
+    }
+  else if (g_str_has_prefix (detail, "cell"))
+    {
+      GtkRegionFlags row, col;
+      gboolean ruled = FALSE;
+      GStrv tokens;
+      guint i;
+
+      tokens = g_strsplit (detail, "_", -1);
+      row = col = 0;
+      i = 0;
+
+      while (tokens[i])
+        {
+          if (strcmp (tokens[i], "even") == 0)
+            row |= GTK_REGION_EVEN;
+          else if (strcmp (tokens[i], "odd") == 0)
+            row |= GTK_REGION_ODD;
+          else if (strcmp (tokens[i], "start") == 0)
+            col |= GTK_REGION_FIRST;
+          else if (strcmp (tokens[i], "end") == 0)
+            col |= GTK_REGION_LAST;
+          else if (strcmp (tokens[i], "ruled") == 0)
+            ruled = TRUE;
+          else if (strcmp (tokens[i], "sorted") == 0)
+            col |= GTK_REGION_SORTED;
+
+          i++;
+        }
+
+      if (!ruled)
+        row &= ~(GTK_REGION_EVEN | GTK_REGION_ODD);
+
+      gtk_style_context_add_class (context, "cell");
+      gtk_style_context_add_region (context, "row", row);
+      gtk_style_context_add_region (context, "column", col);
+
+      g_strfreev (tokens);
+    }
+}
+
+static void
+gtk_default_draw_hline (GtkStyle     *style,
+                        cairo_t       *cr,
+                        GtkStateType  state_type,
+                        GtkWidget     *widget,
+                        const gchar   *detail,
+                        gint          x1,
+                        gint          x2,
+                        gint          y)
+{
+  GtkStyleContext *context;
+  GtkStylePrivate *priv;
+
+  if (widget)
+    context = gtk_widget_get_style_context (widget);
+  else
+    {
+      priv = GTK_STYLE_GET_PRIVATE (style);
+      context = priv->context;
+    }
+
+  gtk_style_context_save (context);
+
+  if (detail)
+    transform_detail_string (detail, context);
+
+  cairo_save (cr);
+
+  gtk_render_line (context, cr,
+                   x1, y, x2, y);
+
+  cairo_restore (cr);
+
+  gtk_style_context_restore (context);
+}
+
+
+static void
+gtk_default_draw_vline (GtkStyle      *style,
+                        cairo_t       *cr,
+                        GtkStateType  state_type,
+                        GtkWidget     *widget,
+                        const gchar   *detail,
+                        gint          y1,
+                        gint          y2,
+                        gint          x)
+{
+  GtkStyleContext *context;
+  GtkStylePrivate *priv;
+
+  if (widget)
+    context = gtk_widget_get_style_context (widget);
+  else
+    {
+      priv = GTK_STYLE_GET_PRIVATE (style);
+      context = priv->context;
+    }
+
+  gtk_style_context_save (context);
+
+  if (detail)
+    transform_detail_string (detail, context);
+
+  cairo_save (cr);
+
+  gtk_render_line (context, cr,
+                   x, y1, x, y2);
+
+  cairo_restore (cr);
+  gtk_style_context_restore (context);
+}
+
+static void
+gtk_default_draw_shadow (GtkStyle      *style,
+                         cairo_t       *cr,
+                         GtkStateType   state_type,
+                         GtkShadowType  shadow_type,
+                         GtkWidget     *widget,
+                         const gchar   *detail,
+                         gint           x,
+                         gint           y,
+                         gint           width,
+                         gint           height)
+{
+  GtkStyleContext *context;
+  GtkStylePrivate *priv;
+
+  if (shadow_type == GTK_SHADOW_NONE)
+    return;
+
+  if (widget)
+    context = gtk_widget_get_style_context (widget);
+  else
+    {
+      priv = GTK_STYLE_GET_PRIVATE (style);
+      context = priv->context;
+    }
+
+  gtk_style_context_save (context);
+
+  if (detail)
+    transform_detail_string (detail, context);
+
+  cairo_save (cr);
+
+  gtk_render_frame (context, cr,
+                    (gdouble) x,
+                    (gdouble) y,
+                    (gdouble) width,
+                    (gdouble) height);
+
+  cairo_restore (cr);
+  gtk_style_context_restore (context);
+}
+
+static void
+draw_arrow (cairo_t       *cr,
+	    GdkColor      *color,
+	    GtkArrowType   arrow_type,
+	    gint           x,
+	    gint           y,
+	    gint           width,
+	    gint           height)
+{
+  gdk_cairo_set_source_color (cr, color);
+  cairo_save (cr);
+    
+  if (arrow_type == GTK_ARROW_DOWN)
+    {
+      cairo_move_to (cr, x,              y);
+      cairo_line_to (cr, x + width,      y);
+      cairo_line_to (cr, x + width / 2., y + height);
+    }
+  else if (arrow_type == GTK_ARROW_UP)
+    {
+      cairo_move_to (cr, x,              y + height);
+      cairo_line_to (cr, x + width / 2., y);
+      cairo_line_to (cr, x + width,      y + height);
+    }
+  else if (arrow_type == GTK_ARROW_LEFT)
+    {
+      cairo_move_to (cr, x + width,      y);
+      cairo_line_to (cr, x + width,      y + height);
+      cairo_line_to (cr, x,              y + height / 2.);
+    }
+  else if (arrow_type == GTK_ARROW_RIGHT)
+    {
+      cairo_move_to (cr, x,              y);
+      cairo_line_to (cr, x + width,      y + height / 2.);
+      cairo_line_to (cr, x,              y + height);
+    }
+
+  cairo_close_path (cr);
+  cairo_fill (cr);
+
+  cairo_restore (cr);
+}
+
+static void
+gtk_default_draw_arrow (GtkStyle      *style,
+			cairo_t       *cr,
+			GtkStateType   state,
+			GtkShadowType  shadow,
+			GtkWidget     *widget,
+			const gchar   *detail,
+			GtkArrowType   arrow_type,
+			gboolean       fill,
+			gint           x,
+			gint           y,
+			gint           width,
+			gint           height)
+{
+  GtkStyleContext *context;
+  GtkStylePrivate *priv;
+  GtkStateFlags flags = 0;
+  gdouble angle, size;
+
+  if (arrow_type == GTK_ARROW_NONE)
+    return;
+
+  if (widget)
+    context = gtk_widget_get_style_context (widget);
+  else
+    {
+      priv = GTK_STYLE_GET_PRIVATE (style);
+      context = priv->context;
+    }
+
+  gtk_style_context_save (context);
+
+  if (detail)
+    transform_detail_string (detail, context);
+
+  switch (arrow_type)
+    {
+    case GTK_ARROW_UP:
+      angle = 0;
+      size = width;
+      break;
+    case GTK_ARROW_RIGHT:
+      angle = G_PI / 2;
+      size = height;
+      break;
+    case GTK_ARROW_DOWN:
+      angle = G_PI;
+      size = width;
+      break;
+    case GTK_ARROW_LEFT:
+      angle = 3 * (G_PI / 2);
+      size = height;
+      break;
+    default:
+      g_assert_not_reached ();
+    }
+
+  switch (state)
+    {
+    case GTK_STATE_PRELIGHT:
+      flags |= GTK_STATE_FLAG_PRELIGHT;
+      break;
+    case GTK_STATE_SELECTED:
+      flags |= GTK_STATE_FLAG_SELECTED;
+      break;
+    case GTK_STATE_INSENSITIVE:
+      flags |= GTK_STATE_FLAG_INSENSITIVE;
+      break;
+    case GTK_STATE_ACTIVE:
+      flags |= GTK_STATE_FLAG_ACTIVE;
+      break;
+    default:
+      break;
+    }
+
+  gtk_style_context_set_state (context, flags);
+
+  cairo_save (cr);
+
+  gtk_render_arrow (context,
+                    cr, angle,
+                    (gdouble) x,
+                    (gdouble) y,
+                    size);
+
+  cairo_restore (cr);
+  gtk_style_context_restore (context);
+}
+
+static void
+gtk_default_draw_diamond (GtkStyle      *style,
+                          cairo_t       *cr,
+                          GtkStateType   state_type,
+                          GtkShadowType  shadow_type,
+                          GtkWidget     *widget,
+                          const gchar   *detail,
+                          gint           x,
+                          gint           y,
+                          gint           width,
+                          gint           height)
+{
+  gint half_width;
+  gint half_height;
+  GdkColor *outer_nw = NULL;
+  GdkColor *outer_ne = NULL;
+  GdkColor *outer_sw = NULL;
+  GdkColor *outer_se = NULL;
+  GdkColor *middle_nw = NULL;
+  GdkColor *middle_ne = NULL;
+  GdkColor *middle_sw = NULL;
+  GdkColor *middle_se = NULL;
+  GdkColor *inner_nw = NULL;
+  GdkColor *inner_ne = NULL;
+  GdkColor *inner_sw = NULL;
+  GdkColor *inner_se = NULL;
+  
+  half_width = width / 2;
+  half_height = height / 2;
+  
+  switch (shadow_type)
+    {
+    case GTK_SHADOW_IN:
+      inner_sw = inner_se = &style->bg[state_type];
+      middle_sw = middle_se = &style->light[state_type];
+      outer_sw = outer_se = &style->light[state_type];
+      inner_nw = inner_ne = &style->black;
+      middle_nw = middle_ne = &style->dark[state_type];
+      outer_nw = outer_ne = &style->dark[state_type];
+      break;
+          
+    case GTK_SHADOW_OUT:
+      inner_sw = inner_se = &style->dark[state_type];
+      middle_sw = middle_se = &style->dark[state_type];
+      outer_sw = outer_se = &style->black;
+      inner_nw = inner_ne = &style->bg[state_type];
+      middle_nw = middle_ne = &style->light[state_type];
+      outer_nw = outer_ne = &style->light[state_type];
+      break;
+
+    case GTK_SHADOW_ETCHED_IN:
+      inner_sw = inner_se = &style->bg[state_type];
+      middle_sw = middle_se = &style->dark[state_type];
+      outer_sw = outer_se = &style->light[state_type];
+      inner_nw = inner_ne = &style->bg[state_type];
+      middle_nw = middle_ne = &style->light[state_type];
+      outer_nw = outer_ne = &style->dark[state_type];
+      break;
+
+    case GTK_SHADOW_ETCHED_OUT:
+      inner_sw = inner_se = &style->bg[state_type];
+      middle_sw = middle_se = &style->light[state_type];
+      outer_sw = outer_se = &style->dark[state_type];
+      inner_nw = inner_ne = &style->bg[state_type];
+      middle_nw = middle_ne = &style->dark[state_type];
+      outer_nw = outer_ne = &style->light[state_type];
+      break;
+      
+    default:
+
+      break;
+    }
+
+  if (inner_sw)
+    {
+      _cairo_draw_line (cr, inner_sw,
+                        x + 2, y + half_height,
+                        x + half_width, y + height - 2);
+      _cairo_draw_line (cr, inner_se,
+                        x + half_width, y + height - 2,
+                        x + width - 2, y + half_height);
+      _cairo_draw_line (cr, middle_sw,
+                        x + 1, y + half_height,
+                        x + half_width, y + height - 1);
+      _cairo_draw_line (cr, middle_se,
+                        x + half_width, y + height - 1,
+                        x + width - 1, y + half_height);
+      _cairo_draw_line (cr, outer_sw,
+                        x, y + half_height,
+                        x + half_width, y + height);
+      _cairo_draw_line (cr, outer_se,
+                        x + half_width, y + height,
+                        x + width, y + half_height);
+  
+      _cairo_draw_line (cr, inner_nw,
+                        x + 2, y + half_height,
+                        x + half_width, y + 2);
+      _cairo_draw_line (cr, inner_ne,
+                        x + half_width, y + 2,
+                        x + width - 2, y + half_height);
+      _cairo_draw_line (cr, middle_nw,
+                        x + 1, y + half_height,
+                        x + half_width, y + 1);
+      _cairo_draw_line (cr, middle_ne,
+                        x + half_width, y + 1,
+                        x + width - 1, y + half_height);
+      _cairo_draw_line (cr, outer_nw,
+                        x, y + half_height,
+                        x + half_width, y);
+      _cairo_draw_line (cr, outer_ne,
+                        x + half_width, y,
+                        x + width, y + half_height);
+    }
+}
+
+static void
+option_menu_get_props (GtkWidget      *widget,
+		       GtkRequisition *indicator_size,
+		       GtkBorder      *indicator_spacing)
+{
+  GtkRequisition *tmp_size = NULL;
+  GtkBorder *tmp_spacing = NULL;
+
+  if (tmp_size)
+    {
+      *indicator_size = *tmp_size;
+      gtk_requisition_free (tmp_size);
+    }
+  else
+    *indicator_size = default_option_indicator_size;
+
+  if (tmp_spacing)
+    {
+      *indicator_spacing = *tmp_spacing;
+      gtk_border_free (tmp_spacing);
+    }
+  else
+    *indicator_spacing = default_option_indicator_spacing;
+}
+
+static void 
+gtk_default_draw_box (GtkStyle      *style,
+		      cairo_t       *cr,
+		      GtkStateType   state_type,
+		      GtkShadowType  shadow_type,
+		      GtkWidget     *widget,
+		      const gchar   *detail,
+		      gint           x,
+		      gint           y,
+		      gint           width,
+		      gint           height)
+{
+  GtkStyleContext *context;
+  GtkStylePrivate *priv;
+  GtkStateFlags flags = 0;
+
+  if (widget)
+    context = gtk_widget_get_style_context (widget);
+  else
+    {
+      priv = GTK_STYLE_GET_PRIVATE (style);
+      context = priv->context;
+    }
+
+  gtk_style_context_save (context);
+
+  if (detail)
+    transform_detail_string (detail, context);
+
+  switch (state_type)
+    {
+    case GTK_STATE_ACTIVE:
+      flags |= GTK_STATE_FLAG_ACTIVE;
+      break;
+    case GTK_STATE_PRELIGHT:
+      flags |= GTK_STATE_FLAG_PRELIGHT;
+      break;
+    case GTK_STATE_SELECTED:
+      flags |= GTK_STATE_FLAG_SELECTED;
+      break;
+    case GTK_STATE_INSENSITIVE:
+      flags |= GTK_STATE_FLAG_INSENSITIVE;
+      break;
+    default:
+      break;
+    }
+
+  if (shadow_type == GTK_SHADOW_IN)
+    flags |= GTK_STATE_FLAG_ACTIVE;
+
+  gtk_style_context_set_state (context, flags);
+
+  cairo_save (cr);
+
+  if (gtk_style_context_has_class (context, GTK_STYLE_CLASS_PROGRESSBAR))
+    gtk_render_activity (context, cr, x, y, width, height);
+  else
+    {
+      gtk_render_background (context, cr, x, y, width, height);
+
+      if (shadow_type != GTK_SHADOW_NONE)
+	gtk_render_frame (context, cr, x, y, width, height);
+    }
+
+  cairo_restore (cr);
+  gtk_style_context_restore (context);
+}
+
+static void 
+gtk_default_draw_flat_box (GtkStyle      *style,
+                           cairo_t       *cr,
+                           GtkStateType   state_type,
+                           GtkShadowType  shadow_type,
+                           GtkWidget     *widget,
+                           const gchar   *detail,
+                           gint           x,
+                           gint           y,
+                           gint           width,
+                           gint           height)
+{
+  GtkStyleContext *context;
+  GtkStylePrivate *priv;
+  GtkStateFlags flags = 0;
+
+  if (widget)
+    context = gtk_widget_get_style_context (widget);
+  else
+    {
+      priv = GTK_STYLE_GET_PRIVATE (style);
+      context = priv->context;
+    }
+
+  gtk_style_context_save (context);
+
+  if (detail)
+    transform_detail_string (detail, context);
+
+  switch (state_type)
+    {
+    case GTK_STATE_PRELIGHT:
+      flags |= GTK_STATE_FLAG_PRELIGHT;
+      break;
+    case GTK_STATE_SELECTED:
+      flags |= GTK_STATE_FLAG_SELECTED;
+      break;
+    case GTK_STATE_INSENSITIVE:
+      flags |= GTK_STATE_FLAG_INSENSITIVE;
+      break;
+    case GTK_STATE_ACTIVE:
+      flags |= GTK_STATE_FLAG_ACTIVE;
+      break;
+    case GTK_STATE_FOCUSED:
+      flags |= GTK_STATE_FLAG_FOCUSED;
+      break;
+    default:
+      break;
+    }
+
+  gtk_style_context_set_state (context, flags);
+
+  cairo_save (cr);
+
+  gtk_render_background (context, cr,
+                         (gdouble) x,
+                         (gdouble) y,
+                         (gdouble) width,
+                         (gdouble) height);
+
+  cairo_restore (cr);
+  gtk_style_context_restore (context);
+}
+
+static void 
+gtk_default_draw_check (GtkStyle      *style,
+			cairo_t       *cr,
+			GtkStateType   state_type,
+			GtkShadowType  shadow_type,
+			GtkWidget     *widget,
+			const gchar   *detail,
+			gint           x,
+			gint           y,
+			gint           width,
+			gint           height)
+{
+  GtkStyleContext *context;
+  GtkStylePrivate *priv;
+  GtkStateFlags flags = 0;
+
+  if (widget)
+    context = gtk_widget_get_style_context (widget);
+  else
+    {
+      priv = GTK_STYLE_GET_PRIVATE (style);
+      context = priv->context;
+    }
+
+  gtk_style_context_save (context);
+
+  if (detail)
+    transform_detail_string (detail, context);
+
+  switch (state_type)
+    {
+    case GTK_STATE_PRELIGHT:
+      flags |= GTK_STATE_FLAG_PRELIGHT;
+      break;
+    case GTK_STATE_SELECTED:
+      flags |= GTK_STATE_FLAG_SELECTED;
+      break;
+    case GTK_STATE_INSENSITIVE:
+      flags |= GTK_STATE_FLAG_INSENSITIVE;
+      break;
+    default:
+      break;
+    }
+
+  if (shadow_type == GTK_SHADOW_IN)
+    flags |= GTK_STATE_FLAG_ACTIVE;
+  else if (shadow_type == GTK_SHADOW_ETCHED_IN)
+    flags |= GTK_STATE_FLAG_INCONSISTENT;
+
+  gtk_style_context_set_state (context, flags);
+
+  cairo_save (cr);
+
+  gtk_render_check (context,
+                    cr, x, y,
+                    width, height);
+
+  cairo_restore (cr);
+  gtk_style_context_restore (context);
+}
+
+static void 
+gtk_default_draw_option (GtkStyle      *style,
+			 cairo_t       *cr,
+			 GtkStateType   state_type,
+			 GtkShadowType  shadow_type,
+			 GtkWidget     *widget,
+			 const gchar   *detail,
+			 gint           x,
+			 gint           y,
+			 gint           width,
+			 gint           height)
+{
+  GtkStyleContext *context;
+  GtkStylePrivate *priv;
+  GtkStateFlags flags = 0;
+
+  if (widget)
+    context = gtk_widget_get_style_context (widget);
+  else
+    {
+      priv = GTK_STYLE_GET_PRIVATE (style);
+      context = priv->context;
+    }
+
+  gtk_style_context_save (context);
+
+  if (detail)
+    transform_detail_string (detail, context);
+
+  switch (state_type)
+    {
+    case GTK_STATE_PRELIGHT:
+      flags |= GTK_STATE_FLAG_PRELIGHT;
+      break;
+    case GTK_STATE_SELECTED:
+      flags |= GTK_STATE_FLAG_SELECTED;
+      break;
+    case GTK_STATE_INSENSITIVE:
+      flags |= GTK_STATE_FLAG_INSENSITIVE;
+      break;
+    default:
+      break;
+    }
+
+  if (shadow_type == GTK_SHADOW_IN)
+    flags |= GTK_STATE_FLAG_ACTIVE;
+  else if (shadow_type == GTK_SHADOW_ETCHED_IN)
+    flags |= GTK_STATE_FLAG_INCONSISTENT;
+
+  gtk_style_context_set_state (context, flags);
+
+  cairo_save (cr);
+  gtk_render_option (context, cr,
+                     (gdouble) x,
+                     (gdouble) y,
+                     (gdouble) width,
+                     (gdouble) height);
+
+  cairo_restore (cr);
+  gtk_style_context_restore (context);
+}
+
+static void
+gtk_default_draw_tab (GtkStyle      *style,
+		      cairo_t       *cr,
+		      GtkStateType   state_type,
+		      GtkShadowType  shadow_type,
+		      GtkWidget     *widget,
+		      const gchar   *detail,
+		      gint           x,
+		      gint           y,
+		      gint           width,
+		      gint           height)
+{
+#define ARROW_SPACE 4
+
+  GtkRequisition indicator_size;
+  GtkBorder indicator_spacing;
+  gint arrow_height;
+
+  option_menu_get_props (widget, &indicator_size, &indicator_spacing);
+
+  indicator_size.width += (indicator_size.width % 2) - 1;
+  arrow_height = indicator_size.width / 2 + 1;
+
+  x += (width - indicator_size.width) / 2;
+  y += (height - (2 * arrow_height + ARROW_SPACE)) / 2;
+
+  if (state_type == GTK_STATE_INSENSITIVE)
+    {
+      draw_arrow (cr, &style->white,
+		  GTK_ARROW_UP, x + 1, y + 1,
+		  indicator_size.width, arrow_height);
+      
+      draw_arrow (cr, &style->white,
+		  GTK_ARROW_DOWN, x + 1, y + arrow_height + ARROW_SPACE + 1,
+		  indicator_size.width, arrow_height);
+    }
+  
+  draw_arrow (cr, &style->fg[state_type],
+	      GTK_ARROW_UP, x, y,
+	      indicator_size.width, arrow_height);
+  
+  
+  draw_arrow (cr, &style->fg[state_type],
+	      GTK_ARROW_DOWN, x, y + arrow_height + ARROW_SPACE,
+	      indicator_size.width, arrow_height);
+}
+
+static void 
+gtk_default_draw_shadow_gap (GtkStyle       *style,
+                             cairo_t        *cr,
+                             GtkStateType    state_type,
+                             GtkShadowType   shadow_type,
+                             GtkWidget      *widget,
+                             const gchar    *detail,
+                             gint            x,
+                             gint            y,
+                             gint            width,
+                             gint            height,
+                             GtkPositionType gap_side,
+                             gint            gap_x,
+                             gint            gap_width)
+{
+  GtkStyleContext *context;
+  GtkStylePrivate *priv;
+  GtkStateFlags flags = 0;
+
+  if (shadow_type == GTK_SHADOW_NONE)
+    return;
+
+  if (widget)
+    context = gtk_widget_get_style_context (widget);
+  else
+    {
+      priv = GTK_STYLE_GET_PRIVATE (style);
+      context = priv->context;
+    }
+
+  gtk_style_context_save (context);
+
+  if (detail)
+    transform_detail_string (detail, context);
+
+  switch (state_type)
+    {
+    case GTK_STATE_ACTIVE:
+      flags |= GTK_STATE_FLAG_ACTIVE;
+      break;
+    case GTK_STATE_PRELIGHT:
+      flags |= GTK_STATE_FLAG_PRELIGHT;
+      break;
+    case GTK_STATE_SELECTED:
+      flags |= GTK_STATE_FLAG_SELECTED;
+      break;
+    case GTK_STATE_INSENSITIVE:
+      flags |= GTK_STATE_FLAG_INSENSITIVE;
+      break;
+    default:
+      break;
+    }
+
+  gtk_style_context_set_state (context, flags);
+
+  cairo_save (cr);
+  gtk_render_frame_gap (context, cr,
+                        (gdouble) x,
+                        (gdouble) y,
+                        (gdouble) width,
+                        (gdouble) height,
+                        gap_side,
+                        (gdouble) gap_x,
+                        (gdouble) gap_x + gap_width);
+
+  cairo_restore (cr);
+  gtk_style_context_restore (context);
+}
+
+static void 
+gtk_default_draw_box_gap (GtkStyle       *style,
+                          cairo_t        *cr,
+                          GtkStateType    state_type,
+                          GtkShadowType   shadow_type,
+                          GtkWidget      *widget,
+                          const gchar    *detail,
+                          gint            x,
+                          gint            y,
+                          gint            width,
+                          gint            height,
+                          GtkPositionType gap_side,
+                          gint            gap_x,
+                          gint            gap_width)
+{
+  GtkStyleContext *context;
+  GtkStylePrivate *priv;
+  GtkStateFlags flags = 0;
+
+  if (widget)
+    context = gtk_widget_get_style_context (widget);
+  else
+    {
+      priv = GTK_STYLE_GET_PRIVATE (style);
+      context = priv->context;
+    }
+
+  gtk_style_context_save (context);
+
+  if (detail)
+    transform_detail_string (detail, context);
+
+  switch (state_type)
+    {
+    case GTK_STATE_ACTIVE:
+      flags |= GTK_STATE_FLAG_ACTIVE;
+      break;
+    case GTK_STATE_PRELIGHT:
+      flags |= GTK_STATE_FLAG_PRELIGHT;
+      break;
+    case GTK_STATE_SELECTED:
+      flags |= GTK_STATE_FLAG_SELECTED;
+      break;
+    case GTK_STATE_INSENSITIVE:
+      flags |= GTK_STATE_FLAG_INSENSITIVE;
+      break;
+    default:
+      break;
+    }
+
+  gtk_style_context_set_state (context, flags);
+
+  cairo_save (cr);
+  gtk_render_background (context, cr,
+                         (gdouble) x,
+                         (gdouble) y,
+                         (gdouble) width,
+                         (gdouble) height);
+
+
+  if (shadow_type != GTK_SHADOW_NONE)
+    gtk_render_frame_gap (context, cr,
+			  (gdouble) x,
+			  (gdouble) y,
+			  (gdouble) width,
+			  (gdouble) height,
+			  gap_side,
+			  (gdouble) gap_x,
+			  (gdouble) gap_x + gap_width);
+  
+  cairo_restore (cr);
+  gtk_style_context_restore (context);
+}
+
+static void 
+gtk_default_draw_extension (GtkStyle       *style,
+                            cairo_t        *cr,
+                            GtkStateType    state_type,
+                            GtkShadowType   shadow_type,
+                            GtkWidget      *widget,
+                            const gchar    *detail,
+                            gint            x,
+                            gint            y,
+                            gint            width,
+                            gint            height,
+                            GtkPositionType gap_side)
+{
+  GtkStyleContext *context;
+  GtkStylePrivate *priv;
+  GtkStateFlags flags = 0;
+
+  if (widget)
+    context = gtk_widget_get_style_context (widget);
+  else
+    {
+      priv = GTK_STYLE_GET_PRIVATE (style);
+      context = priv->context;
+    }
+
+  gtk_style_context_save (context);
+
+  if (detail)
+    transform_detail_string (detail, context);
+
+  switch (state_type)
+    {
+    case GTK_STATE_ACTIVE:
+      flags |= GTK_STATE_FLAG_ACTIVE;
+      break;
+    case GTK_STATE_PRELIGHT:
+      flags |= GTK_STATE_FLAG_PRELIGHT;
+      break;
+    case GTK_STATE_SELECTED:
+      flags |= GTK_STATE_FLAG_SELECTED;
+      break;
+    case GTK_STATE_INSENSITIVE:
+      flags |= GTK_STATE_FLAG_INSENSITIVE;
+      break;
+    default:
+      break;
+    }
+
+  gtk_style_context_set_state (context, flags);
+
+  cairo_save (cr);
+
+  gtk_render_extension (context, cr,
+                        (gdouble) x,
+                        (gdouble) y,
+                        (gdouble) width,
+                        (gdouble) height,
+                        gap_side);
+
+  cairo_restore (cr);
+  gtk_style_context_restore (context);
+}
+
+static void 
+gtk_default_draw_focus (GtkStyle      *style,
+			cairo_t       *cr,
+			GtkStateType   state_type,
+			GtkWidget     *widget,
+			const gchar   *detail,
+			gint           x,
+			gint           y,
+			gint           width,
+			gint           height)
+{
+  GtkStyleContext *context;
+  GtkStylePrivate *priv;
+
+  if (widget)
+    context = gtk_widget_get_style_context (widget);
+  else
+    {
+      priv = GTK_STYLE_GET_PRIVATE (style);
+      context = priv->context;
+    }
+
+  gtk_style_context_save (context);
+
+  if (detail)
+    transform_detail_string (detail, context);
+
+  cairo_save (cr);
+
+  gtk_render_focus (context, cr,
+                    (gdouble) x,
+                    (gdouble) y,
+                    (gdouble) width,
+                    (gdouble) height);
+
+  cairo_restore (cr);
+  gtk_style_context_restore (context);
+}
+
+static void 
+gtk_default_draw_slider (GtkStyle      *style,
+                         cairo_t       *cr,
+                         GtkStateType   state_type,
+                         GtkShadowType  shadow_type,
+                         GtkWidget     *widget,
+                         const gchar   *detail,
+                         gint           x,
+                         gint           y,
+                         gint           width,
+                         gint           height,
+                         GtkOrientation orientation)
+{
+  GtkStyleContext *context;
+  GtkStylePrivate *priv;
+  GtkStateFlags flags = 0;
+
+  if (widget)
+    context = gtk_widget_get_style_context (widget);
+  else
+    {
+      priv = GTK_STYLE_GET_PRIVATE (style);
+      context = priv->context;
+    }
+
+  gtk_style_context_save (context);
+
+  if (detail)
+    transform_detail_string (detail, context);
+
+  switch (state_type)
+    {
+    case GTK_STATE_PRELIGHT:
+      flags |= GTK_STATE_FLAG_PRELIGHT;
+      break;
+    case GTK_STATE_SELECTED:
+      flags |= GTK_STATE_FLAG_SELECTED;
+      break;
+    case GTK_STATE_INSENSITIVE:
+      flags |= GTK_STATE_FLAG_INSENSITIVE;
+      break;
+    default:
+      break;
+    }
+
+  gtk_style_context_set_state (context, flags);
+
+  cairo_save (cr);
+
+  gtk_render_slider (context, cr,  x, y, width, height, orientation);
+
+  cairo_restore (cr);
+  gtk_style_context_restore (context);
+}
+
+static void 
+gtk_default_draw_handle (GtkStyle      *style,
+			 cairo_t       *cr,
+			 GtkStateType   state_type,
+			 GtkShadowType  shadow_type,
+			 GtkWidget     *widget,
+			 const gchar   *detail,
+			 gint           x,
+			 gint           y,
+			 gint           width,
+			 gint           height,
+			 GtkOrientation orientation)
+{
+  GtkStyleContext *context;
+  GtkStylePrivate *priv;
+  GtkStateFlags flags = 0;
+
+  if (widget)
+    context = gtk_widget_get_style_context (widget);
+  else
+    {
+      priv = GTK_STYLE_GET_PRIVATE (style);
+      context = priv->context;
+    }
+
+  gtk_style_context_save (context);
+
+  if (detail)
+    transform_detail_string (detail, context);
+
+  switch (state_type)
+    {
+    case GTK_STATE_PRELIGHT:
+      flags |= GTK_STATE_FLAG_PRELIGHT;
+      break;
+    case GTK_STATE_SELECTED:
+      flags |= GTK_STATE_FLAG_SELECTED;
+      break;
+    case GTK_STATE_INSENSITIVE:
+      flags |= GTK_STATE_FLAG_INSENSITIVE;
+      break;
+    default:
+      break;
+    }
+
+  gtk_style_context_set_state (context, flags);
+
+  cairo_save (cr);
+
+  gtk_render_handle (context, cr,
+                     (gdouble) x,
+                     (gdouble) y,
+                     (gdouble) width,
+                     (gdouble) height);
+
+  cairo_restore (cr);
+  gtk_style_context_restore (context);
+}
+
+static void
+gtk_default_draw_expander (GtkStyle        *style,
+                           cairo_t         *cr,
+                           GtkStateType     state_type,
+                           GtkWidget       *widget,
+                           const gchar     *detail,
+                           gint             x,
+                           gint             y,
+			   GtkExpanderStyle expander_style)
+{
+  GtkStyleContext *context;
+  GtkStylePrivate *priv;
+  GtkStateFlags flags = 0;
+  gint size;
+
+  if (widget)
+    context = gtk_widget_get_style_context (widget);
+  else
+    {
+      priv = GTK_STYLE_GET_PRIVATE (style);
+      context = priv->context;
+    }
+
+  gtk_style_context_save (context);
+
+  if (detail)
+    transform_detail_string (detail, context);
+
+  gtk_style_context_add_class (context, "expander");
+
+  switch (state_type)
+    {
+    case GTK_STATE_PRELIGHT:
+      flags |= GTK_STATE_FLAG_PRELIGHT;
+      break;
+    case GTK_STATE_SELECTED:
+      flags |= GTK_STATE_FLAG_SELECTED;
+      break;
+    case GTK_STATE_INSENSITIVE:
+      flags |= GTK_STATE_FLAG_INSENSITIVE;
+      break;
+    default:
+      break;
+    }
+
+  if (widget &&
+      gtk_widget_class_find_style_property (GTK_WIDGET_GET_CLASS (widget),
+                                            "expander-size"))
+    gtk_widget_style_get (widget, "expander-size", &size, NULL);
+  else
+    size = 12;
+
+  if (expander_style == GTK_EXPANDER_EXPANDED)
+    flags |= GTK_STATE_FLAG_ACTIVE;
+
+  gtk_style_context_set_state (context, flags);
+
+  cairo_save (cr);
+
+  gtk_render_expander (context, cr,
+                       (gdouble) x - (size / 2),
+                       (gdouble) y - (size / 2),
+                       (gdouble) size,
+                       (gdouble) size);
+
+  cairo_restore (cr);
+  gtk_style_context_restore (context);
+}
+
+static void
+gtk_default_draw_layout (GtkStyle        *style,
+                         cairo_t         *cr,
+                         GtkStateType     state_type,
+			 gboolean         use_text,
+                         GtkWidget       *widget,
+                         const gchar     *detail,
+                         gint             x,
+                         gint             y,
+                         PangoLayout     *layout)
+{
+  GtkStyleContext *context;
+  GtkStylePrivate *priv;
+  GtkStateFlags flags = 0;
+
+  if (widget)
+    context = gtk_widget_get_style_context (widget);
+  else
+    {
+      priv = GTK_STYLE_GET_PRIVATE (style);
+      context = priv->context;
+    }
+
+  gtk_style_context_save (context);
+
+  if (detail)
+    transform_detail_string (detail, context);
+
+  switch (state_type)
+    {
+    case GTK_STATE_PRELIGHT:
+      flags |= GTK_STATE_FLAG_PRELIGHT;
+      break;
+    case GTK_STATE_SELECTED:
+      flags |= GTK_STATE_FLAG_SELECTED;
+      break;
+    case GTK_STATE_INSENSITIVE:
+      flags |= GTK_STATE_FLAG_INSENSITIVE;
+      break;
+    default:
+      break;
+    }
+
+  gtk_style_context_set_state (context, flags);
+
+  cairo_save (cr);
+
+  gtk_render_layout (context, cr,
+                     (gdouble) x,
+                     (gdouble) y,
+                     layout);
+
+  cairo_restore (cr);
+  gtk_style_context_restore (context);
+}
+
+static void
+gtk_default_draw_resize_grip (GtkStyle       *style,
+                              cairo_t        *cr,
+                              GtkStateType    state_type,
+                              GtkWidget      *widget,
+                              const gchar    *detail,
+                              GdkWindowEdge   edge,
+                              gint            x,
+                              gint            y,
+                              gint            width,
+                              gint            height)
+{
+  GtkStyleContext *context;
+  GtkStylePrivate *priv;
+  GtkStateFlags flags = 0;
+  GtkJunctionSides sides = 0;
+
+  if (widget)
+    context = gtk_widget_get_style_context (widget);
+  else
+    {
+      priv = GTK_STYLE_GET_PRIVATE (style);
+      context = priv->context;
+    }
+
+  gtk_style_context_save (context);
+
+  if (detail)
+    transform_detail_string (detail, context);
+
+  gtk_style_context_add_class (context, "grip");
+
+  switch (state_type)
+    {
+    case GTK_STATE_PRELIGHT:
+      flags |= GTK_STATE_FLAG_PRELIGHT;
+      break;
+    case GTK_STATE_SELECTED:
+      flags |= GTK_STATE_FLAG_SELECTED;
+      break;
+    case GTK_STATE_INSENSITIVE:
+      flags |= GTK_STATE_FLAG_INSENSITIVE;
+      break;
+    default:
+      break;
+    }
+
+  gtk_style_context_set_state (context, flags);
+
+  switch (edge)
+    {
+    case GDK_WINDOW_EDGE_NORTH_WEST:
+      sides = GTK_JUNCTION_CORNER_TOPLEFT;
+      break;
+    case GDK_WINDOW_EDGE_NORTH:
+      sides = GTK_JUNCTION_TOP;
+      break;
+    case GDK_WINDOW_EDGE_NORTH_EAST:
+      sides = GTK_JUNCTION_CORNER_TOPRIGHT;
+      break;
+    case GDK_WINDOW_EDGE_WEST:
+      sides = GTK_JUNCTION_LEFT;
+      break;
+    case GDK_WINDOW_EDGE_EAST:
+      sides = GTK_JUNCTION_RIGHT;
+      break;
+    case GDK_WINDOW_EDGE_SOUTH_WEST:
+      sides = GTK_JUNCTION_CORNER_BOTTOMLEFT;
+      break;
+    case GDK_WINDOW_EDGE_SOUTH:
+      sides = GTK_JUNCTION_BOTTOM;
+      break;
+    case GDK_WINDOW_EDGE_SOUTH_EAST:
+      sides = GTK_JUNCTION_CORNER_BOTTOMRIGHT;
+      break;
+    }
+
+  gtk_style_context_set_junction_sides (context, sides);
+
+  cairo_save (cr);
+
+  gtk_render_handle (context, cr,
+                     (gdouble) x,
+                     (gdouble) y,
+                     (gdouble) width,
+                     (gdouble) height);
+
+  cairo_restore (cr);
+  gtk_style_context_restore (context);
+}
+
+static void
+gtk_default_draw_spinner (GtkStyle     *style,
+                          cairo_t      *cr,
+                          GtkStateType  state_type,
+                          GtkWidget    *widget,
+                          const gchar  *detail,
+                          guint         step,
+                          gint          x,
+                          gint          y,
+                          gint          width,
+                          gint          height)
+{
+  GdkColor *color;
+  guint num_steps;
+  gdouble dx, dy;
+  gdouble radius;
+  gdouble half;
+  gint i;
+  guint real_step;
+
+  num_steps = 12;
+  real_step = step % num_steps;
+
+  /* set a clip region for the expose event */
+  cairo_rectangle (cr, x, y, width, height);
+  cairo_clip (cr);
+
+  cairo_translate (cr, x, y);
+
+  /* draw clip region */
+  cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
+
+  color = &style->fg[state_type];
+  dx = width / 2;
+  dy = height / 2;
+  radius = MIN (width / 2, height / 2);
+  half = num_steps / 2;
+
+  for (i = 0; i < num_steps; i++)
+    {
+      gint inset = 0.7 * radius;
+
+      /* transparency is a function of time and intial value */
+      gdouble t = (gdouble) ((i + num_steps - real_step)
+                             % num_steps) / num_steps;
+
+      cairo_save (cr);
+
+      cairo_set_source_rgba (cr,
+                             color->red / 65535.,
+                             color->green / 65535.,
+                             color->blue / 65535.,
+                             t);
+
+      cairo_set_line_width (cr, 2.0);
+      cairo_move_to (cr,
+                     dx + (radius - inset) * cos (i * G_PI / half),
+                     dy + (radius - inset) * sin (i * G_PI / half));
+      cairo_line_to (cr,
+                     dx + radius * cos (i * G_PI / half),
+                     dy + radius * sin (i * G_PI / half));
+      cairo_stroke (cr);
+
+      cairo_restore (cr);
+    }
+}
+
+void
+_gtk_style_shade (const GdkColor *a,
+                  GdkColor       *b,
+                  gdouble         k)
+{
+  gdouble red;
+  gdouble green;
+  gdouble blue;
+  
+  red = (gdouble) a->red / 65535.0;
+  green = (gdouble) a->green / 65535.0;
+  blue = (gdouble) a->blue / 65535.0;
+  
+  rgb_to_hls (&red, &green, &blue);
+  
+  green *= k;
+  if (green > 1.0)
+    green = 1.0;
+  else if (green < 0.0)
+    green = 0.0;
+  
+  blue *= k;
+  if (blue > 1.0)
+    blue = 1.0;
+  else if (blue < 0.0)
+    blue = 0.0;
+  
+  hls_to_rgb (&red, &green, &blue);
+  
+  b->red = red * 65535.0;
+  b->green = green * 65535.0;
+  b->blue = blue * 65535.0;
+}
+
+static void
+rgb_to_hls (gdouble *r,
+            gdouble *g,
+            gdouble *b)
+{
+  gdouble min;
+  gdouble max;
+  gdouble red;
+  gdouble green;
+  gdouble blue;
+  gdouble h, l, s;
+  gdouble delta;
+  
+  red = *r;
+  green = *g;
+  blue = *b;
+  
+  if (red > green)
+    {
+      if (red > blue)
+        max = red;
+      else
+        max = blue;
+      
+      if (green < blue)
+        min = green;
+      else
+        min = blue;
+    }
+  else
+    {
+      if (green > blue)
+        max = green;
+      else
+        max = blue;
+      
+      if (red < blue)
+        min = red;
+      else
+        min = blue;
+    }
+  
+  l = (max + min) / 2;
+  s = 0;
+  h = 0;
+  
+  if (max != min)
+    {
+      if (l <= 0.5)
+        s = (max - min) / (max + min);
+      else
+        s = (max - min) / (2 - max - min);
+      
+      delta = max -min;
+      if (red == max)
+        h = (green - blue) / delta;
+      else if (green == max)
+        h = 2 + (blue - red) / delta;
+      else if (blue == max)
+        h = 4 + (red - green) / delta;
+      
+      h *= 60;
+      if (h < 0.0)
+        h += 360;
+    }
+  
+  *r = h;
+  *g = l;
+  *b = s;
+}
+
+static void
+hls_to_rgb (gdouble *h,
+            gdouble *l,
+            gdouble *s)
+{
+  gdouble hue;
+  gdouble lightness;
+  gdouble saturation;
+  gdouble m1, m2;
+  gdouble r, g, b;
+  
+  lightness = *l;
+  saturation = *s;
+  
+  if (lightness <= 0.5)
+    m2 = lightness * (1 + saturation);
+  else
+    m2 = lightness + saturation - lightness * saturation;
+  m1 = 2 * lightness - m2;
+  
+  if (saturation == 0)
+    {
+      *h = lightness;
+      *l = lightness;
+      *s = lightness;
+    }
+  else
+    {
+      hue = *h + 120;
+      while (hue > 360)
+        hue -= 360;
+      while (hue < 0)
+        hue += 360;
+      
+      if (hue < 60)
+        r = m1 + (m2 - m1) * hue / 60;
+      else if (hue < 180)
+        r = m2;
+      else if (hue < 240)
+        r = m1 + (m2 - m1) * (240 - hue) / 60;
+      else
+        r = m1;
+      
+      hue = *h;
+      while (hue > 360)
+        hue -= 360;
+      while (hue < 0)
+        hue += 360;
+      
+      if (hue < 60)
+        g = m1 + (m2 - m1) * hue / 60;
+      else if (hue < 180)
+        g = m2;
+      else if (hue < 240)
+        g = m1 + (m2 - m1) * (240 - hue) / 60;
+      else
+        g = m1;
+      
+      hue = *h - 120;
+      while (hue > 360)
+        hue -= 360;
+      while (hue < 0)
+        hue += 360;
+      
+      if (hue < 60)
+        b = m1 + (m2 - m1) * hue / 60;
+      else if (hue < 180)
+        b = m2;
+      else if (hue < 240)
+        b = m1 + (m2 - m1) * (240 - hue) / 60;
+      else
+        b = m1;
+      
+      *h = r;
+      *l = g;
+      *s = b;
+    }
+}
+
+
+/**
+ * gtk_paint_hline:
+ * @style: a #GtkStyle
+ * @cr: a #caio_t
+ * @state_type: a state
+ * @widget: (allow-none): the widget
+ * @detail: (allow-none): a style detail
+ * @x1: the starting x coordinate
+ * @x2: the ending x coordinate
+ * @y: the y coordinate
+ *
+ * Draws a horizontal line from (@x1, @y) to (@x2, @y) in @cr
+ * using the given style and state.
+ *
+ * Deprecated:3.0: Use gtk_render_line() instead
+ **/
+void
+gtk_paint_hline (GtkStyle           *style,
+                 cairo_t            *cr,
+                 GtkStateType        state_type,
+                 GtkWidget          *widget,
+                 const gchar        *detail,
+                 gint                x1,
+                 gint                x2,
+                 gint                y)
+{
+  g_return_if_fail (GTK_IS_STYLE (style));
+  g_return_if_fail (cr != NULL);
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_hline != NULL);
+
+  cairo_save (cr);
+
+  GTK_STYLE_GET_CLASS (style)->draw_hline (style, cr, state_type,
+                                           widget, detail,
+                                           x1, x2, y);
+
+  cairo_restore (cr);
+}
+
+/**
+ * gtk_paint_vline:
+ * @style: a #GtkStyle
+ * @cr: a #cairo_t
+ * @state_type: a state
+ * @widget: (allow-none): the widget
+ * @detail: (allow-none): a style detail
+ * @y1_: the starting y coordinate
+ * @y2_: the ending y coordinate
+ * @x: the x coordinate
+ *
+ * Draws a vertical line from (@x, @y1_) to (@x, @y2_) in @cr
+ * using the given style and state.
+ *
+ * Deprecated:3.0: Use gtk_render_line() instead
+ */
+void
+gtk_paint_vline (GtkStyle           *style,
+                 cairo_t            *cr,
+                 GtkStateType        state_type,
+                 GtkWidget          *widget,
+                 const gchar        *detail,
+                 gint                y1_,
+                 gint                y2_,
+                 gint                x)
+{
+  g_return_if_fail (GTK_IS_STYLE (style));
+  g_return_if_fail (cr != NULL);
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_vline != NULL);
+
+  cairo_save (cr);
+
+  GTK_STYLE_GET_CLASS (style)->draw_vline (style, cr, state_type,
+                                           widget, detail,
+                                           y1_, y2_, x);
+
+  cairo_restore (cr);
+}
+
+/**
+ * gtk_paint_shadow:
+ * @style: a #GtkStyle
+ * @cr: a #cairo_t
+ * @state_type: a state
+ * @shadow_type: type of shadow to draw
+ * @widget: (allow-none): the widget
+ * @detail: (allow-none): a style detail
+ * @x: x origin of the rectangle
+ * @y: y origin of the rectangle
+ * @width: width of the rectangle
+ * @height: width of the rectangle
+ *
+ * Draws a shadow around the given rectangle in @cr
+ * using the given style and state and shadow type.
+ *
+ * Deprecated:3.0: Use gtk_render_frame() instead
+ */
+void
+gtk_paint_shadow (GtkStyle           *style,
+                  cairo_t            *cr,
+                  GtkStateType        state_type,
+                  GtkShadowType       shadow_type,
+                  GtkWidget          *widget,
+                  const gchar        *detail,
+                  gint                x,
+                  gint                y,
+                  gint                width,
+                  gint                height)
+{
+  g_return_if_fail (GTK_IS_STYLE (style));
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_shadow != NULL);
+  g_return_if_fail (cr != NULL);
+  g_return_if_fail (width >= 0);
+  g_return_if_fail (height >= 0);
+
+  cairo_save (cr);
+
+  GTK_STYLE_GET_CLASS (style)->draw_shadow (style, cr, state_type, shadow_type,
+                                            widget, detail,
+                                            x, y, width, height);
+
+  cairo_restore (cr);
+}
+
+/**
+ * gtk_paint_arrow:
+ * @style: a #GtkStyle
+ * @cr: a #cairo_t
+ * @state_type: a state
+ * @shadow_type: the type of shadow to draw
+ * @widget: (allow-none): the widget
+ * @detail: (allow-none): a style detail
+ * @arrow_type: the type of arrow to draw
+ * @fill: %TRUE if the arrow tip should be filled
+ * @x: x origin of the rectangle to draw the arrow in
+ * @y: y origin of the rectangle to draw the arrow in
+ * @width: width of the rectangle to draw the arrow in
+ * @height: height of the rectangle to draw the arrow in
+ *
+ * Draws an arrow in the given rectangle on @cr using the given
+ * parameters. @arrow_type determines the direction of the arrow.
+ *
+ * Deprecated:3.0: Use gtk_render_arrow() instead
+ */
+void
+gtk_paint_arrow (GtkStyle           *style,
+                 cairo_t            *cr,
+                 GtkStateType        state_type,
+                 GtkShadowType       shadow_type,
+                 GtkWidget          *widget,
+                 const gchar        *detail,
+                 GtkArrowType        arrow_type,
+                 gboolean            fill,
+                 gint                x,
+                 gint                y,
+                 gint                width,
+                 gint                height)
+{
+  g_return_if_fail (GTK_IS_STYLE (style));
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_arrow != NULL);
+  g_return_if_fail (cr != NULL);
+  g_return_if_fail (width >= 0);
+  g_return_if_fail (height >= 0);
+
+  cairo_save (cr);
+
+  GTK_STYLE_GET_CLASS (style)->draw_arrow (style, cr, state_type, shadow_type,
+                                           widget, detail,
+                                           arrow_type, fill, x, y, width, height);
+
+  cairo_restore (cr);
+}
+
+/**
+ * gtk_paint_diamond:
+ * @style: a #GtkStyle
+ * @cr: a #cairo_t
+ * @state_type: a state
+ * @shadow_type: the type of shadow to draw
+ * @widget: (allow-none): the widget
+ * @detail: (allow-none): a style detail
+ * @x: x origin of the rectangle to draw the diamond in
+ * @y: y origin of the rectangle to draw the diamond in
+ * @width: width of the rectangle to draw the diamond in
+ * @height: height of the rectangle to draw the diamond in
+ *
+ * Draws a diamond in the given rectangle on @window using the given
+ * parameters.
+ *
+ * Deprecated:3.0: Use cairo instead
+ */
+void
+gtk_paint_diamond (GtkStyle           *style,
+                   cairo_t            *cr,
+                   GtkStateType        state_type,
+                   GtkShadowType       shadow_type,
+                   GtkWidget          *widget,
+                   const gchar        *detail,
+                   gint                x,
+                   gint                y,
+                   gint                width,
+                   gint                height)
+{
+  g_return_if_fail (GTK_IS_STYLE (style));
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_diamond != NULL);
+  g_return_if_fail (cr != NULL);
+  g_return_if_fail (width >= 0);
+  g_return_if_fail (height >= 0);
+
+  cairo_save (cr);
+
+  GTK_STYLE_GET_CLASS (style)->draw_diamond (style, cr, state_type, shadow_type,
+                                             widget, detail,
+                                             x, y, width, height);
+
+  cairo_restore (cr);
+}
+
+/**
+ * gtk_paint_box:
+ * @style: a #GtkStyle
+ * @cr: a #cairo_t
+ * @state_type: a state
+ * @shadow_type: the type of shadow to draw
+ * @widget: (allow-none): the widget
+ * @detail: (allow-none): a style detail
+ * @x: x origin of the box
+ * @y: y origin of the box
+ * @width: the width of the box
+ * @height: the height of the box
+ *
+ * Draws a box on @cr with the given parameters.
+ *
+ * Deprecated:3.0: Use gtk_render_frame() and gtk_render_background() instead
+ */
+void
+gtk_paint_box (GtkStyle           *style,
+               cairo_t            *cr,
+               GtkStateType        state_type,
+               GtkShadowType       shadow_type,
+               GtkWidget          *widget,
+               const gchar        *detail,
+               gint                x,
+               gint                y,
+               gint                width,
+               gint                height)
+{
+  g_return_if_fail (GTK_IS_STYLE (style));
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_box != NULL);
+  g_return_if_fail (cr != NULL);
+
+  cairo_save (cr);
+
+  GTK_STYLE_GET_CLASS (style)->draw_box (style, cr, state_type, shadow_type,
+                                         widget, detail,
+                                         x, y, width, height);
+
+  cairo_restore (cr);
+}
+
+/**
+ * gtk_paint_flat_box:
+ * @style: a #GtkStyle
+ * @cr: a #cairo_t
+ * @state_type: a state
+ * @shadow_type: the type of shadow to draw
+ * @widget: (allow-none): the widget
+ * @detail: (allow-none): a style detail
+ * @x: x origin of the box
+ * @y: y origin of the box
+ * @width: the width of the box
+ * @height: the height of the box
+ *
+ * Draws a flat box on @cr with the given parameters.
+ *
+ * Deprecated:3.0: Use gtk_render_frame() and gtk_render_background() instead
+ */
+void
+gtk_paint_flat_box (GtkStyle           *style,
+                    cairo_t            *cr,
+                    GtkStateType        state_type,
+                    GtkShadowType       shadow_type,
+                    GtkWidget          *widget,
+                    const gchar        *detail,
+                    gint                x,
+                    gint                y,
+                    gint                width,
+                    gint                height)
+{
+  g_return_if_fail (GTK_IS_STYLE (style));
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_flat_box != NULL);
+  g_return_if_fail (cr != NULL);
+  g_return_if_fail (width >= 0);
+  g_return_if_fail (height >= 0);
+
+  cairo_save (cr);
+
+  GTK_STYLE_GET_CLASS (style)->draw_flat_box (style, cr, state_type, shadow_type,
+                                              widget, detail,
+                                              x, y, width, height);
+
+  cairo_restore (cr);
+}
+
+/**
+ * gtk_paint_check:
+ * @style: a #GtkStyle
+ * @cr: a #cairo_t
+ * @state_type: a state
+ * @shadow_type: the type of shadow to draw
+ * @widget: (allow-none): the widget
+ * @detail: (allow-none): a style detail
+ * @x: x origin of the rectangle to draw the check in
+ * @y: y origin of the rectangle to draw the check in
+ * @width: the width of the rectangle to draw the check in
+ * @height: the height of the rectangle to draw the check in
+ *
+ * Draws a check button indicator in the given rectangle on @cr with
+ * the given parameters.
+ *
+ * Deprecated:3.0: Use gtk_render_check() instead
+ */
+void
+gtk_paint_check (GtkStyle           *style,
+                 cairo_t            *cr,
+                 GtkStateType        state_type,
+                 GtkShadowType       shadow_type,
+                 GtkWidget          *widget,
+                 const gchar        *detail,
+                 gint                x,
+                 gint                y,
+                 gint                width,
+                 gint                height)
+{
+  g_return_if_fail (GTK_IS_STYLE (style));
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_check != NULL);
+  g_return_if_fail (cr != NULL);
+
+  cairo_save (cr);
+
+  GTK_STYLE_GET_CLASS (style)->draw_check (style, cr, state_type, shadow_type,
+                                           widget, detail,
+                                           x, y, width, height);
+
+  cairo_restore (cr);
+}
+
+/**
+ * gtk_paint_option:
+ * @style: a #GtkStyle
+ * @cr: a #cairo_t
+ * @state_type: a state
+ * @shadow_type: the type of shadow to draw
+ * @widget: (allow-none): the widget
+ * @detail: (allow-none): a style detail
+ * @x: x origin of the rectangle to draw the option in
+ * @y: y origin of the rectangle to draw the option in
+ * @width: the width of the rectangle to draw the option in
+ * @height: the height of the rectangle to draw the option in
+ *
+ * Draws a radio button indicator in the given rectangle on @cr with
+ * the given parameters.
+ *
+ * Deprecated:3.0: Use gtk_render_option() instead
+ */
+void
+gtk_paint_option (GtkStyle           *style,
+                  cairo_t            *cr,
+                  GtkStateType        state_type,
+                  GtkShadowType       shadow_type,
+                  GtkWidget          *widget,
+                  const gchar        *detail,
+                  gint                x,
+                  gint                y,
+                  gint                width,
+                  gint                height)
+{
+  g_return_if_fail (GTK_IS_STYLE (style));
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_option != NULL);
+  g_return_if_fail (cr != NULL);
+
+  cairo_save (cr);
+
+  GTK_STYLE_GET_CLASS (style)->draw_option (style, cr, state_type, shadow_type,
+                                            widget, detail,
+                                            x, y, width, height);
+
+  cairo_restore (cr);
+}
+
+/**
+ * gtk_paint_tab:
+ * @style: a #GtkStyle
+ * @cr: a #cairo_t
+ * @state_type: a state
+ * @shadow_type: the type of shadow to draw
+ * @widget: (allow-none): the widget
+ * @detail: (allow-none): a style detail
+ * @x: x origin of the rectangle to draw the tab in
+ * @y: y origin of the rectangle to draw the tab in
+ * @width: the width of the rectangle to draw the tab in
+ * @height: the height of the rectangle to draw the tab in
+ *
+ * Draws an option menu tab (i.e. the up and down pointing arrows)
+ * in the given rectangle on @cr using the given parameters.
+ *
+ * Deprecated:3.0: Use cairo instead
+ */
+void
+gtk_paint_tab (GtkStyle           *style,
+               cairo_t            *cr,
+               GtkStateType        state_type,
+               GtkShadowType       shadow_type,
+               GtkWidget          *widget,
+               const gchar        *detail,
+               gint                x,
+               gint                y,
+               gint                width,
+               gint                height)
+{
+  g_return_if_fail (GTK_IS_STYLE (style));
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_tab != NULL);
+  g_return_if_fail (cr != NULL);
+
+  cairo_save (cr);
+
+  GTK_STYLE_GET_CLASS (style)->draw_tab (style, cr, state_type, shadow_type,
+                                         widget, detail,
+                                         x, y, width, height);
+
+  cairo_restore (cr);
+}
+
+/**
+ * gtk_paint_shadow_gap:
+ * @style: a #GtkStyle
+ * @cr: a #cairo_t
+ * @state_type: a state
+ * @shadow_type: type of shadow to draw
+ * @widget: (allow-none): the widget
+ * @detail: (allow-none): a style detail
+ * @x: x origin of the rectangle
+ * @y: y origin of the rectangle
+ * @width: width of the rectangle
+ * @height: width of the rectangle
+ * @gap_side: side in which to leave the gap
+ * @gap_x: starting position of the gap
+ * @gap_width: width of the gap
+ *
+ * Draws a shadow around the given rectangle in @cr
+ * using the given style and state and shadow type, leaving a
+ * gap in one side.
+ *
+ * Deprecated:3.0: Use gtk_render_frame_gap() instead
+ */
+void
+gtk_paint_shadow_gap (GtkStyle           *style,
+                      cairo_t            *cr,
+                      GtkStateType        state_type,
+                      GtkShadowType       shadow_type,
+                      GtkWidget          *widget,
+                      const gchar        *detail,
+                      gint                x,
+                      gint                y,
+                      gint                width,
+                      gint                height,
+                      GtkPositionType     gap_side,
+                      gint                gap_x,
+                      gint                gap_width)
+{
+  g_return_if_fail (GTK_IS_STYLE (style));
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_shadow_gap != NULL);
+  g_return_if_fail (cr != NULL);
+  g_return_if_fail (width >= 0);
+  g_return_if_fail (height >= 0);
+
+  cairo_save (cr);
+
+  GTK_STYLE_GET_CLASS (style)->draw_shadow_gap (style, cr, state_type, shadow_type,
+                                                widget, detail,
+                                                x, y, width, height, gap_side, gap_x, gap_width);
+
+  cairo_restore (cr);
+}
+
+/**
+ * gtk_paint_box_gap:
+ * @style: a #GtkStyle
+ * @cr: a #cairo_t
+ * @state_type: a state
+ * @shadow_type: type of shadow to draw
+ * @widget: (allow-none): the widget
+ * @detail: (allow-none): a style detail
+ * @x: x origin of the rectangle
+ * @y: y origin of the rectangle
+ * @width: width of the rectangle
+ * @height: width of the rectangle
+ * @gap_side: side in which to leave the gap
+ * @gap_x: starting position of the gap
+ * @gap_width: width of the gap
+ *
+ * Draws a box in @cr using the given style and state and shadow type,
+ * leaving a gap in one side.
+ *
+ * Deprecated:3.0: Use gtk_render_frame_gap() instead
+ */
+void
+gtk_paint_box_gap (GtkStyle           *style,
+                   cairo_t            *cr,
+                   GtkStateType        state_type,
+                   GtkShadowType       shadow_type,
+                   GtkWidget          *widget,
+                   const gchar        *detail,
+                   gint                x,
+                   gint                y,
+                   gint                width,
+                   gint                height,
+                   GtkPositionType     gap_side,
+                   gint                gap_x,
+                   gint                gap_width)
+{
+  g_return_if_fail (GTK_IS_STYLE (style));
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_box_gap != NULL);
+  g_return_if_fail (cr != NULL);
+  g_return_if_fail (width >= 0);
+  g_return_if_fail (height >= 0);
+
+  cairo_save (cr);
+
+  GTK_STYLE_GET_CLASS (style)->draw_box_gap (style, cr, state_type, shadow_type,
+                                             widget, detail,
+                                             x, y, width, height, gap_side, gap_x, gap_width);
+
+  cairo_restore (cr);
+}
+
+/**
+ * gtk_paint_extension:
+ * @style: a #GtkStyle
+ * @cr: a #cairo_t
+ * @state_type: a state
+ * @shadow_type: type of shadow to draw
+ * @widget: (allow-none): the widget
+ * @detail: (allow-none): a style detail
+ * @x: x origin of the extension
+ * @y: y origin of the extension
+ * @width: width of the extension
+ * @height: width of the extension
+ * @gap_side: the side on to which the extension is attached
+ *
+ * Draws an extension, i.e. a notebook tab.
+ *
+ * Deprecated:3.0: Use gtk_render_extension() instead
+ **/
+void
+gtk_paint_extension (GtkStyle           *style,
+                     cairo_t            *cr,
+                     GtkStateType        state_type,
+                     GtkShadowType       shadow_type,
+                     GtkWidget          *widget,
+                     const gchar        *detail,
+                     gint                x,
+                     gint                y,
+                     gint                width,
+                     gint                height,
+                     GtkPositionType     gap_side)
+{
+  g_return_if_fail (GTK_IS_STYLE (style));
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_extension != NULL);
+  g_return_if_fail (cr != NULL);
+  g_return_if_fail (width >= 0);
+  g_return_if_fail (height >= 0);
+
+  cairo_save (cr);
+
+  GTK_STYLE_GET_CLASS (style)->draw_extension (style, cr, state_type, shadow_type,
+                                               widget, detail,
+                                               x, y, width, height, gap_side);
+
+  cairo_restore (cr);
+}
+
+/**
+ * gtk_paint_focus:
+ * @style: a #GtkStyle
+ * @cr: a #cairo_t
+ * @state_type: a state
+ * @widget: (allow-none): the widget
+ * @detail: (allow-none): a style detail
+ * @x: the x origin of the rectangle around which to draw a focus indicator
+ * @y: the y origin of the rectangle around which to draw a focus indicator
+ * @width: the width of the rectangle around which to draw a focus indicator
+ * @height: the height of the rectangle around which to draw a focus indicator
+ *
+ * Draws a focus indicator around the given rectangle on @cr using the
+ * given style.
+ *
+ * Deprecated:3.0: Use gtk_render_focus() instead
+ */
+void
+gtk_paint_focus (GtkStyle           *style,
+                 cairo_t            *cr,
+                 GtkStateType        state_type,
+                 GtkWidget          *widget,
+                 const gchar        *detail,
+                 gint                x,
+                 gint                y,
+                 gint                width,
+                 gint                height)
+{
+  g_return_if_fail (GTK_IS_STYLE (style));
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_focus != NULL);
+  g_return_if_fail (cr != NULL);
+  g_return_if_fail (width >= 0);
+  g_return_if_fail (height >= 0);
+
+  cairo_save (cr);
+
+  GTK_STYLE_GET_CLASS (style)->draw_focus (style, cr, state_type,
+                                           widget, detail,
+                                           x, y, width, height);
+
+  cairo_restore (cr);
+}
+
+/**
+ * gtk_paint_slider:
+ * @style: a #GtkStyle
+ * @cr: a #cairo_t
+ * @state_type: a state
+ * @shadow_type: a shadow
+ * @widget: (allow-none): the widget
+ * @detail: (allow-none): a style detail
+ * @x: the x origin of the rectangle in which to draw a slider
+ * @y: the y origin of the rectangle in which to draw a slider
+ * @width: the width of the rectangle in which to draw a slider
+ * @height: the height of the rectangle in which to draw a slider
+ * @orientation: the orientation to be used
+ *
+ * Draws a slider in the given rectangle on @cr using the
+ * given style and orientation.
+ *
+ * Deprecated:3.0: Use gtk_render_slider() instead
+ **/
+void
+gtk_paint_slider (GtkStyle           *style,
+                  cairo_t            *cr,
+                  GtkStateType        state_type,
+                  GtkShadowType       shadow_type,
+                  GtkWidget          *widget,
+                  const gchar        *detail,
+                  gint                x,
+                  gint                y,
+                  gint                width,
+                  gint                height,
+                  GtkOrientation      orientation)
+{
+  g_return_if_fail (GTK_IS_STYLE (style));
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_slider != NULL);
+  g_return_if_fail (cr != NULL);
+  g_return_if_fail (width >= 0);
+  g_return_if_fail (height >= 0);
+
+  cairo_save (cr);
+
+  GTK_STYLE_GET_CLASS (style)->draw_slider (style, cr, state_type, shadow_type,
+                                            widget, detail,
+                                            x, y, width, height, orientation);
+
+  cairo_restore (cr);
+}
+
+/**
+ * gtk_paint_handle:
+ * @style: a #GtkStyle
+ * @cr: a #cairo_t
+ * @state_type: a state
+ * @shadow_type: type of shadow to draw
+ * @widget: (allow-none): the widget
+ * @detail: (allow-none): a style detail
+ * @x: x origin of the handle
+ * @y: y origin of the handle
+ * @width: with of the handle
+ * @height: height of the handle
+ * @orientation: the orientation of the handle
+ *
+ * Draws a handle as used in #GtkHandleBox and #GtkPaned.
+ *
+ * Deprecated:3.0: Use gtk_render_handle() instead
+ **/
+void
+gtk_paint_handle (GtkStyle           *style,
+                  cairo_t            *cr,
+                  GtkStateType        state_type,
+                  GtkShadowType       shadow_type,
+                  GtkWidget          *widget,
+                  const gchar        *detail,
+                  gint                x,
+                  gint                y,
+                  gint                width,
+                  gint                height,
+                  GtkOrientation      orientation)
+{
+  g_return_if_fail (GTK_IS_STYLE (style));
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_handle != NULL);
+  g_return_if_fail (cr != NULL);
+  g_return_if_fail (width >= 0);
+  g_return_if_fail (height >= 0);
+
+  cairo_save (cr);
+
+  GTK_STYLE_GET_CLASS (style)->draw_handle (style, cr, state_type, shadow_type,
+                                            widget, detail,
+                                            x, y, width, height, orientation);
+
+  cairo_restore (cr);
+}
+
+/**
+ * gtk_paint_expander:
+ * @style: a #GtkStyle
+ * @cr: a #cairo_t
+ * @state_type: a state
+ * @widget: (allow-none): the widget
+ * @detail: (allow-none): a style detail
+ * @x: the x position to draw the expander at
+ * @y: the y position to draw the expander at
+ * @expander_style: the style to draw the expander in; determines
+ *   whether the expander is collapsed, expanded, or in an
+ *   intermediate state.
+ *
+ * Draws an expander as used in #GtkTreeView. @x and @y specify the
+ * center the expander. The size of the expander is determined by the
+ * "expander-size" style property of @widget.  (If widget is not
+ * specified or doesn't have an "expander-size" property, an
+ * unspecified default size will be used, since the caller doesn't
+ * have sufficient information to position the expander, this is
+ * likely not useful.) The expander is expander_size pixels tall
+ * in the collapsed position and expander_size pixels wide in the
+ * expanded position.
+ *
+ * Deprecated:3.0: Use gtk_render_expander() instead
+ **/
+void
+gtk_paint_expander (GtkStyle           *style,
+                    cairo_t            *cr,
+                    GtkStateType        state_type,
+                    GtkWidget          *widget,
+                    const gchar        *detail,
+                    gint                x,
+                    gint                y,
+                    GtkExpanderStyle    expander_style)
+{
+  g_return_if_fail (GTK_IS_STYLE (style));
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_expander != NULL);
+  g_return_if_fail (cr != NULL);
+
+  cairo_save (cr);
+
+  GTK_STYLE_GET_CLASS (style)->draw_expander (style, cr, state_type,
+                                              widget, detail,
+                                              x, y, expander_style);
+
+  cairo_restore (cr);
+}
+
+/**
+ * gtk_paint_layout:
+ * @style: a #GtkStyle
+ * @cr: a #cairo_t
+ * @state_type: a state
+ * @use_text: whether to use the text or foreground
+ *            graphics context of @style
+ * @widget: (allow-none): the widget
+ * @detail: (allow-none): a style detail
+ * @x: x origin
+ * @y: y origin
+ * @layout: the layout to draw
+ *
+ * Draws a layout on @cr using the given parameters.
+ *
+ * Deprecated:3.0: Use gtk_render_layout() instead
+ **/
+void
+gtk_paint_layout (GtkStyle           *style,
+                  cairo_t            *cr,
+                  GtkStateType        state_type,
+                  gboolean            use_text,
+                  GtkWidget          *widget,
+                  const gchar        *detail,
+                  gint                x,
+                  gint                y,
+                  PangoLayout        *layout)
+{
+  g_return_if_fail (GTK_IS_STYLE (style));
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_layout != NULL);
+  g_return_if_fail (cr != NULL);
+
+  cairo_save (cr);
+
+  GTK_STYLE_GET_CLASS (style)->draw_layout (style, cr, state_type, use_text,
+                                            widget, detail,
+                                            x, y, layout);
+
+  cairo_restore (cr);
+}
+
+/**
+ * gtk_paint_resize_grip:
+ * @style: a #GtkStyle
+ * @cr: a #cairo_t
+ * @state_type: a state
+ * @widget: (allow-none): the widget
+ * @detail: (allow-none): a style detail
+ * @edge: the edge in which to draw the resize grip
+ * @x: the x origin of the rectangle in which to draw the resize grip
+ * @y: the y origin of the rectangle in which to draw the resize grip
+ * @width: the width of the rectangle in which to draw the resize grip
+ * @height: the height of the rectangle in which to draw the resize grip
+ *
+ * Draws a resize grip in the given rectangle on @cr using the given
+ * parameters.
+ *
+ * Deprecated:3.0: Use gtk_render_handle() instead
+ */
+void
+gtk_paint_resize_grip (GtkStyle           *style,
+                       cairo_t            *cr,
+                       GtkStateType        state_type,
+                       GtkWidget          *widget,
+                       const gchar        *detail,
+                       GdkWindowEdge       edge,
+                       gint                x,
+                       gint                y,
+                       gint                width,
+                       gint                height)
+{
+  g_return_if_fail (GTK_IS_STYLE (style));
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_resize_grip != NULL);
+  g_return_if_fail (cr != NULL);
+
+  cairo_save (cr);
+
+  GTK_STYLE_GET_CLASS (style)->draw_resize_grip (style, cr, state_type,
+                                                 widget, detail,
+                                                 edge, x, y, width, height);
+  cairo_restore (cr);
+}
+
+/**
+ * gtk_paint_spinner:
+ * @style: a #GtkStyle
+ * @cr: a #cairo_t
+ * @state_type: a state
+ * @widget: (allow-none): the widget (may be %NULL)
+ * @detail: (allow-none): a style detail (may be %NULL)
+ * @step: the nth step, a value between 0 and #GtkSpinner:num-steps
+ * @x: the x origin of the rectangle in which to draw the spinner
+ * @y: the y origin of the rectangle in which to draw the spinner
+ * @width: the width of the rectangle in which to draw the spinner
+ * @height: the height of the rectangle in which to draw the spinner
+ *
+ * Draws a spinner on @window using the given parameters.
+ *
+ * Deprecated:3.0: Use gtk_render_activity() instead
+ */
+void
+gtk_paint_spinner (GtkStyle           *style,
+                   cairo_t            *cr,
+                   GtkStateType        state_type,
+                   GtkWidget          *widget,
+                   const gchar        *detail,
+                   guint               step,
+                   gint                x,
+                   gint                y,
+                   gint                width,
+                   gint                height)
+{
+  g_return_if_fail (GTK_IS_STYLE (style));
+  g_return_if_fail (cr != NULL);
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_spinner != NULL);
+
+  cairo_save (cr);
+
+  GTK_STYLE_GET_CLASS (style)->draw_spinner (style, cr, state_type,
+                                             widget, detail,
+					     step, x, y, width, height);
+
+  cairo_restore (cr);
+}
diff --git a/gtk/deprecated/gtkstyle.h b/gtk/deprecated/gtkstyle.h
new file mode 100644
index 0000000000..ec7d6d38f2
--- /dev/null
+++ b/gtk/deprecated/gtkstyle.h
@@ -0,0 +1,666 @@
+/* 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/.
+ */
+
+#if !defined (__GTK_H_INSIDE__) && !defined (GTK_COMPILATION)
+#error "Only <gtk/gtk.h> can be included directly."
+#endif
+
+#ifndef __GTK_STYLE_H__
+#define __GTK_STYLE_H__
+
+
+#include <gdk/gdk.h>
+#include <gtk/gtkenums.h>
+#include <gtk/gtkwidgetpath.h>
+
+
+G_BEGIN_DECLS
+
+#define GTK_TYPE_STYLE              (gtk_style_get_type ())
+#define GTK_STYLE(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GTK_TYPE_STYLE, GtkStyle))
+#define GTK_STYLE_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_STYLE, GtkStyleClass))
+#define GTK_IS_STYLE(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GTK_TYPE_STYLE))
+#define GTK_IS_STYLE_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_STYLE))
+#define GTK_STYLE_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_STYLE, GtkStyleClass))
+
+/* Some forward declarations needed to rationalize the header
+ * files.
+ */
+typedef struct _GtkStyleClass  GtkStyleClass;
+typedef struct _GtkThemeEngine GtkThemeEngine;
+typedef struct _GtkRcProperty  GtkRcProperty;
+
+/**
+ * GTK_STYLE_ATTACHED:
+ * @style: a #GtkStyle.
+ *
+ * Returns whether the style is attached to a window.
+ */
+#define GTK_STYLE_ATTACHED(style)       (GTK_STYLE (style)->attach_count > 0)
+
+struct _GtkStyle
+{
+  GObject parent_instance;
+
+  /*< public >*/
+
+  GdkColor fg[5];
+  GdkColor bg[5];
+  GdkColor light[5];
+  GdkColor dark[5];
+  GdkColor mid[5];
+  GdkColor text[5];
+  GdkColor base[5];
+  GdkColor text_aa[5];          /* Halfway between text/base */
+
+  GdkColor black;
+  GdkColor white;
+  PangoFontDescription *font_desc;
+
+  gint xthickness;
+  gint ythickness;
+
+  cairo_pattern_t *background[5];
+
+  /*< private >*/
+
+  gint attach_count;
+
+  GdkVisual *visual;
+  PangoFontDescription *private_font_desc; /* Font description for style->private_font or %NULL */
+
+  /* the RcStyle from which this style was created */
+  GtkRcStyle     *rc_style;
+
+  GSList         *styles;         /* of type GtkStyle* */
+  GArray         *property_cache;
+  GSList         *icon_factories; /* of type GtkIconFactory* */
+};
+
+struct _GtkStyleClass
+{
+  GObjectClass parent_class;
+
+  /* Initialize for a particular visual. style->visual
+   * will have been set at this point. Will typically chain
+   * to parent.
+   */
+  void (*realize)               (GtkStyle               *style);
+
+  /* Clean up for a particular visual. Will typically chain
+   * to parent.
+   */
+  void (*unrealize)             (GtkStyle               *style);
+
+  /* Make style an exact duplicate of src.
+   */
+  void (*copy)                  (GtkStyle               *style,
+                                 GtkStyle               *src);
+
+  /* Create an empty style of the same type as this style.
+   * The default implementation, which does
+   * g_object_new (G_OBJECT_TYPE (style), NULL);
+   * should work in most cases.
+   */
+  GtkStyle *(*clone)             (GtkStyle               *style);
+
+  /* Initialize the GtkStyle with the values in the GtkRcStyle.
+   * should chain to the parent implementation.
+   */
+  void     (*init_from_rc)      (GtkStyle               *style,
+                                 GtkRcStyle             *rc_style);
+
+  void (*set_background)        (GtkStyle               *style,
+                                 GdkWindow              *window,
+                                 GtkStateType            state_type);
+
+
+  GdkPixbuf * (* render_icon)   (GtkStyle               *style,
+                                 const GtkIconSource    *source,
+                                 GtkTextDirection        direction,
+                                 GtkStateType            state,
+                                 GtkIconSize             size,
+                                 GtkWidget              *widget,
+                                 const gchar            *detail);
+
+  /* Drawing functions
+   */
+
+  void (*draw_hline)            (GtkStyle               *style,
+                                 cairo_t                *cr,
+                                 GtkStateType            state_type,
+                                 GtkWidget              *widget,
+                                 const gchar            *detail,
+                                 gint                    x1,
+                                 gint                    x2,
+                                 gint                    y);
+  void (*draw_vline)            (GtkStyle               *style,
+                                 cairo_t                *cr,
+                                 GtkStateType            state_type,
+                                 GtkWidget              *widget,
+                                 const gchar            *detail,
+                                 gint                    y1_,
+                                 gint                    y2_,
+                                 gint                    x);
+  void (*draw_shadow)           (GtkStyle               *style,
+                                 cairo_t                *cr,
+                                 GtkStateType            state_type,
+                                 GtkShadowType           shadow_type,
+                                 GtkWidget              *widget,
+                                 const gchar            *detail,
+                                 gint                    x,
+                                 gint                    y,
+                                 gint                    width,
+                                 gint                    height);
+  void (*draw_arrow)            (GtkStyle               *style,
+                                 cairo_t                *cr,
+                                 GtkStateType            state_type,
+                                 GtkShadowType           shadow_type,
+                                 GtkWidget              *widget,
+                                 const gchar            *detail,
+                                 GtkArrowType            arrow_type,
+                                 gboolean                fill,
+                                 gint                    x,
+                                 gint                    y,
+                                 gint                    width,
+                                 gint                    height);
+  void (*draw_diamond)          (GtkStyle               *style,
+                                 cairo_t                *cr,
+                                 GtkStateType            state_type,
+                                 GtkShadowType           shadow_type,
+                                 GtkWidget              *widget,
+                                 const gchar            *detail,
+                                 gint                    x,
+                                 gint                    y,
+                                 gint                    width,
+                                 gint                    height);
+  void (*draw_box)              (GtkStyle               *style,
+                                 cairo_t                *cr,
+                                 GtkStateType            state_type,
+                                 GtkShadowType           shadow_type,
+                                 GtkWidget              *widget,
+                                 const gchar            *detail,
+                                 gint                    x,
+                                 gint                    y,
+                                 gint                    width,
+                                 gint                    height);
+  void (*draw_flat_box)         (GtkStyle               *style,
+                                 cairo_t                *cr,
+                                 GtkStateType            state_type,
+                                 GtkShadowType           shadow_type,
+                                 GtkWidget              *widget,
+                                 const gchar            *detail,
+                                 gint                    x,
+                                 gint                    y,
+                                 gint                    width,
+                                 gint                    height);
+  void (*draw_check)            (GtkStyle               *style,
+                                 cairo_t                *cr,
+                                 GtkStateType            state_type,
+                                 GtkShadowType           shadow_type,
+                                 GtkWidget              *widget,
+                                 const gchar            *detail,
+                                 gint                    x,
+                                 gint                    y,
+                                 gint                    width,
+                                 gint                    height);
+  void (*draw_option)           (GtkStyle               *style,
+                                 cairo_t                *cr,
+                                 GtkStateType            state_type,
+                                 GtkShadowType           shadow_type,
+                                 GtkWidget              *widget,
+                                 const gchar            *detail,
+                                 gint                    x,
+                                 gint                    y,
+                                 gint                    width,
+                                 gint                    height);
+  void (*draw_tab)              (GtkStyle               *style,
+                                 cairo_t                *cr,
+                                 GtkStateType            state_type,
+                                 GtkShadowType           shadow_type,
+                                 GtkWidget              *widget,
+                                 const gchar            *detail,
+                                 gint                    x,
+                                 gint                    y,
+                                 gint                    width,
+                                 gint                    height);
+  void (*draw_shadow_gap)       (GtkStyle               *style,
+                                 cairo_t                *cr,
+                                 GtkStateType            state_type,
+                                 GtkShadowType           shadow_type,
+                                 GtkWidget              *widget,
+                                 const gchar            *detail,
+                                 gint                    x,
+                                 gint                    y,
+                                 gint                    width,
+                                 gint                    height,
+                                 GtkPositionType         gap_side,
+                                 gint                    gap_x,
+                                 gint                    gap_width);
+  void (*draw_box_gap)          (GtkStyle               *style,
+                                 cairo_t                *cr,
+                                 GtkStateType            state_type,
+                                 GtkShadowType           shadow_type,
+                                 GtkWidget              *widget,
+                                 const gchar            *detail,
+                                 gint                    x,
+                                 gint                    y,
+                                 gint                    width,
+                                 gint                    height,
+                                 GtkPositionType         gap_side,
+                                 gint                    gap_x,
+                                 gint                    gap_width);
+  void (*draw_extension)        (GtkStyle               *style,
+                                 cairo_t                *cr,
+                                 GtkStateType            state_type,
+                                 GtkShadowType           shadow_type,
+                                 GtkWidget              *widget,
+                                 const gchar            *detail,
+                                 gint                    x,
+                                 gint                    y,
+                                 gint                    width,
+                                 gint                    height,
+                                 GtkPositionType         gap_side);
+  void (*draw_focus)            (GtkStyle               *style,
+                                 cairo_t                *cr,
+                                 GtkStateType            state_type,
+                                 GtkWidget              *widget,
+                                 const gchar            *detail,
+                                 gint                    x,
+                                 gint                    y,
+                                 gint                    width,
+                                 gint                    height);
+  void (*draw_slider)           (GtkStyle               *style,
+                                 cairo_t                *cr,
+                                 GtkStateType            state_type,
+                                 GtkShadowType           shadow_type,
+                                 GtkWidget              *widget,
+                                 const gchar            *detail,
+                                 gint                    x,
+                                 gint                    y,
+                                 gint                    width,
+                                 gint                    height,
+                                 GtkOrientation          orientation);
+  void (*draw_handle)           (GtkStyle               *style,
+                                 cairo_t                *cr,
+                                 GtkStateType            state_type,
+                                 GtkShadowType           shadow_type,
+                                 GtkWidget              *widget,
+                                 const gchar            *detail,
+                                 gint                    x,
+                                 gint                    y,
+                                 gint                    width,
+                                 gint                    height,
+                                 GtkOrientation          orientation);
+
+  void (*draw_expander)         (GtkStyle               *style,
+                                 cairo_t                *cr,
+                                 GtkStateType            state_type,
+                                 GtkWidget              *widget,
+                                 const gchar            *detail,
+                                 gint                    x,
+                                 gint                    y,
+                                 GtkExpanderStyle        expander_style);
+  void (*draw_layout)           (GtkStyle               *style,
+                                 cairo_t                *cr,
+                                 GtkStateType            state_type,
+                                 gboolean                use_text,
+                                 GtkWidget              *widget,
+                                 const gchar            *detail,
+                                 gint                    x,
+                                 gint                    y,
+                                 PangoLayout            *layout);
+  void (*draw_resize_grip)      (GtkStyle               *style,
+                                 cairo_t                *cr,
+                                 GtkStateType            state_type,
+                                 GtkWidget              *widget,
+                                 const gchar            *detail,
+                                 GdkWindowEdge           edge,
+                                 gint                    x,
+                                 gint                    y,
+                                 gint                    width,
+                                 gint                    height);
+  void (*draw_spinner)          (GtkStyle               *style,
+                                 cairo_t                *cr,
+                                 GtkStateType            state_type,
+                                 GtkWidget              *widget,
+                                 const gchar            *detail,
+                                 guint                   step,
+                                 gint                    x,
+                                 gint                    y,
+                                 gint                    width,
+                                 gint                    height);
+
+  /* Padding for future expansion */
+  void (*_gtk_reserved1)  (void);
+  void (*_gtk_reserved2)  (void);
+  void (*_gtk_reserved3)  (void);
+  void (*_gtk_reserved4)  (void);
+  void (*_gtk_reserved5)  (void);
+  void (*_gtk_reserved6)  (void);
+  void (*_gtk_reserved7)  (void);
+  void (*_gtk_reserved8)  (void);
+  void (*_gtk_reserved9)  (void);
+  void (*_gtk_reserved10) (void);
+  void (*_gtk_reserved11) (void);
+};
+
+GType     gtk_style_get_type                 (void) G_GNUC_CONST;
+GDK_DEPRECATED_FOR(GtkStyleContext)
+GtkStyle* gtk_style_new                      (void);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+GtkStyle* gtk_style_copy                     (GtkStyle     *style);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+GtkStyle* gtk_style_attach                   (GtkStyle     *style,
+                                              GdkWindow    *window);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void      gtk_style_detach                   (GtkStyle     *style);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void      gtk_style_set_background           (GtkStyle     *style,
+                                              GdkWindow    *window,
+                                              GtkStateType  state_type);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void      gtk_style_apply_default_background (GtkStyle     *style,
+                                              cairo_t      *cr,
+                                              GdkWindow    *window,
+                                              GtkStateType  state_type,
+                                              gint          x,
+                                              gint          y,
+                                              gint          width,
+                                              gint          height);
+
+GDK_DEPRECATED_FOR(GtkStyleContext)
+GtkIconSet* gtk_style_lookup_icon_set        (GtkStyle     *style,
+                                              const gchar  *stock_id);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+gboolean    gtk_style_lookup_color           (GtkStyle     *style,
+                                              const gchar  *color_name,
+                                              GdkColor     *color);
+
+GDK_DEPRECATED_FOR(GtkStyleContext)
+GdkPixbuf*  gtk_style_render_icon     (GtkStyle            *style,
+                                       const GtkIconSource *source,
+                                       GtkTextDirection     direction,
+                                       GtkStateType         state,
+                                       GtkIconSize          size,
+                                       GtkWidget           *widget,
+                                       const gchar         *detail);
+
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_paint_hline             (GtkStyle           *style,
+                                  cairo_t            *cr,
+                                  GtkStateType        state_type,
+                                  GtkWidget          *widget,
+                                  const gchar        *detail,
+                                  gint                x1,
+                                  gint                x2,
+                                  gint                y);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_paint_vline             (GtkStyle           *style,
+                                  cairo_t            *cr,
+                                  GtkStateType        state_type,
+                                  GtkWidget          *widget,
+                                  const gchar        *detail,
+                                  gint                y1_,
+                                  gint                y2_,
+                                  gint                x);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_paint_shadow            (GtkStyle           *style,
+                                  cairo_t            *cr,
+                                  GtkStateType        state_type,
+                                  GtkShadowType       shadow_type,
+                                  GtkWidget          *widget,
+                                  const gchar        *detail,
+                                  gint                x,
+                                  gint                y,
+                                  gint                width,
+                                  gint                height);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_paint_arrow             (GtkStyle           *style,
+                                  cairo_t            *cr,
+                                  GtkStateType        state_type,
+                                  GtkShadowType       shadow_type,
+                                  GtkWidget          *widget,
+                                  const gchar        *detail,
+                                  GtkArrowType        arrow_type,
+                                  gboolean            fill,
+                                  gint                x,
+                                  gint                y,
+                                  gint                width,
+                                  gint                height);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_paint_diamond           (GtkStyle           *style,
+                                  cairo_t            *cr,
+                                  GtkStateType        state_type,
+                                  GtkShadowType       shadow_type,
+                                  GtkWidget          *widget,
+                                  const gchar        *detail,
+                                  gint                x,
+                                  gint                y,
+                                  gint                width,
+                                  gint                height);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_paint_box               (GtkStyle           *style,
+                                  cairo_t            *cr,
+                                  GtkStateType        state_type,
+                                  GtkShadowType       shadow_type,
+                                  GtkWidget          *widget,
+                                  const gchar        *detail,
+                                  gint                x,
+                                  gint                y,
+                                  gint                width,
+                                  gint                height);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_paint_flat_box          (GtkStyle           *style,
+                                  cairo_t            *cr,
+                                  GtkStateType        state_type,
+                                  GtkShadowType       shadow_type,
+                                  GtkWidget          *widget,
+                                  const gchar        *detail,
+                                  gint                x,
+                                  gint                y,
+                                  gint                width,
+                                  gint                height);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_paint_check             (GtkStyle           *style,
+                                  cairo_t            *cr,
+                                  GtkStateType        state_type,
+                                  GtkShadowType       shadow_type,
+                                  GtkWidget          *widget,
+                                  const gchar        *detail,
+                                  gint                x,
+                                  gint                y,
+                                  gint                width,
+                                  gint                height);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_paint_option            (GtkStyle           *style,
+                                  cairo_t            *cr,
+                                  GtkStateType        state_type,
+                                  GtkShadowType       shadow_type,
+                                  GtkWidget          *widget,
+                                  const gchar        *detail,
+                                  gint                x,
+                                  gint                y,
+                                  gint                width,
+                                  gint                height);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_paint_tab               (GtkStyle           *style,
+                                  cairo_t            *cr,
+                                  GtkStateType        state_type,
+                                  GtkShadowType       shadow_type,
+                                  GtkWidget          *widget,
+                                  const gchar        *detail,
+                                  gint                x,
+                                  gint                y,
+                                  gint                width,
+                                  gint                height);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_paint_shadow_gap        (GtkStyle           *style,
+                                  cairo_t            *cr,
+                                  GtkStateType        state_type,
+                                  GtkShadowType       shadow_type,
+                                  GtkWidget          *widget,
+                                  const gchar        *detail,
+                                  gint                x,
+                                  gint                y,
+                                  gint                width,
+                                  gint                height,
+                                  GtkPositionType     gap_side,
+                                  gint                gap_x,
+                                  gint                gap_width);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_paint_box_gap           (GtkStyle           *style,
+                                  cairo_t            *cr,
+                                  GtkStateType        state_type,
+                                  GtkShadowType       shadow_type,
+                                  GtkWidget          *widget,
+                                  const gchar        *detail,
+                                  gint                x,
+                                  gint                y,
+                                  gint                width,
+                                  gint                height,
+                                  GtkPositionType     gap_side,
+                                  gint                gap_x,
+                                  gint                gap_width);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_paint_extension         (GtkStyle           *style,
+                                  cairo_t            *cr,
+                                  GtkStateType        state_type,
+                                  GtkShadowType       shadow_type,
+                                  GtkWidget          *widget,
+                                  const gchar        *detail,
+                                  gint                x,
+                                  gint                y,
+                                  gint                width,
+                                  gint                height,
+                                  GtkPositionType     gap_side);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_paint_focus             (GtkStyle           *style,
+                                  cairo_t            *cr,
+                                  GtkStateType        state_type,
+                                  GtkWidget          *widget,
+                                  const gchar        *detail,
+                                  gint                x,
+                                  gint                y,
+                                  gint                width,
+                                  gint                height);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_paint_slider            (GtkStyle           *style,
+                                  cairo_t            *cr,
+                                  GtkStateType        state_type,
+                                  GtkShadowType       shadow_type,
+                                  GtkWidget          *widget,
+                                  const gchar        *detail,
+                                  gint                x,
+                                  gint                y,
+                                  gint                width,
+                                  gint                height,
+                                  GtkOrientation      orientation);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_paint_handle            (GtkStyle           *style,
+                                  cairo_t            *cr,
+                                  GtkStateType        state_type,
+                                  GtkShadowType       shadow_type,
+                                  GtkWidget          *widget,
+                                  const gchar        *detail,
+                                  gint                x,
+                                  gint                y,
+                                  gint                width,
+                                  gint                height,
+                                  GtkOrientation      orientation);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_paint_expander          (GtkStyle           *style,
+                                  cairo_t            *cr,
+                                  GtkStateType        state_type,
+                                  GtkWidget          *widget,
+                                  const gchar        *detail,
+                                  gint                x,
+                                  gint                y,
+                                  GtkExpanderStyle    expander_style);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_paint_layout            (GtkStyle           *style,
+                                  cairo_t            *cr,
+                                  GtkStateType        state_type,
+                                  gboolean            use_text,
+                                  GtkWidget          *widget,
+                                  const gchar        *detail,
+                                  gint                x,
+                                  gint                y,
+                                  PangoLayout        *layout);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_paint_resize_grip       (GtkStyle           *style,
+                                  cairo_t            *cr,
+                                  GtkStateType        state_type,
+                                  GtkWidget          *widget,
+                                  const gchar        *detail,
+                                  GdkWindowEdge       edge,
+                                  gint                x,
+                                  gint                y,
+                                  gint                width,
+                                  gint                height);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_paint_spinner           (GtkStyle           *style,
+                                  cairo_t            *cr,
+                                  GtkStateType        state_type,
+                                  GtkWidget          *widget,
+                                  const gchar        *detail,
+                                  guint               step,
+                                  gint                x,
+                                  gint                y,
+                                  gint                width,
+                                  gint                height);
+
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_style_get_style_property (GtkStyle    *style,
+                                   GType        widget_type,
+                                   const gchar *property_name,
+                                   GValue      *value);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_style_get_valist         (GtkStyle    *style,
+                                   GType        widget_type,
+                                   const gchar *first_property_name,
+                                   va_list      var_args);
+GDK_DEPRECATED_FOR(GtkStyleContext)
+void gtk_style_get                (GtkStyle    *style,
+                                   GType        widget_type,
+                                   const gchar *first_property_name,
+                                   ...) G_GNUC_NULL_TERMINATED;
+
+
+/* --- private API --- */
+GtkStyle*     _gtk_style_new_for_path        (GdkScreen          *screen,
+                                              GtkWidgetPath      *path);
+void          _gtk_style_shade               (const GdkColor     *a,
+                                              GdkColor           *b,
+                                              gdouble             k);
+
+gboolean   gtk_style_has_context    (GtkStyle *style);
+
+
+
+G_END_DECLS
+
+#endif /* __GTK_STYLE_H__ */