Allow %NULL for style to mean "revert to default style"

Tue Jun 26 19:39:03 2001  Owen Taylor  <otaylor@redhat.com>

	* gtk/gtkwidget.c (gtk_widget_set_style): Allow %NULL
	for style to mean "revert to default style"

	* gtk/gtkwidget.[ch] (gtk_widget_set_rc_style,
	  gtk_widget_restore_default_style): Make this functions
	deprecated aliases for gtk_widget_set_style (widget, NULL).

	* gtk/gtkwidget.[ch]: Remove:
	   gtk_widget_set_default_style ()
	   gtk_widget_push_style ()
	   gtk_widget_pop_style ()
	These functions interact are overriden by RC files, and
	thus virtually useless, and complicated.

Fri Jun 22 18:49:48 2001  Owen Taylor  <otaylor@redhat.com>

        * gtk/gtkrc.c: Add a GtkRcContext structure to hold
	most of the previous global variables in gtkrc.c. This is
	in preparation for multi-head, since each screen can
	have different GtkSettings and RC information.

	* gtk/gtkrc.[ch]:

	* gtk/gtkrc.h (struct _GtkRcStyleClass): Add a
	GtkSettings parameter to GtkRcStyle::parse.

	* gdk/x11/gdkevents-x11.c gtk/gtksettings.c gtk/gtkrc.c:
	Add two new settings gtk-theme-name, gtk-key-theme-name,
	for RC files that are loaded by name after reading
	the default RC files.

	* gtk/gtkrc.c: Allow priorities for styles, as wll as
	bindings.

	* gtk/gtkenums.h gtk/gtkrc.c: Add GTK_PATH_PRIO_THEME,
	and use it by default for RC files loaded via
	gtk-theme-name, gtk-key-theme-name.

	* gtk/gtkiconfactory.c (gtk_icon_source_set_filename)
        gtk/gtkrc.c (gtk_rc_parse_pixmap_path_string)
	tests/testgtkrc: Require pathnames to be absolute.

	* gtk/gtkrc.c gtk/gtkiconfactory.c: Look up the full filename for
	the source when parsing, since the operation of looking up a
	pixmap from an RC file depends on the parsing context.

	* gtk/gtkrc.c (gtk_rc_context_reparse_all): Automatically
	reset RC styles on all widgets when files are reparsed.

	* tests/testgtk.c (create_rc_file)
	  gtk/gtkwindow.c (gtk_window_read_rcfiles):
	Simplify, now that gtk_rc_reparse_all() resets styles on
	all widgets itself.

	* gtk/gtkmain.c (gtk_get_default_language): Fix broken
	return value.

	* gtk/gtksettings.[ch] (gtk_settings_install_property[_ch]): Remove
	GtkSettings argument.

	* gtk/gtksettings.[ch] (gtk_settings_get_default): Rename from
	gtk_settings_get_global().

	* gtk/gtkwidget.[ch]: Add a function gtk_widget_Get_settings()
	to get the appropriate GtkSettings for a widget. (For now,
	just gets the default GtkSetttings.)

	* gtk/gtkcolorsel.c gtk/gtkentry.c gtk/gtkmenu.c gtk/gtkmenubar.c
	  gtk/gtktextview.c gtk/gtktoolbar.c: Fixes for GtkSettings
        changes.

	* gtk/gtkrc.[ch]: Add gtk_rc_get_style_by_paths() to allow
	getting a style for a path without actually having a widget.
	(Allows using a style for a subpart of a widget, for
	example.)

	* gtk/gtkrc.[ch]: Add gtk_rc_reparse_all_for_setting() to allow forcing
	the RC files to be reloaded for just one GtkSettings
	(not sure how useful this really is.)

	* gtk/gtkrc.h: Deprecate
	gtk_rc_add_widget_name/widget_class/class_style

28 files changed, 1516 insertions, 642 deletions

diff --git a/ChangeLog b/ChangeLog
index 2eec9871e3..c256b216e5 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,88 @@
+Tue Jun 26 19:39:03 2001  Owen Taylor  <otaylor@redhat.com>
+
+	* gtk/gtkwidget.c (gtk_widget_set_style): Allow %NULL
+	for style to mean "revert to default style"
+
+	* gtk/gtkwidget.[ch] (gtk_widget_set_rc_style,
+	  gtk_widget_restore_default_style): Make this functions
+	deprecated aliases for gtk_widget_set_style (widget, NULL).
+
+	* gtk/gtkwidget.[ch]: Remove:
+	   gtk_widget_set_default_style ()
+	   gtk_widget_push_style ()
+	   gtk_widget_pop_style ()
+	These functions interact are overriden by RC files, and
+	thus virtually useless, and complicated.
+
+Fri Jun 22 18:49:48 2001  Owen Taylor  <otaylor@redhat.com>
+
+        * gtk/gtkrc.c: Add a GtkRcContext structure to hold 
+	most of the previous global variables in gtkrc.c. This is
+	in preparation for multi-head, since each screen can
+	have different GtkSettings and RC information.
+
+	* gtk/gtkrc.[ch]: 
+
+	* gtk/gtkrc.h (struct _GtkRcStyleClass): Add a
+	GtkSettings parameter to GtkRcStyle::parse.
+
+	* gdk/x11/gdkevents-x11.c gtk/gtksettings.c gtk/gtkrc.c: 
+	Add two new settings gtk-theme-name, gtk-key-theme-name,
+	for RC files that are loaded by name after reading
+	the default RC files.
+	
+	* gtk/gtkrc.c: Allow priorities for styles, as wll as
+	bindings.
+
+	* gtk/gtkenums.h gtk/gtkrc.c: Add GTK_PATH_PRIO_THEME,
+	and use it by default for RC files loaded via 
+	gtk-theme-name, gtk-key-theme-name.
+
+	* gtk/gtkiconfactory.c (gtk_icon_source_set_filename)
+        gtk/gtkrc.c (gtk_rc_parse_pixmap_path_string) 
+	tests/testgtkrc: Require pathnames to be absolute.
+
+	* gtk/gtkrc.c gtk/gtkiconfactory.c: Look up the full filename for
+	the source when parsing, since the operation of looking up a
+	pixmap from an RC file depends on the parsing context.
+
+	* gtk/gtkrc.c (gtk_rc_context_reparse_all): Automatically
+	reset RC styles on all widgets when files are reparsed.
+
+	* tests/testgtk.c (create_rc_file) 
+	  gtk/gtkwindow.c (gtk_window_read_rcfiles): 
+	Simplify, now that gtk_rc_reparse_all() resets styles on
+	all widgets itself.
+
+	* gtk/gtkmain.c (gtk_get_default_language): Fix broken
+	return value.
+
+	* gtk/gtksettings.[ch] (gtk_settings_install_property[_ch]): Remove
+	GtkSettings argument.
+
+	* gtk/gtksettings.[ch] (gtk_settings_get_default): Rename from
+	gtk_settings_get_global().
+
+	* gtk/gtkwidget.[ch]: Add a function gtk_widget_Get_settings()
+	to get the appropriate GtkSettings for a widget. (For now,
+	just gets the default GtkSetttings.) 
+
+	* gtk/gtkcolorsel.c gtk/gtkentry.c gtk/gtkmenu.c gtk/gtkmenubar.c
+	  gtk/gtktextview.c gtk/gtktoolbar.c: Fixes for GtkSettings
+        changes.
+
+	* gtk/gtkrc.[ch]: Add gtk_rc_get_style_by_paths() to allow
+	getting a style for a path without actually having a widget.
+	(Allows using a style for a subpart of a widget, for
+	example.)
+
+	* gtk/gtkrc.[ch]: Add gtk_rc_reparse_all_for_setting() to allow forcing
+	the RC files to be reloaded for just one GtkSettings
+	(not sure how useful this really is.)
+
+	* gtk/gtkrc.h: Deprecate
+	gtk_rc_add_widget_name/widget_class/class_style
+
 2001-06-30  Alex Larsson  <alexl@redhat.com>
 
 	* gdk/linux-fb/gdkinput-none.c:
diff --git a/ChangeLog.pre-2-0 b/ChangeLog.pre-2-0
index 2eec9871e3..c256b216e5 100644
--- a/ChangeLog.pre-2-0
+++ b/ChangeLog.pre-2-0
@@ -1,3 +1,88 @@
+Tue Jun 26 19:39:03 2001  Owen Taylor  <otaylor@redhat.com>
+
+	* gtk/gtkwidget.c (gtk_widget_set_style): Allow %NULL
+	for style to mean "revert to default style"
+
+	* gtk/gtkwidget.[ch] (gtk_widget_set_rc_style,
+	  gtk_widget_restore_default_style): Make this functions
+	deprecated aliases for gtk_widget_set_style (widget, NULL).
+
+	* gtk/gtkwidget.[ch]: Remove:
+	   gtk_widget_set_default_style ()
+	   gtk_widget_push_style ()
+	   gtk_widget_pop_style ()
+	These functions interact are overriden by RC files, and
+	thus virtually useless, and complicated.
+
+Fri Jun 22 18:49:48 2001  Owen Taylor  <otaylor@redhat.com>
+
+        * gtk/gtkrc.c: Add a GtkRcContext structure to hold 
+	most of the previous global variables in gtkrc.c. This is
+	in preparation for multi-head, since each screen can
+	have different GtkSettings and RC information.
+
+	* gtk/gtkrc.[ch]: 
+
+	* gtk/gtkrc.h (struct _GtkRcStyleClass): Add a
+	GtkSettings parameter to GtkRcStyle::parse.
+
+	* gdk/x11/gdkevents-x11.c gtk/gtksettings.c gtk/gtkrc.c: 
+	Add two new settings gtk-theme-name, gtk-key-theme-name,
+	for RC files that are loaded by name after reading
+	the default RC files.
+	
+	* gtk/gtkrc.c: Allow priorities for styles, as wll as
+	bindings.
+
+	* gtk/gtkenums.h gtk/gtkrc.c: Add GTK_PATH_PRIO_THEME,
+	and use it by default for RC files loaded via 
+	gtk-theme-name, gtk-key-theme-name.
+
+	* gtk/gtkiconfactory.c (gtk_icon_source_set_filename)
+        gtk/gtkrc.c (gtk_rc_parse_pixmap_path_string) 
+	tests/testgtkrc: Require pathnames to be absolute.
+
+	* gtk/gtkrc.c gtk/gtkiconfactory.c: Look up the full filename for
+	the source when parsing, since the operation of looking up a
+	pixmap from an RC file depends on the parsing context.
+
+	* gtk/gtkrc.c (gtk_rc_context_reparse_all): Automatically
+	reset RC styles on all widgets when files are reparsed.
+
+	* tests/testgtk.c (create_rc_file) 
+	  gtk/gtkwindow.c (gtk_window_read_rcfiles): 
+	Simplify, now that gtk_rc_reparse_all() resets styles on
+	all widgets itself.
+
+	* gtk/gtkmain.c (gtk_get_default_language): Fix broken
+	return value.
+
+	* gtk/gtksettings.[ch] (gtk_settings_install_property[_ch]): Remove
+	GtkSettings argument.
+
+	* gtk/gtksettings.[ch] (gtk_settings_get_default): Rename from
+	gtk_settings_get_global().
+
+	* gtk/gtkwidget.[ch]: Add a function gtk_widget_Get_settings()
+	to get the appropriate GtkSettings for a widget. (For now,
+	just gets the default GtkSetttings.) 
+
+	* gtk/gtkcolorsel.c gtk/gtkentry.c gtk/gtkmenu.c gtk/gtkmenubar.c
+	  gtk/gtktextview.c gtk/gtktoolbar.c: Fixes for GtkSettings
+        changes.
+
+	* gtk/gtkrc.[ch]: Add gtk_rc_get_style_by_paths() to allow
+	getting a style for a path without actually having a widget.
+	(Allows using a style for a subpart of a widget, for
+	example.)
+
+	* gtk/gtkrc.[ch]: Add gtk_rc_reparse_all_for_setting() to allow forcing
+	the RC files to be reloaded for just one GtkSettings
+	(not sure how useful this really is.)
+
+	* gtk/gtkrc.h: Deprecate
+	gtk_rc_add_widget_name/widget_class/class_style
+
 2001-06-30  Alex Larsson  <alexl@redhat.com>
 
 	* gdk/linux-fb/gdkinput-none.c:
diff --git a/ChangeLog.pre-2-10 b/ChangeLog.pre-2-10
index 2eec9871e3..c256b216e5 100644
--- a/ChangeLog.pre-2-10
+++ b/ChangeLog.pre-2-10
@@ -1,3 +1,88 @@
+Tue Jun 26 19:39:03 2001  Owen Taylor  <otaylor@redhat.com>
+
+	* gtk/gtkwidget.c (gtk_widget_set_style): Allow %NULL
+	for style to mean "revert to default style"
+
+	* gtk/gtkwidget.[ch] (gtk_widget_set_rc_style,
+	  gtk_widget_restore_default_style): Make this functions
+	deprecated aliases for gtk_widget_set_style (widget, NULL).
+
+	* gtk/gtkwidget.[ch]: Remove:
+	   gtk_widget_set_default_style ()
+	   gtk_widget_push_style ()
+	   gtk_widget_pop_style ()
+	These functions interact are overriden by RC files, and
+	thus virtually useless, and complicated.
+
+Fri Jun 22 18:49:48 2001  Owen Taylor  <otaylor@redhat.com>
+
+        * gtk/gtkrc.c: Add a GtkRcContext structure to hold 
+	most of the previous global variables in gtkrc.c. This is
+	in preparation for multi-head, since each screen can
+	have different GtkSettings and RC information.
+
+	* gtk/gtkrc.[ch]: 
+
+	* gtk/gtkrc.h (struct _GtkRcStyleClass): Add a
+	GtkSettings parameter to GtkRcStyle::parse.
+
+	* gdk/x11/gdkevents-x11.c gtk/gtksettings.c gtk/gtkrc.c: 
+	Add two new settings gtk-theme-name, gtk-key-theme-name,
+	for RC files that are loaded by name after reading
+	the default RC files.
+	
+	* gtk/gtkrc.c: Allow priorities for styles, as wll as
+	bindings.
+
+	* gtk/gtkenums.h gtk/gtkrc.c: Add GTK_PATH_PRIO_THEME,
+	and use it by default for RC files loaded via 
+	gtk-theme-name, gtk-key-theme-name.
+
+	* gtk/gtkiconfactory.c (gtk_icon_source_set_filename)
+        gtk/gtkrc.c (gtk_rc_parse_pixmap_path_string) 
+	tests/testgtkrc: Require pathnames to be absolute.
+
+	* gtk/gtkrc.c gtk/gtkiconfactory.c: Look up the full filename for
+	the source when parsing, since the operation of looking up a
+	pixmap from an RC file depends on the parsing context.
+
+	* gtk/gtkrc.c (gtk_rc_context_reparse_all): Automatically
+	reset RC styles on all widgets when files are reparsed.
+
+	* tests/testgtk.c (create_rc_file) 
+	  gtk/gtkwindow.c (gtk_window_read_rcfiles): 
+	Simplify, now that gtk_rc_reparse_all() resets styles on
+	all widgets itself.
+
+	* gtk/gtkmain.c (gtk_get_default_language): Fix broken
+	return value.
+
+	* gtk/gtksettings.[ch] (gtk_settings_install_property[_ch]): Remove
+	GtkSettings argument.
+
+	* gtk/gtksettings.[ch] (gtk_settings_get_default): Rename from
+	gtk_settings_get_global().
+
+	* gtk/gtkwidget.[ch]: Add a function gtk_widget_Get_settings()
+	to get the appropriate GtkSettings for a widget. (For now,
+	just gets the default GtkSetttings.) 
+
+	* gtk/gtkcolorsel.c gtk/gtkentry.c gtk/gtkmenu.c gtk/gtkmenubar.c
+	  gtk/gtktextview.c gtk/gtktoolbar.c: Fixes for GtkSettings
+        changes.
+
+	* gtk/gtkrc.[ch]: Add gtk_rc_get_style_by_paths() to allow
+	getting a style for a path without actually having a widget.
+	(Allows using a style for a subpart of a widget, for
+	example.)
+
+	* gtk/gtkrc.[ch]: Add gtk_rc_reparse_all_for_setting() to allow forcing
+	the RC files to be reloaded for just one GtkSettings
+	(not sure how useful this really is.)
+
+	* gtk/gtkrc.h: Deprecate
+	gtk_rc_add_widget_name/widget_class/class_style
+
 2001-06-30  Alex Larsson  <alexl@redhat.com>
 
 	* gdk/linux-fb/gdkinput-none.c:
diff --git a/ChangeLog.pre-2-2 b/ChangeLog.pre-2-2
index 2eec9871e3..c256b216e5 100644
--- a/ChangeLog.pre-2-2
+++ b/ChangeLog.pre-2-2
@@ -1,3 +1,88 @@
+Tue Jun 26 19:39:03 2001  Owen Taylor  <otaylor@redhat.com>
+
+	* gtk/gtkwidget.c (gtk_widget_set_style): Allow %NULL
+	for style to mean "revert to default style"
+
+	* gtk/gtkwidget.[ch] (gtk_widget_set_rc_style,
+	  gtk_widget_restore_default_style): Make this functions
+	deprecated aliases for gtk_widget_set_style (widget, NULL).
+
+	* gtk/gtkwidget.[ch]: Remove:
+	   gtk_widget_set_default_style ()
+	   gtk_widget_push_style ()
+	   gtk_widget_pop_style ()
+	These functions interact are overriden by RC files, and
+	thus virtually useless, and complicated.
+
+Fri Jun 22 18:49:48 2001  Owen Taylor  <otaylor@redhat.com>
+
+        * gtk/gtkrc.c: Add a GtkRcContext structure to hold 
+	most of the previous global variables in gtkrc.c. This is
+	in preparation for multi-head, since each screen can
+	have different GtkSettings and RC information.
+
+	* gtk/gtkrc.[ch]: 
+
+	* gtk/gtkrc.h (struct _GtkRcStyleClass): Add a
+	GtkSettings parameter to GtkRcStyle::parse.
+
+	* gdk/x11/gdkevents-x11.c gtk/gtksettings.c gtk/gtkrc.c: 
+	Add two new settings gtk-theme-name, gtk-key-theme-name,
+	for RC files that are loaded by name after reading
+	the default RC files.
+	
+	* gtk/gtkrc.c: Allow priorities for styles, as wll as
+	bindings.
+
+	* gtk/gtkenums.h gtk/gtkrc.c: Add GTK_PATH_PRIO_THEME,
+	and use it by default for RC files loaded via 
+	gtk-theme-name, gtk-key-theme-name.
+
+	* gtk/gtkiconfactory.c (gtk_icon_source_set_filename)
+        gtk/gtkrc.c (gtk_rc_parse_pixmap_path_string) 
+	tests/testgtkrc: Require pathnames to be absolute.
+
+	* gtk/gtkrc.c gtk/gtkiconfactory.c: Look up the full filename for
+	the source when parsing, since the operation of looking up a
+	pixmap from an RC file depends on the parsing context.
+
+	* gtk/gtkrc.c (gtk_rc_context_reparse_all): Automatically
+	reset RC styles on all widgets when files are reparsed.
+
+	* tests/testgtk.c (create_rc_file) 
+	  gtk/gtkwindow.c (gtk_window_read_rcfiles): 
+	Simplify, now that gtk_rc_reparse_all() resets styles on
+	all widgets itself.
+
+	* gtk/gtkmain.c (gtk_get_default_language): Fix broken
+	return value.
+
+	* gtk/gtksettings.[ch] (gtk_settings_install_property[_ch]): Remove
+	GtkSettings argument.
+
+	* gtk/gtksettings.[ch] (gtk_settings_get_default): Rename from
+	gtk_settings_get_global().
+
+	* gtk/gtkwidget.[ch]: Add a function gtk_widget_Get_settings()
+	to get the appropriate GtkSettings for a widget. (For now,
+	just gets the default GtkSetttings.) 
+
+	* gtk/gtkcolorsel.c gtk/gtkentry.c gtk/gtkmenu.c gtk/gtkmenubar.c
+	  gtk/gtktextview.c gtk/gtktoolbar.c: Fixes for GtkSettings
+        changes.
+
+	* gtk/gtkrc.[ch]: Add gtk_rc_get_style_by_paths() to allow
+	getting a style for a path without actually having a widget.
+	(Allows using a style for a subpart of a widget, for
+	example.)
+
+	* gtk/gtkrc.[ch]: Add gtk_rc_reparse_all_for_setting() to allow forcing
+	the RC files to be reloaded for just one GtkSettings
+	(not sure how useful this really is.)
+
+	* gtk/gtkrc.h: Deprecate
+	gtk_rc_add_widget_name/widget_class/class_style
+
 2001-06-30  Alex Larsson  <alexl@redhat.com>
 
 	* gdk/linux-fb/gdkinput-none.c:
diff --git a/ChangeLog.pre-2-4 b/ChangeLog.pre-2-4
index 2eec9871e3..c256b216e5 100644
--- a/ChangeLog.pre-2-4
+++ b/ChangeLog.pre-2-4
@@ -1,3 +1,88 @@
+Tue Jun 26 19:39:03 2001  Owen Taylor  <otaylor@redhat.com>
+
+	* gtk/gtkwidget.c (gtk_widget_set_style): Allow %NULL
+	for style to mean "revert to default style"
+
+	* gtk/gtkwidget.[ch] (gtk_widget_set_rc_style,
+	  gtk_widget_restore_default_style): Make this functions
+	deprecated aliases for gtk_widget_set_style (widget, NULL).
+
+	* gtk/gtkwidget.[ch]: Remove:
+	   gtk_widget_set_default_style ()
+	   gtk_widget_push_style ()
+	   gtk_widget_pop_style ()
+	These functions interact are overriden by RC files, and
+	thus virtually useless, and complicated.
+
+Fri Jun 22 18:49:48 2001  Owen Taylor  <otaylor@redhat.com>
+
+        * gtk/gtkrc.c: Add a GtkRcContext structure to hold 
+	most of the previous global variables in gtkrc.c. This is
+	in preparation for multi-head, since each screen can
+	have different GtkSettings and RC information.
+
+	* gtk/gtkrc.[ch]: 
+
+	* gtk/gtkrc.h (struct _GtkRcStyleClass): Add a
+	GtkSettings parameter to GtkRcStyle::parse.
+
+	* gdk/x11/gdkevents-x11.c gtk/gtksettings.c gtk/gtkrc.c: 
+	Add two new settings gtk-theme-name, gtk-key-theme-name,
+	for RC files that are loaded by name after reading
+	the default RC files.
+	
+	* gtk/gtkrc.c: Allow priorities for styles, as wll as
+	bindings.
+
+	* gtk/gtkenums.h gtk/gtkrc.c: Add GTK_PATH_PRIO_THEME,
+	and use it by default for RC files loaded via 
+	gtk-theme-name, gtk-key-theme-name.
+
+	* gtk/gtkiconfactory.c (gtk_icon_source_set_filename)
+        gtk/gtkrc.c (gtk_rc_parse_pixmap_path_string) 
+	tests/testgtkrc: Require pathnames to be absolute.
+
+	* gtk/gtkrc.c gtk/gtkiconfactory.c: Look up the full filename for
+	the source when parsing, since the operation of looking up a
+	pixmap from an RC file depends on the parsing context.
+
+	* gtk/gtkrc.c (gtk_rc_context_reparse_all): Automatically
+	reset RC styles on all widgets when files are reparsed.
+
+	* tests/testgtk.c (create_rc_file) 
+	  gtk/gtkwindow.c (gtk_window_read_rcfiles): 
+	Simplify, now that gtk_rc_reparse_all() resets styles on
+	all widgets itself.
+
+	* gtk/gtkmain.c (gtk_get_default_language): Fix broken
+	return value.
+
+	* gtk/gtksettings.[ch] (gtk_settings_install_property[_ch]): Remove
+	GtkSettings argument.
+
+	* gtk/gtksettings.[ch] (gtk_settings_get_default): Rename from
+	gtk_settings_get_global().
+
+	* gtk/gtkwidget.[ch]: Add a function gtk_widget_Get_settings()
+	to get the appropriate GtkSettings for a widget. (For now,
+	just gets the default GtkSetttings.) 
+
+	* gtk/gtkcolorsel.c gtk/gtkentry.c gtk/gtkmenu.c gtk/gtkmenubar.c
+	  gtk/gtktextview.c gtk/gtktoolbar.c: Fixes for GtkSettings
+        changes.
+
+	* gtk/gtkrc.[ch]: Add gtk_rc_get_style_by_paths() to allow
+	getting a style for a path without actually having a widget.
+	(Allows using a style for a subpart of a widget, for
+	example.)
+
+	* gtk/gtkrc.[ch]: Add gtk_rc_reparse_all_for_setting() to allow forcing
+	the RC files to be reloaded for just one GtkSettings
+	(not sure how useful this really is.)
+
+	* gtk/gtkrc.h: Deprecate
+	gtk_rc_add_widget_name/widget_class/class_style
+
 2001-06-30  Alex Larsson  <alexl@redhat.com>
 
 	* gdk/linux-fb/gdkinput-none.c:
diff --git a/ChangeLog.pre-2-6 b/ChangeLog.pre-2-6
index 2eec9871e3..c256b216e5 100644
--- a/ChangeLog.pre-2-6
+++ b/ChangeLog.pre-2-6
@@ -1,3 +1,88 @@
+Tue Jun 26 19:39:03 2001  Owen Taylor  <otaylor@redhat.com>
+
+	* gtk/gtkwidget.c (gtk_widget_set_style): Allow %NULL
+	for style to mean "revert to default style"
+
+	* gtk/gtkwidget.[ch] (gtk_widget_set_rc_style,
+	  gtk_widget_restore_default_style): Make this functions
+	deprecated aliases for gtk_widget_set_style (widget, NULL).
+
+	* gtk/gtkwidget.[ch]: Remove:
+	   gtk_widget_set_default_style ()
+	   gtk_widget_push_style ()
+	   gtk_widget_pop_style ()
+	These functions interact are overriden by RC files, and
+	thus virtually useless, and complicated.
+
+Fri Jun 22 18:49:48 2001  Owen Taylor  <otaylor@redhat.com>
+
+        * gtk/gtkrc.c: Add a GtkRcContext structure to hold 
+	most of the previous global variables in gtkrc.c. This is
+	in preparation for multi-head, since each screen can
+	have different GtkSettings and RC information.
+
+	* gtk/gtkrc.[ch]: 
+
+	* gtk/gtkrc.h (struct _GtkRcStyleClass): Add a
+	GtkSettings parameter to GtkRcStyle::parse.
+
+	* gdk/x11/gdkevents-x11.c gtk/gtksettings.c gtk/gtkrc.c: 
+	Add two new settings gtk-theme-name, gtk-key-theme-name,
+	for RC files that are loaded by name after reading
+	the default RC files.
+	
+	* gtk/gtkrc.c: Allow priorities for styles, as wll as
+	bindings.
+
+	* gtk/gtkenums.h gtk/gtkrc.c: Add GTK_PATH_PRIO_THEME,
+	and use it by default for RC files loaded via 
+	gtk-theme-name, gtk-key-theme-name.
+
+	* gtk/gtkiconfactory.c (gtk_icon_source_set_filename)
+        gtk/gtkrc.c (gtk_rc_parse_pixmap_path_string) 
+	tests/testgtkrc: Require pathnames to be absolute.
+
+	* gtk/gtkrc.c gtk/gtkiconfactory.c: Look up the full filename for
+	the source when parsing, since the operation of looking up a
+	pixmap from an RC file depends on the parsing context.
+
+	* gtk/gtkrc.c (gtk_rc_context_reparse_all): Automatically
+	reset RC styles on all widgets when files are reparsed.
+
+	* tests/testgtk.c (create_rc_file) 
+	  gtk/gtkwindow.c (gtk_window_read_rcfiles): 
+	Simplify, now that gtk_rc_reparse_all() resets styles on
+	all widgets itself.
+
+	* gtk/gtkmain.c (gtk_get_default_language): Fix broken
+	return value.
+
+	* gtk/gtksettings.[ch] (gtk_settings_install_property[_ch]): Remove
+	GtkSettings argument.
+
+	* gtk/gtksettings.[ch] (gtk_settings_get_default): Rename from
+	gtk_settings_get_global().
+
+	* gtk/gtkwidget.[ch]: Add a function gtk_widget_Get_settings()
+	to get the appropriate GtkSettings for a widget. (For now,
+	just gets the default GtkSetttings.) 
+
+	* gtk/gtkcolorsel.c gtk/gtkentry.c gtk/gtkmenu.c gtk/gtkmenubar.c
+	  gtk/gtktextview.c gtk/gtktoolbar.c: Fixes for GtkSettings
+        changes.
+
+	* gtk/gtkrc.[ch]: Add gtk_rc_get_style_by_paths() to allow
+	getting a style for a path without actually having a widget.
+	(Allows using a style for a subpart of a widget, for
+	example.)
+
+	* gtk/gtkrc.[ch]: Add gtk_rc_reparse_all_for_setting() to allow forcing
+	the RC files to be reloaded for just one GtkSettings
+	(not sure how useful this really is.)
+
+	* gtk/gtkrc.h: Deprecate
+	gtk_rc_add_widget_name/widget_class/class_style
+
 2001-06-30  Alex Larsson  <alexl@redhat.com>
 
 	* gdk/linux-fb/gdkinput-none.c:
diff --git a/ChangeLog.pre-2-8 b/ChangeLog.pre-2-8
index 2eec9871e3..c256b216e5 100644
--- a/ChangeLog.pre-2-8
+++ b/ChangeLog.pre-2-8
@@ -1,3 +1,88 @@
+Tue Jun 26 19:39:03 2001  Owen Taylor  <otaylor@redhat.com>
+
+	* gtk/gtkwidget.c (gtk_widget_set_style): Allow %NULL
+	for style to mean "revert to default style"
+
+	* gtk/gtkwidget.[ch] (gtk_widget_set_rc_style,
+	  gtk_widget_restore_default_style): Make this functions
+	deprecated aliases for gtk_widget_set_style (widget, NULL).
+
+	* gtk/gtkwidget.[ch]: Remove:
+	   gtk_widget_set_default_style ()
+	   gtk_widget_push_style ()
+	   gtk_widget_pop_style ()
+	These functions interact are overriden by RC files, and
+	thus virtually useless, and complicated.
+
+Fri Jun 22 18:49:48 2001  Owen Taylor  <otaylor@redhat.com>
+
+        * gtk/gtkrc.c: Add a GtkRcContext structure to hold 
+	most of the previous global variables in gtkrc.c. This is
+	in preparation for multi-head, since each screen can
+	have different GtkSettings and RC information.
+
+	* gtk/gtkrc.[ch]: 
+
+	* gtk/gtkrc.h (struct _GtkRcStyleClass): Add a
+	GtkSettings parameter to GtkRcStyle::parse.
+
+	* gdk/x11/gdkevents-x11.c gtk/gtksettings.c gtk/gtkrc.c: 
+	Add two new settings gtk-theme-name, gtk-key-theme-name,
+	for RC files that are loaded by name after reading
+	the default RC files.
+	
+	* gtk/gtkrc.c: Allow priorities for styles, as wll as
+	bindings.
+
+	* gtk/gtkenums.h gtk/gtkrc.c: Add GTK_PATH_PRIO_THEME,
+	and use it by default for RC files loaded via 
+	gtk-theme-name, gtk-key-theme-name.
+
+	* gtk/gtkiconfactory.c (gtk_icon_source_set_filename)
+        gtk/gtkrc.c (gtk_rc_parse_pixmap_path_string) 
+	tests/testgtkrc: Require pathnames to be absolute.
+
+	* gtk/gtkrc.c gtk/gtkiconfactory.c: Look up the full filename for
+	the source when parsing, since the operation of looking up a
+	pixmap from an RC file depends on the parsing context.
+
+	* gtk/gtkrc.c (gtk_rc_context_reparse_all): Automatically
+	reset RC styles on all widgets when files are reparsed.
+
+	* tests/testgtk.c (create_rc_file) 
+	  gtk/gtkwindow.c (gtk_window_read_rcfiles): 
+	Simplify, now that gtk_rc_reparse_all() resets styles on
+	all widgets itself.
+
+	* gtk/gtkmain.c (gtk_get_default_language): Fix broken
+	return value.
+
+	* gtk/gtksettings.[ch] (gtk_settings_install_property[_ch]): Remove
+	GtkSettings argument.
+
+	* gtk/gtksettings.[ch] (gtk_settings_get_default): Rename from
+	gtk_settings_get_global().
+
+	* gtk/gtkwidget.[ch]: Add a function gtk_widget_Get_settings()
+	to get the appropriate GtkSettings for a widget. (For now,
+	just gets the default GtkSetttings.) 
+
+	* gtk/gtkcolorsel.c gtk/gtkentry.c gtk/gtkmenu.c gtk/gtkmenubar.c
+	  gtk/gtktextview.c gtk/gtktoolbar.c: Fixes for GtkSettings
+        changes.
+
+	* gtk/gtkrc.[ch]: Add gtk_rc_get_style_by_paths() to allow
+	getting a style for a path without actually having a widget.
+	(Allows using a style for a subpart of a widget, for
+	example.)
+
+	* gtk/gtkrc.[ch]: Add gtk_rc_reparse_all_for_setting() to allow forcing
+	the RC files to be reloaded for just one GtkSettings
+	(not sure how useful this really is.)
+
+	* gtk/gtkrc.h: Deprecate
+	gtk_rc_add_widget_name/widget_class/class_style
+
 2001-06-30  Alex Larsson  <alexl@redhat.com>
 
 	* gdk/linux-fb/gdkinput-none.c:
diff --git a/docs/Changes-2.0.txt b/docs/Changes-2.0.txt
index 4c6a49b124..38fa740852 100644
--- a/docs/Changes-2.0.txt
+++ b/docs/Changes-2.0.txt
@@ -367,6 +367,11 @@ Incompatible Changes from GTK+-1.2 to GTK+-2.0:
 * gtk_rc_set_image_loader() and gtk_rc_load_image() has been removed, now 
   that GTK+ includes decent image loading capabilities itself.
 
+* An extra GtkSettings argument has been added to
+  gtk_rc_find_pixmap_in_path(). This function is only actually useful
+  from a theme engine during parsing, at which point the GtkSettings
+  is provided.
+
 * The child argument facility in gtkcontainer.c has been converted
   to a child property facility using GParamSpec and other facilities
   for GObject.   
diff --git a/docs/reference/gtk/tmpl/gtkenums.sgml b/docs/reference/gtk/tmpl/gtkenums.sgml
index 0b086b36c0..3c1b296a37 100644
--- a/docs/reference/gtk/tmpl/gtkenums.sgml
+++ b/docs/reference/gtk/tmpl/gtkenums.sgml
@@ -182,6 +182,7 @@ Represents the packing location #GtkBox children. (See: #GtkVBox,
 @GTK_PATH_PRIO_LOWEST: 
 @GTK_PATH_PRIO_GTK: 
 @GTK_PATH_PRIO_APPLICATION: 
+@GTK_PATH_PRIO_THEME: 
 @GTK_PATH_PRIO_RC: 
 @GTK_PATH_PRIO_HIGHEST: 
 @GTK_PATH_PRIO_MASK: 
diff --git a/docs/reference/gtk/tmpl/gtkrc.sgml b/docs/reference/gtk/tmpl/gtkrc.sgml
index 5f8876c8fe..30ffca8235 100644
--- a/docs/reference/gtk/tmpl/gtkrc.sgml
+++ b/docs/reference/gtk/tmpl/gtkrc.sgml
@@ -589,6 +589,7 @@ specific portions of a RC file.
 @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: 
@@ -610,19 +611,10 @@ specific portions of a RC file.
 
 <!-- ##### FUNCTION gtk_rc_get_style ##### -->
 <para>
-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.)
 </para>
 
-@widget: a #GtkWidget
-@Returns: the resulting style. The caller should
-reference the result, since GTK+ will retain the
-initial reference count itself for the cache
-of created styles.
+@widget: 
+@Returns: 
 
 
 <!-- ##### FUNCTION gtk_rc_add_widget_name_style ##### -->
@@ -686,42 +678,30 @@ Parse resource information directly from a string.
 
 <!-- ##### FUNCTION gtk_rc_reparse_all ##### -->
 <para>
-If the modification time on any previously read file
-has changed, discard all style information
-and then reread all previously read RC files.
 </para>
 
-@Returns: %TRUE if the files were reread.
+@Returns: 
 
 
 <!-- ##### FUNCTION gtk_rc_add_default_file ##### -->
 <para>
-Adds a file to the list of files to be parsed at the
-end of gtk_init().
 </para>
 
-@filename: the pathname to the file.
+@filename: 
 
 
 <!-- ##### FUNCTION gtk_rc_get_default_files ##### -->
 <para>
-Retrieves the current list of RC files that will be parsed
-at the end of gtk_init()
 </para>
 
-@Returns: 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.
+@Returns: 
 
 
 <!-- ##### FUNCTION gtk_rc_set_default_files ##### -->
 <para>
-Sets the list of files that GTK+ will read at the
-end of gtk_init()
 </para>
 
-@filenames: A %NULL terminated list of filenames.
+@filenames: 
 
 
 <!-- ##### FUNCTION gtk_rc_parse_color ##### -->
@@ -773,11 +753,9 @@ otherwise %NULL.
 
 <!-- ##### FUNCTION gtk_rc_find_pixmap_in_path ##### -->
 <para>
-Looks up a file in the current pixmap path. If the file is
-not found, it outputs a warning message using g_warning()
-and returns %NULL.
 </para>
 
+@context: 
 @scanner: a #GtkScanner. Used for printing out warning messages
 if the file is not found.
 @pixmap_file: The name of the file to search for.
diff --git a/gdk/x11/gdkevents-x11.c b/gdk/x11/gdkevents-x11.c
index 8352527729..a2c7740b71 100644
--- a/gdk/x11/gdkevents-x11.c
+++ b/gdk/x11/gdkevents-x11.c
@@ -2027,7 +2027,9 @@ static struct
   { "Gtk/ToolbarStyle", "gtk-toolbar-style" },
   { "Gtk/ToolbarIconSize", "gtk-toolbar-icon-size" },
   { "Net/CursorBlink", "gtk-cursor-blink" },
-  { "Net/CursorBlinkTime", "gtk-cursor-blink-time" }
+  { "Net/CursorBlinkTime", "gtk-cursor-blink-time" },
+  { "Net/ThemeName", "gtk-theme-name" },
+  { "Gtk/KeyThemeName", "gtk-key-theme-name" }
 };
 
 static void
diff --git a/gtk/gtkcolorsel.c b/gtk/gtkcolorsel.c
index ba204ec040..26a531d3af 100644
--- a/gtk/gtkcolorsel.c
+++ b/gtk/gtkcolorsel.c
@@ -1586,7 +1586,7 @@ default_change_palette_func (const GdkColor *colors,
   
   str = gtk_color_selection_palette_to_string (colors, n_colors);
 
-  gtk_settings_set_string_property (gtk_settings_get_global (),
+  gtk_settings_set_string_property (gtk_settings_get_default (),
                                     "gtk-color-palette",
                                     str,
                                     "gtk_color_selection_palette_to_string");
@@ -1642,14 +1642,13 @@ gtk_color_selection_class_init (GtkColorSelectionClass *klass)
                     gtk_marshal_VOID__VOID,
                     GTK_TYPE_NONE, 0);
 
-  gtk_settings_install_property (gtk_settings_get_global (),
-                                 g_param_spec_string ("gtk-color-palette",
+  gtk_settings_install_property (g_param_spec_string ("gtk-color-palette",
                                                       _("Custom palette"),
                                                       _("Palette to use in the color selector"),
                                                       default_colors,
                                                       G_PARAM_READWRITE));
 
-  g_object_get (G_OBJECT (gtk_settings_get_global ()),
+  g_object_get (G_OBJECT (gtk_settings_get_default ()),
                 "gtk-color-palette",
                 &palette,
                 NULL);
@@ -1659,7 +1658,7 @@ gtk_color_selection_class_init (GtkColorSelectionClass *klass)
 
   change_palette_hook = default_change_palette_func;
   
-  g_signal_connect_data (G_OBJECT (gtk_settings_get_global ()),
+  g_signal_connect_data (G_OBJECT (gtk_settings_get_default ()),
                          "notify::gtk-color-palette",
                          G_CALLBACK (palette_change_notify_class),
                          NULL, NULL, 0);
@@ -1825,7 +1824,7 @@ gtk_color_selection_init (GtkColorSelection *colorsel)
   update_palette (colorsel);
 
   priv->settings_connection = 
-    g_signal_connect_data (G_OBJECT (gtk_settings_get_global ()),
+    g_signal_connect_data (G_OBJECT (gtk_settings_get_default ()),
                            "notify::gtk-color-palette",
                            G_CALLBACK (palette_change_notify_instance),
                            colorsel, NULL, 0);
@@ -1877,7 +1876,7 @@ gtk_color_selection_finalize (GObject *object)
 
       priv = cselection->private_data;
 
-      g_signal_handler_disconnect (gtk_settings_get_global (),
+      g_signal_handler_disconnect (gtk_settings_get_default (),
                                    priv->settings_connection);
       
       g_free (cselection->private_data);
diff --git a/gtk/gtkentry.c b/gtk/gtkentry.c
index 7a9dfab24d..9eb7fc1280 100644
--- a/gtk/gtkentry.c
+++ b/gtk/gtkentry.c
@@ -2467,7 +2467,7 @@ gtk_entry_draw_cursor (GtkEntry  *entry,
       
       gtk_entry_get_cursor_locations (entry, type, &strong_x, &weak_x);
 
-      g_object_get (gtk_settings_get_global (),
+      g_object_get (gtk_widget_get_settings (widget),
 		    "gtk-split-cursor", &split_cursor,
 		    NULL);
 
@@ -2694,7 +2694,7 @@ gtk_entry_move_visually (GtkEntry *entry,
       gboolean split_cursor;
       gboolean strong;
 
-      g_object_get (gtk_settings_get_global (),
+      g_object_get (gtk_widget_get_settings (GTK_WIDGET (entry)),
 		    "gtk-split-cursor", &split_cursor,
 		    NULL);
 
@@ -3749,7 +3749,7 @@ gtk_entry_drag_data_delete (GtkWidget      *widget,
 static gboolean
 cursor_blinks (GtkEntry *entry)
 {
-  GtkSettings *settings = gtk_settings_get_global ();
+  GtkSettings *settings = gtk_widget_get_settings (GTK_WIDGET (entry));
   gboolean blink;
 
   if (GTK_WIDGET_HAS_FOCUS (entry) &&
@@ -3765,7 +3765,7 @@ cursor_blinks (GtkEntry *entry)
 static gint
 get_cursor_time (GtkEntry *entry)
 {
-  GtkSettings *settings = gtk_settings_get_global ();
+  GtkSettings *settings = gtk_widget_get_settings (GTK_WIDGET (entry));
   gint time;
 
   g_object_get (G_OBJECT (settings), "gtk-cursor-blink-time", &time, NULL);
diff --git a/gtk/gtkenums.h b/gtk/gtkenums.h
index 0f3545dc7b..71884c83b3 100644
--- a/gtk/gtkenums.h
+++ b/gtk/gtkenums.h
@@ -221,6 +221,7 @@ typedef enum
   GTK_PATH_PRIO_LOWEST      = 0,
   GTK_PATH_PRIO_GTK	    = 4,
   GTK_PATH_PRIO_APPLICATION = 8,
+  GTK_PATH_PRIO_THEME       = 10,
   GTK_PATH_PRIO_RC          = 12,
   GTK_PATH_PRIO_HIGHEST     = 15,
   GTK_PATH_PRIO_MASK        = 0x0f
diff --git a/gtk/gtkiconfactory.c b/gtk/gtkiconfactory.c
index 64c57b33b5..a6b742669e 100644
--- a/gtk/gtkiconfactory.c
+++ b/gtk/gtkiconfactory.c
@@ -1038,20 +1038,10 @@ find_and_prep_icon_source (GtkIconSet       *icon_set,
   if (source->pixbuf == NULL)
     {
       GError *error;
-      gchar *full;
       
       g_assert (source->filename);
+      source->pixbuf = gdk_pixbuf_new_from_file (source->filename, &error);
 
-      if (g_path_is_absolute (source->filename))
-        full = g_strdup (source->filename);
-      else
-        full = gtk_rc_find_pixmap_in_path (NULL, source->filename);
-
-      error = NULL;
-      source->pixbuf = gdk_pixbuf_new_from_file (full, &error);
-
-      g_free (full);
-      
       if (source->pixbuf == NULL)
         {
           /* Remove this icon source so we don't keep trying to
@@ -1435,19 +1425,15 @@ gtk_icon_source_free (GtkIconSource *source)
  * @source: a #GtkIconSource
  * @filename: image file to use
  *
- * Sets the name of an image file to use as a base image when creating icon
- * variants for #GtkIconSet. If the filename is absolute, GTK+ will
- * attempt to open the exact file given. If the filename is relative,
- * GTK+ will search for it in the "pixmap path" which can be configured
- * by users in their gtkrc files or specified as part of a theme's gtkrc
- * file. See #GtkRcStyle for information on gtkrc files.
- * 
+ * Sets the name of an image file to use as a base image when creating
+ * icon variants for #GtkIconSet. The filename must be absolute. 
  **/
 void
-gtk_icon_source_set_filename             (GtkIconSource *source,
-                                          const gchar   *filename)
+gtk_icon_source_set_filename (GtkIconSource *source,
+			      const gchar   *filename)
 {
   g_return_if_fail (source != NULL);
+  g_return_if_fail (filename == NULL || g_path_is_absolute (filename));
 
   if (source->filename == filename)
     return;
diff --git a/gtk/gtkmenu.c b/gtk/gtkmenu.c
index eb085fbbb8..b0c7eff112 100644
--- a/gtk/gtkmenu.c
+++ b/gtk/gtkmenu.c
@@ -1443,7 +1443,7 @@ gtk_menu_key_press (GtkWidget	*widget,
   if (GTK_WIDGET_CLASS (parent_class)->key_press_event (widget, event))
     return TRUE;
     
-  g_object_get (G_OBJECT (gtk_settings_get_global ()),
+  g_object_get (G_OBJECT (gtk_settings_get_default ()),
                 "gtk-menu-bar-accel",
                 &accel,
                 NULL);
diff --git a/gtk/gtkmenubar.c b/gtk/gtkmenubar.c
index f266340176..e5b20b8560 100644
--- a/gtk/gtkmenubar.c
+++ b/gtk/gtkmenubar.c
@@ -142,8 +142,7 @@ gtk_menu_bar_class_init (GtkMenuBarClass *class)
 				GTK_TYPE_MENU_DIRECTION_TYPE,
 				GTK_MENU_DIR_CHILD);
   
-  gtk_settings_install_property (gtk_settings_get_global (),
-                                 g_param_spec_string ("gtk-menu-bar-accel",
+  gtk_settings_install_property (g_param_spec_string ("gtk-menu-bar-accel",
                                                       _("Menu bar accelerator"),
                                                       _("Keybinding to activate the menu bar"),
                                                       "F10",
@@ -395,7 +394,7 @@ window_key_press_handler (GtkWidget   *widget,
   gchar *accel = NULL;
   gboolean retval = FALSE;
   
-  g_object_get (G_OBJECT (gtk_settings_get_global ()),
+  g_object_get (G_OBJECT (gtk_widget_get_settings (widget)),
                 "gtk-menu-bar-accel",
                 &accel,
                 NULL);
diff --git a/gtk/gtkrc.c b/gtk/gtkrc.c
index 4766fa56e1..b454d2051c 100644
--- a/gtk/gtkrc.c
+++ b/gtk/gtkrc.c
@@ -54,6 +54,7 @@
 #include "gtkintl.h"
 #include "gtkiconfactory.h"
 #include "gtksettings.h"
+#include "gtkwindow.h"
 
 #ifdef G_OS_WIN32
 #include <io.h>
@@ -66,7 +67,8 @@ typedef struct _GtkRcFile   GtkRcFile;
 struct _GtkRcSet
 {
   GPatternSpec *pspec;
-  GtkRcStyle   *rc_style;
+  GtkRcStyle *rc_style;
+  gint priority;
 };
 
 struct _GtkRcFile
@@ -74,16 +76,40 @@ struct _GtkRcFile
   time_t mtime;
   gchar *name;
   gchar *canonical_name;
-  gboolean reload;
+  guint reload;
 };
 
+#define GTK_RC_MAX_PIXMAP_PATHS 128
+
+struct _GtkRcContext
+{
+  GHashTable *rc_style_ht;
+  GtkSettings *settings;
+  GSList *rc_sets_widget;
+  GSList *rc_sets_widget_class;
+  GSList *rc_sets_class;
+
+  /* The files we have parsed, to reread later if necessary */
+  GSList *rc_files;
+
+  gchar *theme_name;
+  gchar *key_theme_name;
+  
+  gchar *pixmap_path[GTK_RC_MAX_PIXMAP_PATHS];
+
+  gint default_priority;
+};
+
+static GtkRcContext *gtk_rc_context_get              (GtkSettings     *settings);
+
 static guint       gtk_rc_style_hash                 (const gchar     *name);
 static gboolean    gtk_rc_style_equal                (const gchar     *a,
                                                       const gchar     *b);
 static guint       gtk_rc_styles_hash                (const GSList    *rc_styles);
 static gboolean    gtk_rc_styles_equal               (const GSList    *a,
                                                       const GSList    *b);
-static GtkRcStyle* gtk_rc_style_find                 (const gchar     *name);
+static GtkRcStyle* gtk_rc_style_find                 (GtkRcContext    *context,
+						      const gchar     *name);
 static GSList *    gtk_rc_styles_match               (GSList          *rc_styles,
                                                       GSList          *sets,
                                                       guint            path_length,
@@ -91,13 +117,22 @@ static GSList *    gtk_rc_styles_match               (GSList          *rc_styles
                                                       const gchar     *path_reversed);
 static GtkStyle *  gtk_rc_style_to_style             (GtkRcStyle      *rc_style);
 static GtkStyle*   gtk_rc_init_style                 (GSList          *rc_styles);
-static void        gtk_rc_parse_file                 (const gchar     *filename,
+static void        gtk_rc_parse_default_files        (GtkRcContext    *context);
+static void        gtk_rc_parse_named                (GtkRcContext    *context,
+						      const gchar     *name,
+						      const gchar     *type);
+static void        gtk_rc_parse_file                 (GtkRcContext    *context,
+						      const gchar     *filename,
+						      gint             priority,
                                                       gboolean         reload);
-static void        gtk_rc_parse_any                  (const gchar     *input_name,
+static void        gtk_rc_parse_any                  (GtkRcContext    *context,
+						      const gchar     *input_name,
                                                       gint             input_fd,
                                                       const gchar     *input_string);
-static guint       gtk_rc_parse_statement            (GScanner        *scanner);
-static guint       gtk_rc_parse_style                (GScanner        *scanner);
+static guint       gtk_rc_parse_statement            (GtkRcContext    *context,
+						      GScanner        *scanner);
+static guint       gtk_rc_parse_style                (GtkRcContext    *context,
+						      GScanner        *scanner);
 static guint       gtk_rc_parse_assignment           (GScanner        *scanner,
 						      GtkRcProperty   *prop);
 static guint       gtk_rc_parse_bg                   (GScanner        *scanner,
@@ -112,7 +147,8 @@ static guint       gtk_rc_parse_xthickness           (GScanner        *scanner,
                                                       GtkRcStyle      *style);
 static guint       gtk_rc_parse_ythickness           (GScanner        *scanner,
                                                       GtkRcStyle      *style);
-static guint       gtk_rc_parse_bg_pixmap            (GScanner        *scanner,
+static guint       gtk_rc_parse_bg_pixmap            (GtkRcContext    *context,
+						      GScanner        *scanner,
                                                       GtkRcStyle      *rc_style);
 static guint       gtk_rc_parse_font                 (GScanner        *scanner,
                                                       GtkRcStyle      *rc_style);
@@ -120,22 +156,28 @@ static guint       gtk_rc_parse_fontset              (GScanner        *scanner,
                                                       GtkRcStyle      *rc_style);
 static guint       gtk_rc_parse_font_name            (GScanner        *scanner,
                                                       GtkRcStyle      *rc_style);
-static guint       gtk_rc_parse_engine               (GScanner        *scanner,
+static guint       gtk_rc_parse_engine               (GtkRcContext    *context,
+						      GScanner        *scanner,
                                                       GtkRcStyle     **rc_style);
-static guint       gtk_rc_parse_pixmap_path          (GScanner        *scanner);
-static void        gtk_rc_parse_pixmap_path_string   (gchar           *pix_path);
+static guint       gtk_rc_parse_pixmap_path          (GtkRcContext    *context,
+						      GScanner        *scanner);
+static void        gtk_rc_parse_pixmap_path_string   (GtkRcContext    *context,
+						      GScanner        *scanner,
+						      const gchar     *pix_path);
 static guint       gtk_rc_parse_module_path          (GScanner        *scanner);
-static void        gtk_rc_parse_module_path_string   (gchar           *mod_path);
+static void        gtk_rc_parse_module_path_string   (const gchar     *mod_path);
 static guint       gtk_rc_parse_im_module_path       (GScanner        *scanner);
 static guint       gtk_rc_parse_im_module_file       (GScanner        *scanner);
-static guint       gtk_rc_parse_path_pattern         (GScanner        *scanner);
-static guint       gtk_rc_parse_stock                (GScanner        *scanner,
+static guint       gtk_rc_parse_path_pattern         (GtkRcContext    *context,
+						      GScanner        *scanner);
+static guint       gtk_rc_parse_stock                (GtkRcContext    *context,
+						      GScanner        *scanner,
                                                       GtkRcStyle      *rc_style,
                                                       GtkIconFactory  *factory);
 static void        gtk_rc_clear_hash_node            (gpointer         key,
                                                       gpointer         data,
                                                       gpointer         user_data);
-static void        gtk_rc_clear_styles               (void);
+static void        gtk_rc_clear_styles               (GtkRcContext    *context);
 static void        gtk_rc_append_default_module_path (void);
 static void        gtk_rc_add_initial_default_files  (void);
 
@@ -223,6 +265,7 @@ static const struct
   { "lowest", GTK_RC_TOKEN_LOWEST },
   { "gtk", GTK_RC_TOKEN_GTK },
   { "application", GTK_RC_TOKEN_APPLICATION },
+  { "theme", GTK_RC_TOKEN_THEME },
   { "rc", GTK_RC_TOKEN_RC },
   { "highest", GTK_RC_TOKEN_HIGHEST },
   { "engine", GTK_RC_TOKEN_ENGINE },
@@ -234,22 +277,14 @@ static const struct
   { "RTL", GTK_RC_TOKEN_RTL }
 };
 
-static const guint n_symbols = sizeof (symbols) / sizeof (symbols[0]);
+static GHashTable *realized_style_ht = NULL;
 
 static gchar *im_module_path = NULL;
 static gchar *im_module_file = NULL;
 
-static GHashTable *rc_style_ht = NULL;
-static GHashTable *realized_style_ht = NULL;
-static GSList *gtk_rc_sets_widget = NULL;
-static GSList *gtk_rc_sets_widget_class = NULL;
-static GSList *gtk_rc_sets_class = NULL;
-
 #define GTK_RC_MAX_DEFAULT_FILES 128
 static gchar *gtk_rc_default_files[GTK_RC_MAX_DEFAULT_FILES];
 
-#define GTK_RC_MAX_PIXMAP_PATHS 128
-static gchar *pixmap_path[GTK_RC_MAX_PIXMAP_PATHS];
 #define GTK_RC_MAX_MODULE_PATHS 128
 static gchar *module_path[GTK_RC_MAX_MODULE_PATHS];
 
@@ -258,12 +293,8 @@ static gchar *module_path[GTK_RC_MAX_MODULE_PATHS];
  */
 static GSList *rc_dir_stack = NULL;
 
-/* The files we have parsed, to reread later if necessary */
-static GSList *rc_files = NULL;
-
 /* RC file handling */
 
-
 #ifdef G_OS_WIN32
 static gchar *
 get_gtk_dll_name (void)
@@ -459,6 +490,13 @@ gtk_rc_add_initial_default_files (void)
     }
 }
 
+/**
+ * gtk_rc_add_default_file:
+ * @file: the pathname to the file.
+ * 
+ * Adds a file to the list of files to be parsed at the
+ * end of gtk_init().
+ **/
 void
 gtk_rc_add_default_file (const gchar *file)
 {
@@ -474,6 +512,13 @@ gtk_rc_add_default_file (const gchar *file)
   gtk_rc_default_files[n] = NULL;
 }
 
+/**
+ * gtk_rc_set_default_files:
+ * @files: A %NULL terminated list of filenames.
+ * 
+ * Sets the list of files that GTK+ will read at the
+ * end of gtk_init()
+ **/
 void
 gtk_rc_set_default_files (gchar **files)
 {
@@ -498,6 +543,18 @@ gtk_rc_set_default_files (gchar **files)
     }
 }
 
+/**
+ * gtk_rc_get_default_files:
+ * @void: 
+ * 
+ * Retrieves the current list of RC files that will be parsed
+ * at the end of gtk_init()
+ * 
+ * Return value: 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.
+ **/
 gchar **
 gtk_rc_get_default_files (void)
 {
@@ -506,126 +563,238 @@ gtk_rc_get_default_files (void)
   return gtk_rc_default_files;
 }
 
- /* The following routine is based on _nl_normalize_codeset from
-  * the GNU C library. Contributed by
-  *
-  * Contributed by Ulrich Drepper <drepper@gnu.ai.mit.edu>, 1995.
-  * Copyright (C) 1995, 1996, 1997, 1998, 1999 Free Software Foundation, Inc.
-  * 
-  * Normalize codeset name.  There is no standard for the codeset
-  * names.  Normalization allows the user to use any of the common
-  * names.
-  */
- static gchar *
- _gtk_normalize_codeset (const gchar *codeset, gint name_len)
- {
-   gint len = 0;
-   gint only_digit = 1;
-   gchar *retval;
-   gchar *wp;
-   gint cnt;
- 
-   for (cnt = 0; cnt < name_len; ++cnt)
-     if (isalnum (codeset[cnt]))
-       {
- 	++len;
- 
- 	if (isalpha (codeset[cnt]))
- 	  only_digit = 0;
-       }
- 
-   retval = g_malloc ((only_digit ? 3 : 0) + len + 1);
- 
-   if (only_digit)
-     {
-       memcpy (retval, "iso", 4);
-       wp = retval + 3;
-     }
-   else
-     wp = retval;
-   
-   for (cnt = 0; cnt < name_len; ++cnt)
-     if (isalpha (codeset[cnt]))
-       *wp++ = isupper(codeset[cnt]) ? tolower (codeset[cnt]) : codeset[cnt];
-     else if (isdigit (codeset[cnt]))
-       *wp++ = codeset[cnt];
-   
-   *wp = '\0';
- 
-   return retval;
- }
- 
-void
-_gtk_rc_init (void)
+/* The following routine is based on _nl_normalize_codeset from
+ * the GNU C library. Contributed by
+ *
+ * Contributed by Ulrich Drepper <drepper@gnu.ai.mit.edu>, 1995.
+ * Copyright (C) 1995, 1996, 1997, 1998, 1999 Free Software Foundation, Inc.
+ * 
+ * Normalize codeset name.  There is no standard for the codeset
+ * names.  Normalization allows the user to use any of the common
+ * names.
+ */
+static gchar *
+_gtk_normalize_codeset (const gchar *codeset, gint name_len)
 {
-  static gboolean initialized = FALSE;
-  static gchar *locale_suffixes[3];
-  static gint n_locale_suffixes = 0;
-  gint i, j;
+  gint len = 0;
+  gint only_digit = 1;
+  gchar *retval;
+  gchar *wp;
+  gint cnt;
 
+  for (cnt = 0; cnt < name_len; ++cnt)
+    if (isalnum (codeset[cnt]))
+      {
+       ++len;
 
-  if (!initialized)
+       if (isalpha (codeset[cnt]))
+	 only_digit = 0;
+      }
+
+  retval = g_malloc ((only_digit ? 3 : 0) + len + 1);
+
+  if (only_digit)
+    {
+      memcpy (retval, "iso", 4);
+      wp = retval + 3;
+    }
+  else
+    wp = retval;
+
+  for (cnt = 0; cnt < name_len; ++cnt)
+    if (isalpha (codeset[cnt]))
+      *wp++ = isupper(codeset[cnt]) ? tolower (codeset[cnt]) : codeset[cnt];
+    else if (isdigit (codeset[cnt]))
+      *wp++ = codeset[cnt];
+
+  *wp = '\0';
+
+  return retval;
+}
+
+static void
+gtk_rc_settings_changed (GtkSettings  *settings,
+			 GParamSpec   *pspec,
+			 GtkRcContext *context)
+{
+  gchar *new_theme_name;
+  gchar *new_key_theme_name;
+
+  g_object_get (settings,
+		"gtk-theme-name", &new_theme_name,
+		"gtk-key-theme-name", &new_key_theme_name,
+		NULL);
+
+  if ((new_theme_name != context->theme_name && 
+       !(new_theme_name && context->theme_name && strcmp (new_theme_name, context->theme_name) == 0)) ||
+      (new_key_theme_name != context->key_theme_name &&
+       !(new_key_theme_name && context->key_theme_name && strcmp (new_key_theme_name, context->key_theme_name) == 0)))
+    {
+      gtk_rc_reparse_all_for_settings (settings, TRUE);
+    }
+
+  g_free (new_theme_name);
+  g_free (new_key_theme_name);
+}
+
+static GtkRcContext *
+gtk_rc_context_get (GtkSettings *settings)
+{
+  if (!settings->rc_context)
+    {
+      GtkRcContext *context = settings->rc_context = g_new (GtkRcContext, 1);
+
+      context->settings = settings;
+      context->rc_style_ht = NULL;
+      context->rc_sets_widget = NULL;
+      context->rc_sets_widget_class = NULL;
+      context->rc_sets_class = NULL;
+      context->rc_files = NULL;
+
+      g_object_get (settings,
+		    "gtk-theme-name", &context->theme_name,
+		    "gtk-key-theme-name", &context->key_theme_name,
+		    NULL);
+
+      g_signal_connect (settings,
+			"notify::gtk-theme-name",
+			G_CALLBACK (gtk_rc_settings_changed),
+			context);
+      g_signal_connect (settings,
+			"notify::gtk-key-theme-name",
+			G_CALLBACK (gtk_rc_settings_changed),
+			context);
+      
+      context->pixmap_path[0] = NULL;
+
+      context->default_priority = GTK_PATH_PRIO_RC;
+    }
+
+  return settings->rc_context;
+}
+
+static void
+gtk_rc_parse_named (GtkRcContext *context,
+		    const gchar  *name,
+		    const gchar  *type)
+{
+  gchar *path = NULL;
+  gchar *home_dir;
+  gchar *subpath;
+
+  if (type)
+    subpath = g_strconcat (G_DIR_SEPARATOR_S "gtk-2.0-",
+			   type,
+			   G_DIR_SEPARATOR_S "gtkrc",
+			   NULL);
+  else
+    subpath = g_strdup (G_DIR_SEPARATOR_S "gtk-2.0" G_DIR_SEPARATOR_S "gtkrc");
+  
+  /* First look in the users home directory
+   */
+  home_dir = g_get_home_dir ();
+  if (home_dir)
+    {
+      gchar *sep;
+      /* Don't duplicate the directory separator, causes trouble at
+       * least on Windows.
+       */
+      if (home_dir[strlen (home_dir) -1] != G_DIR_SEPARATOR)
+	sep = G_DIR_SEPARATOR_S;
+      else
+	sep = "";
+      path = g_strconcat (home_dir, sep,
+			  ".themes" G_DIR_SEPARATOR_S ,
+			  name,
+			  subpath,
+			  NULL);
+
+      if (!g_file_test (path, G_FILE_TEST_EXISTS))
+	{
+	  g_free (path);
+	  path = NULL;
+	}
+    }
+
+  if (!name)
+    {
+      gchar *theme_dir = gtk_rc_get_theme_dir ();
+      gchar *path = g_strconcat (theme_dir, G_DIR_SEPARATOR_S, name, subpath);
+      g_free (theme_dir);
+      
+      if (!g_file_test (path, G_FILE_TEST_EXISTS))
+	{
+	  g_free (path);
+	  path = NULL;
+	}
+    }
+
+  if (path)
     {
-      gint length;
-      gchar *locale;
-      gchar *p;
+      gtk_rc_parse_file (context, path, GTK_PATH_PRIO_THEME, FALSE);
+      g_free (path);
+    }
+
+  g_free (subpath);
+}
+
+static void
+gtk_rc_parse_default_files (GtkRcContext *context)
+{
+  gchar *locale_suffixes[3];
+  gint n_locale_suffixes = 0;
+  gint i, j;
+  gint length;
+  gchar *locale;
+  gchar *p;
 
 #ifdef G_OS_WIN32      
-      locale = g_win32_getlocale ();
+  locale = g_win32_getlocale ();
 #else      
-      locale = setlocale (LC_CTYPE, NULL);
+  locale = setlocale (LC_CTYPE, NULL);
 #endif      
-      initialized = TRUE;
 
-      pixmap_path[0] = NULL;
-      module_path[0] = NULL;
-      gtk_rc_append_default_module_path();
+  if (strcmp (locale, "C") && strcmp (locale, "POSIX"))
+    {
+      /* Determine locale-specific suffixes for RC files
+       *
+       * We normalize the charset into a standard form,
+       * which has all '-' and '_' characters removed,
+       * and is lowercase.
+       */
+      gchar *normalized_locale;
       
-      gtk_rc_add_initial_default_files ();
-
-      if (strcmp (locale, "C") && strcmp (locale, "POSIX"))
+      p = strchr (locale, '@');
+      length = p ? (p -locale) : strlen (locale);
+      
+      p = strchr (locale, '.');
+      if (p)
 	{
-	  /* Determine locale-specific suffixes for RC files
-	   *
-	   * We normalize the charset into a standard form,
-	   * which has all '-' and '_' characters removed,
-	   * and is lowercase.
-	   */
-	  gchar *normalized_locale;
-
-	  p = strchr (locale, '@');
-	  length = p ? (p -locale) : strlen (locale);
-
-	  p = strchr (locale, '.');
-	  if (p)
-	    {
-	      gchar *tmp1 = g_strndup (locale, p - locale + 1);
-	      gchar *tmp2 = _gtk_normalize_codeset (p + 1, length - (p - locale + 1));
-	      
-	      normalized_locale = g_strconcat (tmp1, tmp2, NULL);
-	      g_free (tmp1);
-	      g_free (tmp2);
-						 
-	      locale_suffixes[n_locale_suffixes++] = g_strdup (normalized_locale);
-	      length = p - locale;
-	    }
-	  else
-	    normalized_locale = g_strndup (locale, length);
+	  gchar *tmp1 = g_strndup (locale, p - locale + 1);
+	  gchar *tmp2 = _gtk_normalize_codeset (p + 1, length - (p - locale + 1));
 	  
-	  p = strchr (normalized_locale, '_');
-	  if (p)
-	    {
-	      locale_suffixes[n_locale_suffixes++] = g_strndup (normalized_locale, length);
-	      length = p - normalized_locale;
-	    }
+	  normalized_locale = g_strconcat (tmp1, tmp2, NULL);
+	  g_free (tmp1);
+	  g_free (tmp2);
 	  
+	  locale_suffixes[n_locale_suffixes++] = g_strdup (normalized_locale);
+	  length = p - locale;
+	}
+      else
+	normalized_locale = g_strndup (locale, length);
+      
+      p = strchr (normalized_locale, '_');
+      if (p)
+	{
 	  locale_suffixes[n_locale_suffixes++] = g_strndup (normalized_locale, length);
-
-	  g_free (normalized_locale);
+	  length = p - normalized_locale;
 	}
+      
+      locale_suffixes[n_locale_suffixes++] = g_strndup (normalized_locale, length);
+      
+      g_free (normalized_locale);
     }
   
-  g_object_freeze_notify (G_OBJECT (gtk_settings_get_global ()));
   for (i = 0; gtk_rc_default_files[i] != NULL; i++)
     {
       /* Try to find a locale specific RC file corresponding to the
@@ -637,32 +806,60 @@ _gtk_rc_init (void)
 				     ".",
 				     locale_suffixes[j],
 				     NULL);
-	  gtk_rc_parse (name);
+	  gtk_rc_parse_file (context, name, GTK_PATH_PRIO_RC, FALSE);
 	  g_free (name);
 	}
-      gtk_rc_parse (gtk_rc_default_files[i]);
+      gtk_rc_parse_file (context, gtk_rc_default_files[i], GTK_PATH_PRIO_RC, FALSE);
     }
-  g_object_thaw_notify (G_OBJECT (gtk_settings_get_global ()));
+
+  for (j = 0; j < n_locale_suffixes; j++)
+    g_free (locale_suffixes[j]);
 }
 
 void
+_gtk_rc_init (void)
+{
+  static gboolean initialized = FALSE;
+
+  if (!initialized)
+    {
+      initialized = TRUE;
+      
+      module_path[0] = NULL;
+      gtk_rc_append_default_module_path();
+      
+      gtk_rc_add_initial_default_files ();
+    }
+  
+  gtk_rc_reparse_all_for_settings (gtk_settings_get_default (), TRUE);
+}
+  
+void
 gtk_rc_parse_string (const gchar *rc_string)
 {
   g_return_if_fail (rc_string != NULL);
 
-  gtk_rc_parse_any ("-", -1, rc_string);
+  gtk_rc_parse_any (gtk_rc_context_get (gtk_settings_get_default ()),
+		    "-", -1, rc_string);	/* FIXME */
 }
 
 static void
-gtk_rc_parse_file (const gchar *filename, gboolean reload)
+gtk_rc_parse_file (GtkRcContext *context,
+		   const gchar  *filename,
+		   gint          priority,
+		   gboolean      reload)
 {
   GtkRcFile *rc_file = NULL;
   struct stat statbuf;
   GSList *tmp_list;
+  gint saved_priority;
 
   g_return_if_fail (filename != NULL);
 
-  tmp_list = rc_files;
+  saved_priority = context->default_priority;
+  context->default_priority = priority;
+  
+  tmp_list = context->rc_files;
   while (tmp_list)
     {
       rc_file = tmp_list->data;
@@ -680,7 +877,7 @@ gtk_rc_parse_file (const gchar *filename, gboolean reload)
       rc_file->mtime = 0;
       rc_file->reload = reload;
 
-      rc_files = g_slist_append (rc_files, rc_file);
+      context->rc_files = g_slist_append (context->rc_files, rc_file);
     }
 
   if (!rc_file->canonical_name)
@@ -715,7 +912,7 @@ gtk_rc_parse_file (const gchar *filename, gboolean reload)
 
       fd = open (rc_file->canonical_name, O_RDONLY);
       if (fd < 0)
-	return;
+	goto out;
 
       /* Temporarily push directory name for this file on
        * a stack of directory names while parsing it
@@ -723,7 +920,7 @@ gtk_rc_parse_file (const gchar *filename, gboolean reload)
       rc_dir_stack = 
 	g_slist_prepend (rc_dir_stack,
 			 g_path_get_dirname (rc_file->canonical_name));
-      gtk_rc_parse_any (filename, fd, NULL);
+      gtk_rc_parse_any (context, filename, fd, NULL);
  
       tmp_list = rc_dir_stack;
       rc_dir_stack = rc_dir_stack->next;
@@ -733,6 +930,9 @@ gtk_rc_parse_file (const gchar *filename, gboolean reload)
 
       close (fd);
     }
+
+ out:
+  context->default_priority = saved_priority;
 }
 
 void
@@ -740,7 +940,8 @@ gtk_rc_parse (const gchar *filename)
 {
   g_return_if_fail (filename != NULL);
 
-  gtk_rc_parse_file (filename, TRUE);
+  gtk_rc_parse_file (gtk_rc_context_get (gtk_settings_get_default ()),
+		     filename, GTK_PATH_PRIO_RC, TRUE); /* FIXME */
 }
 
 /* Handling of RC styles */
@@ -1064,75 +1265,162 @@ gtk_rc_free_rc_sets (GSList *slist)
 }
 
 static void
-gtk_rc_clear_styles (void)
+gtk_rc_clear_styles (GtkRcContext *context)
 {
   /* Clear out all old rc_styles */
 
-  if (rc_style_ht)
+  if (context->rc_style_ht)
     {
-      g_hash_table_foreach (rc_style_ht, gtk_rc_clear_hash_node, NULL);
-      g_hash_table_destroy (rc_style_ht);
-      rc_style_ht = NULL;
+      g_hash_table_foreach (context->rc_style_ht, gtk_rc_clear_hash_node, NULL);
+      g_hash_table_destroy (context->rc_style_ht);
+      context->rc_style_ht = NULL;
     }
 
-  gtk_rc_free_rc_sets (gtk_rc_sets_widget);
-  g_slist_free (gtk_rc_sets_widget);
-  gtk_rc_sets_widget = NULL;
+  gtk_rc_free_rc_sets (context->rc_sets_widget);
+  g_slist_free (context->rc_sets_widget);
+  context->rc_sets_widget = NULL;
 
-  gtk_rc_free_rc_sets (gtk_rc_sets_widget_class);
-  g_slist_free (gtk_rc_sets_widget_class);
-  gtk_rc_sets_widget_class = NULL;
+  gtk_rc_free_rc_sets (context->rc_sets_widget_class);
+  g_slist_free (context->rc_sets_widget_class);
+  context->rc_sets_widget_class = NULL;
 
-  gtk_rc_free_rc_sets (gtk_rc_sets_class);
-  g_slist_free (gtk_rc_sets_class);
-  gtk_rc_sets_class = NULL;
+  gtk_rc_free_rc_sets (context->rc_sets_class);
+  g_slist_free (context->rc_sets_class);
+  context->rc_sets_class = NULL;
 }
 
+/* Reset all our widgets. Also, we have to invalidate cached icons in
+ * icon sets so they get re-rendered.
+ */
+static void
+gtk_rc_reset_widgets (GtkRcContext *context)
+{
+  GList *list, *toplevels;
+  
+  _gtk_icon_set_invalidate_caches ();
+  
+  toplevels = gtk_window_list_toplevels ();
+  g_list_foreach (toplevels, (GFunc)g_object_ref, NULL);
+  
+  for (list = toplevels; list; list = list->next)
+    {
+      gtk_widget_reset_rc_styles (list->data);
+      gtk_widget_unref (list->data);
+    }
+  g_list_free (toplevels);
+}
+
+/**
+ * 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.
+ **/
 gboolean
-gtk_rc_reparse_all (void)
+gtk_rc_reparse_all_for_settings (GtkSettings *settings,
+				 gboolean     force_load)
 {
-  GSList *tmp_list;
   gboolean mtime_modified = FALSE;
   GtkRcFile *rc_file;
+  GSList *tmp_list;
+  GtkRcContext *context;
 
   struct stat statbuf;
 
-  /* Check through and see if any of the RC's have had their
-   * mtime modified. If so, reparse everything.
-   */
-  tmp_list = rc_files;
-  while (tmp_list)
+  g_return_val_if_fail (GTK_IS_SETTINGS (settings), FALSE);
+
+  context = gtk_rc_context_get (settings);
+
+  if (!force_load)
     {
-      rc_file = tmp_list->data;
-      
-      if (!lstat (rc_file->name, &statbuf) && 
-	  (statbuf.st_mtime > rc_file->mtime))
+      /* Check through and see if any of the RC's have had their
+       * mtime modified. If so, reparse everything.
+       */
+      tmp_list = context->rc_files;
+      while (tmp_list)
 	{
-	  mtime_modified = TRUE;
-	  break;
+	  rc_file = tmp_list->data;
+	  
+	  if (!lstat (rc_file->name, &statbuf) && 
+	      (statbuf.st_mtime > rc_file->mtime))
+	    {
+	      mtime_modified = TRUE;
+	      break;
+	    }
+	  
+	  tmp_list = tmp_list->next;
 	}
-      
-      tmp_list = tmp_list->next;
     }
-
-  if (mtime_modified)
+      
+  if (force_load || mtime_modified)
     {
-      gtk_rc_clear_styles();
+      GSList *old_files;
+      
+      gtk_rc_clear_styles (context);
+      g_object_freeze_notify (G_OBJECT (context->settings));
+
+      old_files = context->rc_files;
+      context->rc_files = NULL;
+
+      gtk_rc_parse_default_files (context);
 
-      tmp_list = rc_files;
+      tmp_list = old_files;
       while (tmp_list)
 	{
 	  rc_file = tmp_list->data;
 	  if (rc_file->reload)
-	    gtk_rc_parse_file (rc_file->name, FALSE);
+	    gtk_rc_parse_file (context, rc_file->name, GTK_PATH_PRIO_RC, TRUE);
+
+	  if (rc_file->canonical_name != rc_file->name)
+	    g_free (rc_file->canonical_name);
+	  g_free (rc_file->name);
+	  g_free (rc_file);
 	  
 	  tmp_list = tmp_list->next;
 	}
+
+      g_slist_free (old_files);;
+
+      g_free (context->theme_name);
+      g_free (context->key_theme_name);
+      g_object_get (context->settings,
+		    "gtk-theme-name", &context->theme_name,
+		    "gtk-key-theme-name", &context->key_theme_name,
+		    NULL);
+
+      if (context->theme_name && context->theme_name[0])
+	gtk_rc_parse_named (context, context->theme_name, NULL);
+      if (context->key_theme_name && context->key_theme_name[0])
+	gtk_rc_parse_named (context, context->key_theme_name, "key");
+      
+      g_object_thaw_notify (G_OBJECT (context->settings));
+
+      gtk_rc_reset_widgets (context);
     }
 
   return mtime_modified;
 }
 
+/**
+ * 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.
+ **/
+gboolean
+gtk_rc_reparse_all (void)
+{
+  return gtk_rc_reparse_all_for_settings (gtk_settings_get_default (), FALSE);
+}
+
 static GSList *
 gtk_rc_styles_match (GSList       *rc_styles,
 		     GSList	  *sets,
@@ -1155,14 +1443,34 @@ gtk_rc_styles_match (GSList       *rc_styles,
   return rc_styles;
 }
 
+/**
+ * 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: 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.
+ **/
 GtkStyle *
 gtk_rc_get_style (GtkWidget *widget)
 {
   GtkRcStyle *widget_rc_style;
   GSList *rc_styles = NULL;
+  GtkRcContext *context;
 
   static guint rc_style_key_id = 0;
 
+  g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
+
+  context = gtk_rc_context_get (gtk_widget_get_settings (widget));
+
   /* We allow the specification of a single rc style to be bound
    * tightly to a widget, for application modifications
    */
@@ -1175,30 +1483,29 @@ gtk_rc_get_style (GtkWidget *widget)
   if (widget_rc_style)
     rc_styles = g_slist_prepend (rc_styles, widget_rc_style);
   
-  if (gtk_rc_sets_widget)
+  if (context->rc_sets_widget)
     {
       gchar *path, *path_reversed;
       guint path_length;
 
       gtk_widget_path (widget, &path_length, &path, &path_reversed);
-      rc_styles = gtk_rc_styles_match (rc_styles, gtk_rc_sets_widget, path_length, path, path_reversed);
+      rc_styles = gtk_rc_styles_match (rc_styles, context->rc_sets_widget, path_length, path, path_reversed);
       g_free (path);
       g_free (path_reversed);
-      
     }
   
-  if (gtk_rc_sets_widget_class)
+  if (context->rc_sets_widget_class)
     {
       gchar *path, *path_reversed;
       guint path_length;
 
       gtk_widget_class_path (widget, &path_length, &path, &path_reversed);
-      rc_styles = gtk_rc_styles_match (rc_styles, gtk_rc_sets_widget_class, path_length, path, path_reversed);
+      rc_styles = gtk_rc_styles_match (rc_styles, context->rc_sets_widget_class, path_length, path, path_reversed);
       g_free (path);
       g_free (path_reversed);
     }
 
-  if (gtk_rc_sets_class)
+  if (context->rc_sets_class)
     {
       GtkType type;
 
@@ -1214,7 +1521,7 @@ gtk_rc_get_style (GtkWidget *widget)
 	  path_reversed = g_strdup (path);
 	  g_strreverse (path_reversed);
 	  
-	  rc_styles = gtk_rc_styles_match (rc_styles, gtk_rc_sets_class, path_length, path, path_reversed);
+	  rc_styles = gtk_rc_styles_match (rc_styles, context->rc_sets_class, path_length, path, path_reversed);
 	  g_free (path_reversed);
       
 	  type = gtk_type_parent (type);
@@ -1227,6 +1534,102 @@ gtk_rc_get_style (GtkWidget *widget)
   return NULL;
 }
 
+/**
+ * gtk_rc_get_style_by_paths:
+ * @settings: a #GtkSettings object
+ * @widget_path: the widget path to use when looking up the style, or %NULL
+ * @class_path: the class path to use when looking up the style, or %NULL
+ * @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: A style created by matching with the supplied paths,
+ *   or %NULL if nothign 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.
+ **/
+GtkStyle *
+gtk_rc_get_style_by_paths (GtkSettings *settings,
+			   const char  *widget_path,
+			   const char  *class_path,
+			   GType        type)
+{
+  /* We duplicate the code from above to avoid slowing down the above
+   * by generating paths when we don't need them. I don't know if
+   * this is really worth it.
+   */
+  GSList *rc_styles = NULL;
+  GtkRcContext *context;
+
+  g_return_val_if_fail (GTK_IS_SETTINGS (settings), NULL);
+
+  context = gtk_rc_context_get (settings);
+
+  if (context->rc_sets_widget)
+    {
+      gchar *path_reversed;
+      guint path_length;
+
+      path_length = strlen (widget_path);
+      path_reversed = g_strdup (widget_path);
+      g_strreverse (path_reversed);
+
+      rc_styles = gtk_rc_styles_match (rc_styles, context->rc_sets_widget, path_length, widget_path, path_reversed);
+      g_free (path_reversed);
+    }
+  
+  if (context->rc_sets_widget_class)
+    {
+      gchar *path_reversed;
+      guint path_length;
+
+      path_length = strlen (class_path);
+      path_reversed = g_strdup (class_path);
+      g_strreverse (path_reversed);
+
+      rc_styles = gtk_rc_styles_match (rc_styles, context->rc_sets_widget_class, path_length, class_path, path_reversed);
+      g_free (path_reversed);
+    }
+
+  if (type != G_TYPE_NONE && context->rc_sets_class)
+    {
+      while (type)
+	{
+	  const gchar *path;
+          gchar *path_reversed;
+	  guint path_length;
+
+	  path = g_type_name (type);
+	  path_length = strlen (path);
+	  path_reversed = g_strdup (path);
+	  g_strreverse (path_reversed);
+	  
+	  rc_styles = gtk_rc_styles_match (rc_styles, context->rc_sets_class, path_length, path, path_reversed);
+	  g_free (path_reversed);
+      
+	  type = g_type_parent (type);
+	}
+    }
+  
+  if (rc_styles)
+    return gtk_rc_init_style (rc_styles);
+
+  return NULL;
+}
+
 static GSList *
 gtk_rc_add_rc_sets (GSList      *slist,
 		    GtkRcStyle  *rc_style,
@@ -1256,30 +1659,42 @@ void
 gtk_rc_add_widget_name_style (GtkRcStyle  *rc_style,
 			      const gchar *pattern)
 {
+  GtkRcContext *context;
+  
   g_return_if_fail (rc_style != NULL);
   g_return_if_fail (pattern != NULL);
 
-  gtk_rc_sets_widget = gtk_rc_add_rc_sets (gtk_rc_sets_widget, rc_style, pattern);
+  context = gtk_rc_context_get (gtk_settings_get_default ());
+  
+  context->rc_sets_widget = gtk_rc_add_rc_sets (context->rc_sets_widget, rc_style, pattern);
 }
 
 void
 gtk_rc_add_widget_class_style (GtkRcStyle  *rc_style,
 			       const gchar *pattern)
 {
+  GtkRcContext *context;
+  
   g_return_if_fail (rc_style != NULL);
   g_return_if_fail (pattern != NULL);
 
-  gtk_rc_sets_widget_class = gtk_rc_add_rc_sets (gtk_rc_sets_widget_class, rc_style, pattern);
+  context = gtk_rc_context_get (gtk_settings_get_default ());
+  
+  context->rc_sets_widget_class = gtk_rc_add_rc_sets (context->rc_sets_widget_class, rc_style, pattern);
 }
 
 void
 gtk_rc_add_class_style (GtkRcStyle  *rc_style,
 			const gchar *pattern)
 {
+  GtkRcContext *context;
+  
   g_return_if_fail (rc_style != NULL);
   g_return_if_fail (pattern != NULL);
 
-  gtk_rc_sets_class = gtk_rc_add_rc_sets (gtk_rc_sets_class, rc_style, pattern);
+  context = gtk_rc_context_get (gtk_settings_get_default ());
+  
+  context->rc_sets_class = gtk_rc_add_rc_sets (context->rc_sets_class, rc_style, pattern);
 }
 
 GScanner*
@@ -1289,7 +1704,8 @@ gtk_rc_scanner_new (void)
 }
 
 static void
-gtk_rc_parse_any (const gchar  *input_name,
+gtk_rc_parse_any (GtkRcContext *context,
+		  const gchar  *input_name,
 		  gint		input_fd,
 		  const gchar  *input_string)
 {
@@ -1313,7 +1729,7 @@ gtk_rc_parse_any (const gchar  *input_name,
     }
   scanner->input_name = input_name;
 
-  for (i = 0; i < n_symbols; i++)
+  for (i = 0; i < G_N_ELEMENTS (symbols); i++)
     g_scanner_add_symbol (scanner, symbols[i].name, GINT_TO_POINTER (symbols[i].token));
   
   done = FALSE;
@@ -1325,7 +1741,7 @@ gtk_rc_parse_any (const gchar  *input_name,
 	{
 	  guint expected_token;
 	  
-	  expected_token = gtk_rc_parse_statement (scanner);
+	  expected_token = gtk_rc_parse_statement (context, scanner);
 
 	  if (expected_token != G_TOKEN_NONE)
 	    {
@@ -1344,7 +1760,7 @@ gtk_rc_parse_any (const gchar  *input_name,
 		  if (expected_token > GTK_RC_TOKEN_INVALID &&
 		      expected_token < GTK_RC_TOKEN_LAST)
 		    {
-		      for (i = 0; i < n_symbols; i++)
+		      for (i = 0; i < G_N_ELEMENTS (symbols); i++)
 			if (symbols[i].token == expected_token)
 			  msg = symbols[i].name;
 		      if (msg)
@@ -1354,7 +1770,7 @@ gtk_rc_parse_any (const gchar  *input_name,
 		      scanner->token < GTK_RC_TOKEN_LAST)
 		    {
 		      symbol_name = "???";
-		      for (i = 0; i < n_symbols; i++)
+		      for (i = 0; i < G_N_ELEMENTS (symbols); i++)
 			if (symbols[i].token == scanner->token)
 			  symbol_name = symbols[i].name;
 		    }
@@ -1425,10 +1841,11 @@ gtk_rc_style_equal (const gchar *a,
 }
 
 static GtkRcStyle*
-gtk_rc_style_find (const gchar *name)
+gtk_rc_style_find (GtkRcContext *context,
+		   const gchar  *name)
 {
-  if (rc_style_ht)
-    return g_hash_table_lookup (rc_style_ht, (gpointer) name);
+  if (context->rc_style_ht)
+    return g_hash_table_lookup (context->rc_style_ht, (gpointer) name);
   else
     return NULL;
 }
@@ -1460,7 +1877,7 @@ gtk_rc_init_style (GSList *rc_styles)
   
   if (!realized_style_ht)
     realized_style_ht = g_hash_table_new ((GHashFunc) gtk_rc_styles_hash,
-					  (GEqualFunc) gtk_rc_styles_equal);
+ (GEqualFunc) gtk_rc_styles_equal);
 
   style = g_hash_table_lookup (realized_style_ht, rc_styles);
 
@@ -1734,7 +2151,8 @@ is_c_identifier (const gchar *string)
 }
 
 static guint
-gtk_rc_parse_statement (GScanner *scanner)
+gtk_rc_parse_statement (GtkRcContext *context,
+			GScanner     *scanner)
 {
   guint token;
   
@@ -1748,26 +2166,26 @@ gtk_rc_parse_statement (GScanner *scanner)
       token = g_scanner_get_next_token (scanner);
       if (token != G_TOKEN_STRING)
 	return G_TOKEN_STRING;
-      gtk_rc_parse_file (scanner->value.v_string, FALSE);
+      gtk_rc_parse_file (context, scanner->value.v_string, context->default_priority, FALSE);
       return G_TOKEN_NONE;
       
     case GTK_RC_TOKEN_STYLE:
-      return gtk_rc_parse_style (scanner);
+      return gtk_rc_parse_style (context, scanner);
       
     case GTK_RC_TOKEN_BINDING:
       return gtk_binding_parse_binding (scanner);
       
     case GTK_RC_TOKEN_PIXMAP_PATH:
-      return gtk_rc_parse_pixmap_path (scanner);
+      return gtk_rc_parse_pixmap_path (context, scanner);
       
     case GTK_RC_TOKEN_WIDGET:
-      return gtk_rc_parse_path_pattern (scanner);
+      return gtk_rc_parse_path_pattern (context, scanner);
       
     case GTK_RC_TOKEN_WIDGET_CLASS:
-      return gtk_rc_parse_path_pattern (scanner);
+      return gtk_rc_parse_path_pattern (context, scanner);
       
     case GTK_RC_TOKEN_CLASS:
-      return gtk_rc_parse_path_pattern (scanner);
+      return gtk_rc_parse_path_pattern (context, scanner);
       
     case GTK_RC_TOKEN_MODULE_PATH:
       return gtk_rc_parse_module_path (scanner);
@@ -1795,7 +2213,7 @@ gtk_rc_parse_statement (GScanner *scanner)
 	      svalue.origin = prop.origin;
 	      memcpy (&svalue.value, &prop.value, sizeof (prop.value));
 	      g_strcanon (name, G_CSET_A_2_Z G_CSET_a_2_z G_CSET_DIGITS "-", '-');
-	      gtk_settings_set_property_value (gtk_settings_get_global (),
+	      gtk_settings_set_property_value (context->settings,
 					       name,
 					       &svalue);
 	    }
@@ -1818,7 +2236,8 @@ gtk_rc_parse_statement (GScanner *scanner)
 }
 
 static guint
-gtk_rc_parse_style (GScanner *scanner)
+gtk_rc_parse_style (GtkRcContext *context,
+		    GScanner     *scanner)
 {
   GtkRcStyle *rc_style;
   GtkRcStyle *parent_style;
@@ -1836,7 +2255,7 @@ gtk_rc_parse_style (GScanner *scanner)
     return G_TOKEN_STRING;
   
   insert = FALSE;
-  rc_style = gtk_rc_style_find (scanner->value.v_string);
+  rc_style = gtk_rc_style_find (context, scanner->value.v_string);
 
   /* If there's a list, its first member is always the factory belonging
    * to this RcStyle
@@ -1871,7 +2290,7 @@ gtk_rc_parse_style (GScanner *scanner)
 	  return G_TOKEN_STRING;
 	}
       
-      parent_style = gtk_rc_style_find (scanner->value.v_string);
+      parent_style = gtk_rc_style_find (context, scanner->value.v_string);
       if (parent_style)
 	{
           GSList *factories;
@@ -1993,7 +2412,7 @@ gtk_rc_parse_style (GScanner *scanner)
 	  token = gtk_rc_parse_ythickness (scanner, rc_style);
 	  break;
 	case GTK_RC_TOKEN_BG_PIXMAP:
-	  token = gtk_rc_parse_bg_pixmap (scanner, rc_style);
+	  token = gtk_rc_parse_bg_pixmap (context, scanner, rc_style);
 	  break;
 	case GTK_RC_TOKEN_FONT:
 	  token = gtk_rc_parse_font (scanner, rc_style);
@@ -2005,7 +2424,7 @@ gtk_rc_parse_style (GScanner *scanner)
 	  token = gtk_rc_parse_font_name (scanner, rc_style);
 	  break;
 	case GTK_RC_TOKEN_ENGINE:
-	  token = gtk_rc_parse_engine (scanner, &rc_style);
+	  token = gtk_rc_parse_engine (context, scanner, &rc_style);
 	  break;
         case GTK_RC_TOKEN_STOCK:
           if (our_factory == NULL)
@@ -2014,7 +2433,7 @@ gtk_rc_parse_style (GScanner *scanner)
               rc_style->icon_factories = g_slist_prepend (rc_style->icon_factories,
                                                           our_factory);
             }
-          token = gtk_rc_parse_stock (scanner, rc_style, our_factory);
+          token = gtk_rc_parse_stock (context, scanner, rc_style, our_factory);
           break;
 	case G_TOKEN_IDENTIFIER:
 	  if (is_c_identifier (scanner->next_value.v_identifier) &&
@@ -2110,11 +2529,11 @@ gtk_rc_parse_style (GScanner *scanner)
   
   if (insert)
     {
-      if (!rc_style_ht)
-	rc_style_ht = g_hash_table_new ((GHashFunc) gtk_rc_style_hash,
-					(GEqualFunc) gtk_rc_style_equal);
+      if (!context->rc_style_ht)
+	context->rc_style_ht = g_hash_table_new ((GHashFunc) gtk_rc_style_hash,
+						 (GEqualFunc) gtk_rc_style_equal);
       
-      g_hash_table_insert (rc_style_ht, rc_style->name, rc_style);
+      g_hash_table_insert (context->rc_style_ht, rc_style->name, rc_style);
     }
   
   return G_TOKEN_NONE;
@@ -2271,8 +2690,9 @@ gtk_rc_parse_ythickness (GScanner   *scanner,
 }
 
 static guint
-gtk_rc_parse_bg_pixmap (GScanner   *scanner,
-			GtkRcStyle *rc_style)
+gtk_rc_parse_bg_pixmap (GtkRcContext *context,
+			GScanner     *scanner,
+			GtkRcStyle   *rc_style)
 {
   GtkStateType state;
   guint token;
@@ -2298,7 +2718,8 @@ gtk_rc_parse_bg_pixmap (GScanner   *scanner,
       (strcmp (scanner->value.v_string, "<none>") == 0))
     pixmap_file = g_strdup (scanner->value.v_string);
   else
-    pixmap_file = gtk_rc_find_pixmap_in_path (scanner, scanner->value.v_string);
+    pixmap_file = gtk_rc_find_pixmap_in_path (context->settings,
+					      scanner, scanner->value.v_string);
   
   if (pixmap_file)
     {
@@ -2329,18 +2750,34 @@ gtk_rc_check_pixmap_dir (const gchar *dir, const gchar *pixmap_file)
  
    return NULL;
  }
- 
+
+/**
+ * gtk_rc_context_find_pixmap_in_path:
+ * @settings: a #GtkSettinsg
+ * @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: 
+ **/
 gchar*
-gtk_rc_find_pixmap_in_path (GScanner *scanner,
-  			    const gchar *pixmap_file)
+gtk_rc_find_pixmap_in_path (GtkSettings  *settings,
+			    GScanner     *scanner,
+			    const gchar  *pixmap_file)
 {
   gint i;
   gchar *filename;
   GSList *tmp_list;
+
+  GtkRcContext *context = gtk_rc_context_get (settings);
     
-  for (i = 0; (i < GTK_RC_MAX_PIXMAP_PATHS) && (pixmap_path[i] != NULL); i++)
+  for (i = 0; (i < GTK_RC_MAX_PIXMAP_PATHS) && (context->pixmap_path[i] != NULL); i++)
     {
-      filename = gtk_rc_check_pixmap_dir (pixmap_path[i], pixmap_file);
+      filename = gtk_rc_check_pixmap_dir (context->pixmap_path[i], pixmap_file);
       if (filename)
  	return filename;
     }
@@ -2460,8 +2897,9 @@ gtk_rc_parse_font_name (GScanner   *scanner,
 }
 
 static guint	   
-gtk_rc_parse_engine (GScanner	 *scanner,
-		     GtkRcStyle	**rc_style)
+gtk_rc_parse_engine (GtkRcContext *context,
+		     GScanner	  *scanner,
+		     GtkRcStyle	 **rc_style)
 {
   guint token;
   GtkThemeEngine *engine;
@@ -2499,7 +2937,7 @@ gtk_rc_parse_engine (GScanner	 *scanner,
       if (new_class->parse)
 	{
 	  parsed_curlies = TRUE;
-	  result = new_class->parse (new_style, scanner);
+	  result = new_class->parse (new_style, context->settings, scanner);
 
 	  if (result != G_TOKEN_NONE)
 	    {
@@ -2623,6 +3061,9 @@ gtk_rc_parse_priority (GScanner	           *scanner,
     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;
@@ -2654,10 +3095,6 @@ gtk_rc_parse_color (GScanner *scanner,
   switch (token)
     {
       gint token_int;
-      gint length;
-      gint temp;
-      gchar buf[9];
-      gint i, j;
       
     case G_TOKEN_LEFT_CURLY:
       token = g_scanner_get_next_token (scanner);
@@ -2701,54 +3138,14 @@ gtk_rc_parse_color (GScanner *scanner,
       return G_TOKEN_NONE;
       
     case G_TOKEN_STRING:
-      if (scanner->value.v_string[0] != '#')
-	return G_TOKEN_STRING;
-      
-      length = strlen (scanner->value.v_string) - 1;
-      if (((length % 3) != 0) || (length > 12))
-	return G_TOKEN_STRING;
-      length /= 3;
-      
-      for (i = 0, j = 1; i < length; i++, j++)
-	buf[i] = scanner->value.v_string[j];
-      buf[i] = '\0';
-      
-      sscanf (buf, "%x", &temp);
-      color->red = temp;
-      
-      for (i = 0; i < length; i++, j++)
-	buf[i] = scanner->value.v_string[j];
-      buf[i] = '\0';
-      
-      sscanf (buf, "%x", &temp);
-      color->green = temp;
-      
-      for (i = 0; i < length; i++, j++)
-	buf[i] = scanner->value.v_string[j];
-      buf[i] = '\0';
-      
-      sscanf (buf, "%x", &temp);
-      color->blue = temp;
-      
-      if (length == 1)
+      if (!gdk_color_parse (scanner->value.v_string, color))
 	{
-	  color->red *= 4369;
-	  color->green *= 4369;
-	  color->blue *= 4369;
-	}
-      else if (length == 2)
-	{
-	  color->red *= 257;
-	  color->green *= 257;
-	  color->blue *= 257;
-	}
-      else if (length == 3)
-	{
-	  color->red *= 16;
-	  color->green *= 16;
-	  color->blue *= 16;
+	  g_scanner_warn (scanner, "Invalid color constant '%s'",
+			  scanner->value.v_string);
+	  return G_TOKEN_STRING;
 	}
-      return G_TOKEN_NONE;
+      else
+	return G_TOKEN_NONE;
       
     default:
       return G_TOKEN_STRING;
@@ -2756,7 +3153,8 @@ gtk_rc_parse_color (GScanner *scanner,
 }
 
 static guint
-gtk_rc_parse_pixmap_path (GScanner *scanner)
+gtk_rc_parse_pixmap_path (GtkRcContext *context,
+			  GScanner     *scanner)
 {
   guint token;
   
@@ -2768,46 +3166,54 @@ gtk_rc_parse_pixmap_path (GScanner *scanner)
   if (token != G_TOKEN_STRING)
     return G_TOKEN_STRING;
   
-  gtk_rc_parse_pixmap_path_string (scanner->value.v_string);
+  gtk_rc_parse_pixmap_path_string (context, scanner, scanner->value.v_string);
   
   return G_TOKEN_NONE;
 }
 
 static void
-gtk_rc_parse_pixmap_path_string (gchar *pix_path)
+gtk_rc_parse_pixmap_path_string (GtkRcContext *context,
+				 GScanner     *scanner,
+				 const gchar  *pix_path)
 {
-  gchar *buf;
   gint end_offset;
   gint start_offset = 0;
   gint path_len;
   gint path_num;
   
   /* free the old one, or just add to the old one ? */
-  for (path_num=0; pixmap_path[path_num]; path_num++)
+  for (path_num = 0; context->pixmap_path[path_num]; path_num++)
     {
-      g_free (pixmap_path[path_num]);
-      pixmap_path[path_num] = NULL;
+      g_free (context->pixmap_path[path_num]);
+      context->pixmap_path[path_num] = NULL;
     }
   
   path_num = 0;
   
   path_len = strlen (pix_path);
   
-  buf = g_strdup (pix_path);
-  
   for (end_offset = 0; end_offset <= path_len; end_offset++)
     {
-      if ((buf[end_offset] == G_SEARCHPATH_SEPARATOR) ||
+      if ((pix_path[end_offset] == G_SEARCHPATH_SEPARATOR) ||
 	  (end_offset == path_len))
 	{
-	  buf[end_offset] = '\0';
-	  pixmap_path[path_num] = g_strdup (buf + start_offset);
-	  path_num++;
-	  pixmap_path[path_num] = NULL;
+	  gchar *path_element = g_strndup (pix_path + start_offset, end_offset - start_offset);
+	  if (g_path_is_absolute (path_element))
+	    {
+	      context->pixmap_path[path_num] = path_element;
+	      path_num++;
+	      context->pixmap_path[path_num] = NULL;
+	    }
+	  else
+	    {
+	      g_warning (_("Pixmap path element: \"%s\" must be absolute, %s, line %d"),
+			 path_element, scanner->input_name, scanner->line);
+	      g_free (path_element);
+	    }
+
 	  start_offset = end_offset + 1;
 	}
     }
-  g_free (buf);
 }
 
 static guint
@@ -2871,9 +3277,8 @@ gtk_rc_parse_im_module_file (GScanner *scanner)
 }
 
 static void
-gtk_rc_parse_module_path_string (gchar *mod_path)
+gtk_rc_parse_module_path_string (const gchar *mod_path)
 {
-  gchar *buf;
   gint end_offset;
   gint start_offset = 0;
   gint path_len;
@@ -2890,32 +3295,44 @@ gtk_rc_parse_module_path_string (gchar *mod_path)
   
   path_len = strlen (mod_path);
   
-  buf = g_strdup (mod_path);
-  
   for (end_offset = 0; end_offset <= path_len; end_offset++)
     {
-      if ((buf[end_offset] == G_SEARCHPATH_SEPARATOR) ||
+      if ((mod_path[end_offset] == G_SEARCHPATH_SEPARATOR) ||
 	  (end_offset == path_len))
 	{
-	  buf[end_offset] = '\0';
-	  module_path[path_num] = g_strdup (buf + start_offset);
+	  module_path[path_num] = g_strndup (mod_path + start_offset, end_offset - start_offset);
 	  path_num++;
 	  module_path[path_num] = NULL;
 	  start_offset = end_offset + 1;
 	}
     }
-  g_free (buf);
   gtk_rc_append_default_module_path();
 }
 
+static gint
+rc_set_compare (gconstpointer a, gconstpointer b)
+{
+  const GtkRcSet *set_a = a;
+  const GtkRcSet *set_b = b;
+
+  return (set_a->priority < set_b->priority) ? 1 : (set_a->priority == set_b->priority ? 0 : -1);
+}
+
+static GSList *
+insert_rc_set (GSList *list, GtkRcSet *set)
+{
+  return g_slist_insert_sorted (list, set, rc_set_compare);
+}
+
 static guint
-gtk_rc_parse_path_pattern (GScanner   *scanner)
+gtk_rc_parse_path_pattern (GtkRcContext *context,
+			   GScanner     *scanner)
 {
   guint token;
   GtkPathType path_type;
   gchar *pattern;
   gboolean is_binding;
-  GtkPathPriorityType priority = GTK_PATH_PRIO_RC;
+  GtkPathPriorityType priority = context->default_priority;
   
   token = g_scanner_get_next_token (scanner);
   switch (token)
@@ -2932,7 +3349,7 @@ gtk_rc_parse_path_pattern (GScanner   *scanner)
     default:
       return GTK_RC_TOKEN_WIDGET_CLASS;
     }
-  
+
   token = g_scanner_get_next_token (scanner);
   if (token != G_TOKEN_STRING)
     return G_TOKEN_STRING;
@@ -2943,24 +3360,23 @@ gtk_rc_parse_path_pattern (GScanner   *scanner)
   if (token == GTK_RC_TOKEN_STYLE)
     is_binding = FALSE;
   else if (token == GTK_RC_TOKEN_BINDING)
-    {
-      is_binding = TRUE;
-      if (g_scanner_peek_next_token (scanner) == ':')
-	{
-	  token = gtk_rc_parse_priority (scanner, &priority);
-	  if (token != G_TOKEN_NONE)
-	    {
-	      g_free (pattern);
-	      return token;
-	    }
-	}
-    }
+    is_binding = TRUE;
   else
     {
       g_free (pattern);
       return GTK_RC_TOKEN_STYLE;
     }
   
+  if (g_scanner_peek_next_token (scanner) == ':')
+    {
+      token = gtk_rc_parse_priority (scanner, &priority);
+      if (token != G_TOKEN_NONE)
+	{
+	  g_free (pattern);
+	  return token;
+	}
+    }
+  
   token = g_scanner_get_next_token (scanner);
   if (token != G_TOKEN_STRING)
     {
@@ -2985,7 +3401,7 @@ gtk_rc_parse_path_pattern (GScanner   *scanner)
       GtkRcStyle *rc_style;
       GtkRcSet *rc_set;
 
-      rc_style = gtk_rc_style_find (scanner->value.v_string);
+      rc_style = gtk_rc_style_find (context, scanner->value.v_string);
       
       if (!rc_style)
 	{
@@ -2996,13 +3412,14 @@ gtk_rc_parse_path_pattern (GScanner   *scanner)
       rc_set = g_new (GtkRcSet, 1);
       rc_set->pspec = g_pattern_spec_new (pattern);
       rc_set->rc_style = rc_style;
+      rc_set->priority = priority;
 
       if (path_type == GTK_PATH_WIDGET)
-	gtk_rc_sets_widget = g_slist_prepend (gtk_rc_sets_widget, rc_set);
+	context->rc_sets_widget = insert_rc_set (context->rc_sets_widget, rc_set);
       else if (path_type == GTK_PATH_WIDGET_CLASS)
-	gtk_rc_sets_widget_class = g_slist_prepend (gtk_rc_sets_widget_class, rc_set);
+	context->rc_sets_widget_class = insert_rc_set (context->rc_sets_widget_class, rc_set);
       else
-	gtk_rc_sets_class = g_slist_prepend (gtk_rc_sets_class, rc_set);
+	context->rc_sets_class = insert_rc_set (context->rc_sets_class, rc_set);
     }
 
   g_free (pattern);
@@ -3037,11 +3454,13 @@ gtk_rc_parse_stock_id (GScanner	 *scanner,
 }
 
 static guint
-gtk_rc_parse_icon_source (GScanner	 *scanner,
+gtk_rc_parse_icon_source (GtkRcContext   *context,
+			  GScanner	 *scanner,
                           GtkIconSet     *icon_set)
 {
   guint token;
   GtkIconSource *source;
+  gchar *full_filename;
   
   token = g_scanner_get_next_token (scanner);
   if (token != G_TOKEN_LEFT_CURLY)
@@ -3052,18 +3471,23 @@ gtk_rc_parse_icon_source (GScanner	 *scanner,
   if (token != G_TOKEN_STRING)
     return G_TOKEN_STRING;
 
+  
   source = gtk_icon_source_new ();
-
-  gtk_icon_source_set_filename (source, scanner->value.v_string);
   
+  full_filename = gtk_rc_find_pixmap_in_path (context->settings, scanner, scanner->value.v_string);
+  if (full_filename)
+    {
+      gtk_icon_source_set_filename (source, full_filename);
+      g_free (full_filename);
+    }
+
+  /* We continue parsing even if we didn't find the pixmap so that rest of the
+   * file is read, even if the syntax is bad
+   */
   token = g_scanner_get_next_token (scanner);
 
   if (token == G_TOKEN_RIGHT_CURLY)
-    {
-      gtk_icon_set_add_source (icon_set, source);
-      gtk_icon_source_free (source);
-      return G_TOKEN_NONE;
-    }  
+    goto done;
   else if (token != G_TOKEN_COMMA)
     {
       gtk_icon_source_free (source);
@@ -3098,11 +3522,7 @@ gtk_rc_parse_icon_source (GScanner	 *scanner,
   token = g_scanner_get_next_token (scanner);
 
   if (token == G_TOKEN_RIGHT_CURLY)
-    {
-      gtk_icon_set_add_source (icon_set, source);
-      gtk_icon_source_free (source);
-      return G_TOKEN_NONE;
-    }  
+    goto done;
   else if (token != G_TOKEN_COMMA)
     {
       gtk_icon_source_free (source);
@@ -3153,11 +3573,7 @@ gtk_rc_parse_icon_source (GScanner	 *scanner,
   token = g_scanner_get_next_token (scanner);
 
   if (token == G_TOKEN_RIGHT_CURLY)
-    {
-      gtk_icon_set_add_source (icon_set, source);
-      gtk_icon_source_free (source);
-      return G_TOKEN_NONE;
-    }
+    goto done;
   else if (token != G_TOKEN_COMMA)
     {
       gtk_icon_source_free (source);
@@ -3196,15 +3612,17 @@ gtk_rc_parse_icon_source (GScanner	 *scanner,
       return G_TOKEN_RIGHT_CURLY;
     }
 
-  gtk_icon_set_add_source (icon_set, source);
-
+ done:
+  if (gtk_icon_source_get_filename (source))
+    gtk_icon_set_add_source (icon_set, source);
   gtk_icon_source_free (source);
   
   return G_TOKEN_NONE;
 }
 
 static guint
-gtk_rc_parse_stock (GScanner       *scanner,
+gtk_rc_parse_stock (GtkRcContext   *context,
+		    GScanner       *scanner,
                     GtkRcStyle     *rc_style,
                     GtkIconFactory *factory)
 {
@@ -3240,7 +3658,7 @@ gtk_rc_parse_stock (GScanner       *scanner,
       if (icon_set == NULL)
         icon_set = gtk_icon_set_new ();
       
-      token = gtk_rc_parse_icon_source (scanner, icon_set);
+      token = gtk_rc_parse_icon_source (context, scanner, icon_set);
       if (token != G_TOKEN_NONE)
         {
           g_free (stock_id);
diff --git a/gtk/gtkrc.h b/gtk/gtkrc.h
index 1507b177ac..d655ca2b00 100644
--- a/gtk/gtkrc.h
+++ b/gtk/gtkrc.h
@@ -29,17 +29,17 @@
 
 
 #include <gtk/gtkstyle.h>
-#include <gtk/gtkwidget.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif /* __cplusplus */
 
-/* Forward declaration */
-typedef struct _GtkIconFactory GtkIconFactory;
+/* Forward declarations */
+typedef struct _GtkIconFactory  GtkIconFactory;
+typedef struct _GtkRcContext    GtkRcContext;
+typedef struct _GtkSettings     GtkSettings;
 
 typedef struct _GtkRcStyleClass GtkRcStyleClass;
-typedef struct _GtkRCContext    GtkRcContext;
 
 #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))
@@ -74,7 +74,7 @@ struct _GtkRcStyle
 
   gint xthickness;
   gint ythickness;
-  
+
   /*< private >*/
   GBSearchArray *rc_properties;
   
@@ -99,8 +99,9 @@ struct _GtkRcStyleClass
    * of brackets. Returns G_TOKEN_NONE if succesful, otherwise returns
    * the token it expected but didn't get.
    */
-  guint     (*parse)  (GtkRcStyle *rc_style,
-		       GScanner   *scanner);
+  guint     (*parse)  (GtkRcStyle   *rc_style,
+		       GtkSettings  *settings,
+		       GScanner     *scanner);
   
   /* Combine RC style data from src into dest. If overriden, this
    * function should chain to the parent.
@@ -117,18 +118,30 @@ void	  _gtk_rc_init			(void);
 void      gtk_rc_add_default_file	(const gchar *filename);
 void      gtk_rc_set_default_files      (gchar **filenames);
 gchar**   gtk_rc_get_default_files      (void);
-void	  gtk_rc_parse			(const gchar *filename);
-void	  gtk_rc_parse_string		(const gchar *rc_string);
 GtkStyle* gtk_rc_get_style		(GtkWidget   *widget);
+GtkStyle* gtk_rc_get_style_by_paths     (GtkSettings *settings,
+					 const char  *widget_path,
+					 const char  *class_path,
+					 GType        type);
 
+gboolean gtk_rc_reparse_all_for_settings (GtkSettings *settings,
+					  gboolean     force_load);
+gchar*   gtk_rc_find_pixmap_in_path (GtkSettings  *context,
+				     GScanner     *scanner,
+				     const gchar  *pixmap_file);
+
+void	  gtk_rc_parse			(const gchar *filename);
+void	  gtk_rc_parse_string		(const gchar *rc_string);
 gboolean  gtk_rc_reparse_all		(void);
-void	  gtk_rc_add_widget_name_style	(GtkRcStyle  *rc_style,
-					 const gchar *pattern);
-void	  gtk_rc_add_widget_class_style (GtkRcStyle  *rc_style,
-					 const gchar *pattern);
-void	  gtk_rc_add_class_style	(GtkRcStyle  *rc_style,
-					 const gchar *pattern);
 
+#ifndef GTK_DISABLE_DEPRECATED
+void	  gtk_rc_add_widget_name_style	(GtkRcStyle   *rc_style,
+					 const gchar  *pattern);
+void	  gtk_rc_add_widget_class_style (GtkRcStyle   *rc_style,
+					 const gchar  *pattern);
+void	  gtk_rc_add_class_style	(GtkRcStyle   *rc_style,
+					 const gchar  *pattern);
+#endif /* GTK_DISABLE_DEPRECATED */
 
 
 GType       gtk_rc_style_get_type   (void) G_GNUC_CONST;
@@ -137,8 +150,6 @@ GtkRcStyle* gtk_rc_style_copy       (GtkRcStyle *orig);
 void        gtk_rc_style_ref        (GtkRcStyle *rc_style);
 void        gtk_rc_style_unref      (GtkRcStyle *rc_style);
 
-gchar*		gtk_rc_find_pixmap_in_path	(GScanner    	*scanner,
-						 const gchar	*pixmap_file);
 gchar*		gtk_rc_find_module_in_path	(const gchar 	*module_file);
 gchar*		gtk_rc_get_theme_dir		(void);
 gchar*		gtk_rc_get_module_dir		(void);
@@ -174,6 +185,7 @@ typedef enum {
   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,
@@ -212,7 +224,6 @@ const GtkRcProperty* _gtk_rc_style_lookup_rc_property (GtkRcStyle *rc_style,
 						       GQuark      type_name,
 						       GQuark      property_name);
 
-
 #ifdef G_OS_WIN32
 gchar*  gtk_win32_get_installation_directory (void);
 #endif
diff --git a/gtk/gtksettings.c b/gtk/gtksettings.c
index f5816ccf14..8439fce4a3 100644
--- a/gtk/gtksettings.c
+++ b/gtk/gtksettings.c
@@ -17,14 +17,18 @@
  */
 
 #include "gtksettings.h"
+#include "gtkrc.h"
 #include "gtkintl.h"
+#include "gtkwidget.h"
 
 enum {
   PROP_0,
   PROP_DOUBLE_CLICK_TIME,
   PROP_CURSOR_BLINK,
   PROP_CURSOR_BLINK_TIME,
-  PROP_SPLIT_CURSOR
+  PROP_SPLIT_CURSOR,
+  PROP_THEME_NAME,
+  PROP_KEY_THEME_NAME
 };
 
 
@@ -166,6 +170,22 @@ gtk_settings_class_init (GtkSettingsClass *class)
 								   G_PARAM_READWRITE),
                                              NULL);
   g_assert (result == PROP_SPLIT_CURSOR);
+  result = settings_install_property_parser (class,
+                                             g_param_spec_string ("gtk-theme-name",
+								   _("Theme Name"),
+								   _("Name of theme RC file to load"),
+								  NULL,
+								  G_PARAM_READWRITE),
+                                             NULL);
+  g_assert (result == PROP_THEME_NAME);
+  result = settings_install_property_parser (class,
+                                             g_param_spec_string ("gtk-key-theme-name",
+								  _("Key Theme Name"),
+								  _("Name of key theme RC file to load"),
+								  NULL,
+								  G_PARAM_READWRITE),
+                                             NULL);
+  g_assert (result == PROP_KEY_THEME_NAME);
 }
 
 static void
@@ -207,7 +227,7 @@ gtk_settings_constructor (GType			 type,
 }
 
 GtkSettings*
-gtk_settings_get_global (void)
+gtk_settings_get_default (void)
 {
   if (!the_singleton)
     g_object_new (GTK_TYPE_SETTINGS, NULL);
@@ -294,6 +314,7 @@ gtk_settings_notify (GObject    *object,
 {
   guint property_id = pspec->param_id;
   gint double_click_time;
+  gchar *str_value;
   
 #if 1
   GValue tmp_value = { 0, };
@@ -484,29 +505,25 @@ _gtk_rc_property_parser_from_type (GType type)
 }
 
 void
-gtk_settings_install_property (GtkSettings *settings,
-			       GParamSpec  *pspec)
+gtk_settings_install_property (GParamSpec  *pspec)
 {
   GtkRcPropertyParser parser = NULL;
 
-  g_return_if_fail (GTK_IS_SETTINGS (settings));
   g_return_if_fail (G_IS_PARAM_SPEC (pspec));
 
   parser = _gtk_rc_property_parser_from_type (G_PARAM_SPEC_VALUE_TYPE (pspec));
 
-  settings_install_property_parser (GTK_SETTINGS_GET_CLASS (settings), pspec, parser);
+  settings_install_property_parser (gtk_type_class (GTK_TYPE_SETTINGS), pspec, parser);
 }
 
 void
-gtk_settings_install_property_parser (GtkSettings        *settings,
-				      GParamSpec         *pspec,
+gtk_settings_install_property_parser (GParamSpec         *pspec,
 				      GtkRcPropertyParser parser)
 {
-  g_return_if_fail (GTK_IS_SETTINGS (settings));
   g_return_if_fail (G_IS_PARAM_SPEC (pspec));
   g_return_if_fail (parser != NULL);
   
-  settings_install_property_parser (GTK_SETTINGS_GET_CLASS (settings), pspec, parser);
+  settings_install_property_parser (gtk_type_class (GTK_TYPE_SETTINGS), pspec, parser);
 }
 
 static void
@@ -884,7 +901,7 @@ gtk_rc_property_parse_border (const GParamSpec *pspec,
 void
 _gtk_settings_handle_event (GdkEventSetting *event)
 {
-  GtkSettings *settings = gtk_settings_get_global ();
+  GtkSettings *settings = gtk_settings_get_default ();
   
   if (g_object_class_find_property (G_OBJECT_GET_CLASS (settings), event->name))
     g_object_notify (G_OBJECT (settings), event->name);
diff --git a/gtk/gtksettings.h b/gtk/gtksettings.h
index 59c2fd90cd..463c5d226f 100644
--- a/gtk/gtksettings.h
+++ b/gtk/gtksettings.h
@@ -35,7 +35,6 @@ extern "C" {
 
 
 /* --- typedefs --- */
-typedef struct    _GtkSettings      GtkSettings;
 typedef struct    _GtkSettingsClass GtkSettingsClass;
 typedef struct    _GtkSettingsValue GtkSettingsValue;
 
@@ -47,6 +46,8 @@ struct _GtkSettings
 
   GData  *queued_settings;	/* of type GtkSettingsValue* */
   GValue *property_values;
+
+  GtkRcContext *rc_context;
 };
 struct _GtkSettingsClass
 {
@@ -69,11 +70,9 @@ struct _GtkSettingsValue
 
 /* --- functions --- */
 GType		gtk_settings_get_type		     (void);
-GtkSettings*	gtk_settings_get_global		     (void);	/* singleton */
-void		gtk_settings_install_property	     (GtkSettings	 *settings,
-						      GParamSpec         *pspec);
-void		gtk_settings_install_property_parser (GtkSettings        *settings,
-						      GParamSpec         *pspec,
+GtkSettings*	gtk_settings_get_default	     (void);
+void		gtk_settings_install_property	     (GParamSpec         *pspec);
+void		gtk_settings_install_property_parser (GParamSpec         *pspec,
 						      GtkRcPropertyParser parser);
 
 /* --- precoded parsing functions --- */
diff --git a/gtk/gtktextview.c b/gtk/gtktextview.c
index 05adad5a3f..b5750b3aa3 100644
--- a/gtk/gtktextview.c
+++ b/gtk/gtktextview.c
@@ -3663,7 +3663,7 @@ gtk_text_view_forall (GtkContainer *container,
 static gboolean
 cursor_blinks (GtkTextView *text_view)
 {
-  GtkSettings *settings = gtk_settings_get_global ();
+  GtkSettings *settings = gtk_widget_get_settings (GTK_WIDGET (text_view));
   gboolean blink;
 
   g_object_get (G_OBJECT (settings), "gtk-cursor-blink", &blink, NULL);
@@ -3673,7 +3673,7 @@ cursor_blinks (GtkTextView *text_view)
 static gint
 get_cursor_time (GtkTextView *text_view)
 {
-  GtkSettings *settings = gtk_settings_get_global ();
+  GtkSettings *settings = gtk_widget_get_settings (GTK_WIDGET (text_view));
   gint time;
 
   g_object_get (G_OBJECT (settings), "gtk-cursor-blink-time", &time, NULL);
@@ -4352,8 +4352,9 @@ gtk_text_view_check_keymap_direction (GtkTextView *text_view)
     {
       gboolean split_cursor;
       GtkTextDirection new_dir;
+      GtkSettings *settings = gtk_widget_get_settings (GTK_WIDGET (text_view));
   
-      g_object_get (gtk_settings_get_global (),
+      g_object_get (G_OBJECT (settings),
 		    "gtk-split-cursor", &split_cursor,
 		    NULL);
       if (split_cursor)
diff --git a/gtk/gtktoolbar.c b/gtk/gtktoolbar.c
index bb4add2716..b8dce53a33 100644
--- a/gtk/gtktoolbar.c
+++ b/gtk/gtktoolbar.c
@@ -283,16 +283,14 @@ gtk_toolbar_class_init (GtkToolbarClass *class)
                                                               GTK_SHADOW_OUT,
                                                               G_PARAM_READABLE));
 
-  gtk_settings_install_property (gtk_settings_get_global (),
-                                 g_param_spec_enum ("gtk-toolbar-style",
+  gtk_settings_install_property (g_param_spec_enum ("gtk-toolbar-style",
                                                     _("Toolbar style"),
                                                     _("Whether default toolbars have text only, text and icons, icons only, etc."),
                                                     GTK_TYPE_TOOLBAR_STYLE,
                                                     GTK_TOOLBAR_BOTH,
                                                     G_PARAM_READWRITE));
 
-  gtk_settings_install_property (gtk_settings_get_global (),
-                                 g_param_spec_enum ("gtk-toolbar-icon-size",
+  gtk_settings_install_property (g_param_spec_enum ("gtk-toolbar-icon-size",
                                                     _("Toolbar icon size"),
                                                     _("Size of icons in default toolbars"),
                                                     GTK_TYPE_ICON_SIZE,
@@ -350,7 +348,7 @@ gtk_toolbar_init (GtkToolbar *toolbar)
 
   toolbar->style_set = FALSE;
   toolbar->icon_size_set = FALSE;
-  g_object_get (gtk_settings_get_global (),
+  g_object_get (gtk_settings_get_default (),
                 "gtk-toolbar-icon-size",
                 &toolbar->icon_size,
                 "gtk-toolbar-style",
@@ -358,13 +356,13 @@ gtk_toolbar_init (GtkToolbar *toolbar)
                 NULL);
   
   toolbar->style_set_connection =
-    g_signal_connect (G_OBJECT (gtk_settings_get_global ()),
+    g_signal_connect (G_OBJECT (gtk_settings_get_default ()),
 		      "notify::gtk-toolbar-style",
 		      G_CALLBACK (style_change_notify),
 		      toolbar);
 
   toolbar->icon_size_connection =
-    g_signal_connect (G_OBJECT (gtk_settings_get_global ()),
+    g_signal_connect (G_OBJECT (gtk_settings_get_default ()),
 		      "notify::gtk-toolbar-icon-size",
 		      G_CALLBACK (icon_size_change_notify),
 		      toolbar);
@@ -377,9 +375,9 @@ gtk_toolbar_finalize (GObject *object)
 
   toolbar = GTK_TOOLBAR (object);
 
-  g_signal_handler_disconnect (G_OBJECT (gtk_settings_get_global ()),
+  g_signal_handler_disconnect (G_OBJECT (gtk_settings_get_default ()),
                                toolbar->style_set_connection);
-  g_signal_handler_disconnect (G_OBJECT (gtk_settings_get_global ()),
+  g_signal_handler_disconnect (G_OBJECT (gtk_settings_get_default ()),
                                toolbar->icon_size_connection);
   
   G_OBJECT_CLASS (parent_class)->finalize (object);
@@ -1087,7 +1085,7 @@ gtk_toolbar_unset_icon_size (GtkToolbar  *toolbar)
 
   if (toolbar->icon_size_set)
     {
-      g_object_get (gtk_settings_get_global (),
+      g_object_get (gtk_settings_get_default (),
                     "gtk-toolbar-icon-size",
                     &size, NULL);
 
@@ -1542,7 +1540,7 @@ gtk_toolbar_unset_style (GtkToolbar *toolbar)
 
   if (toolbar->style_set)
     {
-      g_object_get (gtk_settings_get_global (),
+      g_object_get (gtk_settings_get_default (),
                     "gtk-toolbar-style",
                     &style,
                     NULL);
diff --git a/gtk/gtkwidget.c b/gtk/gtkwidget.c
index b26a1e2c56..3851d0952f 100644
--- a/gtk/gtkwidget.c
+++ b/gtk/gtkwidget.c
@@ -197,12 +197,12 @@ static gboolean		gtk_widget_real_focus_out_event   	(GtkWidget        *widget,
 static gboolean		gtk_widget_real_focus			(GtkWidget        *widget,
 								 GtkDirectionType  direction);
 static GdkColormap*	gtk_widget_peek_colormap		(void);
-static GtkStyle*	gtk_widget_peek_style			(void);
 static PangoContext*	gtk_widget_peek_pango_context		(GtkWidget	  *widget);
 static void		gtk_widget_reparent_container_child	(GtkWidget	  *widget,
 								 gpointer          client_data);
 static void		gtk_widget_propagate_state		(GtkWidget	  *widget,
 								 GtkStateData 	  *data);
+static void             gtk_widget_reset_rc_style               (GtkWidget        *widget);
 static void		gtk_widget_set_style_internal		(GtkWidget	  *widget,
 								 GtkStyle	  *style,
 								 gboolean	   initial_emission);
@@ -227,7 +227,6 @@ static GMemChunk       *aux_info_mem_chunk = NULL;
 static GdkColormap     *default_colormap = NULL;
 static GtkStyle        *gtk_default_style = NULL;
 static GSList          *colormap_stack = NULL;
-static GSList          *style_stack = NULL;
 static guint            composite_child_stack = 0;
 static GtkTextDirection gtk_default_direction = GTK_TEXT_DIR_LTR;
 static GParamSpecPool  *style_property_spec_pool = NULL;
@@ -237,7 +236,6 @@ static GQuark		quark_aux_info = 0;
 static GQuark		quark_event_mask = 0;
 static GQuark		quark_extension_event_mode = 0;
 static GQuark		quark_parent_window = 0;
-static GQuark		quark_saved_default_style = 0;
 static GQuark		quark_shape_info = 0;
 static GQuark		quark_colormap = 0;
 static GQuark		quark_pango_context = 0;
@@ -307,7 +305,6 @@ gtk_widget_class_init (GtkWidgetClass *klass)
   quark_event_mask = g_quark_from_static_string ("gtk-event-mask");
   quark_extension_event_mode = g_quark_from_static_string ("gtk-extension-event-mode");
   quark_parent_window = g_quark_from_static_string ("gtk-parent-window");
-  quark_saved_default_style = g_quark_from_static_string ("gtk-saved-default-style");
   quark_shape_info = g_quark_from_static_string ("gtk-shape-info");
   quark_colormap = g_quark_from_static_string ("gtk-colormap");
   quark_pango_context = g_quark_from_static_string ("gtk-pango-context");
@@ -1309,7 +1306,7 @@ gtk_widget_init (GtkWidget *widget)
 			(composite_child_stack ? GTK_COMPOSITE_CHILD : 0) |
 			GTK_DOUBLE_BUFFERED);
 
-  widget->style = gtk_widget_peek_style ();
+  widget->style = gtk_widget_get_default_style ();
   gtk_style_ref (widget->style);
   
   colormap = gtk_widget_peek_colormap ();
@@ -3239,7 +3236,7 @@ gtk_widget_set_name (GtkWidget	 *widget,
   widget->name = g_strdup (name);
 
   if (GTK_WIDGET_RC_STYLE (widget))
-    gtk_widget_set_rc_style (widget);
+    gtk_widget_reset_rc_style (widget);
 
   g_object_notify (G_OBJECT (widget), "name");
 }
@@ -3486,7 +3483,8 @@ gtk_widget_get_parent (GtkWidget *widget)
 /**
  * gtk_widget_set_style:
  * @widget: a #GtkWidget
- * @style: a #GtkStyle
+ * @style: a #GtkStyle, or %NULL to remove the effect of a previous
+ *         gtk_widget_set_style and go back to the default style
  *
  * Sets the #GtkStyle for a widget (widget->style). You probably don't
  * want to use this function; it interacts badly with themes, because
@@ -3498,26 +3496,25 @@ void
 gtk_widget_set_style (GtkWidget *widget,
 		      GtkStyle	*style)
 {
-  GtkStyle *default_style;
-  gboolean initial_emission;
-
   g_return_if_fail (widget != NULL);
   g_return_if_fail (GTK_IS_WIDGET (widget));
-  g_return_if_fail (style != NULL);
-
-  initial_emission = !GTK_WIDGET_RC_STYLE (widget) && !GTK_WIDGET_USER_STYLE (widget);
 
-  GTK_WIDGET_UNSET_FLAGS (widget, GTK_RC_STYLE);
-  GTK_PRIVATE_SET_FLAG (widget, GTK_USER_STYLE);
+  if (style)
+    {
+      gboolean initial_emission;
 
-  default_style = gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_saved_default_style);
-  if (!default_style)
+      initial_emission = !GTK_WIDGET_RC_STYLE (widget) && !GTK_WIDGET_USER_STYLE (widget);
+      
+      GTK_WIDGET_UNSET_FLAGS (widget, GTK_RC_STYLE);
+      GTK_PRIVATE_SET_FLAG (widget, GTK_USER_STYLE);
+      
+      gtk_widget_set_style_internal (widget, style, initial_emission);
+    }
+  else
     {
-      gtk_style_ref (widget->style);
-      gtk_object_set_data_by_id (GTK_OBJECT (widget), quark_saved_default_style, widget->style);
+      if (GTK_WIDGET_USER_STYLE (widget))
+	gtk_widget_reset_rc_style (widget);
     }
-
-  gtk_widget_set_style_internal (widget, style, initial_emission);
 }
 
 /**
@@ -3538,19 +3535,15 @@ gtk_widget_ensure_style (GtkWidget *widget)
 
   if (!GTK_WIDGET_USER_STYLE (widget) &&
       !GTK_WIDGET_RC_STYLE (widget))
-    gtk_widget_set_rc_style (widget);
+    gtk_widget_reset_rc_style (widget);
 }
 
-/**
- * gtk_widget_set_rc_style:
- * @widget: a #GtkWidget
- * 
- * 
+/* Look up the RC style for this widget, unsetting any user style that
+ * may be in effect currently
  **/
-void
-gtk_widget_set_rc_style (GtkWidget *widget)
+static void
+gtk_widget_reset_rc_style (GtkWidget *widget)
 {
-  GtkStyle *saved_style;
   GtkStyle *new_style;
   gboolean initial_emission;
   
@@ -3562,52 +3555,12 @@ gtk_widget_set_rc_style (GtkWidget *widget)
   GTK_PRIVATE_UNSET_FLAG (widget, GTK_USER_STYLE);
   GTK_WIDGET_SET_FLAGS (widget, GTK_RC_STYLE);
 
-  saved_style = gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_saved_default_style);
   new_style = gtk_rc_get_style (widget);
-  if (new_style)
-    {
-      if (!saved_style)
-	{
-	  gtk_style_ref (widget->style);
-	  gtk_object_set_data_by_id (GTK_OBJECT (widget), quark_saved_default_style, widget->style);
-	}
-      gtk_widget_set_style_internal (widget, new_style, initial_emission);
-    }
-  else
-    {
-      if (saved_style)
-	{
-	  g_assert (initial_emission == FALSE); /* FIXME: remove this line */
-
-	  gtk_object_remove_data_by_id (GTK_OBJECT (widget), quark_saved_default_style);
-	  gtk_widget_set_style_internal (widget, saved_style, initial_emission);
-	  gtk_style_unref (saved_style);
-	}
-      else
-	{
-	  if (initial_emission)
-	    gtk_widget_set_style_internal (widget, widget->style, TRUE);
-	}
-    }
-}
-
-void
-gtk_widget_restore_default_style (GtkWidget *widget)
-{
-  GtkStyle *default_style;
-
-  g_return_if_fail (widget != NULL);
-  g_return_if_fail (GTK_IS_WIDGET (widget));
-
-  GTK_PRIVATE_UNSET_FLAG (widget, GTK_USER_STYLE);
+  if (!new_style)
+    new_style = gtk_widget_get_default_style ();
 
-  default_style = gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_saved_default_style);
-  if (default_style)
-    {
-      gtk_object_remove_data_by_id (GTK_OBJECT (widget), quark_saved_default_style);
-      gtk_widget_set_style_internal (widget, default_style, FALSE);
-      gtk_style_unref (default_style);
-    }
+  if (initial_emission || new_style != widget->style)
+    gtk_widget_set_style_internal (widget, widget->style, TRUE);
 }
 
 /**
@@ -3671,7 +3624,7 @@ gtk_widget_modify_style (GtkWidget      *widget,
    */
   
   if (GTK_WIDGET_RC_STYLE (widget))
-    gtk_widget_set_rc_style (widget);
+    gtk_widget_reset_rc_style (widget);
 }
 
 /**
@@ -3950,7 +3903,7 @@ gtk_widget_set_style_recurse (GtkWidget *widget,
 			      gpointer	 client_data)
 {
   if (GTK_WIDGET_RC_STYLE (widget))
-    gtk_widget_set_rc_style (widget);
+    gtk_widget_reset_rc_style (widget);
   
   if (GTK_IS_CONTAINER (widget))
     gtk_container_forall (GTK_CONTAINER (widget),
@@ -3995,19 +3948,6 @@ gtk_widget_reset_rc_styles (GtkWidget *widget)
   gtk_widget_set_style_recurse (widget, NULL);
 }
 
-void
-gtk_widget_set_default_style (GtkStyle *style)
-{
-  if (style != gtk_default_style)
-     {
-       if (gtk_default_style)
-	 gtk_style_unref (gtk_default_style);
-       gtk_default_style = style;
-       if (gtk_default_style)
-	 gtk_style_ref (gtk_default_style);
-     }
-}
-
 GtkStyle*
 gtk_widget_get_default_style (void)
 {
@@ -4020,38 +3960,6 @@ gtk_widget_get_default_style (void)
   return gtk_default_style;
 }
 
-void
-gtk_widget_push_style (GtkStyle *style)
-{
-  g_return_if_fail (style != NULL);
-
-  gtk_style_ref (style);
-  style_stack = g_slist_prepend (style_stack, style);
-}
-
-static GtkStyle*
-gtk_widget_peek_style (void)
-{
-  if (style_stack)
-    return (GtkStyle*) style_stack->data;
-  else
-    return gtk_widget_get_default_style ();
-}
-
-void
-gtk_widget_pop_style (void)
-{
-  GSList *tmp;
-  
-  if (style_stack)
-    {
-      tmp = style_stack;
-      style_stack = style_stack->next;
-      gtk_style_unref ((GtkStyle*) tmp->data);
-      g_slist_free_1 (tmp);
-    }
-}
-
 static PangoContext *
 gtk_widget_peek_pango_context (GtkWidget *widget)
 {
@@ -4717,6 +4625,20 @@ gtk_widget_get_visual (GtkWidget *widget)
   return gdk_colormap_get_visual (gtk_widget_get_colormap (widget));
 }
 
+/**
+ * gtk_widget_get_settings:
+ * @widget: a #GtkWidget
+ * 
+ * Get the settings object holding the settings (global property
+ * settings, RC file information, etc) used for this widget.
+ * 
+ * Return value: the relevant #GtkSettings object
+ **/
+GtkSettings*
+gtk_widget_get_settings (GtkWidget *widget)
+{
+  return gtk_settings_get_default ();
+}
 
 /**
  * gtk_widget_set_colormap:
@@ -5161,7 +5083,6 @@ static void
 gtk_widget_real_destroy (GtkObject *object)
 {
   GtkWidget *widget;
-  GtkStyle *saved_style;
 
   /* gtk_object_destroy() will already hold a refcount on object
    */
@@ -5170,15 +5091,8 @@ gtk_widget_real_destroy (GtkObject *object)
   gtk_grab_remove (widget);
   gtk_selection_remove_all (widget);
   
-  saved_style = gtk_object_get_data_by_id (object, quark_saved_default_style);
-  if (saved_style)
-    {
-      gtk_style_unref (saved_style);
-      gtk_object_remove_data_by_id (object, quark_saved_default_style);
-    }
-
   gtk_style_unref (widget->style);
-  widget->style = gtk_widget_peek_style ();
+  widget->style = gtk_widget_get_default_style ();
   gtk_style_ref (widget->style);
 
   GTK_OBJECT_CLASS (parent_class)->destroy (object);
@@ -5191,19 +5105,11 @@ gtk_widget_finalize (GObject *object)
   GtkWidgetAuxInfo *aux_info;
   gint *events;
   GdkExtensionMode *mode;
-  GtkStyle *saved_style;
   GtkAccessible *accessible;
   
   gtk_grab_remove (widget);
   gtk_selection_remove_all (widget);
 
-  saved_style = gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_saved_default_style);
-  if (saved_style)
-    {
-      gtk_style_unref (saved_style);
-      gtk_object_remove_data_by_id (GTK_OBJECT (widget), quark_saved_default_style);
-    }
-
   gtk_style_unref (widget->style);
   widget->style = NULL;
 
diff --git a/gtk/gtkwidget.h b/gtk/gtkwidget.h
index f2c0fa75e3..83f416e4b2 100644
--- a/gtk/gtkwidget.h
+++ b/gtk/gtkwidget.h
@@ -32,6 +32,7 @@
 #include <gtk/gtkobject.h>
 #include <gtk/gtkadjustment.h>
 #include <gtk/gtkstyle.h>
+#include <gtk/gtksettings.h>
 #include <atk/atkobject.h>
 
 #ifdef __cplusplus
@@ -579,6 +580,8 @@ GtkWidget*   gtk_widget_get_ancestor	(GtkWidget	*widget,
 GdkColormap* gtk_widget_get_colormap	(GtkWidget	*widget);
 GdkVisual*   gtk_widget_get_visual	(GtkWidget	*widget);
 
+GtkSettings* gtk_widget_get_settings    (GtkWidget      *widget);
+
 
 /* Accessibility support */
 AtkObject*       gtk_widget_get_accessible               (GtkWidget          *widget);
@@ -608,10 +611,8 @@ gboolean     gtk_widget_hide_on_delete	(GtkWidget	*widget);
  */
 void	   gtk_widget_set_style		(GtkWidget	*widget,
 					 GtkStyle	*style);
-void	   gtk_widget_set_rc_style	(GtkWidget	*widget);
 void	   gtk_widget_ensure_style	(GtkWidget	*widget);
 GtkStyle*  gtk_widget_get_style		(GtkWidget	*widget);
-void	   gtk_widget_restore_default_style (GtkWidget	*widget);
 
 void        gtk_widget_modify_style       (GtkWidget            *widget,
 					   GtkRcStyle           *style);
@@ -631,6 +632,11 @@ void        gtk_widget_modify_base        (GtkWidget            *widget,
 void        gtk_widget_modify_font        (GtkWidget            *widget,
 					   PangoFontDescription *font_desc);
 
+#ifndef GTK_DISABLE_DEPRECATED
+#define gtk_widget_set_rc_style(widget)          (gtk_widget_set_style (widget, NULL))
+#define gtk_widget_restore_default_style(widget) (gtk_widget_set_style (widget, NULL))
+#endif
+
 PangoContext *gtk_widget_create_pango_context (GtkWidget   *widget);
 PangoContext *gtk_widget_get_pango_context    (GtkWidget   *widget);
 PangoLayout  *gtk_widget_create_pango_layout  (GtkWidget   *widget,
@@ -655,11 +661,9 @@ void       gtk_widget_reset_rc_styles   (GtkWidget      *widget);
  * This will override the values that got set by the
  * gtk_widget_set_default_* () functions.
  */
-void	     gtk_widget_push_style	     (GtkStyle	 *style);
 void	     gtk_widget_push_colormap	     (GdkColormap *cmap);
 void	     gtk_widget_push_composite_child (void);
 void	     gtk_widget_pop_composite_child  (void);
-void	     gtk_widget_pop_style	     (void);
 void	     gtk_widget_pop_colormap	     (void);
 
 /* widget style properties
diff --git a/gtk/gtkwindow.c b/gtk/gtkwindow.c
index 8b3fccab89..b4b6f9f26b 100644
--- a/gtk/gtkwindow.c
+++ b/gtk/gtkwindow.c
@@ -2524,29 +2524,7 @@ gtk_window_read_rcfiles (GtkWidget *widget,
 	}
     }
 
-  if (gtk_rc_reparse_all ())
-    {
-      /* If the above returned true, some of our RC files are out
-       * of date, so we need to reset all our widgets. Our other
-       * toplevel windows will also get the message, but by
-       * then, the RC file will up to date, so we have to tell
-       * them now. Also, we have to invalidate cached icons in
-       * icon sets so they get re-rendered.
-       */
-      GList *list, *toplevels;
-
-      _gtk_icon_set_invalidate_caches ();
-      
-      toplevels = gtk_window_list_toplevels ();
-      g_list_foreach (toplevels, (GFunc)g_object_ref, NULL);
-      
-      for (list = toplevels; list; list = list->next)
-	{
-	  gtk_widget_reset_rc_styles (list->data);
-	  gtk_widget_unref (list->data);
-	}
-      g_list_free (toplevels);
-    }
+  gtk_rc_reparse_all ();
 }
 
 static gint
diff --git a/tests/testgtk.c b/tests/testgtk.c
index 91678f469a..b9a1fa9a20 100644
--- a/tests/testgtk.c
+++ b/tests/testgtk.c
@@ -9883,28 +9883,6 @@ create_idle_test (void)
  */
 
 void
-reload_rc_file (void)
-{
-  GList *toplevels;
-
-  if (gtk_rc_reparse_all ())
-    {
-      toplevels = gdk_window_get_toplevels();
-      while (toplevels)
-	{
-	  GtkWidget *widget;
-	  gdk_window_get_user_data (toplevels->data, (gpointer *)&widget);
-	  
-	  if (widget)
-	    gtk_widget_reset_rc_styles (widget);
-	  
-	  toplevels = toplevels->next;
-	}
-      g_list_free (toplevels);
-    }
-}
-
-void
 reload_all_rc_files (void)
 {
   static GdkAtom atom_rcfiles = GDK_NONE;
@@ -9941,7 +9919,7 @@ create_rc_file (void)
 
       button = gtk_button_new_with_label ("Reload");
       gtk_signal_connect (GTK_OBJECT (button), "clicked",
-			  GTK_SIGNAL_FUNC(reload_rc_file), NULL);
+			  GTK_SIGNAL_FUNC(gtk_rc_reparse_all), NULL);
       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), 
 			  button, TRUE, TRUE, 0);
diff --git a/tests/testgtkrc b/tests/testgtkrc
index 31250b3464..d13a30d0ff 100644
--- a/tests/testgtkrc
+++ b/tests/testgtkrc
@@ -26,8 +26,6 @@ double-click_timeout = 42
 bell-duration = 39
 bell_duration = 40
 
-pixmap_path "."
-
 style "global-style-properties"
 {
 #  xthickness = 20